1: /* alloc.c
2:
3: Functions supporting memory allocation for the object management
4: protocol... */
5:
6: /*
7: * Copyright (c) 2009-2010 by Internet Systems Consortium, Inc. ("ISC")
8: * Copyright (c) 2004-2007 by Internet Systems Consortium, Inc. ("ISC")
9: * Copyright (c) 1999-2003 by Internet Software Consortium
10: *
11: * Permission to use, copy, modify, and distribute this software for any
12: * purpose with or without fee is hereby granted, provided that the above
13: * copyright notice and this permission notice appear in all copies.
14: *
15: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
16: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
18: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
21: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22: *
23: * Internet Systems Consortium, Inc.
24: * 950 Charter Street
25: * Redwood City, CA 94063
26: * <info@isc.org>
27: * https://www.isc.org/
28: *
29: * This software has been written for Internet Systems Consortium
30: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
31: * To learn more about Internet Systems Consortium, see
32: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
33: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
34: * ``http://www.nominum.com''.
35: */
36:
37: #include "dhcpd.h"
38:
39: #include <omapip/omapip_p.h>
40:
41: #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
42: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
43: struct dmalloc_preamble *dmalloc_list;
44: unsigned long dmalloc_outstanding;
45: unsigned long dmalloc_longterm;
46: unsigned long dmalloc_generation;
47: unsigned long dmalloc_cutoff_generation;
48: #endif
49:
50: #if defined (DEBUG_RC_HISTORY)
51: struct rc_history_entry rc_history [RC_HISTORY_MAX];
52: int rc_history_index;
53: int rc_history_count;
54: #endif
55:
56: #if defined (DEBUG_RC_HISTORY)
57: static void print_rc_hist_entry (int);
58: #endif
59:
60: void *
61: dmalloc(unsigned size, const char *file, int line) {
62: unsigned char *foo;
63: unsigned len;
64: void **bar;
65: #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
66: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
67: int i;
68: struct dmalloc_preamble *dp;
69: #endif
70:
71: len = size + DMDSIZE;
72: if (len < size)
73: return NULL;
74:
75: foo = malloc(len);
76:
77: if (!foo)
78: return NULL;
79: bar = (void *)(foo + DMDOFFSET);
80: memset (bar, 0, size);
81:
82: #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
83: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
84: dp = (struct dmalloc_preamble *)foo;
85: dp -> prev = dmalloc_list;
86: if (dmalloc_list)
87: dmalloc_list -> next = dp;
88: dmalloc_list = dp;
89: dp -> next = (struct dmalloc_preamble *)0;
90: dp -> size = size;
91: dp -> file = file;
92: dp -> line = line;
93: dp -> generation = dmalloc_generation++;
94: dmalloc_outstanding += size;
95: for (i = 0; i < DMLFSIZE; i++)
96: dp -> low_fence [i] =
97: (((unsigned long)
98: (&dp -> low_fence [i])) % 143) + 113;
99: for (i = DMDOFFSET; i < DMDSIZE; i++)
100: foo [i + size] =
101: (((unsigned long)
102: (&foo [i + size])) % 143) + 113;
103: #if defined (DEBUG_MALLOC_POOL_EXHAUSTIVELY)
104: /* Check _every_ entry in the pool! Very expensive. */
105: for (dp = dmalloc_list; dp; dp = dp -> prev) {
106: for (i = 0; i < DMLFSIZE; i++) {
107: if (dp -> low_fence [i] !=
108: (((unsigned long)
109: (&dp -> low_fence [i])) % 143) + 113)
110: {
111: log_error ("malloc fence modified: %s(%d)",
112: dp -> file, dp -> line);
113: abort ();
114: }
115: }
116: foo = (unsigned char *)dp;
117: for (i = DMDOFFSET; i < DMDSIZE; i++) {
118: if (foo [i + dp -> size] !=
119: (((unsigned long)
120: (&foo [i + dp -> size])) % 143) + 113) {
121: log_error ("malloc fence modified: %s(%d)",
122: dp -> file, dp -> line);
123: abort ();
124: }
125: }
126: }
127: #endif
128: #endif
129: #ifdef DEBUG_REFCNT_DMALLOC_FREE
130: rc_register (file, line, 0, foo + DMDOFFSET, 1, 0, RC_MALLOC);
131: #endif
132: return bar;
133: }
134:
135: void
136: dfree(void *ptr, const char *file, int line) {
137: if (!ptr) {
138: log_error ("dfree %s(%d): free on null pointer.", file, line);
139: return;
140: }
141: #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
142: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
143: {
144: unsigned char *bar = ptr;
145: struct dmalloc_preamble *dp, *cur;
146: int i;
147: bar -= DMDOFFSET;
148: cur = (struct dmalloc_preamble *)bar;
149: for (dp = dmalloc_list; dp; dp = dp -> prev)
150: if (dp == cur)
151: break;
152: if (!dp) {
153: log_error ("%s(%d): freeing unknown memory: %lx",
154: file, line, (unsigned long)cur);
155: abort ();
156: }
157: if (dp -> prev)
158: dp -> prev -> next = dp -> next;
159: if (dp -> next)
160: dp -> next -> prev = dp -> prev;
161: if (dp == dmalloc_list)
162: dmalloc_list = dp -> prev;
163: if (dp -> generation >= dmalloc_cutoff_generation)
164: dmalloc_outstanding -= dp -> size;
165: else
166: dmalloc_longterm -= dp -> size;
167:
168: for (i = 0; i < DMLFSIZE; i++) {
169: if (dp -> low_fence [i] !=
170: (((unsigned long)
171: (&dp -> low_fence [i])) % 143) + 113)
172: {
173: log_error ("malloc fence modified: %s(%d)",
174: dp -> file, dp -> line);
175: abort ();
176: }
177: }
178: for (i = DMDOFFSET; i < DMDSIZE; i++) {
179: if (bar [i + dp -> size] !=
180: (((unsigned long)
181: (&bar [i + dp -> size])) % 143) + 113) {
182: log_error ("malloc fence modified: %s(%d)",
183: dp -> file, dp -> line);
184: abort ();
185: }
186: }
187: ptr = bar;
188: }
189: #endif
190: #ifdef DEBUG_REFCNT_DMALLOC_FREE
191: rc_register (file, line,
192: 0, (unsigned char *)ptr + DMDOFFSET, 0, 1, RC_MALLOC);
193: #endif
194: free (ptr);
195: }
196:
197: #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
198: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
199: /* For allocation functions that keep their own free lists, we want to
200: account for the reuse of the memory. */
201:
202: void
203: dmalloc_reuse(void *foo, const char *file, int line, int justref) {
204: struct dmalloc_preamble *dp;
205:
206: /* Get the pointer to the dmalloc header. */
207: dp = foo;
208: dp--;
209:
210: /* If we just allocated this and are now referencing it, this
211: function would almost be a no-op, except that it would
212: increment the generation count needlessly. So just return
213: in this case. */
214: if (dp -> generation == dmalloc_generation)
215: return;
216:
217: /* If this is longterm data, and we just made reference to it,
218: don't put it on the short-term list or change its name -
219: we don't need to know about this. */
220: if (dp -> generation < dmalloc_cutoff_generation && justref)
221: return;
222:
223: /* Take it out of the place in the allocated list where it was. */
224: if (dp -> prev)
225: dp -> prev -> next = dp -> next;
226: if (dp -> next)
227: dp -> next -> prev = dp -> prev;
228: if (dp == dmalloc_list)
229: dmalloc_list = dp -> prev;
230:
231: /* Account for its removal. */
232: if (dp -> generation >= dmalloc_cutoff_generation)
233: dmalloc_outstanding -= dp -> size;
234: else
235: dmalloc_longterm -= dp -> size;
236:
237: /* Now put it at the head of the list. */
238: dp -> prev = dmalloc_list;
239: if (dmalloc_list)
240: dmalloc_list -> next = dp;
241: dmalloc_list = dp;
242: dp -> next = (struct dmalloc_preamble *)0;
243:
244: /* Change the reference location information. */
245: dp -> file = file;
246: dp -> line = line;
247:
248: /* Increment the generation. */
249: dp -> generation = dmalloc_generation++;
250:
251: /* Account for it. */
252: dmalloc_outstanding += dp -> size;
253: }
254:
255: void dmalloc_dump_outstanding ()
256: {
257: static unsigned long dmalloc_cutoff_point;
258: struct dmalloc_preamble *dp;
259: #if defined(DEBUG_MALLOC_POOL)
260: unsigned char *foo;
261: int i;
262: #endif
263:
264: if (!dmalloc_cutoff_point)
265: dmalloc_cutoff_point = dmalloc_cutoff_generation;
266: for (dp = dmalloc_list; dp; dp = dp -> prev) {
267: if (dp -> generation <= dmalloc_cutoff_point)
268: break;
269: #if defined (DEBUG_MALLOC_POOL)
270: for (i = 0; i < DMLFSIZE; i++) {
271: if (dp -> low_fence [i] !=
272: (((unsigned long)
273: (&dp -> low_fence [i])) % 143) + 113)
274: {
275: log_error ("malloc fence modified: %s(%d)",
276: dp -> file, dp -> line);
277: abort ();
278: }
279: }
280: foo = (unsigned char *)dp;
281: for (i = DMDOFFSET; i < DMDSIZE; i++) {
282: if (foo [i + dp -> size] !=
283: (((unsigned long)
284: (&foo [i + dp -> size])) % 143) + 113) {
285: log_error ("malloc fence modified: %s(%d)",
286: dp -> file, dp -> line);
287: abort ();
288: }
289: }
290: #endif
291: #if defined (DEBUG_MEMORY_LEAKAGE) || \
292: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
293: /* Don't count data that's actually on a free list
294: somewhere. */
295: if (dp -> file) {
296: #if defined (DEBUG_RC_HISTORY)
297: int i, count, inhistory = 0, noted = 0;
298:
299: /* If we have the info, see if this is actually
300: new garbage. */
301: if (rc_history_count < RC_HISTORY_MAX) {
302: count = rc_history_count;
303: } else
304: count = RC_HISTORY_MAX;
305: i = rc_history_index - 1;
306: if (i < 0)
307: i += RC_HISTORY_MAX;
308:
309: do {
310: if (rc_history [i].addr == dp + 1) {
311: inhistory = 1;
312: if (!noted) {
313: log_info (" %s(%d): %ld", dp -> file,
314: dp -> line, dp -> size);
315: noted = 1;
316: }
317: print_rc_hist_entry (i);
318: if (!rc_history [i].refcnt)
319: break;
320: }
321: if (--i < 0)
322: i = RC_HISTORY_MAX - 1;
323: } while (count--);
324: if (!inhistory)
325: #endif
326: log_info (" %s(%d): %ld",
327: dp -> file, dp -> line, dp -> size);
328: }
329: #endif
330: }
331: if (dmalloc_list)
332: dmalloc_cutoff_point = dmalloc_list -> generation;
333: }
334: #endif /* DEBUG_MEMORY_LEAKAGE || DEBUG_MALLOC_POOL */
335:
336: #if defined (DEBUG_RC_HISTORY)
337: static void print_rc_hist_entry (int i)
338: {
339: log_info (" referenced by %s(%d)[%lx]: addr = %lx refcnt = %x",
340: rc_history [i].file, rc_history [i].line,
341: (unsigned long)rc_history [i].reference,
342: (unsigned long)rc_history [i].addr,
343: rc_history [i].refcnt);
344: }
345:
346: void dump_rc_history (void *addr)
347: {
348: int i;
349:
350: i = rc_history_index;
351: if (!rc_history [i].file)
352: i = 0;
353: else if (rc_history_count < RC_HISTORY_MAX) {
354: i -= rc_history_count;
355: if (i < 0)
356: i += RC_HISTORY_MAX;
357: }
358: rc_history_count = 0;
359:
360: while (rc_history [i].file) {
361: if (!addr || addr == rc_history [i].addr)
362: print_rc_hist_entry (i);
363: ++i;
364: if (i == RC_HISTORY_MAX)
365: i = 0;
366: if (i == rc_history_index)
367: break;
368: }
369: }
370: void rc_history_next (int d)
371: {
372: #if defined (RC_HISTORY_COMPRESSION)
373: int i, j = 0, m, n = 0;
374: void *ap, *rp;
375:
376: /* If we are decreasing the reference count, try to find the
377: entry where the reference was made and eliminate it; then
378: we can also eliminate this reference. */
379: if (d) {
380: m = rc_history_index - 1000;
381: if (m < -1)
382: m = -1;
383: ap = rc_history [rc_history_index].addr;
384: rp = rc_history [rc_history_index].reference;
385: for (i = rc_history_index - 1; i > m; i--) {
386: if (rc_history [i].addr == ap) {
387: if (rc_history [i].reference == rp) {
388: if (n > 10) {
389: for (n = i; n <= rc_history_index; n++)
390: print_rc_hist_entry (n);
391: n = 11;
392: }
393: memmove (&rc_history [i],
394: &rc_history [i + 1],
395: (unsigned)((rc_history_index - i) *
396: sizeof (struct rc_history_entry)));
397: --rc_history_count;
398: --rc_history_index;
399: for (j = i; j < rc_history_count; j++) {
400: if (rc_history [j].addr == ap)
401: --rc_history [j].refcnt;
402: }
403: if (n > 10) {
404: for (n = i; n <= rc_history_index; n++)
405: print_rc_hist_entry (n);
406: n = 11;
407: exit (0);
408: }
409: return;
410: }
411: }
412: }
413: }
414: #endif
415: if (++rc_history_index == RC_HISTORY_MAX)
416: rc_history_index = 0;
417: ++rc_history_count;
418: }
419: #endif /* DEBUG_RC_HISTORY */
420:
421: #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
422: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
423: struct caller {
424: struct dmalloc_preamble *dp;
425: int count;
426: };
427:
428: static int dmalloc_find_entry (struct dmalloc_preamble *dp,
429: struct caller *array,
430: int min, int max)
431: {
432: int middle;
433:
434: middle = (min + max) / 2;
435: if (middle == min)
436: return middle;
437: if (array [middle].dp -> file == dp -> file) {
438: if (array [middle].dp -> line == dp -> line)
439: return middle;
440: else if (array [middle].dp -> line < dp -> line)
441: return dmalloc_find_entry (dp, array, middle, max);
442: else
443: return dmalloc_find_entry (dp, array, 0, middle);
444: } else if (array [middle].dp -> file < dp -> file)
445: return dmalloc_find_entry (dp, array, middle, max);
446: else
447: return dmalloc_find_entry (dp, array, 0, middle);
448: }
449:
450: void omapi_print_dmalloc_usage_by_caller ()
451: {
452: struct dmalloc_preamble *dp;
453: int ccur, cmax, i;
454: struct caller cp [1024];
455:
456: cmax = 1024;
457: ccur = 0;
458:
459: memset (cp, 0, sizeof cp);
460: for (dp = dmalloc_list; dp; dp = dp -> prev) {
461: i = dmalloc_find_entry (dp, cp, 0, ccur);
462: if ((i == ccur ||
463: cp [i].dp -> file != dp -> file ||
464: cp [i].dp -> line != dp -> line) &&
465: ccur == cmax) {
466: log_error ("no space for memory usage summary.");
467: return;
468: }
469: if (i == ccur) {
470: cp [ccur++].dp = dp;
471: cp [i].count = 1;
472: } else if (cp [i].dp -> file < dp -> file ||
473: (cp [i].dp -> file == dp -> file &&
474: cp [i].dp -> line < dp -> line)) {
475: if (i + 1 != ccur)
476: memmove (cp + i + 2, cp + i + 1,
477: (ccur - i) * sizeof *cp);
478: cp [i + 1].dp = dp;
479: cp [i + 1].count = 1;
480: ccur++;
481: } else if (cp [i].dp -> file != dp -> file ||
482: cp [i].dp -> line != dp -> line) {
483: memmove (cp + i + 1,
484: cp + i, (ccur - i) * sizeof *cp);
485: cp [i].dp = dp;
486: cp [i].count = 1;
487: ccur++;
488: } else
489: cp [i].count++;
490: #if 0
491: printf ("%d\t%s:%d\n", i, dp -> file, dp -> line);
492: dump_rc_history (dp + 1);
493: #endif
494: }
495: for (i = 0; i < ccur; i++) {
496: printf ("%d\t%s:%d\t%d\n", i,
497: cp [i].dp -> file, cp [i].dp -> line, cp [i].count);
498: #if defined(DUMP_RC_HISTORY)
499: dump_rc_history (cp [i].dp + 1);
500: #endif
501: }
502: }
503: #endif /* DEBUG_MEMORY_LEAKAGE || DEBUG_MALLOC_POOL */
504:
505: isc_result_t omapi_object_allocate (omapi_object_t **o,
506: omapi_object_type_t *type,
507: size_t size,
508: const char *file, int line)
509: {
510: size_t tsize;
511: omapi_object_t *foo;
512: isc_result_t status;
513:
514: if (type -> allocator) {
515: foo = (omapi_object_t *)0;
516: status = (*type -> allocator) (&foo, file, line);
517: tsize = type -> size;
518: } else {
519: status = ISC_R_NOMEMORY;
520: tsize = 0;
521: }
522:
523: if (status == ISC_R_NOMEMORY) {
524: if (type -> sizer)
525: tsize = (*type -> sizer) (size);
526: else
527: tsize = type -> size;
528:
529: /* Sanity check. */
530: if (tsize < sizeof (omapi_object_t))
531: return ISC_R_INVALIDARG;
532:
533: foo = dmalloc (tsize, file, line);
534: if (!foo)
535: return ISC_R_NOMEMORY;
536: }
537:
538: status = omapi_object_initialize (foo, type, size, tsize, file, line);
539: if (status != ISC_R_SUCCESS) {
540: if (type -> freer)
541: (*type -> freer) (foo, file, line);
542: else
543: dfree (foo, file, line);
544: return status;
545: }
546: return omapi_object_reference (o, foo, file, line);
547: }
548:
549: isc_result_t omapi_object_initialize (omapi_object_t *o,
550: omapi_object_type_t *type,
551: size_t usize, size_t psize,
552: const char *file, int line)
553: {
554: memset (o, 0, psize);
555: o -> type = type;
556: if (type -> initialize)
557: (*type -> initialize) (o, file, line);
558: return ISC_R_SUCCESS;
559: }
560:
561: isc_result_t omapi_object_reference (omapi_object_t **r,
562: omapi_object_t *h,
563: const char *file, int line)
564: {
565: if (!h || !r)
566: return ISC_R_INVALIDARG;
567:
568: if (*r) {
569: #if defined (POINTER_DEBUG)
570: log_error ("%s(%d): reference store into non-null pointer!",
571: file, line);
572: abort ();
573: #else
574: return ISC_R_INVALIDARG;
575: #endif
576: }
577: *r = h;
578: h -> refcnt++;
579: rc_register (file, line, r, h, h -> refcnt, 0, h -> type -> rc_flag);
580: return ISC_R_SUCCESS;
581: }
582:
583: isc_result_t omapi_object_dereference (omapi_object_t **h,
584: const char *file, int line)
585: {
586: int outer_reference = 0;
587: int inner_reference = 0;
588: int handle_reference = 0;
589: int extra_references;
590: omapi_object_t *p, *hp;
591:
592: if (!h)
593: return ISC_R_INVALIDARG;
594:
595: if (!*h) {
596: #if defined (POINTER_DEBUG)
597: log_error ("%s(%d): dereference of null pointer!", file, line);
598: abort ();
599: #else
600: return ISC_R_INVALIDARG;
601: #endif
602: }
603:
604: if ((*h) -> refcnt <= 0) {
605: #if defined (POINTER_DEBUG)
606: log_error ("%s(%d): dereference of pointer with refcnt of zero!",
607: file, line);
608: #if defined (DEBUG_RC_HISTORY)
609: dump_rc_history (*h);
610: #endif
611: abort ();
612: #else
613: *h = 0;
614: return ISC_R_INVALIDARG;
615: #endif
616: }
617:
618: /* See if this object's inner object refers to it, but don't
619: count this as a reference if we're being asked to free the
620: reference from the inner object. */
621: if ((*h) -> inner && (*h) -> inner -> outer &&
622: h != &((*h) -> inner -> outer))
623: inner_reference = 1;
624:
625: /* Ditto for the outer object. */
626: if ((*h) -> outer && (*h) -> outer -> inner &&
627: h != &((*h) -> outer -> inner))
628: outer_reference = 1;
629:
630: /* Ditto for the outer object. The code below assumes that
631: the only reason we'd get a dereference from the handle
632: table is if this function does it - otherwise we'd have to
633: traverse the handle table to find the address where the
634: reference is stored and compare against that, and we don't
635: want to do that if we can avoid it. */
636: if ((*h) -> handle)
637: handle_reference = 1;
638:
639: /* If we are getting rid of the last reference other than
640: references to inner and outer objects, or from the handle
641: table, then we must examine all the objects in either
642: direction to see if they hold any non-inner, non-outer,
643: non-handle-table references. If not, we need to free the
644: entire chain of objects. */
645: if ((*h) -> refcnt ==
646: inner_reference + outer_reference + handle_reference + 1) {
647: if (inner_reference || outer_reference || handle_reference) {
648: /* XXX we could check for a reference from the
649: handle table here. */
650: extra_references = 0;
651: for (p = (*h) -> inner;
652: p && !extra_references; p = p -> inner) {
653: extra_references += p -> refcnt;
654: if (p -> inner && p -> inner -> outer == p)
655: --extra_references;
656: if (p -> outer)
657: --extra_references;
658: if (p -> handle)
659: --extra_references;
660: }
661: for (p = (*h) -> outer;
662: p && !extra_references; p = p -> outer) {
663: extra_references += p -> refcnt;
664: if (p -> outer && p -> outer -> inner == p)
665: --extra_references;
666: if (p -> inner)
667: --extra_references;
668: if (p -> handle)
669: --extra_references;
670: }
671: } else
672: extra_references = 0;
673:
674: if (!extra_references) {
675: hp = *h;
676: *h = 0;
677: hp -> refcnt--;
678: if (inner_reference)
679: omapi_object_dereference
680: (&hp -> inner, file, line);
681: if (outer_reference)
682: omapi_object_dereference
683: (&hp -> outer, file, line);
684: /* if (!hp -> type -> freer) */
685: rc_register (file, line, h, hp,
686: 0, 1, hp -> type -> rc_flag);
687: if (handle_reference) {
688: if (omapi_handle_clear(hp->handle) !=
689: ISC_R_SUCCESS) {
690: log_debug("Attempt to clear null "
691: "handle pointer");
692: }
693: }
694: if (hp -> type -> destroy)
695: (*(hp -> type -> destroy)) (hp, file, line);
696: if (hp -> type -> freer)
697: (hp -> type -> freer (hp, file, line));
698: else
699: dfree (hp, file, line);
700: } else {
701: (*h) -> refcnt--;
702: /* if (!(*h) -> type -> freer) */
703: rc_register (file, line,
704: h, *h, (*h) -> refcnt, 1,
705: (*h) -> type -> rc_flag);
706: }
707: } else {
708: (*h) -> refcnt--;
709: /* if (!(*h) -> type -> freer) */
710: rc_register (file, line, h, *h, (*h) -> refcnt, 1,
711: (*h) -> type -> rc_flag);
712: }
713: *h = 0;
714: return ISC_R_SUCCESS;
715: }
716:
717: isc_result_t omapi_buffer_new (omapi_buffer_t **h,
718: const char *file, int line)
719: {
720: omapi_buffer_t *t;
721: isc_result_t status;
722:
723: t = (omapi_buffer_t *)dmalloc (sizeof *t, file, line);
724: if (!t)
725: return ISC_R_NOMEMORY;
726: memset (t, 0, sizeof *t);
727: status = omapi_buffer_reference (h, t, file, line);
728: if (status != ISC_R_SUCCESS)
729: dfree (t, file, line);
730: (*h) -> head = sizeof ((*h) -> buf) - 1;
731: return status;
732: }
733:
734: isc_result_t omapi_buffer_reference (omapi_buffer_t **r,
735: omapi_buffer_t *h,
736: const char *file, int line)
737: {
738: if (!h || !r)
739: return ISC_R_INVALIDARG;
740:
741: if (*r) {
742: #if defined (POINTER_DEBUG)
743: log_error ("%s(%d): reference store into non-null pointer!",
744: file, line);
745: abort ();
746: #else
747: return ISC_R_INVALIDARG;
748: #endif
749: }
750: *r = h;
751: h -> refcnt++;
752: rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
753: return ISC_R_SUCCESS;
754: }
755:
756: isc_result_t omapi_buffer_dereference (omapi_buffer_t **h,
757: const char *file, int line)
758: {
759: if (!h)
760: return ISC_R_INVALIDARG;
761:
762: if (!*h) {
763: #if defined (POINTER_DEBUG)
764: log_error ("%s(%d): dereference of null pointer!", file, line);
765: abort ();
766: #else
767: return ISC_R_INVALIDARG;
768: #endif
769: }
770:
771: if ((*h) -> refcnt <= 0) {
772: #if defined (POINTER_DEBUG)
773: log_error ("%s(%d): dereference of pointer with refcnt of zero!",
774: file, line);
775: #if defined (DEBUG_RC_HISTORY)
776: dump_rc_history (*h);
777: #endif
778: abort ();
779: #else
780: *h = 0;
781: return ISC_R_INVALIDARG;
782: #endif
783: }
784:
785: --(*h) -> refcnt;
786: rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
787: if ((*h) -> refcnt == 0)
788: dfree (*h, file, line);
789: *h = 0;
790: return ISC_R_SUCCESS;
791: }
792:
793: isc_result_t omapi_typed_data_new (const char *file, int line,
794: omapi_typed_data_t **t,
795: omapi_datatype_t type, ...)
796: {
797: va_list l;
798: omapi_typed_data_t *new;
799: unsigned len;
800: unsigned val = 0;
801: int intval = 0;
802: char *s = NULL;
803: isc_result_t status;
804: omapi_object_t *obj = NULL;
805:
806: va_start (l, type);
807:
808: switch (type) {
809: case omapi_datatype_int:
810: len = OMAPI_TYPED_DATA_INT_LEN;
811: intval = va_arg (l, int);
812: break;
813: case omapi_datatype_string:
814: s = va_arg (l, char *);
815: val = strlen (s);
816: len = OMAPI_TYPED_DATA_NOBUFFER_LEN + val;
817: if (len < val) {
818: va_end(l);
819: return ISC_R_INVALIDARG;
820: }
821: break;
822: case omapi_datatype_data:
823: val = va_arg (l, unsigned);
824: len = OMAPI_TYPED_DATA_NOBUFFER_LEN + val;
825: if (len < val) {
826: va_end(l);
827: return ISC_R_INVALIDARG;
828: }
829: break;
830: case omapi_datatype_object:
831: len = OMAPI_TYPED_DATA_OBJECT_LEN;
832: obj = va_arg (l, omapi_object_t *);
833: break;
834: default:
835: va_end (l);
836: return ISC_R_INVALIDARG;
837: }
838: va_end (l);
839:
840: new = dmalloc (len, file, line);
841: if (!new)
842: return ISC_R_NOMEMORY;
843: memset (new, 0, len);
844:
845: switch (type) {
846: case omapi_datatype_int:
847: new -> u.integer = intval;
848: break;
849: case omapi_datatype_string:
850: memcpy (new -> u.buffer.value, s, val);
851: new -> u.buffer.len = val;
852: break;
853: case omapi_datatype_data:
854: new -> u.buffer.len = val;
855: break;
856: case omapi_datatype_object:
857: status = omapi_object_reference (&new -> u.object, obj,
858: file, line);
859: if (status != ISC_R_SUCCESS) {
860: dfree (new, file, line);
861: return status;
862: }
863: break;
864: }
865: new -> type = type;
866:
867: return omapi_typed_data_reference (t, new, file, line);
868: }
869:
870: isc_result_t omapi_typed_data_reference (omapi_typed_data_t **r,
871: omapi_typed_data_t *h,
872: const char *file, int line)
873: {
874: if (!h || !r)
875: return ISC_R_INVALIDARG;
876:
877: if (*r) {
878: #if defined (POINTER_DEBUG)
879: log_error ("%s(%d): reference store into non-null pointer!", file, line);
880: abort ();
881: #else
882: return ISC_R_INVALIDARG;
883: #endif
884: }
885: *r = h;
886: h -> refcnt++;
887: rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
888: return ISC_R_SUCCESS;
889: }
890:
891: isc_result_t omapi_typed_data_dereference (omapi_typed_data_t **h,
892: const char *file, int line)
893: {
894: if (!h)
895: return ISC_R_INVALIDARG;
896:
897: if (!*h) {
898: #if defined (POINTER_DEBUG)
899: log_error ("%s(%d): dereference of null pointer!", file, line);
900: abort ();
901: #else
902: return ISC_R_INVALIDARG;
903: #endif
904: }
905:
906: if ((*h) -> refcnt <= 0) {
907: #if defined (POINTER_DEBUG)
908: log_error ("%s(%d): dereference of pointer with refcnt of zero!",
909: file, line);
910: #if defined (DEBUG_RC_HISTORY)
911: dump_rc_history (*h);
912: #endif
913: abort ();
914: #else
915: *h = 0;
916: return ISC_R_INVALIDARG;
917: #endif
918: }
919:
920: --((*h) -> refcnt);
921: rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
922: if ((*h) -> refcnt <= 0 ) {
923: switch ((*h) -> type) {
924: case omapi_datatype_int:
925: case omapi_datatype_string:
926: case omapi_datatype_data:
927: default:
928: break;
929: case omapi_datatype_object:
930: omapi_object_dereference (&(*h) -> u.object,
931: file, line);
932: break;
933: }
934: dfree (*h, file, line);
935: }
936: *h = 0;
937: return ISC_R_SUCCESS;
938: }
939:
940: isc_result_t omapi_data_string_new (omapi_data_string_t **d, unsigned len,
941: const char *file, int line)
942: {
943: omapi_data_string_t *new;
944: unsigned nlen;
945:
946: nlen = OMAPI_DATA_STRING_EMPTY_SIZE + len;
947: if (nlen < len)
948: return ISC_R_INVALIDARG;
949: new = dmalloc (nlen, file, line);
950: if (!new)
951: return ISC_R_NOMEMORY;
952: memset (new, 0, OMAPI_DATA_STRING_EMPTY_SIZE);
953: new -> len = len;
954: return omapi_data_string_reference (d, new, file, line);
955: }
956:
957: isc_result_t omapi_data_string_reference (omapi_data_string_t **r,
958: omapi_data_string_t *h,
959: const char *file, int line)
960: {
961: if (!h || !r)
962: return ISC_R_INVALIDARG;
963:
964: if (*r) {
965: #if defined (POINTER_DEBUG)
966: log_error ("%s(%d): reference store into non-null pointer!", file, line);
967: abort ();
968: #else
969: return ISC_R_INVALIDARG;
970: #endif
971: }
972: *r = h;
973: h -> refcnt++;
974: rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
975: return ISC_R_SUCCESS;
976: }
977:
978: isc_result_t omapi_data_string_dereference (omapi_data_string_t **h,
979: const char *file, int line)
980: {
981: if (!h)
982: return ISC_R_INVALIDARG;
983:
984: if (!*h) {
985: #if defined (POINTER_DEBUG)
986: log_error ("%s(%d): dereference of null pointer!", file, line);
987: abort ();
988: #else
989: return ISC_R_INVALIDARG;
990: #endif
991: }
992:
993: if ((*h) -> refcnt <= 0) {
994: #if defined (POINTER_DEBUG)
995: log_error ("%s(%d): dereference of pointer with refcnt of zero!",
996: file, line);
997: #if defined (DEBUG_RC_HISTORY)
998: dump_rc_history (*h);
999: #endif
1000: abort ();
1001: #else
1002: *h = 0;
1003: return ISC_R_INVALIDARG;
1004: #endif
1005: }
1006:
1007: --((*h) -> refcnt);
1008: rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
1009: if ((*h) -> refcnt <= 0 ) {
1010: dfree (*h, file, line);
1011: }
1012: *h = 0;
1013: return ISC_R_SUCCESS;
1014: }
1015:
1016: isc_result_t omapi_value_new (omapi_value_t **d,
1017: const char *file, int line)
1018: {
1019: omapi_value_t *new;
1020:
1021: new = dmalloc (sizeof *new, file, line);
1022: if (!new)
1023: return ISC_R_NOMEMORY;
1024: memset (new, 0, sizeof *new);
1025: return omapi_value_reference (d, new, file, line);
1026: }
1027:
1028: isc_result_t omapi_value_reference (omapi_value_t **r,
1029: omapi_value_t *h,
1030: const char *file, int line)
1031: {
1032: if (!h || !r)
1033: return ISC_R_INVALIDARG;
1034:
1035: if (*r) {
1036: #if defined (POINTER_DEBUG)
1037: log_error ("%s(%d): reference store into non-null pointer!",
1038: file, line);
1039: abort ();
1040: #else
1041: return ISC_R_INVALIDARG;
1042: #endif
1043: }
1044: *r = h;
1045: h -> refcnt++;
1046: rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
1047: return ISC_R_SUCCESS;
1048: }
1049:
1050: isc_result_t omapi_value_dereference (omapi_value_t **h,
1051: const char *file, int line)
1052: {
1053: if (!h)
1054: return ISC_R_INVALIDARG;
1055:
1056: if (!*h) {
1057: #if defined (POINTER_DEBUG)
1058: log_error ("%s(%d): dereference of null pointer!", file, line);
1059: abort ();
1060: #else
1061: return ISC_R_INVALIDARG;
1062: #endif
1063: }
1064:
1065: if ((*h) -> refcnt <= 0) {
1066: #if defined (POINTER_DEBUG)
1067: log_error ("%s(%d): dereference of pointer with refcnt of zero!",
1068: file, line);
1069: #if defined (DEBUG_RC_HISTORY)
1070: dump_rc_history (*h);
1071: #endif
1072: abort ();
1073: #else
1074: *h = 0;
1075: return ISC_R_INVALIDARG;
1076: #endif
1077: }
1078:
1079: --((*h) -> refcnt);
1080: rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
1081: if ((*h) -> refcnt == 0) {
1082: if ((*h) -> name)
1083: omapi_data_string_dereference (&(*h) -> name,
1084: file, line);
1085: if ((*h) -> value)
1086: omapi_typed_data_dereference (&(*h) -> value,
1087: file, line);
1088: dfree (*h, file, line);
1089: }
1090: *h = 0;
1091: return ISC_R_SUCCESS;
1092: }
1093:
1094: isc_result_t omapi_addr_list_new (omapi_addr_list_t **d, unsigned count,
1095: const char *file, int line)
1096: {
1097: omapi_addr_list_t *new;
1098:
1099: new = dmalloc ((count * sizeof (omapi_addr_t)) +
1100: sizeof (omapi_addr_list_t), file, line);
1101: if (!new)
1102: return ISC_R_NOMEMORY;
1103: memset (new, 0, ((count * sizeof (omapi_addr_t)) +
1104: sizeof (omapi_addr_list_t)));
1105: new -> count = count;
1106: new -> addresses = (omapi_addr_t *)(new + 1);
1107: return omapi_addr_list_reference (d, new, file, line);
1108: }
1109:
1110: isc_result_t omapi_addr_list_reference (omapi_addr_list_t **r,
1111: omapi_addr_list_t *h,
1112: const char *file, int line)
1113: {
1114: if (!h || !r)
1115: return ISC_R_INVALIDARG;
1116:
1117: if (*r) {
1118: #if defined (POINTER_DEBUG)
1119: log_error ("%s(%d): reference store into non-null pointer!",
1120: file, line);
1121: abort ();
1122: #else
1123: return ISC_R_INVALIDARG;
1124: #endif
1125: }
1126: *r = h;
1127: h -> refcnt++;
1128: rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
1129: return ISC_R_SUCCESS;
1130: }
1131:
1132: isc_result_t omapi_addr_list_dereference (omapi_addr_list_t **h,
1133: const char *file, int line)
1134: {
1135: if (!h)
1136: return ISC_R_INVALIDARG;
1137:
1138: if (!*h) {
1139: #if defined (POINTER_DEBUG)
1140: log_error ("%s(%d): dereference of null pointer!", file, line);
1141: abort ();
1142: #else
1143: return ISC_R_INVALIDARG;
1144: #endif
1145: }
1146:
1147: if ((*h) -> refcnt <= 0) {
1148: #if defined (POINTER_DEBUG)
1149: log_error ("%s(%d): dereference of pointer with zero refcnt!",
1150: file, line);
1151: #if defined (DEBUG_RC_HISTORY)
1152: dump_rc_history (*h);
1153: #endif
1154: abort ();
1155: #else
1156: *h = 0;
1157: return ISC_R_INVALIDARG;
1158: #endif
1159: }
1160:
1161: --((*h) -> refcnt);
1162: rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
1163: if ((*h) -> refcnt <= 0 ) {
1164: dfree (*h, file, line);
1165: }
1166: *h = 0;
1167: return ISC_R_SUCCESS;
1168: }
1169:
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 / omapip