contrib/smbfs/lib/smb/mbuf.c

   1 /*
   2  * Copyright (c) 2000, Boris Popov
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *    This product includes software developed by Boris Popov.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $Id: mbuf.c,v 1.6 2001/02/24 15:56:04 bp Exp $
  33  */
  34
  35 #include <sys/types.h>
  36 #include <sys/endian.h>
  37 #include <ctype.h>
  38 #include <errno.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 #include <netsmb/smb_lib.h>
  44
  45 #define MBERROR(format, args...) printf("%s(%d): "format, __FUNCTION__ , \
  46                                     __LINE__ ,## args)
  47
  48 static int
  49 m_get(size_t len, struct mbuf **mpp)
  50 {
  51         struct mbuf *m;
  52
  53         len = M_ALIGN(len);
  54         if (len < M_MINSIZE)
  55                 len = M_MINSIZE;
  56         m = malloc(M_BASESIZE + len);
  57         if (m == NULL)
  58                 return ENOMEM;
  59         bzero(m, M_BASESIZE + len);
  60         m->m_maxlen = len;
  61         m->m_data = M_TOP(m);
  62         *mpp = m;
  63         return 0;
  64 }
  65
  66 static void
  67 m_free(struct mbuf *m)
  68 {
  69         free(m);
  70 }
  71
  72 static void
  73 m_freem(struct mbuf *m0)
  74 {
  75         struct mbuf *m;
  76
  77         while (m0) {
  78                 m = m0->m_next;
  79                 m_free(m0);
  80                 m0 = m;
  81         }
  82 }
  83
  84 static size_t
  85 m_totlen(struct mbuf *m0)
  86 {
  87         struct mbuf *m = m0;
  88         int len = 0;
  89
  90         while (m) {
  91                 len += m->m_len;
  92                 m = m->m_next;
  93         }
  94         return len;
  95 }
  96
  97 int
  98 m_lineup(struct mbuf *m0, struct mbuf **mpp)
  99 {
 100         struct mbuf *nm, *m;
 101         char *dp;
 102         size_t len;
 103         int error;
 104
 105         if (m0->m_next == NULL) {
 106                 *mpp = m0;
 107                 return 0;
 108         }
 109         if ((error = m_get(m_totlen(m0), &nm)) != 0)
 110                 return error;
 111         dp = mtod(nm, char *);
 112         while (m0) {
 113                 len = m0->m_len;
 114                 bcopy(m0->m_data, dp, len);
 115                 dp += len;
 116                 m = m0->m_next;
 117                 m_free(m0);
 118                 m0 = m;
 119         }
 120         *mpp = nm;
 121         return 0;
 122 }
 123
 124 int
 125 mb_init(struct mbdata *mbp, size_t size)
 126 {
 127         struct mbuf *m;
 128         int error;
 129
 130         if ((error = m_get(size, &m)) != 0)
 131                 return error;
 132         return mb_initm(mbp, m);
 133 }
 134
 135 int
 136 mb_initm(struct mbdata *mbp, struct mbuf *m)
 137 {
 138         bzero(mbp, sizeof(*mbp));
 139         mbp->mb_top = mbp->mb_cur = m;
 140         mbp->mb_pos = mtod(m, char *);
 141         return 0;
 142 }
 143
 144 int
 145 mb_done(struct mbdata *mbp)
 146 {
 147         if (mbp->mb_top) {
 148                 m_freem(mbp->mb_top);
 149                 mbp->mb_top = NULL;
 150         }
 151         return 0;
 152 }
 153
 154 /*
 155 int
 156 mb_fixhdr(struct mbdata *mbp)
 157 {
 158         struct mbuf *m = mbp->mb_top;
 159         int len = 0;
 160
 161         while (m) {
 162                 len += m->m_len;
 163                 m = m->m_next;
 164         }
 165         mbp->mb_top->m_pkthdr.len = len;
 166         return len;
 167 }
 168 */
 169 int
 170 m_getm(struct mbuf *top, size_t len, struct mbuf **mpp)
 171 {
 172         struct mbuf *m, *mp;
 173         int error;
 174
 175         for (mp = top; ; mp = mp->m_next) {
 176                 len -= M_TRAILINGSPACE(mp);
 177                 if (mp->m_next == NULL)
 178                         break;
 179
 180         }
 181         if (len > 0) {
 182                 if ((error = m_get(len, &m)) != 0)
 183                         return error;
 184                 mp->m_next = m;
 185         }
 186         *mpp = top;
 187         return 0;
 188 }
 189
 190 /*
 191  * Routines to put data in a buffer
 192  */
 193 #define MB_PUT(t)       int error; t *p; \
 194                         if ((error = mb_fit(mbp, sizeof(t), (char**)&p)) != 0) \
 195                                 return error
 196
 197 /*
 198  * Check if object of size 'size' fit to the current position and
 199  * allocate new mbuf if not. Advance pointers and increase length of mbuf(s).
 200  * Return pointer to the object placeholder or NULL if any error occured.
 201  */
 202 int
 203 mb_fit(struct mbdata *mbp, size_t size, char **pp)
 204 {
 205         struct mbuf *m, *mn;
 206         int error;
 207
 208         m = mbp->mb_cur;
 209         if (M_TRAILINGSPACE(m) < (int)size) {
 210                 if ((error = m_get(size, &mn)) != 0)
 211                         return error;
 212                 mbp->mb_pos = mtod(mn, char *);
 213                 mbp->mb_cur = m->m_next = mn;
 214                 m = mn;
 215         }
 216         m->m_len += size;
 217         *pp = mbp->mb_pos;
 218         mbp->mb_pos += size;
 219         mbp->mb_count += size;
 220         return 0;
 221 }
 222
 223 int
 224 mb_put_uint8(struct mbdata *mbp, u_int8_t x)
 225 {
 226         MB_PUT(u_int8_t);
 227         *p = x;
 228         return 0;
 229 }
 230
 231 int
 232 mb_put_uint16be(struct mbdata *mbp, u_int16_t x)
 233 {
 234         MB_PUT(u_int16_t);
 235         setwbe(p, 0, x);
 236         return 0;
 237 }
 238
 239 int
 240 mb_put_uint16le(struct mbdata *mbp, u_int16_t x)
 241 {
 242         MB_PUT(u_int16_t);
 243         setwle(p, 0, x);
 244         return 0;
 245 }
 246
 247 int
 248 mb_put_uint32be(struct mbdata *mbp, u_int32_t x)
 249 {
 250         MB_PUT(u_int32_t);
 251         setdbe(p, 0, x);
 252         return 0;
 253 }
 254
 255 int
 256 mb_put_uint32le(struct mbdata *mbp, u_int32_t x)
 257 {
 258         MB_PUT(u_int32_t);
 259         setdle(p, 0, x);
 260         return 0;
 261 }
 262
 263 int
 264 mb_put_int64be(struct mbdata *mbp, int64_t x)
 265 {
 266         MB_PUT(int64_t);
 267         *p = htobe64(x);
 268         return 0;
 269 }
 270
 271 int
 272 mb_put_int64le(struct mbdata *mbp, int64_t x)
 273 {
 274         MB_PUT(int64_t);
 275         *p = htole64(x);
 276         return 0;
 277 }
 278
 279 int
 280 mb_put_mem(struct mbdata *mbp, const char *source, size_t size)
 281 {
 282         struct mbuf *m;
 283         char * dst;
 284         size_t cplen;
 285         int error;
 286
 287         if (size == 0)
 288                 return 0;
 289         m = mbp->mb_cur;
 290         if ((error = m_getm(m, size, &m)) != 0)
 291                 return error;
 292         while (size > 0) {
 293                 cplen = M_TRAILINGSPACE(m);
 294                 if (cplen == 0) {
 295                         m = m->m_next;
 296                         continue;
 297                 }
 298                 if (cplen > size)
 299                         cplen = size;
 300                 dst = mtod(m, char *) + m->m_len;
 301                 if (source) {
 302                         bcopy(source, dst, cplen);
 303                         source += cplen;
 304                 } else
 305                         bzero(dst, cplen);
 306                 size -= cplen;
 307                 m->m_len += cplen;
 308                 mbp->mb_count += cplen;
 309         }
 310         mbp->mb_pos = mtod(m, char *) + m->m_len;
 311         mbp->mb_cur = m;
 312         return 0;
 313 }
 314
 315 int
 316 mb_put_mbuf(struct mbdata *mbp, struct mbuf *m)
 317 {
 318         mbp->mb_cur->m_next = m;
 319         while (m) {
 320                 mbp->mb_count += m->m_len;
 321                 if (m->m_next == NULL)
 322                         break;
 323                 m = m->m_next;
 324         }
 325         mbp->mb_pos = mtod(m, char *) + m->m_len;
 326         mbp->mb_cur = m;
 327         return 0;
 328 }
 329
 330 int
 331 mb_put_pstring(struct mbdata *mbp, const char *s)
 332 {
 333         int error, len = strlen(s);
 334
 335         if (len > 255) {
 336                 len = 255;
 337         }
 338         if ((error = mb_put_uint8(mbp, len)) != 0)
 339                 return error;
 340         return mb_put_mem(mbp, s, len);
 341 }
 342
 343 /*
 344  * Routines for fetching data from an mbuf chain
 345  */
 346 #define mb_left(m,p)    (mtod(m, char *) + (m)->m_len - (p))
 347
 348 int
 349 mb_get_uint8(struct mbdata *mbp, u_int8_t *x)
 350 {
 351         return mb_get_mem(mbp, x, 1);
 352 }
 353
 354 int
 355 mb_get_uint16(struct mbdata *mbp, u_int16_t *x)
 356 {
 357         return mb_get_mem(mbp, (char *)x, 2);
 358 }
 359
 360 int
 361 mb_get_uint16le(struct mbdata *mbp, u_int16_t *x)
 362 {
 363         u_int16_t v;
 364         int error = mb_get_uint16(mbp, &v);
 365
 366         if (x != NULL)
 367                 *x = le16toh(v);
 368         return error;
 369 }
 370
 371 int
 372 mb_get_uint16be(struct mbdata *mbp, u_int16_t *x) {
 373         u_int16_t v;
 374         int error = mb_get_uint16(mbp, &v);
 375
 376         if (x != NULL)
 377                 *x = be16toh(v);
 378         return error;
 379 }
 380
 381 int
 382 mb_get_uint32(struct mbdata *mbp, u_int32_t *x)
 383 {
 384         return mb_get_mem(mbp, (char *)x, 4);
 385 }
 386
 387 int
 388 mb_get_uint32be(struct mbdata *mbp, u_int32_t *x)
 389 {
 390         u_int32_t v;
 391         int error;
 392
 393         error = mb_get_uint32(mbp, &v);
 394         if (x != NULL)
 395                 *x = be32toh(v);
 396         return error;
 397 }
 398
 399 int
 400 mb_get_uint32le(struct mbdata *mbp, u_int32_t *x)
 401 {
 402         u_int32_t v;
 403         int error;
 404
 405         error = mb_get_uint32(mbp, &v);
 406         if (x != NULL)
 407                 *x = le32toh(v);
 408         return error;
 409 }
 410
 411 int
 412 mb_get_int64(struct mbdata *mbp, int64_t *x)
 413 {
 414         return mb_get_mem(mbp, (char *)x, 8);
 415 }
 416
 417 int
 418 mb_get_int64be(struct mbdata *mbp, int64_t *x)
 419 {
 420         int64_t v;
 421         int error;
 422
 423         error = mb_get_int64(mbp, &v);
 424         if (x != NULL)
 425                 *x = be64toh(v);
 426         return error;
 427 }
 428
 429 int
 430 mb_get_int64le(struct mbdata *mbp, int64_t *x)
 431 {
 432         int64_t v;
 433         int error;
 434
 435         error = mb_get_int64(mbp, &v);
 436         if (x != NULL)
 437                 *x = le64toh(v);
 438         return error;
 439 }
 440
 441 int
 442 mb_get_mem(struct mbdata *mbp, char * target, size_t size)
 443 {
 444         struct mbuf *m = mbp->mb_cur;
 445         u_int count;
 446
 447         while (size > 0) {
 448                 if (m == NULL) {
 449                         MBERROR("incomplete copy\n");
 450                         return EBADRPC;
 451                 }
 452                 count = mb_left(m, mbp->mb_pos);
 453                 if (count == 0) {
 454                         mbp->mb_cur = m = m->m_next;
 455                         if (m)
 456                                 mbp->mb_pos = mtod(m, char *);
 457                         continue;
 458                 }
 459                 if (count > size)
 460                         count = size;
 461                 size -= count;
 462                 if (target) {
 463                         if (count == 1) {
 464                                 *target++ = *mbp->mb_pos;
 465                         } else {
 466                                 bcopy(mbp->mb_pos, target, count);
 467                                 target += count;
 468                         }
 469                 }
 470                 mbp->mb_pos += count;
 471         }
 472         return 0;
 473 }