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