/* alloc.c
Functions supporting memory allocation for the object management
protocol... */
/*
* Copyright (c) 2009-2010 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 2004-2007 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1999-2003 by Internet Software Consortium
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Internet Systems Consortium, Inc.
* 950 Charter Street
* Redwood City, CA 94063
* <info@isc.org>
* https://www.isc.org/
*
* This software has been written for Internet Systems Consortium
* by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
* To learn more about Internet Systems Consortium, see
* ``https://www.isc.org/''. To learn more about Vixie Enterprises,
* see ``http://www.vix.com''. To learn more about Nominum, Inc., see
* ``http://www.nominum.com''.
*/
#include "dhcpd.h"
#include <omapip/omapip_p.h>
#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
struct dmalloc_preamble *dmalloc_list;
unsigned long dmalloc_outstanding;
unsigned long dmalloc_longterm;
unsigned long dmalloc_generation;
unsigned long dmalloc_cutoff_generation;
#endif
#if defined (DEBUG_RC_HISTORY)
struct rc_history_entry rc_history [RC_HISTORY_MAX];
int rc_history_index;
int rc_history_count;
#endif
#if defined (DEBUG_RC_HISTORY)
static void print_rc_hist_entry (int);
#endif
void *
dmalloc(unsigned size, const char *file, int line) {
unsigned char *foo;
unsigned len;
void **bar;
#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
int i;
struct dmalloc_preamble *dp;
#endif
len = size + DMDSIZE;
if (len < size)
return NULL;
foo = malloc(len);
if (!foo)
return NULL;
bar = (void *)(foo + DMDOFFSET);
memset (bar, 0, size);
#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
dp = (struct dmalloc_preamble *)foo;
dp -> prev = dmalloc_list;
if (dmalloc_list)
dmalloc_list -> next = dp;
dmalloc_list = dp;
dp -> next = (struct dmalloc_preamble *)0;
dp -> size = size;
dp -> file = file;
dp -> line = line;
dp -> generation = dmalloc_generation++;
dmalloc_outstanding += size;
for (i = 0; i < DMLFSIZE; i++)
dp -> low_fence [i] =
(((unsigned long)
(&dp -> low_fence [i])) % 143) + 113;
for (i = DMDOFFSET; i < DMDSIZE; i++)
foo [i + size] =
(((unsigned long)
(&foo [i + size])) % 143) + 113;
#if defined (DEBUG_MALLOC_POOL_EXHAUSTIVELY)
/* Check _every_ entry in the pool! Very expensive. */
for (dp = dmalloc_list; dp; dp = dp -> prev) {
for (i = 0; i < DMLFSIZE; i++) {
if (dp -> low_fence [i] !=
(((unsigned long)
(&dp -> low_fence [i])) % 143) + 113)
{
log_error ("malloc fence modified: %s(%d)",
dp -> file, dp -> line);
abort ();
}
}
foo = (unsigned char *)dp;
for (i = DMDOFFSET; i < DMDSIZE; i++) {
if (foo [i + dp -> size] !=
(((unsigned long)
(&foo [i + dp -> size])) % 143) + 113) {
log_error ("malloc fence modified: %s(%d)",
dp -> file, dp -> line);
abort ();
}
}
}
#endif
#endif
#ifdef DEBUG_REFCNT_DMALLOC_FREE
rc_register (file, line, 0, foo + DMDOFFSET, 1, 0, RC_MALLOC);
#endif
return bar;
}
void
dfree(void *ptr, const char *file, int line) {
if (!ptr) {
log_error ("dfree %s(%d): free on null pointer.", file, line);
return;
}
#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
{
unsigned char *bar = ptr;
struct dmalloc_preamble *dp, *cur;
int i;
bar -= DMDOFFSET;
cur = (struct dmalloc_preamble *)bar;
for (dp = dmalloc_list; dp; dp = dp -> prev)
if (dp == cur)
break;
if (!dp) {
log_error ("%s(%d): freeing unknown memory: %lx",
file, line, (unsigned long)cur);
abort ();
}
if (dp -> prev)
dp -> prev -> next = dp -> next;
if (dp -> next)
dp -> next -> prev = dp -> prev;
if (dp == dmalloc_list)
dmalloc_list = dp -> prev;
if (dp -> generation >= dmalloc_cutoff_generation)
dmalloc_outstanding -= dp -> size;
else
dmalloc_longterm -= dp -> size;
for (i = 0; i < DMLFSIZE; i++) {
if (dp -> low_fence [i] !=
(((unsigned long)
(&dp -> low_fence [i])) % 143) + 113)
{
log_error ("malloc fence modified: %s(%d)",
dp -> file, dp -> line);
abort ();
}
}
for (i = DMDOFFSET; i < DMDSIZE; i++) {
if (bar [i + dp -> size] !=
(((unsigned long)
(&bar [i + dp -> size])) % 143) + 113) {
log_error ("malloc fence modified: %s(%d)",
dp -> file, dp -> line);
abort ();
}
}
ptr = bar;
}
#endif
#ifdef DEBUG_REFCNT_DMALLOC_FREE
rc_register (file, line,
0, (unsigned char *)ptr + DMDOFFSET, 0, 1, RC_MALLOC);
#endif
free (ptr);
}
#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
/* For allocation functions that keep their own free lists, we want to
account for the reuse of the memory. */
void
dmalloc_reuse(void *foo, const char *file, int line, int justref) {
struct dmalloc_preamble *dp;
/* Get the pointer to the dmalloc header. */
dp = foo;
dp--;
/* If we just allocated this and are now referencing it, this
function would almost be a no-op, except that it would
increment the generation count needlessly. So just return
in this case. */
if (dp -> generation == dmalloc_generation)
return;
/* If this is longterm data, and we just made reference to it,
don't put it on the short-term list or change its name -
we don't need to know about this. */
if (dp -> generation < dmalloc_cutoff_generation && justref)
return;
/* Take it out of the place in the allocated list where it was. */
if (dp -> prev)
dp -> prev -> next = dp -> next;
if (dp -> next)
dp -> next -> prev = dp -> prev;
if (dp == dmalloc_list)
dmalloc_list = dp -> prev;
/* Account for its removal. */
if (dp -> generation >= dmalloc_cutoff_generation)
dmalloc_outstanding -= dp -> size;
else
dmalloc_longterm -= dp -> size;
/* Now put it at the head of the list. */
dp -> prev = dmalloc_list;
if (dmalloc_list)
dmalloc_list -> next = dp;
dmalloc_list = dp;
dp -> next = (struct dmalloc_preamble *)0;
/* Change the reference location information. */
dp -> file = file;
dp -> line = line;
/* Increment the generation. */
dp -> generation = dmalloc_generation++;
/* Account for it. */
dmalloc_outstanding += dp -> size;
}
void dmalloc_dump_outstanding ()
{
static unsigned long dmalloc_cutoff_point;
struct dmalloc_preamble *dp;
#if defined(DEBUG_MALLOC_POOL)
unsigned char *foo;
int i;
#endif
if (!dmalloc_cutoff_point)
dmalloc_cutoff_point = dmalloc_cutoff_generation;
for (dp = dmalloc_list; dp; dp = dp -> prev) {
if (dp -> generation <= dmalloc_cutoff_point)
break;
#if defined (DEBUG_MALLOC_POOL)
for (i = 0; i < DMLFSIZE; i++) {
if (dp -> low_fence [i] !=
(((unsigned long)
(&dp -> low_fence [i])) % 143) + 113)
{
log_error ("malloc fence modified: %s(%d)",
dp -> file, dp -> line);
abort ();
}
}
foo = (unsigned char *)dp;
for (i = DMDOFFSET; i < DMDSIZE; i++) {
if (foo [i + dp -> size] !=
(((unsigned long)
(&foo [i + dp -> size])) % 143) + 113) {
log_error ("malloc fence modified: %s(%d)",
dp -> file, dp -> line);
abort ();
}
}
#endif
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
/* Don't count data that's actually on a free list
somewhere. */
if (dp -> file) {
#if defined (DEBUG_RC_HISTORY)
int i, count, inhistory = 0, noted = 0;
/* If we have the info, see if this is actually
new garbage. */
if (rc_history_count < RC_HISTORY_MAX) {
count = rc_history_count;
} else
count = RC_HISTORY_MAX;
i = rc_history_index - 1;
if (i < 0)
i += RC_HISTORY_MAX;
do {
if (rc_history [i].addr == dp + 1) {
inhistory = 1;
if (!noted) {
log_info (" %s(%d): %ld", dp -> file,
dp -> line, dp -> size);
noted = 1;
}
print_rc_hist_entry (i);
if (!rc_history [i].refcnt)
break;
}
if (--i < 0)
i = RC_HISTORY_MAX - 1;
} while (count--);
if (!inhistory)
#endif
log_info (" %s(%d): %ld",
dp -> file, dp -> line, dp -> size);
}
#endif
}
if (dmalloc_list)
dmalloc_cutoff_point = dmalloc_list -> generation;
}
#endif /* DEBUG_MEMORY_LEAKAGE || DEBUG_MALLOC_POOL */
#if defined (DEBUG_RC_HISTORY)
static void print_rc_hist_entry (int i)
{
log_info (" referenced by %s(%d)[%lx]: addr = %lx refcnt = %x",
rc_history [i].file, rc_history [i].line,
(unsigned long)rc_history [i].reference,
(unsigned long)rc_history [i].addr,
rc_history [i].refcnt);
}
void dump_rc_history (void *addr)
{
int i;
i = rc_history_index;
if (!rc_history [i].file)
i = 0;
else if (rc_history_count < RC_HISTORY_MAX) {
i -= rc_history_count;
if (i < 0)
i += RC_HISTORY_MAX;
}
rc_history_count = 0;
while (rc_history [i].file) {
if (!addr || addr == rc_history [i].addr)
print_rc_hist_entry (i);
++i;
if (i == RC_HISTORY_MAX)
i = 0;
if (i == rc_history_index)
break;
}
}
void rc_history_next (int d)
{
#if defined (RC_HISTORY_COMPRESSION)
int i, j = 0, m, n = 0;
void *ap, *rp;
/* If we are decreasing the reference count, try to find the
entry where the reference was made and eliminate it; then
we can also eliminate this reference. */
if (d) {
m = rc_history_index - 1000;
if (m < -1)
m = -1;
ap = rc_history [rc_history_index].addr;
rp = rc_history [rc_history_index].reference;
for (i = rc_history_index - 1; i > m; i--) {
if (rc_history [i].addr == ap) {
if (rc_history [i].reference == rp) {
if (n > 10) {
for (n = i; n <= rc_history_index; n++)
print_rc_hist_entry (n);
n = 11;
}
memmove (&rc_history [i],
&rc_history [i + 1],
(unsigned)((rc_history_index - i) *
sizeof (struct rc_history_entry)));
--rc_history_count;
--rc_history_index;
for (j = i; j < rc_history_count; j++) {
if (rc_history [j].addr == ap)
--rc_history [j].refcnt;
}
if (n > 10) {
for (n = i; n <= rc_history_index; n++)
print_rc_hist_entry (n);
n = 11;
exit (0);
}
return;
}
}
}
}
#endif
if (++rc_history_index == RC_HISTORY_MAX)
rc_history_index = 0;
++rc_history_count;
}
#endif /* DEBUG_RC_HISTORY */
#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
struct caller {
struct dmalloc_preamble *dp;
int count;
};
static int dmalloc_find_entry (struct dmalloc_preamble *dp,
struct caller *array,
int min, int max)
{
int middle;
middle = (min + max) / 2;
if (middle == min)
return middle;
if (array [middle].dp -> file == dp -> file) {
if (array [middle].dp -> line == dp -> line)
return middle;
else if (array [middle].dp -> line < dp -> line)
return dmalloc_find_entry (dp, array, middle, max);
else
return dmalloc_find_entry (dp, array, 0, middle);
} else if (array [middle].dp -> file < dp -> file)
return dmalloc_find_entry (dp, array, middle, max);
else
return dmalloc_find_entry (dp, array, 0, middle);
}
void omapi_print_dmalloc_usage_by_caller ()
{
struct dmalloc_preamble *dp;
int ccur, cmax, i;
struct caller cp [1024];
cmax = 1024;
ccur = 0;
memset (cp, 0, sizeof cp);
for (dp = dmalloc_list; dp; dp = dp -> prev) {
i = dmalloc_find_entry (dp, cp, 0, ccur);
if ((i == ccur ||
cp [i].dp -> file != dp -> file ||
cp [i].dp -> line != dp -> line) &&
ccur == cmax) {
log_error ("no space for memory usage summary.");
return;
}
if (i == ccur) {
cp [ccur++].dp = dp;
cp [i].count = 1;
} else if (cp [i].dp -> file < dp -> file ||
(cp [i].dp -> file == dp -> file &&
cp [i].dp -> line < dp -> line)) {
if (i + 1 != ccur)
memmove (cp + i + 2, cp + i + 1,
(ccur - i) * sizeof *cp);
cp [i + 1].dp = dp;
cp [i + 1].count = 1;
ccur++;
} else if (cp [i].dp -> file != dp -> file ||
cp [i].dp -> line != dp -> line) {
memmove (cp + i + 1,
cp + i, (ccur - i) * sizeof *cp);
cp [i].dp = dp;
cp [i].count = 1;
ccur++;
} else
cp [i].count++;
#if 0
printf ("%d\t%s:%d\n", i, dp -> file, dp -> line);
dump_rc_history (dp + 1);
#endif
}
for (i = 0; i < ccur; i++) {
printf ("%d\t%s:%d\t%d\n", i,
cp [i].dp -> file, cp [i].dp -> line, cp [i].count);
#if defined(DUMP_RC_HISTORY)
dump_rc_history (cp [i].dp + 1);
#endif
}
}
#endif /* DEBUG_MEMORY_LEAKAGE || DEBUG_MALLOC_POOL */
isc_result_t omapi_object_allocate (omapi_object_t **o,
omapi_object_type_t *type,
size_t size,
const char *file, int line)
{
size_t tsize;
omapi_object_t *foo;
isc_result_t status;
if (type -> allocator) {
foo = (omapi_object_t *)0;
status = (*type -> allocator) (&foo, file, line);
tsize = type -> size;
} else {
status = ISC_R_NOMEMORY;
tsize = 0;
}
if (status == ISC_R_NOMEMORY) {
if (type -> sizer)
tsize = (*type -> sizer) (size);
else
tsize = type -> size;
/* Sanity check. */
if (tsize < sizeof (omapi_object_t))
return ISC_R_INVALIDARG;
foo = dmalloc (tsize, file, line);
if (!foo)
return ISC_R_NOMEMORY;
}
status = omapi_object_initialize (foo, type, size, tsize, file, line);
if (status != ISC_R_SUCCESS) {
if (type -> freer)
(*type -> freer) (foo, file, line);
else
dfree (foo, file, line);
return status;
}
return omapi_object_reference (o, foo, file, line);
}
isc_result_t omapi_object_initialize (omapi_object_t *o,
omapi_object_type_t *type,
size_t usize, size_t psize,
const char *file, int line)
{
memset (o, 0, psize);
o -> type = type;
if (type -> initialize)
(*type -> initialize) (o, file, line);
return ISC_R_SUCCESS;
}
isc_result_t omapi_object_reference (omapi_object_t **r,
omapi_object_t *h,
const char *file, int line)
{
if (!h || !r)
return ISC_R_INVALIDARG;
if (*r) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): reference store into non-null pointer!",
file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
*r = h;
h -> refcnt++;
rc_register (file, line, r, h, h -> refcnt, 0, h -> type -> rc_flag);
return ISC_R_SUCCESS;
}
isc_result_t omapi_object_dereference (omapi_object_t **h,
const char *file, int line)
{
int outer_reference = 0;
int inner_reference = 0;
int handle_reference = 0;
int extra_references;
omapi_object_t *p, *hp;
if (!h)
return ISC_R_INVALIDARG;
if (!*h) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
if ((*h) -> refcnt <= 0) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of pointer with refcnt of zero!",
file, line);
#if defined (DEBUG_RC_HISTORY)
dump_rc_history (*h);
#endif
abort ();
#else
*h = 0;
return ISC_R_INVALIDARG;
#endif
}
/* See if this object's inner object refers to it, but don't
count this as a reference if we're being asked to free the
reference from the inner object. */
if ((*h) -> inner && (*h) -> inner -> outer &&
h != &((*h) -> inner -> outer))
inner_reference = 1;
/* Ditto for the outer object. */
if ((*h) -> outer && (*h) -> outer -> inner &&
h != &((*h) -> outer -> inner))
outer_reference = 1;
/* Ditto for the outer object. The code below assumes that
the only reason we'd get a dereference from the handle
table is if this function does it - otherwise we'd have to
traverse the handle table to find the address where the
reference is stored and compare against that, and we don't
want to do that if we can avoid it. */
if ((*h) -> handle)
handle_reference = 1;
/* If we are getting rid of the last reference other than
references to inner and outer objects, or from the handle
table, then we must examine all the objects in either
direction to see if they hold any non-inner, non-outer,
non-handle-table references. If not, we need to free the
entire chain of objects. */
if ((*h) -> refcnt ==
inner_reference + outer_reference + handle_reference + 1) {
if (inner_reference || outer_reference || handle_reference) {
/* XXX we could check for a reference from the
handle table here. */
extra_references = 0;
for (p = (*h) -> inner;
p && !extra_references; p = p -> inner) {
extra_references += p -> refcnt;
if (p -> inner && p -> inner -> outer == p)
--extra_references;
if (p -> outer)
--extra_references;
if (p -> handle)
--extra_references;
}
for (p = (*h) -> outer;
p && !extra_references; p = p -> outer) {
extra_references += p -> refcnt;
if (p -> outer && p -> outer -> inner == p)
--extra_references;
if (p -> inner)
--extra_references;
if (p -> handle)
--extra_references;
}
} else
extra_references = 0;
if (!extra_references) {
hp = *h;
*h = 0;
hp -> refcnt--;
if (inner_reference)
omapi_object_dereference
(&hp -> inner, file, line);
if (outer_reference)
omapi_object_dereference
(&hp -> outer, file, line);
/* if (!hp -> type -> freer) */
rc_register (file, line, h, hp,
0, 1, hp -> type -> rc_flag);
if (handle_reference) {
if (omapi_handle_clear(hp->handle) !=
ISC_R_SUCCESS) {
log_debug("Attempt to clear null "
"handle pointer");
}
}
if (hp -> type -> destroy)
(*(hp -> type -> destroy)) (hp, file, line);
if (hp -> type -> freer)
(hp -> type -> freer (hp, file, line));
else
dfree (hp, file, line);
} else {
(*h) -> refcnt--;
/* if (!(*h) -> type -> freer) */
rc_register (file, line,
h, *h, (*h) -> refcnt, 1,
(*h) -> type -> rc_flag);
}
} else {
(*h) -> refcnt--;
/* if (!(*h) -> type -> freer) */
rc_register (file, line, h, *h, (*h) -> refcnt, 1,
(*h) -> type -> rc_flag);
}
*h = 0;
return ISC_R_SUCCESS;
}
isc_result_t omapi_buffer_new (omapi_buffer_t **h,
const char *file, int line)
{
omapi_buffer_t *t;
isc_result_t status;
t = (omapi_buffer_t *)dmalloc (sizeof *t, file, line);
if (!t)
return ISC_R_NOMEMORY;
memset (t, 0, sizeof *t);
status = omapi_buffer_reference (h, t, file, line);
if (status != ISC_R_SUCCESS)
dfree (t, file, line);
(*h) -> head = sizeof ((*h) -> buf) - 1;
return status;
}
isc_result_t omapi_buffer_reference (omapi_buffer_t **r,
omapi_buffer_t *h,
const char *file, int line)
{
if (!h || !r)
return ISC_R_INVALIDARG;
if (*r) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): reference store into non-null pointer!",
file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
*r = h;
h -> refcnt++;
rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
return ISC_R_SUCCESS;
}
isc_result_t omapi_buffer_dereference (omapi_buffer_t **h,
const char *file, int line)
{
if (!h)
return ISC_R_INVALIDARG;
if (!*h) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
if ((*h) -> refcnt <= 0) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of pointer with refcnt of zero!",
file, line);
#if defined (DEBUG_RC_HISTORY)
dump_rc_history (*h);
#endif
abort ();
#else
*h = 0;
return ISC_R_INVALIDARG;
#endif
}
--(*h) -> refcnt;
rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
if ((*h) -> refcnt == 0)
dfree (*h, file, line);
*h = 0;
return ISC_R_SUCCESS;
}
isc_result_t omapi_typed_data_new (const char *file, int line,
omapi_typed_data_t **t,
omapi_datatype_t type, ...)
{
va_list l;
omapi_typed_data_t *new;
unsigned len;
unsigned val = 0;
int intval = 0;
char *s = NULL;
isc_result_t status;
omapi_object_t *obj = NULL;
va_start (l, type);
switch (type) {
case omapi_datatype_int:
len = OMAPI_TYPED_DATA_INT_LEN;
intval = va_arg (l, int);
break;
case omapi_datatype_string:
s = va_arg (l, char *);
val = strlen (s);
len = OMAPI_TYPED_DATA_NOBUFFER_LEN + val;
if (len < val) {
va_end(l);
return ISC_R_INVALIDARG;
}
break;
case omapi_datatype_data:
val = va_arg (l, unsigned);
len = OMAPI_TYPED_DATA_NOBUFFER_LEN + val;
if (len < val) {
va_end(l);
return ISC_R_INVALIDARG;
}
break;
case omapi_datatype_object:
len = OMAPI_TYPED_DATA_OBJECT_LEN;
obj = va_arg (l, omapi_object_t *);
break;
default:
va_end (l);
return ISC_R_INVALIDARG;
}
va_end (l);
new = dmalloc (len, file, line);
if (!new)
return ISC_R_NOMEMORY;
memset (new, 0, len);
switch (type) {
case omapi_datatype_int:
new -> u.integer = intval;
break;
case omapi_datatype_string:
memcpy (new -> u.buffer.value, s, val);
new -> u.buffer.len = val;
break;
case omapi_datatype_data:
new -> u.buffer.len = val;
break;
case omapi_datatype_object:
status = omapi_object_reference (&new -> u.object, obj,
file, line);
if (status != ISC_R_SUCCESS) {
dfree (new, file, line);
return status;
}
break;
}
new -> type = type;
return omapi_typed_data_reference (t, new, file, line);
}
isc_result_t omapi_typed_data_reference (omapi_typed_data_t **r,
omapi_typed_data_t *h,
const char *file, int line)
{
if (!h || !r)
return ISC_R_INVALIDARG;
if (*r) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): reference store into non-null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
*r = h;
h -> refcnt++;
rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
return ISC_R_SUCCESS;
}
isc_result_t omapi_typed_data_dereference (omapi_typed_data_t **h,
const char *file, int line)
{
if (!h)
return ISC_R_INVALIDARG;
if (!*h) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
if ((*h) -> refcnt <= 0) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of pointer with refcnt of zero!",
file, line);
#if defined (DEBUG_RC_HISTORY)
dump_rc_history (*h);
#endif
abort ();
#else
*h = 0;
return ISC_R_INVALIDARG;
#endif
}
--((*h) -> refcnt);
rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
if ((*h) -> refcnt <= 0 ) {
switch ((*h) -> type) {
case omapi_datatype_int:
case omapi_datatype_string:
case omapi_datatype_data:
default:
break;
case omapi_datatype_object:
omapi_object_dereference (&(*h) -> u.object,
file, line);
break;
}
dfree (*h, file, line);
}
*h = 0;
return ISC_R_SUCCESS;
}
isc_result_t omapi_data_string_new (omapi_data_string_t **d, unsigned len,
const char *file, int line)
{
omapi_data_string_t *new;
unsigned nlen;
nlen = OMAPI_DATA_STRING_EMPTY_SIZE + len;
if (nlen < len)
return ISC_R_INVALIDARG;
new = dmalloc (nlen, file, line);
if (!new)
return ISC_R_NOMEMORY;
memset (new, 0, OMAPI_DATA_STRING_EMPTY_SIZE);
new -> len = len;
return omapi_data_string_reference (d, new, file, line);
}
isc_result_t omapi_data_string_reference (omapi_data_string_t **r,
omapi_data_string_t *h,
const char *file, int line)
{
if (!h || !r)
return ISC_R_INVALIDARG;
if (*r) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): reference store into non-null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
*r = h;
h -> refcnt++;
rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
return ISC_R_SUCCESS;
}
isc_result_t omapi_data_string_dereference (omapi_data_string_t **h,
const char *file, int line)
{
if (!h)
return ISC_R_INVALIDARG;
if (!*h) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
if ((*h) -> refcnt <= 0) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of pointer with refcnt of zero!",
file, line);
#if defined (DEBUG_RC_HISTORY)
dump_rc_history (*h);
#endif
abort ();
#else
*h = 0;
return ISC_R_INVALIDARG;
#endif
}
--((*h) -> refcnt);
rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
if ((*h) -> refcnt <= 0 ) {
dfree (*h, file, line);
}
*h = 0;
return ISC_R_SUCCESS;
}
isc_result_t omapi_value_new (omapi_value_t **d,
const char *file, int line)
{
omapi_value_t *new;
new = dmalloc (sizeof *new, file, line);
if (!new)
return ISC_R_NOMEMORY;
memset (new, 0, sizeof *new);
return omapi_value_reference (d, new, file, line);
}
isc_result_t omapi_value_reference (omapi_value_t **r,
omapi_value_t *h,
const char *file, int line)
{
if (!h || !r)
return ISC_R_INVALIDARG;
if (*r) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): reference store into non-null pointer!",
file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
*r = h;
h -> refcnt++;
rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
return ISC_R_SUCCESS;
}
isc_result_t omapi_value_dereference (omapi_value_t **h,
const char *file, int line)
{
if (!h)
return ISC_R_INVALIDARG;
if (!*h) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
if ((*h) -> refcnt <= 0) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of pointer with refcnt of zero!",
file, line);
#if defined (DEBUG_RC_HISTORY)
dump_rc_history (*h);
#endif
abort ();
#else
*h = 0;
return ISC_R_INVALIDARG;
#endif
}
--((*h) -> refcnt);
rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
if ((*h) -> refcnt == 0) {
if ((*h) -> name)
omapi_data_string_dereference (&(*h) -> name,
file, line);
if ((*h) -> value)
omapi_typed_data_dereference (&(*h) -> value,
file, line);
dfree (*h, file, line);
}
*h = 0;
return ISC_R_SUCCESS;
}
isc_result_t omapi_addr_list_new (omapi_addr_list_t **d, unsigned count,
const char *file, int line)
{
omapi_addr_list_t *new;
new = dmalloc ((count * sizeof (omapi_addr_t)) +
sizeof (omapi_addr_list_t), file, line);
if (!new)
return ISC_R_NOMEMORY;
memset (new, 0, ((count * sizeof (omapi_addr_t)) +
sizeof (omapi_addr_list_t)));
new -> count = count;
new -> addresses = (omapi_addr_t *)(new + 1);
return omapi_addr_list_reference (d, new, file, line);
}
isc_result_t omapi_addr_list_reference (omapi_addr_list_t **r,
omapi_addr_list_t *h,
const char *file, int line)
{
if (!h || !r)
return ISC_R_INVALIDARG;
if (*r) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): reference store into non-null pointer!",
file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
*r = h;
h -> refcnt++;
rc_register (file, line, r, h, h -> refcnt, 0, RC_MISC);
return ISC_R_SUCCESS;
}
isc_result_t omapi_addr_list_dereference (omapi_addr_list_t **h,
const char *file, int line)
{
if (!h)
return ISC_R_INVALIDARG;
if (!*h) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of null pointer!", file, line);
abort ();
#else
return ISC_R_INVALIDARG;
#endif
}
if ((*h) -> refcnt <= 0) {
#if defined (POINTER_DEBUG)
log_error ("%s(%d): dereference of pointer with zero refcnt!",
file, line);
#if defined (DEBUG_RC_HISTORY)
dump_rc_history (*h);
#endif
abort ();
#else
*h = 0;
return ISC_R_INVALIDARG;
#endif
}
--((*h) -> refcnt);
rc_register (file, line, h, *h, (*h) -> refcnt, 1, RC_MISC);
if ((*h) -> refcnt <= 0 ) {
dfree (*h, file, line);
}
*h = 0;
return ISC_R_SUCCESS;
}
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