Annotation of embedaddon/dhcp/common/alloc.c, revision 1.1
1.1 ! misho 1: /* alloc.c
! 2:
! 3: Memory allocation... */
! 4:
! 5: /*
! 6: * Copyright (c) 2004-2007,2009 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 1996-2003 by Internet Software Consortium
! 8: *
! 9: * Permission to use, copy, modify, and distribute this software for any
! 10: * purpose with or without fee is hereby granted, provided that the above
! 11: * copyright notice and this permission notice appear in all copies.
! 12: *
! 13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 20: *
! 21: * Internet Systems Consortium, Inc.
! 22: * 950 Charter Street
! 23: * Redwood City, CA 94063
! 24: * <info@isc.org>
! 25: * https://www.isc.org/
! 26: *
! 27: * This software has been written for Internet Systems Consortium
! 28: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
! 29: * To learn more about Internet Systems Consortium, see
! 30: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
! 31: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
! 32: * ``http://www.nominum.com''.
! 33: */
! 34:
! 35: #include "dhcpd.h"
! 36: #include <omapip/omapip_p.h>
! 37:
! 38: struct dhcp_packet *dhcp_free_list;
! 39: struct packet *packet_free_list;
! 40:
! 41: int option_chain_head_allocate (ptr, file, line)
! 42: struct option_chain_head **ptr;
! 43: const char *file;
! 44: int line;
! 45: {
! 46: struct option_chain_head *h;
! 47:
! 48: if (!ptr) {
! 49: log_error ("%s(%d): null pointer", file, line);
! 50: #if defined (POINTER_DEBUG)
! 51: abort ();
! 52: #else
! 53: return 0;
! 54: #endif
! 55: }
! 56: if (*ptr) {
! 57: log_error ("%s(%d): non-null pointer", file, line);
! 58: #if defined (POINTER_DEBUG)
! 59: abort ();
! 60: #else
! 61: *ptr = (struct option_chain_head *)0;
! 62: #endif
! 63: }
! 64:
! 65: h = dmalloc (sizeof *h, file, line);
! 66: if (h) {
! 67: memset (h, 0, sizeof *h);
! 68: return option_chain_head_reference (ptr, h, file, line);
! 69: }
! 70: return 0;
! 71: }
! 72:
! 73: int option_chain_head_reference (ptr, bp, file, line)
! 74: struct option_chain_head **ptr;
! 75: struct option_chain_head *bp;
! 76: const char *file;
! 77: int line;
! 78: {
! 79: if (!ptr) {
! 80: log_error ("%s(%d): null pointer", file, line);
! 81: #if defined (POINTER_DEBUG)
! 82: abort ();
! 83: #else
! 84: return 0;
! 85: #endif
! 86: }
! 87: if (*ptr) {
! 88: log_error ("%s(%d): non-null pointer", file, line);
! 89: #if defined (POINTER_DEBUG)
! 90: abort ();
! 91: #else
! 92: *ptr = (struct option_chain_head *)0;
! 93: #endif
! 94: }
! 95: *ptr = bp;
! 96: bp -> refcnt++;
! 97: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 98: return 1;
! 99: }
! 100:
! 101: int option_chain_head_dereference (ptr, file, line)
! 102: struct option_chain_head **ptr;
! 103: const char *file;
! 104: int line;
! 105: {
! 106: struct option_chain_head *option_chain_head;
! 107: pair car, cdr;
! 108:
! 109: if (!ptr || !*ptr) {
! 110: log_error ("%s(%d): null pointer", file, line);
! 111: #if defined (POINTER_DEBUG)
! 112: abort ();
! 113: #else
! 114: return 0;
! 115: #endif
! 116: }
! 117:
! 118: option_chain_head = *ptr;
! 119: *ptr = (struct option_chain_head *)0;
! 120: --option_chain_head -> refcnt;
! 121: rc_register (file, line, ptr, option_chain_head,
! 122: option_chain_head -> refcnt, 1, RC_MISC);
! 123: if (option_chain_head -> refcnt > 0)
! 124: return 1;
! 125:
! 126: if (option_chain_head -> refcnt < 0) {
! 127: log_error ("%s(%d): negative refcnt!", file, line);
! 128: #if defined (DEBUG_RC_HISTORY)
! 129: dump_rc_history (option_chain_head);
! 130: #endif
! 131: #if defined (POINTER_DEBUG)
! 132: abort ();
! 133: #else
! 134: return 0;
! 135: #endif
! 136: }
! 137:
! 138: /* If there are any options on this head, free them. */
! 139: for (car = option_chain_head -> first; car; car = cdr) {
! 140: cdr = car -> cdr;
! 141: if (car -> car)
! 142: option_cache_dereference ((struct option_cache **)
! 143: (&car -> car), MDL);
! 144: dfree (car, MDL);
! 145: car = cdr;
! 146: }
! 147:
! 148: dfree (option_chain_head, file, line);
! 149: return 1;
! 150: }
! 151:
! 152: int group_allocate (ptr, file, line)
! 153: struct group **ptr;
! 154: const char *file;
! 155: int line;
! 156: {
! 157: struct group *g;
! 158:
! 159: if (!ptr) {
! 160: log_error ("%s(%d): null pointer", file, line);
! 161: #if defined (POINTER_DEBUG)
! 162: abort ();
! 163: #else
! 164: return 0;
! 165: #endif
! 166: }
! 167: if (*ptr) {
! 168: log_error ("%s(%d): non-null pointer", file, line);
! 169: #if defined (POINTER_DEBUG)
! 170: abort ();
! 171: #else
! 172: *ptr = (struct group *)0;
! 173: #endif
! 174: }
! 175:
! 176: g = dmalloc (sizeof *g, file, line);
! 177: if (g) {
! 178: memset (g, 0, sizeof *g);
! 179: return group_reference (ptr, g, file, line);
! 180: }
! 181: return 0;
! 182: }
! 183:
! 184: int group_reference (ptr, bp, file, line)
! 185: struct group **ptr;
! 186: struct group *bp;
! 187: const char *file;
! 188: int line;
! 189: {
! 190: if (!ptr) {
! 191: log_error ("%s(%d): null pointer", file, line);
! 192: #if defined (POINTER_DEBUG)
! 193: abort ();
! 194: #else
! 195: return 0;
! 196: #endif
! 197: }
! 198: if (*ptr) {
! 199: log_error ("%s(%d): non-null pointer", file, line);
! 200: #if defined (POINTER_DEBUG)
! 201: abort ();
! 202: #else
! 203: *ptr = (struct group *)0;
! 204: #endif
! 205: }
! 206: *ptr = bp;
! 207: bp -> refcnt++;
! 208: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 209: return 1;
! 210: }
! 211:
! 212: int group_dereference (ptr, file, line)
! 213: struct group **ptr;
! 214: const char *file;
! 215: int line;
! 216: {
! 217: struct group *group;
! 218:
! 219: if (!ptr || !*ptr) {
! 220: log_error ("%s(%d): null pointer", file, line);
! 221: #if defined (POINTER_DEBUG)
! 222: abort ();
! 223: #else
! 224: return 0;
! 225: #endif
! 226: }
! 227:
! 228: group = *ptr;
! 229: *ptr = (struct group *)0;
! 230: --group -> refcnt;
! 231: rc_register (file, line, ptr, group, group -> refcnt, 1, RC_MISC);
! 232: if (group -> refcnt > 0)
! 233: return 1;
! 234:
! 235: if (group -> refcnt < 0) {
! 236: log_error ("%s(%d): negative refcnt!", file, line);
! 237: #if defined (DEBUG_RC_HISTORY)
! 238: dump_rc_history (group);
! 239: #endif
! 240: #if defined (POINTER_DEBUG)
! 241: abort ();
! 242: #else
! 243: return 0;
! 244: #endif
! 245: }
! 246:
! 247: if (group -> object)
! 248: group_object_dereference (&group -> object, file, line);
! 249: if (group -> subnet)
! 250: subnet_dereference (&group -> subnet, file, line);
! 251: if (group -> shared_network)
! 252: shared_network_dereference (&group -> shared_network,
! 253: file, line);
! 254: if (group -> statements)
! 255: executable_statement_dereference (&group -> statements,
! 256: file, line);
! 257: if (group -> next)
! 258: group_dereference (&group -> next, file, line);
! 259: dfree (group, file, line);
! 260: return 1;
! 261: }
! 262:
! 263: struct dhcp_packet *new_dhcp_packet (file, line)
! 264: const char *file;
! 265: int line;
! 266: {
! 267: struct dhcp_packet *rval;
! 268: rval = (struct dhcp_packet *)dmalloc (sizeof (struct dhcp_packet),
! 269: file, line);
! 270: return rval;
! 271: }
! 272:
! 273: struct protocol *new_protocol (file, line)
! 274: const char *file;
! 275: int line;
! 276: {
! 277: struct protocol *rval = dmalloc (sizeof (struct protocol), file, line);
! 278: return rval;
! 279: }
! 280:
! 281: struct domain_search_list *new_domain_search_list (file, line)
! 282: const char *file;
! 283: int line;
! 284: {
! 285: struct domain_search_list *rval =
! 286: dmalloc (sizeof (struct domain_search_list), file, line);
! 287: return rval;
! 288: }
! 289:
! 290: struct name_server *new_name_server (file, line)
! 291: const char *file;
! 292: int line;
! 293: {
! 294: struct name_server *rval =
! 295: dmalloc (sizeof (struct name_server), file, line);
! 296: return rval;
! 297: }
! 298:
! 299: void free_name_server (ptr, file, line)
! 300: struct name_server *ptr;
! 301: const char *file;
! 302: int line;
! 303: {
! 304: dfree ((void *)ptr, file, line);
! 305: }
! 306:
! 307: struct option *new_option (name, file, line)
! 308: const char *name;
! 309: const char *file;
! 310: int line;
! 311: {
! 312: struct option *rval;
! 313: int len;
! 314:
! 315: len = strlen(name);
! 316:
! 317: rval = dmalloc(sizeof(struct option) + len + 1, file, line);
! 318:
! 319: if(rval) {
! 320: memcpy(rval + 1, name, len);
! 321: rval->name = (char *)(rval + 1);
! 322: }
! 323:
! 324: return rval;
! 325: }
! 326:
! 327: struct universe *new_universe (file, line)
! 328: const char *file;
! 329: int line;
! 330: {
! 331: struct universe *rval =
! 332: dmalloc (sizeof (struct universe), file, line);
! 333: return rval;
! 334: }
! 335:
! 336: void free_universe (ptr, file, line)
! 337: struct universe *ptr;
! 338: const char *file;
! 339: int line;
! 340: {
! 341: dfree ((void *)ptr, file, line);
! 342: }
! 343:
! 344: void free_domain_search_list (ptr, file, line)
! 345: struct domain_search_list *ptr;
! 346: const char *file;
! 347: int line;
! 348: {
! 349: dfree ((void *)ptr, file, line);
! 350: }
! 351:
! 352: void free_protocol (ptr, file, line)
! 353: struct protocol *ptr;
! 354: const char *file;
! 355: int line;
! 356: {
! 357: dfree ((void *)ptr, file, line);
! 358: }
! 359:
! 360: void free_dhcp_packet (ptr, file, line)
! 361: struct dhcp_packet *ptr;
! 362: const char *file;
! 363: int line;
! 364: {
! 365: dfree ((void *)ptr, file, line);
! 366: }
! 367:
! 368: struct client_lease *new_client_lease (file, line)
! 369: const char *file;
! 370: int line;
! 371: {
! 372: return (struct client_lease *)dmalloc (sizeof (struct client_lease),
! 373: file, line);
! 374: }
! 375:
! 376: void free_client_lease (lease, file, line)
! 377: struct client_lease *lease;
! 378: const char *file;
! 379: int line;
! 380: {
! 381: dfree (lease, file, line);
! 382: }
! 383:
! 384: pair free_pairs;
! 385:
! 386: pair new_pair (file, line)
! 387: const char *file;
! 388: int line;
! 389: {
! 390: pair foo;
! 391:
! 392: if (free_pairs) {
! 393: foo = free_pairs;
! 394: free_pairs = foo -> cdr;
! 395: memset (foo, 0, sizeof *foo);
! 396: dmalloc_reuse (foo, file, line, 0);
! 397: return foo;
! 398: }
! 399:
! 400: foo = dmalloc (sizeof *foo, file, line);
! 401: if (!foo)
! 402: return foo;
! 403: memset (foo, 0, sizeof *foo);
! 404: return foo;
! 405: }
! 406:
! 407: void free_pair (foo, file, line)
! 408: pair foo;
! 409: const char *file;
! 410: int line;
! 411: {
! 412: foo -> cdr = free_pairs;
! 413: free_pairs = foo;
! 414: dmalloc_reuse (free_pairs, __FILE__, __LINE__, 0);
! 415: }
! 416:
! 417: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 418: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 419: void relinquish_free_pairs ()
! 420: {
! 421: pair pf, pc;
! 422:
! 423: for (pf = free_pairs; pf; pf = pc) {
! 424: pc = pf -> cdr;
! 425: dfree (pf, MDL);
! 426: }
! 427: free_pairs = (pair)0;
! 428: }
! 429: #endif
! 430:
! 431: struct expression *free_expressions;
! 432:
! 433: int expression_allocate (cptr, file, line)
! 434: struct expression **cptr;
! 435: const char *file;
! 436: int line;
! 437: {
! 438: struct expression *rval;
! 439:
! 440: if (free_expressions) {
! 441: rval = free_expressions;
! 442: free_expressions = rval -> data.not;
! 443: dmalloc_reuse (rval, file, line, 1);
! 444: } else {
! 445: rval = dmalloc (sizeof (struct expression), file, line);
! 446: if (!rval)
! 447: return 0;
! 448: }
! 449: memset (rval, 0, sizeof *rval);
! 450: return expression_reference (cptr, rval, file, line);
! 451: }
! 452:
! 453: int expression_reference (ptr, src, file, line)
! 454: struct expression **ptr;
! 455: struct expression *src;
! 456: const char *file;
! 457: int line;
! 458: {
! 459: if (!ptr) {
! 460: log_error ("%s(%d): null pointer", file, line);
! 461: #if defined (POINTER_DEBUG)
! 462: abort ();
! 463: #else
! 464: return 0;
! 465: #endif
! 466: }
! 467: if (*ptr) {
! 468: log_error ("%s(%d): non-null pointer", file, line);
! 469: #if defined (POINTER_DEBUG)
! 470: abort ();
! 471: #else
! 472: *ptr = (struct expression *)0;
! 473: #endif
! 474: }
! 475: *ptr = src;
! 476: src -> refcnt++;
! 477: rc_register (file, line, ptr, src, src -> refcnt, 0, RC_MISC);
! 478: return 1;
! 479: }
! 480:
! 481: void free_expression (expr, file, line)
! 482: struct expression *expr;
! 483: const char *file;
! 484: int line;
! 485: {
! 486: expr -> data.not = free_expressions;
! 487: free_expressions = expr;
! 488: dmalloc_reuse (free_expressions, __FILE__, __LINE__, 0);
! 489: }
! 490:
! 491: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 492: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 493: void relinquish_free_expressions ()
! 494: {
! 495: struct expression *e, *n;
! 496:
! 497: for (e = free_expressions; e; e = n) {
! 498: n = e -> data.not;
! 499: dfree (e, MDL);
! 500: }
! 501: free_expressions = (struct expression *)0;
! 502: }
! 503: #endif
! 504:
! 505: struct binding_value *free_binding_values;
! 506:
! 507: int binding_value_allocate (cptr, file, line)
! 508: struct binding_value **cptr;
! 509: const char *file;
! 510: int line;
! 511: {
! 512: struct binding_value *rval;
! 513:
! 514: if (free_binding_values) {
! 515: rval = free_binding_values;
! 516: free_binding_values = rval -> value.bv;
! 517: dmalloc_reuse (rval, file, line, 1);
! 518: } else {
! 519: rval = dmalloc (sizeof (struct binding_value), file, line);
! 520: if (!rval)
! 521: return 0;
! 522: }
! 523: memset (rval, 0, sizeof *rval);
! 524: return binding_value_reference (cptr, rval, file, line);
! 525: }
! 526:
! 527: int binding_value_reference (ptr, src, file, line)
! 528: struct binding_value **ptr;
! 529: struct binding_value *src;
! 530: const char *file;
! 531: int line;
! 532: {
! 533: if (!ptr) {
! 534: log_error ("%s(%d): null pointer", file, line);
! 535: #if defined (POINTER_DEBUG)
! 536: abort ();
! 537: #else
! 538: return 0;
! 539: #endif
! 540: }
! 541: if (*ptr) {
! 542: log_error ("%s(%d): non-null pointer", file, line);
! 543: #if defined (POINTER_DEBUG)
! 544: abort ();
! 545: #else
! 546: *ptr = (struct binding_value *)0;
! 547: #endif
! 548: }
! 549: *ptr = src;
! 550: src -> refcnt++;
! 551: rc_register (file, line, ptr, src, src -> refcnt, 0, RC_MISC);
! 552: return 1;
! 553: }
! 554:
! 555: void free_binding_value (bv, file, line)
! 556: struct binding_value *bv;
! 557: const char *file;
! 558: int line;
! 559: {
! 560: bv -> value.bv = free_binding_values;
! 561: free_binding_values = bv;
! 562: dmalloc_reuse (free_binding_values, (char *)0, 0, 0);
! 563: }
! 564:
! 565: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 566: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 567: void relinquish_free_binding_values ()
! 568: {
! 569: struct binding_value *b, *n;
! 570:
! 571: for (b = free_binding_values; b; b = n) {
! 572: n = b -> value.bv;
! 573: dfree (b, MDL);
! 574: }
! 575: free_binding_values = (struct binding_value *)0;
! 576: }
! 577: #endif
! 578:
! 579: int fundef_allocate (cptr, file, line)
! 580: struct fundef **cptr;
! 581: const char *file;
! 582: int line;
! 583: {
! 584: struct fundef *rval;
! 585:
! 586: rval = dmalloc (sizeof (struct fundef), file, line);
! 587: if (!rval)
! 588: return 0;
! 589: memset (rval, 0, sizeof *rval);
! 590: return fundef_reference (cptr, rval, file, line);
! 591: }
! 592:
! 593: int fundef_reference (ptr, src, file, line)
! 594: struct fundef **ptr;
! 595: struct fundef *src;
! 596: const char *file;
! 597: int line;
! 598: {
! 599: if (!ptr) {
! 600: log_error ("%s(%d): null pointer", file, line);
! 601: #if defined (POINTER_DEBUG)
! 602: abort ();
! 603: #else
! 604: return 0;
! 605: #endif
! 606: }
! 607: if (*ptr) {
! 608: log_error ("%s(%d): non-null pointer", file, line);
! 609: #if defined (POINTER_DEBUG)
! 610: abort ();
! 611: #else
! 612: *ptr = (struct fundef *)0;
! 613: #endif
! 614: }
! 615: *ptr = src;
! 616: src -> refcnt++;
! 617: rc_register (file, line, ptr, src, src -> refcnt, 0, RC_MISC);
! 618: return 1;
! 619: }
! 620:
! 621: struct option_cache *free_option_caches;
! 622:
! 623: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 624: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 625: void relinquish_free_option_caches ()
! 626: {
! 627: struct option_cache *o, *n;
! 628:
! 629: for (o = free_option_caches; o; o = n) {
! 630: n = (struct option_cache *)(o -> expression);
! 631: dfree (o, MDL);
! 632: }
! 633: free_option_caches = (struct option_cache *)0;
! 634: }
! 635: #endif
! 636:
! 637: int option_cache_allocate (cptr, file, line)
! 638: struct option_cache **cptr;
! 639: const char *file;
! 640: int line;
! 641: {
! 642: struct option_cache *rval;
! 643:
! 644: if (free_option_caches) {
! 645: rval = free_option_caches;
! 646: free_option_caches =
! 647: (struct option_cache *)(rval -> expression);
! 648: dmalloc_reuse (rval, file, line, 0);
! 649: } else {
! 650: rval = dmalloc (sizeof (struct option_cache), file, line);
! 651: if (!rval)
! 652: return 0;
! 653: }
! 654: memset (rval, 0, sizeof *rval);
! 655: return option_cache_reference (cptr, rval, file, line);
! 656: }
! 657:
! 658: int option_cache_reference (ptr, src, file, line)
! 659: struct option_cache **ptr;
! 660: struct option_cache *src;
! 661: const char *file;
! 662: int line;
! 663: {
! 664: if (!ptr) {
! 665: log_error ("%s(%d): null pointer", file, line);
! 666: #if defined (POINTER_DEBUG)
! 667: abort ();
! 668: #else
! 669: return 0;
! 670: #endif
! 671: }
! 672: if (*ptr) {
! 673: log_error ("%s(%d): non-null pointer", file, line);
! 674: #if defined (POINTER_DEBUG)
! 675: abort ();
! 676: #else
! 677: *ptr = (struct option_cache *)0;
! 678: #endif
! 679: }
! 680: *ptr = src;
! 681: src -> refcnt++;
! 682: rc_register (file, line, ptr, src, src -> refcnt, 0, RC_MISC);
! 683: return 1;
! 684: }
! 685:
! 686: int buffer_allocate (ptr, len, file, line)
! 687: struct buffer **ptr;
! 688: unsigned len;
! 689: const char *file;
! 690: int line;
! 691: {
! 692: struct buffer *bp;
! 693:
! 694: /* XXXSK: should check for bad ptr values, otherwise we
! 695: leak memory if they are wrong */
! 696: bp = dmalloc (len + sizeof *bp, file, line);
! 697: if (!bp)
! 698: return 0;
! 699: /* XXXSK: both of these initializations are unnecessary */
! 700: memset (bp, 0, sizeof *bp);
! 701: bp -> refcnt = 0;
! 702: return buffer_reference (ptr, bp, file, line);
! 703: }
! 704:
! 705: int buffer_reference (ptr, bp, file, line)
! 706: struct buffer **ptr;
! 707: struct buffer *bp;
! 708: const char *file;
! 709: int line;
! 710: {
! 711: if (!ptr) {
! 712: log_error ("%s(%d): null pointer", file, line);
! 713: #if defined (POINTER_DEBUG)
! 714: abort ();
! 715: #else
! 716: return 0;
! 717: #endif
! 718: }
! 719: if (*ptr) {
! 720: log_error ("%s(%d): non-null pointer", file, line);
! 721: #if defined (POINTER_DEBUG)
! 722: abort ();
! 723: #else
! 724: *ptr = (struct buffer *)0;
! 725: #endif
! 726: }
! 727: *ptr = bp;
! 728: bp -> refcnt++;
! 729: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 730: return 1;
! 731: }
! 732:
! 733: int buffer_dereference (ptr, file, line)
! 734: struct buffer **ptr;
! 735: const char *file;
! 736: int line;
! 737: {
! 738: if (!ptr) {
! 739: log_error ("%s(%d): null pointer", file, line);
! 740: #if defined (POINTER_DEBUG)
! 741: abort ();
! 742: #else
! 743: return 0;
! 744: #endif
! 745: }
! 746:
! 747: if (!*ptr) {
! 748: log_error ("%s(%d): null pointer", file, line);
! 749: #if defined (POINTER_DEBUG)
! 750: abort ();
! 751: #else
! 752: return 0;
! 753: #endif
! 754: }
! 755:
! 756: (*ptr) -> refcnt--;
! 757: rc_register (file, line, ptr, *ptr, (*ptr) -> refcnt, 1, RC_MISC);
! 758: if (!(*ptr) -> refcnt) {
! 759: dfree ((*ptr), file, line);
! 760: } else if ((*ptr) -> refcnt < 0) {
! 761: log_error ("%s(%d): negative refcnt!", file, line);
! 762: #if defined (DEBUG_RC_HISTORY)
! 763: dump_rc_history (*ptr);
! 764: #endif
! 765: #if defined (POINTER_DEBUG)
! 766: abort ();
! 767: #else
! 768: return 0;
! 769: #endif
! 770: }
! 771: *ptr = (struct buffer *)0;
! 772: return 1;
! 773: }
! 774:
! 775: int dns_host_entry_allocate (ptr, hostname, file, line)
! 776: struct dns_host_entry **ptr;
! 777: const char *hostname;
! 778: const char *file;
! 779: int line;
! 780: {
! 781: struct dns_host_entry *bp;
! 782:
! 783: bp = dmalloc (strlen (hostname) + sizeof *bp, file, line);
! 784: if (!bp)
! 785: return 0;
! 786: memset (bp, 0, sizeof *bp);
! 787: bp -> refcnt = 0;
! 788: strcpy (bp -> hostname, hostname);
! 789: return dns_host_entry_reference (ptr, bp, file, line);
! 790: }
! 791:
! 792: int dns_host_entry_reference (ptr, bp, file, line)
! 793: struct dns_host_entry **ptr;
! 794: struct dns_host_entry *bp;
! 795: const char *file;
! 796: int line;
! 797: {
! 798: if (!ptr) {
! 799: log_error ("%s(%d): null pointer", file, line);
! 800: #if defined (POINTER_DEBUG)
! 801: abort ();
! 802: #else
! 803: return 0;
! 804: #endif
! 805: }
! 806: if (*ptr) {
! 807: log_error ("%s(%d): non-null pointer", file, line);
! 808: #if defined (POINTER_DEBUG)
! 809: abort ();
! 810: #else
! 811: *ptr = (struct dns_host_entry *)0;
! 812: #endif
! 813: }
! 814: *ptr = bp;
! 815: bp -> refcnt++;
! 816: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 817: return 1;
! 818: }
! 819:
! 820: int dns_host_entry_dereference (ptr, file, line)
! 821: struct dns_host_entry **ptr;
! 822: const char *file;
! 823: int line;
! 824: {
! 825: if (!ptr || !*ptr) {
! 826: log_error ("%s(%d): null pointer", file, line);
! 827: #if defined (POINTER_DEBUG)
! 828: abort ();
! 829: #else
! 830: return 0;
! 831: #endif
! 832: }
! 833:
! 834: (*ptr) -> refcnt--;
! 835: rc_register (file, line, ptr, *ptr, (*ptr) -> refcnt, 1, RC_MISC);
! 836: if (!(*ptr) -> refcnt)
! 837: dfree ((*ptr), file, line);
! 838: if ((*ptr) -> refcnt < 0) {
! 839: log_error ("%s(%d): negative refcnt!", file, line);
! 840: #if defined (DEBUG_RC_HISTORY)
! 841: dump_rc_history (*ptr);
! 842: #endif
! 843: #if defined (POINTER_DEBUG)
! 844: abort ();
! 845: #else
! 846: return 0;
! 847: #endif
! 848: }
! 849: *ptr = (struct dns_host_entry *)0;
! 850: return 1;
! 851: }
! 852:
! 853: int option_state_allocate (ptr, file, line)
! 854: struct option_state **ptr;
! 855: const char *file;
! 856: int line;
! 857: {
! 858: unsigned size;
! 859:
! 860: if (!ptr) {
! 861: log_error ("%s(%d): null pointer", file, line);
! 862: #if defined (POINTER_DEBUG)
! 863: abort ();
! 864: #else
! 865: return 0;
! 866: #endif
! 867: }
! 868: if (*ptr) {
! 869: log_error ("%s(%d): non-null pointer", file, line);
! 870: #if defined (POINTER_DEBUG)
! 871: abort ();
! 872: #else
! 873: *ptr = (struct option_state *)0;
! 874: #endif
! 875: }
! 876:
! 877: size = sizeof **ptr + (universe_count - 1) * sizeof (void *);
! 878: *ptr = dmalloc (size, file, line);
! 879: if (*ptr) {
! 880: memset (*ptr, 0, size);
! 881: (*ptr) -> universe_count = universe_count;
! 882: (*ptr) -> refcnt = 1;
! 883: rc_register (file, line,
! 884: ptr, *ptr, (*ptr) -> refcnt, 0, RC_MISC);
! 885: return 1;
! 886: }
! 887: return 0;
! 888: }
! 889:
! 890: int option_state_reference (ptr, bp, file, line)
! 891: struct option_state **ptr;
! 892: struct option_state *bp;
! 893: const char *file;
! 894: int line;
! 895: {
! 896: if (!ptr) {
! 897: log_error ("%s(%d): null pointer", file, line);
! 898: #if defined (POINTER_DEBUG)
! 899: abort ();
! 900: #else
! 901: return 0;
! 902: #endif
! 903: }
! 904: if (*ptr) {
! 905: log_error ("%s(%d): non-null pointer", file, line);
! 906: #if defined (POINTER_DEBUG)
! 907: abort ();
! 908: #else
! 909: *ptr = (struct option_state *)0;
! 910: #endif
! 911: }
! 912: *ptr = bp;
! 913: bp -> refcnt++;
! 914: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 915: return 1;
! 916: }
! 917:
! 918: int option_state_dereference (ptr, file, line)
! 919: struct option_state **ptr;
! 920: const char *file;
! 921: int line;
! 922: {
! 923: int i;
! 924: struct option_state *options;
! 925:
! 926: if (!ptr || !*ptr) {
! 927: log_error ("%s(%d): null pointer", file, line);
! 928: #if defined (POINTER_DEBUG)
! 929: abort ();
! 930: #else
! 931: return 0;
! 932: #endif
! 933: }
! 934:
! 935: options = *ptr;
! 936: *ptr = (struct option_state *)0;
! 937: --options -> refcnt;
! 938: rc_register (file, line, ptr, options, options -> refcnt, 1, RC_MISC);
! 939: if (options -> refcnt > 0)
! 940: return 1;
! 941:
! 942: if (options -> refcnt < 0) {
! 943: log_error ("%s(%d): negative refcnt!", file, line);
! 944: #if defined (DEBUG_RC_HISTORY)
! 945: dump_rc_history (options);
! 946: #endif
! 947: #if defined (POINTER_DEBUG)
! 948: abort ();
! 949: #else
! 950: return 0;
! 951: #endif
! 952: }
! 953:
! 954: /* Loop through the per-universe state. */
! 955: for (i = 0; i < options -> universe_count; i++)
! 956: if (options -> universes [i] &&
! 957: universes [i] -> option_state_dereference)
! 958: ((*(universes [i] -> option_state_dereference))
! 959: (universes [i], options, file, line));
! 960:
! 961: dfree (options, file, line);
! 962: return 1;
! 963: }
! 964:
! 965: int executable_statement_allocate (ptr, file, line)
! 966: struct executable_statement **ptr;
! 967: const char *file;
! 968: int line;
! 969: {
! 970: struct executable_statement *bp;
! 971:
! 972: bp = dmalloc (sizeof *bp, file, line);
! 973: if (!bp)
! 974: return 0;
! 975: memset (bp, 0, sizeof *bp);
! 976: return executable_statement_reference (ptr, bp, file, line);
! 977: }
! 978:
! 979: int executable_statement_reference (ptr, bp, file, line)
! 980: struct executable_statement **ptr;
! 981: struct executable_statement *bp;
! 982: const char *file;
! 983: int line;
! 984: {
! 985: if (!ptr) {
! 986: log_error ("%s(%d): null pointer", file, line);
! 987: #if defined (POINTER_DEBUG)
! 988: abort ();
! 989: #else
! 990: return 0;
! 991: #endif
! 992: }
! 993: if (*ptr) {
! 994: log_error ("%s(%d): non-null pointer", file, line);
! 995: #if defined (POINTER_DEBUG)
! 996: abort ();
! 997: #else
! 998: *ptr = (struct executable_statement *)0;
! 999: #endif
! 1000: }
! 1001: *ptr = bp;
! 1002: bp -> refcnt++;
! 1003: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 1004: return 1;
! 1005: }
! 1006:
! 1007: static struct packet *free_packets;
! 1008:
! 1009: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 1010: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 1011: void relinquish_free_packets ()
! 1012: {
! 1013: struct packet *p, *n;
! 1014: for (p = free_packets; p; p = n) {
! 1015: n = (struct packet *)(p -> raw);
! 1016: dfree (p, MDL);
! 1017: }
! 1018: free_packets = (struct packet *)0;
! 1019: }
! 1020: #endif
! 1021:
! 1022: int packet_allocate (ptr, file, line)
! 1023: struct packet **ptr;
! 1024: const char *file;
! 1025: int line;
! 1026: {
! 1027: struct packet *p;
! 1028:
! 1029: if (!ptr) {
! 1030: log_error ("%s(%d): null pointer", file, line);
! 1031: #if defined (POINTER_DEBUG)
! 1032: abort ();
! 1033: #else
! 1034: return 0;
! 1035: #endif
! 1036: }
! 1037: if (*ptr) {
! 1038: log_error ("%s(%d): non-null pointer", file, line);
! 1039: #if defined (POINTER_DEBUG)
! 1040: abort ();
! 1041: #else
! 1042: *ptr = (struct packet *)0;
! 1043: #endif
! 1044: }
! 1045:
! 1046: if (free_packets) {
! 1047: p = free_packets;
! 1048: free_packets = (struct packet *)(p -> raw);
! 1049: dmalloc_reuse (p, file, line, 1);
! 1050: } else {
! 1051: p = dmalloc (sizeof *p, file, line);
! 1052: }
! 1053: if (p) {
! 1054: memset (p, 0, sizeof *p);
! 1055: return packet_reference (ptr, p, file, line);
! 1056: }
! 1057: return 0;
! 1058: }
! 1059:
! 1060: int packet_reference (ptr, bp, file, line)
! 1061: struct packet **ptr;
! 1062: struct packet *bp;
! 1063: const char *file;
! 1064: int line;
! 1065: {
! 1066: if (!ptr) {
! 1067: log_error ("%s(%d): null pointer", file, line);
! 1068: #if defined (POINTER_DEBUG)
! 1069: abort ();
! 1070: #else
! 1071: return 0;
! 1072: #endif
! 1073: }
! 1074: if (*ptr) {
! 1075: log_error ("%s(%d): non-null pointer", file, line);
! 1076: #if defined (POINTER_DEBUG)
! 1077: abort ();
! 1078: #else
! 1079: *ptr = (struct packet *)0;
! 1080: #endif
! 1081: }
! 1082: *ptr = bp;
! 1083: bp -> refcnt++;
! 1084: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 1085: return 1;
! 1086: }
! 1087:
! 1088: int packet_dereference (ptr, file, line)
! 1089: struct packet **ptr;
! 1090: const char *file;
! 1091: int line;
! 1092: {
! 1093: int i;
! 1094: struct packet *packet;
! 1095:
! 1096: if (!ptr || !*ptr) {
! 1097: log_error ("%s(%d): null pointer", file, line);
! 1098: #if defined (POINTER_DEBUG)
! 1099: abort ();
! 1100: #else
! 1101: return 0;
! 1102: #endif
! 1103: }
! 1104:
! 1105: packet = *ptr;
! 1106: *ptr = (struct packet *)0;
! 1107: --packet -> refcnt;
! 1108: rc_register (file, line, ptr, packet, packet -> refcnt, 1, RC_MISC);
! 1109: if (packet -> refcnt > 0)
! 1110: return 1;
! 1111:
! 1112: if (packet -> refcnt < 0) {
! 1113: log_error ("%s(%d): negative refcnt!", file, line);
! 1114: #if defined (DEBUG_RC_HISTORY)
! 1115: dump_rc_history (packet);
! 1116: #endif
! 1117: #if defined (POINTER_DEBUG)
! 1118: abort ();
! 1119: #else
! 1120: return 0;
! 1121: #endif
! 1122: }
! 1123:
! 1124: if (packet -> options)
! 1125: option_state_dereference (&packet -> options, file, line);
! 1126: if (packet -> interface)
! 1127: interface_dereference (&packet -> interface, MDL);
! 1128: if (packet -> shared_network)
! 1129: shared_network_dereference (&packet -> shared_network, MDL);
! 1130: for (i = 0; i < packet -> class_count && i < PACKET_MAX_CLASSES; i++) {
! 1131: if (packet -> classes [i])
! 1132: omapi_object_dereference ((omapi_object_t **)
! 1133: &packet -> classes [i], MDL);
! 1134: }
! 1135: packet -> raw = (struct dhcp_packet *)free_packets;
! 1136: free_packets = packet;
! 1137: dmalloc_reuse (free_packets, __FILE__, __LINE__, 0);
! 1138: return 1;
! 1139: }
! 1140:
! 1141: int dns_zone_allocate (ptr, file, line)
! 1142: struct dns_zone **ptr;
! 1143: const char *file;
! 1144: int line;
! 1145: {
! 1146: struct dns_zone *d;
! 1147:
! 1148: if (!ptr) {
! 1149: log_error ("%s(%d): null pointer", file, line);
! 1150: #if defined (POINTER_DEBUG)
! 1151: abort ();
! 1152: #else
! 1153: return 0;
! 1154: #endif
! 1155: }
! 1156: if (*ptr) {
! 1157: log_error ("%s(%d): non-null pointer", file, line);
! 1158: #if defined (POINTER_DEBUG)
! 1159: abort ();
! 1160: #else
! 1161: *ptr = (struct dns_zone *)0;
! 1162: #endif
! 1163: }
! 1164:
! 1165: d = dmalloc (sizeof *d, file, line);
! 1166: if (d) {
! 1167: memset (d, 0, sizeof *d);
! 1168: return dns_zone_reference (ptr, d, file, line);
! 1169: }
! 1170: return 0;
! 1171: }
! 1172:
! 1173: int dns_zone_reference (ptr, bp, file, line)
! 1174: struct dns_zone **ptr;
! 1175: struct dns_zone *bp;
! 1176: const char *file;
! 1177: int line;
! 1178: {
! 1179: if (!ptr) {
! 1180: log_error ("%s(%d): null pointer", file, line);
! 1181: #if defined (POINTER_DEBUG)
! 1182: abort ();
! 1183: #else
! 1184: return 0;
! 1185: #endif
! 1186: }
! 1187: if (*ptr) {
! 1188: log_error ("%s(%d): non-null pointer", file, line);
! 1189: #if defined (POINTER_DEBUG)
! 1190: abort ();
! 1191: #else
! 1192: *ptr = (struct dns_zone *)0;
! 1193: #endif
! 1194: }
! 1195: *ptr = bp;
! 1196: bp -> refcnt++;
! 1197: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 1198: return 1;
! 1199: }
! 1200:
! 1201: int binding_scope_allocate (ptr, file, line)
! 1202: struct binding_scope **ptr;
! 1203: const char *file;
! 1204: int line;
! 1205: {
! 1206: struct binding_scope *bp;
! 1207:
! 1208: if (!ptr) {
! 1209: log_error ("%s(%d): null pointer", file, line);
! 1210: #if defined (POINTER_DEBUG)
! 1211: abort ();
! 1212: #else
! 1213: return 0;
! 1214: #endif
! 1215: }
! 1216:
! 1217: if (*ptr) {
! 1218: log_error ("%s(%d): non-null pointer", file, line);
! 1219: #if defined (POINTER_DEBUG)
! 1220: abort ();
! 1221: #else
! 1222: return 0;
! 1223: #endif
! 1224: }
! 1225:
! 1226: bp = dmalloc (sizeof *bp, file, line);
! 1227: if (!bp)
! 1228: return 0;
! 1229: memset (bp, 0, sizeof *bp);
! 1230: binding_scope_reference (ptr, bp, file, line);
! 1231: return 1;
! 1232: }
! 1233:
! 1234: int binding_scope_reference (ptr, bp, file, line)
! 1235: struct binding_scope **ptr;
! 1236: struct binding_scope *bp;
! 1237: const char *file;
! 1238: int line;
! 1239: {
! 1240: if (!ptr) {
! 1241: log_error ("%s(%d): null pointer", file, line);
! 1242: #if defined (POINTER_DEBUG)
! 1243: abort ();
! 1244: #else
! 1245: return 0;
! 1246: #endif
! 1247: }
! 1248: if (*ptr) {
! 1249: log_error ("%s(%d): non-null pointer", file, line);
! 1250: #if defined (POINTER_DEBUG)
! 1251: abort ();
! 1252: #else
! 1253: *ptr = (struct binding_scope *)0;
! 1254: #endif
! 1255: }
! 1256: *ptr = bp;
! 1257: bp -> refcnt++;
! 1258: rc_register (file, line, ptr, bp, bp -> refcnt, 0, RC_MISC);
! 1259: return 1;
! 1260: }
! 1261:
! 1262: /* Make a copy of the data in data_string, upping the buffer reference
! 1263: count if there's a buffer. */
! 1264:
! 1265: void
! 1266: data_string_copy(struct data_string *dest, const struct data_string *src,
! 1267: const char *file, int line)
! 1268: {
! 1269: if (src -> buffer) {
! 1270: buffer_reference (&dest -> buffer, src -> buffer, file, line);
! 1271: } else {
! 1272: dest->buffer = NULL;
! 1273: }
! 1274: dest -> data = src -> data;
! 1275: dest -> terminated = src -> terminated;
! 1276: dest -> len = src -> len;
! 1277: }
! 1278:
! 1279: /* Release the reference count to a data string's buffer (if any) and
! 1280: zero out the other information, yielding the null data string. */
! 1281:
! 1282: void data_string_forget (data, file, line)
! 1283: struct data_string *data;
! 1284: const char *file;
! 1285: int line;
! 1286: {
! 1287: if (data -> buffer)
! 1288: buffer_dereference (&data -> buffer, file, line);
! 1289: memset (data, 0, sizeof *data);
! 1290: }
! 1291:
! 1292: /* If the data_string is larger than the specified length, reduce
! 1293: the data_string to the specified size. */
! 1294:
! 1295: void data_string_truncate (dp, len)
! 1296: struct data_string *dp;
! 1297: int len;
! 1298: {
! 1299: /* XXX: do we need to consider the "terminated" flag in the check? */
! 1300: if (len < dp -> len) {
! 1301: dp -> terminated = 0;
! 1302: dp -> len = len;
! 1303: }
! 1304: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to alloc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / common