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 */ 905