external/bsd/ntp/dist/lib/isc/buffer.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2004-2008  Internet Systems Consortium, Inc. ("ISC")
   5  * Copyright (C) 1998-2002  Internet Software Consortium.
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /* Id: buffer.c,v 1.49 2008/09/25 04:02:39 tbox Exp */
  21
  22 /*! \file */
  23
  24 #include <config.h>
  25
  26 #include <isc/buffer.h>
  27 #include <isc/mem.h>
  28 #include <isc/region.h>
  29 #include <isc/string.h>
  30 #include <isc/util.h>
  31
  32 void
  33 isc__buffer_init(isc_buffer_t *b, const void *base, unsigned int length) {
  34         /*
  35          * Make 'b' refer to the 'length'-byte region starting at 'base'.
  36          * XXXDCL see the comment in buffer.h about base being const.
  37          */
  38
  39         REQUIRE(b != NULL);
  40
  41         ISC__BUFFER_INIT(b, base, length);
  42 }
  43
  44 void
  45 isc__buffer_initnull(isc_buffer_t *b) {
  46         /*
  47          * Initialize a new buffer which has no backing store.  This can
  48          * later be grown as needed and swapped in place.
  49          */
  50
  51         ISC__BUFFER_INIT(b, NULL, 0);
  52 }
  53
  54 void
  55 isc_buffer_reinit(isc_buffer_t *b, void *base, unsigned int length) {
  56         /*
  57          * Re-initialize the buffer enough to reconfigure the base of the
  58          * buffer.  We will swap in the new buffer, after copying any
  59          * data we contain into the new buffer and adjusting all of our
  60          * internal pointers.
  61          *
  62          * The buffer must not be smaller than the length of the original
  63          * buffer.
  64          */
  65         REQUIRE(b->length <= length);
  66         REQUIRE(base != NULL);
  67
  68         (void)memmove(base, b->base, b->length);
  69         b->base = base;
  70         b->length = length;
  71 }
  72
  73 void
  74 isc__buffer_invalidate(isc_buffer_t *b) {
  75         /*
  76          * Make 'b' an invalid buffer.
  77          */
  78
  79         REQUIRE(ISC_BUFFER_VALID(b));
  80         REQUIRE(!ISC_LINK_LINKED(b, link));
  81         REQUIRE(b->mctx == NULL);
  82
  83         ISC__BUFFER_INVALIDATE(b);
  84 }
  85
  86 void
  87 isc__buffer_region(isc_buffer_t *b, isc_region_t *r) {
  88         /*
  89          * Make 'r' refer to the region of 'b'.
  90          */
  91
  92         REQUIRE(ISC_BUFFER_VALID(b));
  93         REQUIRE(r != NULL);
  94
  95         ISC__BUFFER_REGION(b, r);
  96 }
  97
  98 void
  99 isc__buffer_usedregion(isc_buffer_t *b, isc_region_t *r) {
 100         /*
 101          * Make 'r' refer to the used region of 'b'.
 102          */
 103
 104         REQUIRE(ISC_BUFFER_VALID(b));
 105         REQUIRE(r != NULL);
 106
 107         ISC__BUFFER_USEDREGION(b, r);
 108 }
 109
 110 void
 111 isc__buffer_availableregion(isc_buffer_t *b, isc_region_t *r) {
 112         /*
 113          * Make 'r' refer to the available region of 'b'.
 114          */
 115
 116         REQUIRE(ISC_BUFFER_VALID(b));
 117         REQUIRE(r != NULL);
 118
 119         ISC__BUFFER_AVAILABLEREGION(b, r);
 120 }
 121
 122 void
 123 isc__buffer_add(isc_buffer_t *b, unsigned int n) {
 124         /*
 125          * Increase the 'used' region of 'b' by 'n' bytes.
 126          */
 127
 128         REQUIRE(ISC_BUFFER_VALID(b));
 129         REQUIRE(b->used + n <= b->length);
 130
 131         ISC__BUFFER_ADD(b, n);
 132 }
 133
 134 void
 135 isc__buffer_subtract(isc_buffer_t *b, unsigned int n) {
 136         /*
 137          * Decrease the 'used' region of 'b' by 'n' bytes.
 138          */
 139
 140         REQUIRE(ISC_BUFFER_VALID(b));
 141         REQUIRE(b->used >= n);
 142
 143         ISC__BUFFER_SUBTRACT(b, n);
 144 }
 145
 146 void
 147 isc__buffer_clear(isc_buffer_t *b) {
 148         /*
 149          * Make the used region empty.
 150          */
 151
 152         REQUIRE(ISC_BUFFER_VALID(b));
 153
 154         ISC__BUFFER_CLEAR(b);
 155 }
 156
 157 void
 158 isc__buffer_consumedregion(isc_buffer_t *b, isc_region_t *r) {
 159         /*
 160          * Make 'r' refer to the consumed region of 'b'.
 161          */
 162
 163         REQUIRE(ISC_BUFFER_VALID(b));
 164         REQUIRE(r != NULL);
 165
 166         ISC__BUFFER_CONSUMEDREGION(b, r);
 167 }
 168
 169 void
 170 isc__buffer_remainingregion(isc_buffer_t *b, isc_region_t *r) {
 171         /*
 172          * Make 'r' refer to the remaining region of 'b'.
 173          */
 174
 175         REQUIRE(ISC_BUFFER_VALID(b));
 176         REQUIRE(r != NULL);
 177
 178         ISC__BUFFER_REMAININGREGION(b, r);
 179 }
 180
 181 void
 182 isc__buffer_activeregion(isc_buffer_t *b, isc_region_t *r) {
 183         /*
 184          * Make 'r' refer to the active region of 'b'.
 185          */
 186
 187         REQUIRE(ISC_BUFFER_VALID(b));
 188         REQUIRE(r != NULL);
 189
 190         ISC__BUFFER_ACTIVEREGION(b, r);
 191 }
 192
 193 void
 194 isc__buffer_setactive(isc_buffer_t *b, unsigned int n) {
 195         /*
 196          * Sets the end of the active region 'n' bytes after current.
 197          */
 198
 199         REQUIRE(ISC_BUFFER_VALID(b));
 200         REQUIRE(b->current + n <= b->used);
 201
 202         ISC__BUFFER_SETACTIVE(b, n);
 203 }
 204
 205 void
 206 isc__buffer_first(isc_buffer_t *b) {
 207         /*
 208          * Make the consumed region empty.
 209          */
 210
 211         REQUIRE(ISC_BUFFER_VALID(b));
 212
 213         ISC__BUFFER_FIRST(b);
 214 }
 215
 216 void
 217 isc__buffer_forward(isc_buffer_t *b, unsigned int n) {
 218         /*
 219          * Increase the 'consumed' region of 'b' by 'n' bytes.
 220          */
 221
 222         REQUIRE(ISC_BUFFER_VALID(b));
 223         REQUIRE(b->current + n <= b->used);
 224
 225         ISC__BUFFER_FORWARD(b, n);
 226 }
 227
 228 void
 229 isc__buffer_back(isc_buffer_t *b, unsigned int n) {
 230         /*
 231          * Decrease the 'consumed' region of 'b' by 'n' bytes.
 232          */
 233
 234         REQUIRE(ISC_BUFFER_VALID(b));
 235         REQUIRE(n <= b->current);
 236
 237         ISC__BUFFER_BACK(b, n);
 238 }
 239
 240 void
 241 isc_buffer_compact(isc_buffer_t *b) {
 242         unsigned int length;
 243         void *src;
 244
 245         /*
 246          * Compact the used region by moving the remaining region so it occurs
 247          * at the start of the buffer.  The used region is shrunk by the size
 248          * of the consumed region, and the consumed region is then made empty.
 249          */
 250
 251         REQUIRE(ISC_BUFFER_VALID(b));
 252
 253         src = isc_buffer_current(b);
 254         length = isc_buffer_remaininglength(b);
 255         (void)memmove(b->base, src, (size_t)length);
 256
 257         if (b->active > b->current)
 258                 b->active -= b->current;
 259         else
 260                 b->active = 0;
 261         b->current = 0;
 262         b->used = length;
 263 }
 264
 265 isc_uint8_t
 266 isc_buffer_getuint8(isc_buffer_t *b) {
 267         unsigned char *cp;
 268         isc_uint8_t result;
 269
 270         /*
 271          * Read an unsigned 8-bit integer from 'b' and return it.
 272          */
 273
 274         REQUIRE(ISC_BUFFER_VALID(b));
 275         REQUIRE(b->used - b->current >= 1);
 276
 277         cp = isc_buffer_current(b);
 278         b->current += 1;
 279         result = ((isc_uint8_t)(cp[0]));
 280
 281         return (result);
 282 }
 283
 284 void
 285 isc__buffer_putuint8(isc_buffer_t *b, isc_uint8_t val) {
 286         REQUIRE(ISC_BUFFER_VALID(b));
 287         REQUIRE(b->used + 1 <= b->length);
 288
 289         ISC__BUFFER_PUTUINT8(b, val);
 290 }
 291
 292 isc_uint16_t
 293 isc_buffer_getuint16(isc_buffer_t *b) {
 294         unsigned char *cp;
 295         isc_uint16_t result;
 296
 297         /*
 298          * Read an unsigned 16-bit integer in network byte order from 'b',
 299          * convert it to host byte order, and return it.
 300          */
 301
 302         REQUIRE(ISC_BUFFER_VALID(b));
 303         REQUIRE(b->used - b->current >= 2);
 304
 305         cp = isc_buffer_current(b);
 306         b->current += 2;
 307         result = ((unsigned int)(cp[0])) << 8;
 308         result |= ((unsigned int)(cp[1]));
 309
 310         return (result);
 311 }
 312
 313 void
 314 isc__buffer_putuint16(isc_buffer_t *b, isc_uint16_t val) {
 315         REQUIRE(ISC_BUFFER_VALID(b));
 316         REQUIRE(b->used + 2 <= b->length);
 317
 318         ISC__BUFFER_PUTUINT16(b, val);
 319 }
 320
 321 void
 322 isc__buffer_putuint24(isc_buffer_t *b, isc_uint32_t val) {
 323         REQUIRE(ISC_BUFFER_VALID(b));
 324         REQUIRE(b->used + 3 <= b->length);
 325
 326         ISC__BUFFER_PUTUINT24(b, val);
 327 }
 328
 329 isc_uint32_t
 330 isc_buffer_getuint32(isc_buffer_t *b) {
 331         unsigned char *cp;
 332         isc_uint32_t result;
 333
 334         /*
 335          * Read an unsigned 32-bit integer in network byte order from 'b',
 336          * convert it to host byte order, and return it.
 337          */
 338
 339         REQUIRE(ISC_BUFFER_VALID(b));
 340         REQUIRE(b->used - b->current >= 4);
 341
 342         cp = isc_buffer_current(b);
 343         b->current += 4;
 344         result = ((unsigned int)(cp[0])) << 24;
 345         result |= ((unsigned int)(cp[1])) << 16;
 346         result |= ((unsigned int)(cp[2])) << 8;
 347         result |= ((unsigned int)(cp[3]));
 348
 349         return (result);
 350 }
 351
 352 void
 353 isc__buffer_putuint32(isc_buffer_t *b, isc_uint32_t val) {
 354         REQUIRE(ISC_BUFFER_VALID(b));
 355         REQUIRE(b->used + 4 <= b->length);
 356
 357         ISC__BUFFER_PUTUINT32(b, val);
 358 }
 359
 360 isc_uint64_t
 361 isc_buffer_getuint48(isc_buffer_t *b) {
 362         unsigned char *cp;
 363         isc_uint64_t result;
 364
 365         /*
 366          * Read an unsigned 48-bit integer in network byte order from 'b',
 367          * convert it to host byte order, and return it.
 368          */
 369
 370         REQUIRE(ISC_BUFFER_VALID(b));
 371         REQUIRE(b->used - b->current >= 6);
 372
 373         cp = isc_buffer_current(b);
 374         b->current += 6;
 375         result = ((isc_int64_t)(cp[0])) << 40;
 376         result |= ((isc_int64_t)(cp[1])) << 32;
 377         result |= ((isc_int64_t)(cp[2])) << 24;
 378         result |= ((isc_int64_t)(cp[3])) << 16;
 379         result |= ((isc_int64_t)(cp[4])) << 8;
 380         result |= ((isc_int64_t)(cp[5]));
 381
 382         return (result);
 383 }
 384
 385 void
 386 isc__buffer_putuint48(isc_buffer_t *b, isc_uint64_t val) {
 387         isc_uint16_t valhi;
 388         isc_uint32_t vallo;
 389
 390         REQUIRE(ISC_BUFFER_VALID(b));
 391         REQUIRE(b->used + 6 <= b->length);
 392
 393         valhi = (isc_uint16_t)(val >> 32);
 394         vallo = (isc_uint32_t)(val & 0xFFFFFFFF);
 395         ISC__BUFFER_PUTUINT16(b, valhi);
 396         ISC__BUFFER_PUTUINT32(b, vallo);
 397 }
 398
 399 void
 400 isc__buffer_putmem(isc_buffer_t *b, const unsigned char *base,
 401                    unsigned int length)
 402 {
 403         REQUIRE(ISC_BUFFER_VALID(b));
 404         REQUIRE(b->used + length <= b->length);
 405
 406         ISC__BUFFER_PUTMEM(b, base, length);
 407 }
 408
 409 void
 410 isc__buffer_putstr(isc_buffer_t *b, const char *source) {
 411         unsigned int l;
 412         unsigned char *cp;
 413
 414         REQUIRE(ISC_BUFFER_VALID(b));
 415         REQUIRE(source != NULL);
 416
 417         /*
 418          * Do not use ISC__BUFFER_PUTSTR(), so strlen is only done once.
 419          */
 420         l = strlen(source);
 421
 422         REQUIRE(l <= isc_buffer_availablelength(b));
 423
 424         cp = isc_buffer_used(b);
 425         memcpy(cp, source, l);
 426         b->used += l;
 427 }
 428
 429 isc_result_t
 430 isc_buffer_copyregion(isc_buffer_t *b, const isc_region_t *r) {
 431         unsigned char *base;
 432         unsigned int available;
 433
 434         REQUIRE(ISC_BUFFER_VALID(b));
 435         REQUIRE(r != NULL);
 436
 437         /*
 438          * XXXDCL
 439          */
 440         base = isc_buffer_used(b);
 441         available = isc_buffer_availablelength(b);
 442         if (r->length > available)
 443                 return (ISC_R_NOSPACE);
 444         memcpy(base, r->base, r->length);
 445         b->used += r->length;
 446
 447         return (ISC_R_SUCCESS);
 448 }
 449
 450 isc_result_t
 451 isc_buffer_allocate(isc_mem_t *mctx, isc_buffer_t **dynbuffer,
 452                     unsigned int length)
 453 {
 454         isc_buffer_t *dbuf;
 455
 456         REQUIRE(dynbuffer != NULL);
 457         REQUIRE(*dynbuffer == NULL);
 458
 459         dbuf = isc_mem_get(mctx, length + sizeof(isc_buffer_t));
 460         if (dbuf == NULL)
 461                 return (ISC_R_NOMEMORY);
 462
 463         isc_buffer_init(dbuf, ((unsigned char *)dbuf) + sizeof(isc_buffer_t),
 464                         length);
 465         dbuf->mctx = mctx;
 466
 467         *dynbuffer = dbuf;
 468
 469         return (ISC_R_SUCCESS);
 470 }
 471
 472 void
 473 isc_buffer_free(isc_buffer_t **dynbuffer) {
 474         unsigned int real_length;
 475         isc_buffer_t *dbuf;
 476         isc_mem_t *mctx;
 477
 478         REQUIRE(dynbuffer != NULL);
 479         REQUIRE(ISC_BUFFER_VALID(*dynbuffer));
 480         REQUIRE((*dynbuffer)->mctx != NULL);
 481
 482         dbuf = *dynbuffer;
 483         *dynbuffer = NULL;      /* destroy external reference */
 484
 485         real_length = dbuf->length + sizeof(isc_buffer_t);
 486         mctx = dbuf->mctx;
 487         dbuf->mctx = NULL;
 488         isc_buffer_invalidate(dbuf);
 489
 490         isc_mem_put(mctx, dbuf, real_length);
 491 }