contrib/bind9/lib/isc/include/isc/buffer.h

   1 /*
   2  * Copyright (C) 2004-2008, 2010  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1998-2002  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: buffer.h,v 1.55 2010/12/20 23:47:21 tbox Exp $ */
  19
  20 #ifndef ISC_BUFFER_H
  21 #define ISC_BUFFER_H 1
  22
  23 /*****
  24  ***** Module Info
  25  *****/
  26
  27 /*! \file isc/buffer.h
  28  *
  29  * \brief A buffer is a region of memory, together with a set of related subregions.
  30  * Buffers are used for parsing and I/O operations.
  31  *
  32  * The 'used region' and the 'available' region are disjoint, and their
  33  * union is the buffer's region.  The used region extends from the beginning
  34  * of the buffer region to the last used byte.  The available region
  35  * extends from one byte greater than the last used byte to the end of the
  36  * buffer's region.  The size of the used region can be changed using various
  37  * buffer commands.  Initially, the used region is empty.
  38  *
  39  * The used region is further subdivided into two disjoint regions: the
  40  * 'consumed region' and the 'remaining region'.  The union of these two
  41  * regions is the used region.  The consumed region extends from the beginning
  42  * of the used region to the byte before the 'current' offset (if any).  The
  43  * 'remaining' region the current pointer to the end of the used
  44  * region.  The size of the consumed region can be changed using various
  45  * buffer commands.  Initially, the consumed region is empty.
  46  *
  47  * The 'active region' is an (optional) subregion of the remaining region.
  48  * It extends from the current offset to an offset in the remaining region
  49  * that is selected with isc_buffer_setactive().  Initially, the active region
  50  * is empty.  If the current offset advances beyond the chosen offset, the
  51  * active region will also be empty.
  52  *
  53  * \verbatim
  54  *  /------------entire length---------------\
  55  *  /----- used region -----\/-- available --\
  56  *  +----------------------------------------+
  57  *  | consumed  | remaining |                |
  58  *  +----------------------------------------+
  59  *  a           b     c     d                e
  60  *
  61  * a == base of buffer.
  62  * b == current pointer.  Can be anywhere between a and d.
  63  * c == active pointer.  Meaningful between b and d.
  64  * d == used pointer.
  65  * e == length of buffer.
  66  *
  67  * a-e == entire length of buffer.
  68  * a-d == used region.
  69  * a-b == consumed region.
  70  * b-d == remaining region.
  71  * b-c == optional active region.
  72  *\endverbatim
  73  *
  74  * The following invariants are maintained by all routines:
  75  *
  76  *\code
  77  *      length > 0
  78  *
  79  *      base is a valid pointer to length bytes of memory
  80  *
  81  *      0 <= used <= length
  82  *
  83  *      0 <= current <= used
  84  *
  85  *      0 <= active <= used
  86  *      (although active < current implies empty active region)
  87  *\endcode
  88  *
  89  * \li MP:
  90  *      Buffers have no synchronization.  Clients must ensure exclusive
  91  *      access.
  92  *
  93  * \li Reliability:
  94  *      No anticipated impact.
  95  *
  96  * \li Resources:
  97  *      Memory: 1 pointer + 6 unsigned integers per buffer.
  98  *
  99  * \li Security:
 100  *      No anticipated impact.
 101  *
 102  * \li Standards:
 103  *      None.
 104  */
 105
 106 /***
 107  *** Imports
 108  ***/
 109
 110 #include <isc/lang.h>
 111 #include <isc/magic.h>
 112 #include <isc/types.h>
 113
 114 /*!
 115  * To make many functions be inline macros (via \#define) define this.
 116  * If it is undefined, a function will be used.
 117  */
 118 /* #define ISC_BUFFER_USEINLINE */
 119
 120 ISC_LANG_BEGINDECLS
 121
 122 /*@{*/
 123 /*!
 124  *** Magic numbers
 125  ***/
 126 #define ISC_BUFFER_MAGIC                0x42756621U     /* Buf!. */
 127 #define ISC_BUFFER_VALID(b)             ISC_MAGIC_VALID(b, ISC_BUFFER_MAGIC)
 128 /*@}*/
 129
 130 /*
 131  * The following macros MUST be used only on valid buffers.  It is the
 132  * caller's responsibility to ensure this by using the ISC_BUFFER_VALID
 133  * check above, or by calling another isc_buffer_*() function (rather than
 134  * another macro.)
 135  */
 136
 137 /*@{*/
 138 /*!
 139  * Fundamental buffer elements.  (A through E in the introductory comment.)
 140  */
 141 #define isc_buffer_base(b)    ((void *)(b)->base)                         /*a*/
 142 #define isc_buffer_current(b) \
 143                 ((void *)((unsigned char *)(b)->base + (b)->current))     /*b*/
 144 #define isc_buffer_active(b)  \
 145                 ((void *)((unsigned char *)(b)->base + (b)->active))      /*c*/
 146 #define isc_buffer_used(b)    \
 147                 ((void *)((unsigned char *)(b)->base + (b)->used))        /*d*/
 148 #define isc_buffer_length(b)  ((b)->length)                               /*e*/
 149 /*@}*/
 150
 151 /*@{*/
 152 /*!
 153  * Derived lengths.  (Described in the introductory comment.)
 154  */
 155 #define isc_buffer_usedlength(b)        ((b)->used)                   /* d-a */
 156 #define isc_buffer_consumedlength(b)    ((b)->current)                /* b-a */
 157 #define isc_buffer_remaininglength(b)   ((b)->used - (b)->current)    /* d-b */
 158 #define isc_buffer_activelength(b)      ((b)->active - (b)->current)  /* c-b */
 159 #define isc_buffer_availablelength(b)   ((b)->length - (b)->used)     /* e-d */
 160 /*@}*/
 161
 162 /*!
 163  * Note that the buffer structure is public.  This is principally so buffer
 164  * operations can be implemented using macros.  Applications are strongly
 165  * discouraged from directly manipulating the structure.
 166  */
 167
 168 struct isc_buffer {
 169         unsigned int            magic;
 170         void                   *base;
 171         /*@{*/
 172         /*! The following integers are byte offsets from 'base'. */
 173         unsigned int            length;
 174         unsigned int            used;
 175         unsigned int            current;
 176         unsigned int            active;
 177         /*@}*/
 178         /*! linkable */
 179         ISC_LINK(isc_buffer_t)  link;
 180         /*! private internal elements */
 181         isc_mem_t              *mctx;
 182 };
 183
 184 /***
 185  *** Functions
 186  ***/
 187
 188 isc_result_t
 189 isc_buffer_allocate(isc_mem_t *mctx, isc_buffer_t **dynbuffer,
 190                     unsigned int length);
 191 /*!<
 192  * \brief Allocate a dynamic linkable buffer which has "length" bytes in the
 193  * data region.
 194  *
 195  * Requires:
 196  *\li   "mctx" is valid.
 197  *
 198  *\li   "dynbuffer" is non-NULL, and "*dynbuffer" is NULL.
 199  *
 200  * Returns:
 201  *\li   ISC_R_SUCCESS           - success
 202  *\li   ISC_R_NOMEMORY          - no memory available
 203  *
 204  * Note:
 205  *\li   Changing the buffer's length field is not permitted.
 206  */
 207
 208 void
 209 isc_buffer_free(isc_buffer_t **dynbuffer);
 210 /*!<
 211  * \brief Release resources allocated for a dynamic buffer.
 212  *
 213  * Requires:
 214  *\li   "dynbuffer" is not NULL.
 215  *
 216  *\li   "*dynbuffer" is a valid dynamic buffer.
 217  *
 218  * Ensures:
 219  *\li   "*dynbuffer" will be NULL on return, and all memory associated with
 220  *      the dynamic buffer is returned to the memory context used in
 221  *      isc_buffer_allocate().
 222  */
 223
 224 void
 225 isc__buffer_init(isc_buffer_t *b, const void *base, unsigned int length);
 226 /*!<
 227  * \brief Make 'b' refer to the 'length'-byte region starting at base.
 228  *
 229  * Requires:
 230  *
 231  *\li   'length' > 0
 232  *
 233  *\li   'base' is a pointer to a sequence of 'length' bytes.
 234  *
 235  */
 236
 237 void
 238 isc__buffer_initnull(isc_buffer_t *b);
 239 /*!<
 240  *\brief Initialize a buffer 'b' with a null data and zero length/
 241  */
 242
 243 void
 244 isc_buffer_reinit(isc_buffer_t *b, void *base, unsigned int length);
 245 /*!<
 246  * \brief Make 'b' refer to the 'length'-byte region starting at base.
 247  * Any existing data will be copied.
 248  *
 249  * Requires:
 250  *
 251  *\li   'length' > 0 AND length >= previous length
 252  *
 253  *\li   'base' is a pointer to a sequence of 'length' bytes.
 254  *
 255  */
 256
 257 void
 258 isc__buffer_invalidate(isc_buffer_t *b);
 259 /*!<
 260  * \brief Make 'b' an invalid buffer.
 261  *
 262  * Requires:
 263  *\li   'b' is a valid buffer.
 264  *
 265  * Ensures:
 266  *\li   If assertion checking is enabled, future attempts to use 'b' without
 267  *      calling isc_buffer_init() on it will cause an assertion failure.
 268  */
 269
 270 void
 271 isc__buffer_region(isc_buffer_t *b, isc_region_t *r);
 272 /*!<
 273  * \brief Make 'r' refer to the region of 'b'.
 274  *
 275  * Requires:
 276  *
 277  *\li   'b' is a valid buffer.
 278  *
 279  *\li   'r' points to a region structure.
 280  */
 281
 282 void
 283 isc__buffer_usedregion(isc_buffer_t *b, isc_region_t *r);
 284 /*!<
 285  * \brief Make 'r' refer to the used region of 'b'.
 286  *
 287  * Requires:
 288  *
 289  *\li   'b' is a valid buffer.
 290  *
 291  *\li   'r' points to a region structure.
 292  */
 293
 294 void
 295 isc__buffer_availableregion(isc_buffer_t *b, isc_region_t *r);
 296 /*!<
 297  * \brief Make 'r' refer to the available region of 'b'.
 298  *
 299  * Requires:
 300  *
 301  *\li   'b' is a valid buffer.
 302  *
 303  *\li   'r' points to a region structure.
 304  */
 305
 306 void
 307 isc__buffer_add(isc_buffer_t *b, unsigned int n);
 308 /*!<
 309  * \brief Increase the 'used' region of 'b' by 'n' bytes.
 310  *
 311  * Requires:
 312  *
 313  *\li   'b' is a valid buffer
 314  *
 315  *\li   used + n <= length
 316  *
 317  */
 318
 319 void
 320 isc__buffer_subtract(isc_buffer_t *b, unsigned int n);
 321 /*!<
 322  * \brief Decrease the 'used' region of 'b' by 'n' bytes.
 323  *
 324  * Requires:
 325  *
 326  *\li   'b' is a valid buffer
 327  *
 328  *\li   used >= n
 329  *
 330  */
 331
 332 void
 333 isc__buffer_clear(isc_buffer_t *b);
 334 /*!<
 335  * \brief Make the used region empty.
 336  *
 337  * Requires:
 338  *
 339  *\li   'b' is a valid buffer
 340  *
 341  * Ensures:
 342  *
 343  *\li   used = 0
 344  *
 345  */
 346
 347 void
 348 isc__buffer_consumedregion(isc_buffer_t *b, isc_region_t *r);
 349 /*!<
 350  * \brief Make 'r' refer to the consumed region of 'b'.
 351  *
 352  * Requires:
 353  *
 354  *\li   'b' is a valid buffer.
 355  *
 356  *\li   'r' points to a region structure.
 357  */
 358
 359 void
 360 isc__buffer_remainingregion(isc_buffer_t *b, isc_region_t *r);
 361 /*!<
 362  * \brief Make 'r' refer to the remaining region of 'b'.
 363  *
 364  * Requires:
 365  *
 366  *\li   'b' is a valid buffer.
 367  *
 368  *\li   'r' points to a region structure.
 369  */
 370
 371 void
 372 isc__buffer_activeregion(isc_buffer_t *b, isc_region_t *r);
 373 /*!<
 374  * \brief Make 'r' refer to the active region of 'b'.
 375  *
 376  * Requires:
 377  *
 378  *\li   'b' is a valid buffer.
 379  *
 380  *\li   'r' points to a region structure.
 381  */
 382
 383 void
 384 isc__buffer_setactive(isc_buffer_t *b, unsigned int n);
 385 /*!<
 386  * \brief Sets the end of the active region 'n' bytes after current.
 387  *
 388  * Requires:
 389  *
 390  *\li   'b' is a valid buffer.
 391  *
 392  *\li   current + n <= used
 393  */
 394
 395 void
 396 isc__buffer_first(isc_buffer_t *b);
 397 /*!<
 398  * \brief Make the consumed region empty.
 399  *
 400  * Requires:
 401  *
 402  *\li   'b' is a valid buffer
 403  *
 404  * Ensures:
 405  *
 406  *\li   current == 0
 407  *
 408  */
 409
 410 void
 411 isc__buffer_forward(isc_buffer_t *b, unsigned int n);
 412 /*!<
 413  * \brief Increase the 'consumed' region of 'b' by 'n' bytes.
 414  *
 415  * Requires:
 416  *
 417  *\li   'b' is a valid buffer
 418  *
 419  *\li   current + n <= used
 420  *
 421  */
 422
 423 void
 424 isc__buffer_back(isc_buffer_t *b, unsigned int n);
 425 /*!<
 426  * \brief Decrease the 'consumed' region of 'b' by 'n' bytes.
 427  *
 428  * Requires:
 429  *
 430  *\li   'b' is a valid buffer
 431  *
 432  *\li   n <= current
 433  *
 434  */
 435
 436 void
 437 isc_buffer_compact(isc_buffer_t *b);
 438 /*!<
 439  * \brief Compact the used region by moving the remaining region so it occurs
 440  * at the start of the buffer.  The used region is shrunk by the size of
 441  * the consumed region, and the consumed region is then made empty.
 442  *
 443  * Requires:
 444  *
 445  *\li   'b' is a valid buffer
 446  *
 447  * Ensures:
 448  *
 449  *\li   current == 0
 450  *
 451  *\li   The size of the used region is now equal to the size of the remaining
 452  *      region (as it was before the call).  The contents of the used region
 453  *      are those of the remaining region (as it was before the call).
 454  */
 455
 456 isc_uint8_t
 457 isc_buffer_getuint8(isc_buffer_t *b);
 458 /*!<
 459  * \brief Read an unsigned 8-bit integer from 'b' and return it.
 460  *
 461  * Requires:
 462  *
 463  *\li   'b' is a valid buffer.
 464  *
 465  *\li   The length of the available region of 'b' is at least 1.
 466  *
 467  * Ensures:
 468  *
 469  *\li   The current pointer in 'b' is advanced by 1.
 470  *
 471  * Returns:
 472  *
 473  *\li   A 8-bit unsigned integer.
 474  */
 475
 476 void
 477 isc__buffer_putuint8(isc_buffer_t *b, isc_uint8_t val);
 478 /*!<
 479  * \brief Store an unsigned 8-bit integer from 'val' into 'b'.
 480  *
 481  * Requires:
 482  *\li   'b' is a valid buffer.
 483  *
 484  *\li   The length of the unused region of 'b' is at least 1.
 485  *
 486  * Ensures:
 487  *\li   The used pointer in 'b' is advanced by 1.
 488  */
 489
 490 isc_uint16_t
 491 isc_buffer_getuint16(isc_buffer_t *b);
 492 /*!<
 493  * \brief Read an unsigned 16-bit integer in network byte order from 'b', convert
 494  * it to host byte order, and return it.
 495  *
 496  * Requires:
 497  *
 498  *\li   'b' is a valid buffer.
 499  *
 500  *\li   The length of the available region of 'b' is at least 2.
 501  *
 502  * Ensures:
 503  *
 504  *\li   The current pointer in 'b' is advanced by 2.
 505  *
 506  * Returns:
 507  *
 508  *\li   A 16-bit unsigned integer.
 509  */
 510
 511 void
 512 isc__buffer_putuint16(isc_buffer_t *b, isc_uint16_t val);
 513 /*!<
 514  * \brief Store an unsigned 16-bit integer in host byte order from 'val'
 515  * into 'b' in network byte order.
 516  *
 517  * Requires:
 518  *\li   'b' is a valid buffer.
 519  *
 520  *\li   The length of the unused region of 'b' is at least 2.
 521  *
 522  * Ensures:
 523  *\li   The used pointer in 'b' is advanced by 2.
 524  */
 525
 526 isc_uint32_t
 527 isc_buffer_getuint32(isc_buffer_t *b);
 528 /*!<
 529  * \brief Read an unsigned 32-bit integer in network byte order from 'b', convert
 530  * it to host byte order, and return it.
 531  *
 532  * Requires:
 533  *
 534  *\li   'b' is a valid buffer.
 535  *
 536  *\li   The length of the available region of 'b' is at least 4.
 537  *
 538  * Ensures:
 539  *
 540  *\li   The current pointer in 'b' is advanced by 4.
 541  *
 542  * Returns:
 543  *
 544  *\li   A 32-bit unsigned integer.
 545  */
 546
 547 void
 548 isc__buffer_putuint32(isc_buffer_t *b, isc_uint32_t val);
 549 /*!<
 550  * \brief Store an unsigned 32-bit integer in host byte order from 'val'
 551  * into 'b' in network byte order.
 552  *
 553  * Requires:
 554  *\li   'b' is a valid buffer.
 555  *
 556  *\li   The length of the unused region of 'b' is at least 4.
 557  *
 558  * Ensures:
 559  *\li   The used pointer in 'b' is advanced by 4.
 560  */
 561
 562 isc_uint64_t
 563 isc_buffer_getuint48(isc_buffer_t *b);
 564 /*!<
 565  * \brief Read an unsigned 48-bit integer in network byte order from 'b',
 566  * convert it to host byte order, and return it.
 567  *
 568  * Requires:
 569  *
 570  *\li   'b' is a valid buffer.
 571  *
 572  *\li   The length of the available region of 'b' is at least 6.
 573  *
 574  * Ensures:
 575  *
 576  *\li   The current pointer in 'b' is advanced by 6.
 577  *
 578  * Returns:
 579  *
 580  *\li   A 48-bit unsigned integer (stored in a 64-bit integer).
 581  */
 582
 583 void
 584 isc__buffer_putuint48(isc_buffer_t *b, isc_uint64_t val);
 585 /*!<
 586  * \brief Store an unsigned 48-bit integer in host byte order from 'val'
 587  * into 'b' in network byte order.
 588  *
 589  * Requires:
 590  *\li   'b' is a valid buffer.
 591  *
 592  *\li   The length of the unused region of 'b' is at least 6.
 593  *
 594  * Ensures:
 595  *\li   The used pointer in 'b' is advanced by 6.
 596  */
 597
 598 void
 599 isc__buffer_putuint24(isc_buffer_t *b, isc_uint32_t val);
 600 /*!<
 601  * Store an unsigned 24-bit integer in host byte order from 'val'
 602  * into 'b' in network byte order.
 603  *
 604  * Requires:
 605  *\li   'b' is a valid buffer.
 606  *
 607  *      The length of the unused region of 'b' is at least 3.
 608  *
 609  * Ensures:
 610  *\li   The used pointer in 'b' is advanced by 3.
 611  */
 612
 613 void
 614 isc__buffer_putmem(isc_buffer_t *b, const unsigned char *base,
 615                    unsigned int length);
 616 /*!<
 617  * \brief Copy 'length' bytes of memory at 'base' into 'b'.
 618  *
 619  * Requires:
 620  *\li   'b' is a valid buffer.
 621  *
 622  *\li   'base' points to 'length' bytes of valid memory.
 623  *
 624  */
 625
 626 void
 627 isc__buffer_putstr(isc_buffer_t *b, const char *source);
 628 /*!<
 629  * \brief Copy 'source' into 'b', not including terminating NUL.
 630  *
 631  * Requires:
 632  *\li   'b' is a valid buffer.
 633  *
 634  *\li   'source' to be a valid NULL terminated string.
 635  *
 636  *\li   strlen(source) <= isc_buffer_available(b)
 637  */
 638
 639 isc_result_t
 640 isc_buffer_copyregion(isc_buffer_t *b, const isc_region_t *r);
 641 /*!<
 642  * \brief Copy the contents of 'r' into 'b'.
 643  *
 644  * Requires:
 645  *\li   'b' is a valid buffer.
 646  *
 647  *\li   'r' is a valid region.
 648  *
 649  * Returns:
 650  *
 651  *\li   ISC_R_SUCCESS
 652  *\li   ISC_R_NOSPACE                   The available region of 'b' is not
 653  *                                      big enough.
 654  */
 655
 656 ISC_LANG_ENDDECLS
 657
 658 /*
 659  * Inline macro versions of the functions.  These should never be called
 660  * directly by an application, but will be used by the functions within
 661  * buffer.c.  The callers should always use "isc_buffer_*()" names, never
 662  * ones beginning with "isc__"
 663  */
 664
 665 /*! \note
 666  * XXXDCL Something more could be done with initializing buffers that
 667  * point to const data.  For example, a new function, isc_buffer_initconst,
 668  * could be used, and a new boolean flag in the buffer structure could
 669  * indicate whether the buffer was initialized with that function.
 670  * (isc_bufer_init itself would be reprototyped to *not* have its "base"
 671  * parameter be const.)  Then if the boolean were true, the isc_buffer_put*
 672  * functions could assert a contractual requirement for a non-const buffer.
 673  * One drawback is that the isc_buffer_* functions (macros) that return
 674  * pointers would still need to return non-const pointers to avoid compiler
 675  * warnings, so it would be up to code that uses them to have to deal
 676  * with the possibility that the buffer was initialized as const --
 677  * a problem that they *already* have to deal with but have absolutely
 678  * no ability to.  With a new isc_buffer_isconst() function returning
 679  * true/false, they could at least assert a contractual requirement for
 680  * non-const buffers when needed.
 681  */
 682 #define ISC__BUFFER_INIT(_b, _base, _length) \
 683         do { \
 684                 union { \
 685                         const void *    konst; \
 686                         void *          var; \
 687                 } _u; \
 688                 _u.konst = (_base); \
 689                 (_b)->base = _u.var; \
 690                 (_b)->length = (_length); \
 691                 (_b)->used = 0; \
 692                 (_b)->current = 0; \
 693                 (_b)->active = 0; \
 694                 (_b)->mctx = NULL; \
 695                 ISC_LINK_INIT(_b, link); \
 696                 (_b)->magic = ISC_BUFFER_MAGIC; \
 697         } while (0)
 698
 699 #define ISC__BUFFER_INITNULL(_b) ISC__BUFFER_INIT(_b, NULL, 0)
 700
 701 #define ISC__BUFFER_INVALIDATE(_b) \
 702         do { \
 703                 (_b)->magic = 0; \
 704                 (_b)->base = NULL; \
 705                 (_b)->length = 0; \
 706                 (_b)->used = 0; \
 707                 (_b)->current = 0; \
 708                 (_b)->active = 0; \
 709         } while (0)
 710
 711 #define ISC__BUFFER_REGION(_b, _r) \
 712         do { \
 713                 (_r)->base = (_b)->base; \
 714                 (_r)->length = (_b)->length; \
 715         } while (0)
 716
 717 #define ISC__BUFFER_USEDREGION(_b, _r) \
 718         do { \
 719                 (_r)->base = (_b)->base; \
 720                 (_r)->length = (_b)->used; \
 721         } while (0)
 722
 723 #define ISC__BUFFER_AVAILABLEREGION(_b, _r) \
 724         do { \
 725                 (_r)->base = isc_buffer_used(_b); \
 726                 (_r)->length = isc_buffer_availablelength(_b); \
 727         } while (0)
 728
 729 #define ISC__BUFFER_ADD(_b, _n) \
 730         do { \
 731                 (_b)->used += (_n); \
 732         } while (0)
 733
 734 #define ISC__BUFFER_SUBTRACT(_b, _n) \
 735         do { \
 736                 (_b)->used -= (_n); \
 737                 if ((_b)->current > (_b)->used) \
 738                         (_b)->current = (_b)->used; \
 739                 if ((_b)->active > (_b)->used) \
 740                         (_b)->active = (_b)->used; \
 741         } while (0)
 742
 743 #define ISC__BUFFER_CLEAR(_b) \
 744         do { \
 745                 (_b)->used = 0; \
 746                 (_b)->current = 0; \
 747                 (_b)->active = 0; \
 748         } while (0)
 749
 750 #define ISC__BUFFER_CONSUMEDREGION(_b, _r) \
 751         do { \
 752                 (_r)->base = (_b)->base; \
 753                 (_r)->length = (_b)->current; \
 754         } while (0)
 755
 756 #define ISC__BUFFER_REMAININGREGION(_b, _r) \
 757         do { \
 758                 (_r)->base = isc_buffer_current(_b); \
 759                 (_r)->length = isc_buffer_remaininglength(_b); \
 760         } while (0)
 761
 762 #define ISC__BUFFER_ACTIVEREGION(_b, _r) \
 763         do { \
 764                 if ((_b)->current < (_b)->active) { \
 765                         (_r)->base = isc_buffer_current(_b); \
 766                         (_r)->length = isc_buffer_activelength(_b); \
 767                 } else { \
 768                         (_r)->base = NULL; \
 769                         (_r)->length = 0; \
 770                 } \
 771         } while (0)
 772
 773 #define ISC__BUFFER_SETACTIVE(_b, _n) \
 774         do { \
 775                 (_b)->active = (_b)->current + (_n); \
 776         } while (0)
 777
 778 #define ISC__BUFFER_FIRST(_b) \
 779         do { \
 780                 (_b)->current = 0; \
 781         } while (0)
 782
 783 #define ISC__BUFFER_FORWARD(_b, _n) \
 784         do { \
 785                 (_b)->current += (_n); \
 786         } while (0)
 787
 788 #define ISC__BUFFER_BACK(_b, _n) \
 789         do { \
 790                 (_b)->current -= (_n); \
 791         } while (0)
 792
 793 #define ISC__BUFFER_PUTMEM(_b, _base, _length) \
 794         do { \
 795                 memcpy(isc_buffer_used(_b), (_base), (_length)); \
 796                 (_b)->used += (_length); \
 797         } while (0)
 798
 799 #define ISC__BUFFER_PUTSTR(_b, _source) \
 800         do { \
 801                 unsigned int _length; \
 802                 unsigned char *_cp; \
 803                 _length = strlen(_source); \
 804                 _cp = isc_buffer_used(_b); \
 805                 memcpy(_cp, (_source), _length); \
 806                 (_b)->used += (_length); \
 807         } while (0)
 808
 809 #define ISC__BUFFER_PUTUINT8(_b, _val) \
 810         do { \
 811                 unsigned char *_cp; \
 812                 isc_uint8_t _val2 = (_val); \
 813                 _cp = isc_buffer_used(_b); \
 814                 (_b)->used++; \
 815                 _cp[0] = _val2 & 0x00ff; \
 816         } while (0)
 817
 818 #define ISC__BUFFER_PUTUINT16(_b, _val) \
 819         do { \
 820                 unsigned char *_cp; \
 821                 isc_uint16_t _val2 = (_val); \
 822                 _cp = isc_buffer_used(_b); \
 823                 (_b)->used += 2; \
 824                 _cp[0] = (unsigned char)((_val2 & 0xff00U) >> 8); \
 825                 _cp[1] = (unsigned char)(_val2 & 0x00ffU); \
 826         } while (0)
 827
 828 #define ISC__BUFFER_PUTUINT24(_b, _val) \
 829         do { \
 830                 unsigned char *_cp; \
 831                 isc_uint32_t _val2 = (_val); \
 832                 _cp = isc_buffer_used(_b); \
 833                 (_b)->used += 3; \
 834                 _cp[0] = (unsigned char)((_val2 & 0xff0000U) >> 16); \
 835                 _cp[1] = (unsigned char)((_val2 & 0xff00U) >> 8); \
 836                 _cp[2] = (unsigned char)(_val2 & 0x00ffU); \
 837         } while (0)
 838
 839 #define ISC__BUFFER_PUTUINT32(_b, _val) \
 840         do { \
 841                 unsigned char *_cp; \
 842                 isc_uint32_t _val2 = (_val); \
 843                 _cp = isc_buffer_used(_b); \
 844                 (_b)->used += 4; \
 845                 _cp[0] = (unsigned char)((_val2 & 0xff000000) >> 24); \
 846                 _cp[1] = (unsigned char)((_val2 & 0x00ff0000) >> 16); \
 847                 _cp[2] = (unsigned char)((_val2 & 0x0000ff00) >> 8); \
 848                 _cp[3] = (unsigned char)((_val2 & 0x000000ff)); \
 849         } while (0)
 850
 851 #if defined(ISC_BUFFER_USEINLINE)
 852 #define isc_buffer_init                 ISC__BUFFER_INIT
 853 #define isc_buffer_initnull             ISC__BUFFER_INITNULL
 854 #define isc_buffer_invalidate           ISC__BUFFER_INVALIDATE
 855 #define isc_buffer_region               ISC__BUFFER_REGION
 856 #define isc_buffer_usedregion           ISC__BUFFER_USEDREGION
 857 #define isc_buffer_availableregion      ISC__BUFFER_AVAILABLEREGION
 858 #define isc_buffer_add                  ISC__BUFFER_ADD
 859 #define isc_buffer_subtract             ISC__BUFFER_SUBTRACT
 860 #define isc_buffer_clear                ISC__BUFFER_CLEAR
 861 #define isc_buffer_consumedregion       ISC__BUFFER_CONSUMEDREGION
 862 #define isc_buffer_remainingregion      ISC__BUFFER_REMAININGREGION
 863 #define isc_buffer_activeregion         ISC__BUFFER_ACTIVEREGION
 864 #define isc_buffer_setactive            ISC__BUFFER_SETACTIVE
 865 #define isc_buffer_first                ISC__BUFFER_FIRST
 866 #define isc_buffer_forward              ISC__BUFFER_FORWARD
 867 #define isc_buffer_back                 ISC__BUFFER_BACK
 868 #define isc_buffer_putmem               ISC__BUFFER_PUTMEM
 869 #define isc_buffer_putstr               ISC__BUFFER_PUTSTR
 870 #define isc_buffer_putuint8             ISC__BUFFER_PUTUINT8
 871 #define isc_buffer_putuint16            ISC__BUFFER_PUTUINT16
 872 #define isc_buffer_putuint24            ISC__BUFFER_PUTUINT24
 873 #define isc_buffer_putuint32            ISC__BUFFER_PUTUINT32
 874 #else
 875 #define isc_buffer_init                 isc__buffer_init
 876 #define isc_buffer_initnull             isc__buffer_initnull
 877 #define isc_buffer_invalidate           isc__buffer_invalidate
 878 #define isc_buffer_region               isc__buffer_region
 879 #define isc_buffer_usedregion           isc__buffer_usedregion
 880 #define isc_buffer_availableregion      isc__buffer_availableregion
 881 #define isc_buffer_add                  isc__buffer_add
 882 #define isc_buffer_subtract             isc__buffer_subtract
 883 #define isc_buffer_clear                isc__buffer_clear
 884 #define isc_buffer_consumedregion       isc__buffer_consumedregion
 885 #define isc_buffer_remainingregion      isc__buffer_remainingregion
 886 #define isc_buffer_activeregion         isc__buffer_activeregion
 887 #define isc_buffer_setactive            isc__buffer_setactive
 888 #define isc_buffer_first                isc__buffer_first
 889 #define isc_buffer_forward              isc__buffer_forward
 890 #define isc_buffer_back                 isc__buffer_back
 891 #define isc_buffer_putmem               isc__buffer_putmem
 892 #define isc_buffer_putstr               isc__buffer_putstr
 893 #define isc_buffer_putuint8             isc__buffer_putuint8
 894 #define isc_buffer_putuint16            isc__buffer_putuint16
 895 #define isc_buffer_putuint24            isc__buffer_putuint24
 896 #define isc_buffer_putuint32            isc__buffer_putuint32
 897 #endif
 898
 899 /*
 900  * No inline method for this one (yet).
 901  */
 902 #define isc_buffer_putuint48            isc__buffer_putuint48
 903
 904 #endif /* ISC_BUFFER_H */