#ifndef lint
static char copyright[] =
-"$Id: alloc.c,v 1.36 2000/01/05 17:57:03 mellon Exp $ Copyright (c) 1995, 1996, 1998 The Internet Software Consortium. All rights reserved.\n";
+"$Id: alloc.c,v 1.37 2000/01/25 01:02:26 mellon Exp $ Copyright (c) 1995, 1996, 1998 The Internet Software Consortium. All rights reserved.\n";
#endif /* not lint */
#include "dhcpd.h"
struct dhcp_packet *dhcp_free_list;
struct packet *packet_free_list;
-VOIDPTR dmalloc (size, name)
+#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL)
+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;
+#endif
+
+VOIDPTR dmalloc (size, file, line)
unsigned size;
- const char *name;
+ const char *file;
+ int line;
{
- VOIDPTR foo = (VOIDPTR)malloc (size);
- if (!foo)
+ unsigned char *foo = malloc (size + DMDSIZE);
+ int i;
+ VOIDPTR *bar;
+#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL)
+ struct dmalloc_preamble *dp;
+#endif
+ if (!foo) {
log_error ("No memory for %s.", name);
- else
- memset (foo, 0, size);
- return foo;
+ return (VOIDPTR)0;
+ }
+ bar = (VOIDPTR)(foo + DMDOFFSET);
+ memset (bar, 0, size);
+
+#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL)
+ 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
+ return bar;
}
-void dfree (ptr, name)
+void dfree (ptr, file, line)
VOIDPTR ptr;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
- log_error ("dfree %s: free on null pointer.", name);
+ log_error ("dfree %s(%d): free on null pointer.", file, line);
return;
}
+#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL)
+ {
+ 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",
+ dp -> file, dp -> 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
free (ptr);
}
-struct dhcp_packet *new_dhcp_packet (name)
- const char *name;
+#if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL)
+/* For allocation functions that keep their own free lists, we want to
+ account for the reuse of the memory. */
+
+void dmalloc_reuse (foo, file, line, justref)
+ VOIDPTR 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;
+ unsigned char *foo;
+ int i;
+
+ 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)
+ /* Don't count data that's actually on a free list
+ somewhere. */
+ if (dp -> file)
+ log_info (" %s(%d): %d",
+ 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)
+void dump_rc_history ()
+{
+ int i;
+
+ i = rc_history_index;
+ do {
+ log_info (" referenced by %s(%d): addr = %lx refcnt = %x\n",
+ rc_history [i].file, rc_history [i].line,
+ (unsigned long)rc_history [i].addr,
+ rc_history [i].refcnt);
+ ++i;
+ if (i == RC_HISTORY_MAX)
+ i = 0;
+ } while (i != rc_history_index && rc_history [i].file);
+}
+#endif
+
+struct dhcp_packet *new_dhcp_packet (file, line)
+ const char *file;
+ int line;
{
struct dhcp_packet *rval;
rval = (struct dhcp_packet *)dmalloc (sizeof (struct dhcp_packet),
- name);
+ file, line);
return rval;
}
-struct hash_table *new_hash_table (count, name)
+struct hash_table *new_hash_table (count, file, line)
int count;
- const char *name;
+ const char *file;
+ int line;
{
struct hash_table *rval = dmalloc (sizeof (struct hash_table)
- (DEFAULT_HASH_SIZE
* sizeof (struct hash_bucket *))
+ (count
* sizeof (struct hash_bucket *)),
- name);
+ file, line);
rval -> hash_count = count;
return rval;
}
-struct hash_bucket *new_hash_bucket (name)
- const char *name;
+struct hash_bucket *new_hash_bucket (file, line)
+ const char *file;
+ int line;
{
- struct hash_bucket *rval = dmalloc (sizeof (struct hash_bucket), name);
+ struct hash_bucket *rval = dmalloc (sizeof (struct hash_bucket),
+ file, line);
return rval;
}
-struct lease *new_leases (n, name)
+struct lease *new_leases (n, file, line)
unsigned n;
- const char *name;
+ const char *file;
+ int line;
{
- struct lease *rval = dmalloc (n * sizeof (struct lease), name);
+ struct lease *rval = dmalloc (n * sizeof (struct lease), file, line);
return rval;
}
-struct lease *new_lease (name)
- const char *name;
+struct lease *new_lease (file, line)
+ const char *file;
+ int line;
{
- struct lease *rval = dmalloc (sizeof (struct lease), name);
+ struct lease *rval = dmalloc (sizeof (struct lease), file, line);
return rval;
}
-struct subnet *new_subnet (name)
- const char *name;
+struct subnet *new_subnet (file, line)
+ const char *file;
+ int line;
{
- struct subnet *rval = dmalloc (sizeof (struct subnet), name);
+ struct subnet *rval = dmalloc (sizeof (struct subnet), file, line);
return rval;
}
-struct class *new_class (name)
- const char *name;
+struct class *new_class (file, line)
+ const char *file;
+ int line;
{
- struct class *rval = dmalloc (sizeof (struct class), name);
+ struct class *rval = dmalloc (sizeof (struct class), file, line);
return rval;
}
-struct shared_network *new_shared_network (name)
- const char *name;
+struct shared_network *new_shared_network (file, line)
+ const char *file;
+ int line;
{
struct shared_network *rval =
- dmalloc (sizeof (struct shared_network), name);
+ dmalloc (sizeof (struct shared_network), file, line);
return rval;
}
-struct group *new_group (name)
- const char *name;
+struct group *new_group (file, line)
+ const char *file;
+ int line;
{
struct group *rval =
- dmalloc (sizeof (struct group), name);
+ dmalloc (sizeof (struct group), file, line);
if (rval)
memset (rval, 0, sizeof *rval);
return rval;
}
-struct protocol *new_protocol (name)
- const char *name;
+struct protocol *new_protocol (file, line)
+ const char *file;
+ int line;
{
- struct protocol *rval = dmalloc (sizeof (struct protocol), name);
+ struct protocol *rval = dmalloc (sizeof (struct protocol), file, line);
return rval;
}
struct lease_state *free_lease_states;
-struct lease_state *new_lease_state (name)
- const char *name;
+struct lease_state *new_lease_state (file, line)
+ const char *file;
+ int line;
{
struct lease_state *rval;
rval = free_lease_states;
free_lease_states =
(struct lease_state *)(free_lease_states -> next);
+ dmalloc_reuse (rval, file, line, 0);
} else {
- rval = dmalloc (sizeof (struct lease_state), name);
+ rval = dmalloc (sizeof (struct lease_state), file, line);
if (!rval)
return rval;
}
memset (rval, 0, sizeof *rval);
- if (!option_state_allocate (&rval -> options, name)) {
- free_lease_state (rval, name);
+ if (!option_state_allocate (&rval -> options, file, line)) {
+ free_lease_state (rval, file, line);
return (struct lease_state *)0;
}
return rval;
}
-struct domain_search_list *new_domain_search_list (name)
- const char *name;
+struct domain_search_list *new_domain_search_list (file, line)
+ const char *file;
+ int line;
{
struct domain_search_list *rval =
- dmalloc (sizeof (struct domain_search_list), name);
+ dmalloc (sizeof (struct domain_search_list), file, line);
return rval;
}
-struct name_server *new_name_server (name)
- const char *name;
+struct name_server *new_name_server (file, line)
+ const char *file;
+ int line;
{
struct name_server *rval =
- dmalloc (sizeof (struct name_server), name);
+ dmalloc (sizeof (struct name_server), file, line);
return rval;
}
-void free_name_server (ptr, name)
+void free_name_server (ptr, file, line)
struct name_server *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-struct option *new_option (name)
- const char *name;
+struct option *new_option (file, line)
+ const char *file;
+ int line;
{
struct option *rval =
- dmalloc (sizeof (struct option), name);
+ dmalloc (sizeof (struct option), file, line);
if (rval)
memset (rval, 0, sizeof *rval);
return rval;
}
-void free_option (ptr, name)
+void free_option (ptr, file, line)
struct option *ptr;
- const char *name;
+ const char *file;
+ int line;
{
/* XXX have to put all options on heap before this is possible. */
#if 0
if (ptr -> name)
- dfree ((VOIDPTR)option -> name, name);
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)option -> name, file, line);
+ dfree ((VOIDPTR)ptr, file, line);
#endif
}
-struct universe *new_universe (name)
- const char *name;
+struct universe *new_universe (file, line)
+ const char *file;
+ int line;
{
struct universe *rval =
- dmalloc (sizeof (struct universe), name);
+ dmalloc (sizeof (struct universe), file, line);
return rval;
}
-void free_universe (ptr, name)
+void free_universe (ptr, file, line)
struct universe *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_domain_search_list (ptr, name)
+void free_domain_search_list (ptr, file, line)
struct domain_search_list *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_lease_state (ptr, name)
+void free_lease_state (ptr, file, line)
struct lease_state *ptr;
- const char *name;
+ const char *file;
+ int line;
{
if (ptr -> options)
- option_state_dereference (&ptr -> options, name);
+ option_state_dereference (&ptr -> options, file, line);
if (ptr -> packet)
- packet_dereference (&ptr -> packet, name);
+ packet_dereference (&ptr -> packet, file, line);
+ data_string_forget (&state -> parameter_request_list, file, line);
+ data_string_forget (&state -> filename, file, line);
+ data_string_forget (&state -> server_name, file, line);
ptr -> next = free_lease_states;
free_lease_states = ptr;
+ dmalloc_reuse (free_lease_states, (char *)0, 0, 0);
}
-void free_protocol (ptr, name)
+void free_protocol (ptr, file, line)
struct protocol *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_group (ptr, name)
+void free_group (ptr, file, line)
struct group *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_shared_network (ptr, name)
+void free_shared_network (ptr, file, line)
struct shared_network *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_class (ptr, name)
+void free_class (ptr, file, line)
struct class *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_subnet (ptr, name)
+void free_subnet (ptr, file, line)
struct subnet *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_lease (ptr, name)
+void free_lease (ptr, file, line)
struct lease *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_hash_bucket (ptr, name)
+void free_hash_bucket (ptr, file, line)
struct hash_bucket *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_hash_table (ptr, name)
+void free_hash_table (ptr, file, line)
struct hash_table *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-void free_dhcp_packet (ptr, name)
+void free_dhcp_packet (ptr, file, line)
struct dhcp_packet *ptr;
- const char *name;
+ const char *file;
+ int line;
{
- dfree ((VOIDPTR)ptr, name);
+ dfree ((VOIDPTR)ptr, file, line);
}
-struct client_lease *new_client_lease (name)
- const char *name;
+struct client_lease *new_client_lease (file, line)
+ const char *file;
+ int line;
{
return (struct client_lease *)dmalloc (sizeof (struct client_lease),
- name);
+ file, line);
}
-void free_client_lease (lease, name)
+void free_client_lease (lease, file, line)
struct client_lease *lease;
- const char *name;
+ const char *file;
+ int line;
{
- dfree (lease, name);
+ dfree (lease, file, line);
}
-struct pool *new_pool (name)
- const char *name;
+struct pool *new_pool (file, line)
+ const char *file;
+ int line;
{
struct pool *pool = ((struct pool *)
- dmalloc (sizeof (struct pool), name));
+ dmalloc (sizeof (struct pool), file, line));
if (!pool)
return pool;
memset (pool, 0, sizeof *pool);
return pool;
}
-void free_pool (pool, name)
+void free_pool (pool, file, line)
struct pool *pool;
- const char *name;
+ const char *file;
+ int line;
{
- dfree (pool, name);
+ dfree (pool, file, line);
}
-struct auth_key *new_auth_key (len, name)
+struct auth_key *new_auth_key (len, file, line)
unsigned len;
- const char *name;
+ const char *file;
+ int line;
{
struct auth_key *peer;
unsigned size = len - 1 + sizeof (struct auth_key);
- peer = (struct auth_key *)dmalloc (size, name);
+ peer = (struct auth_key *)dmalloc (size, file, line);
if (!peer)
return peer;
memset (peer, 0, size);
return peer;
}
-void free_auth_key (peer, name)
+void free_auth_key (peer, file, line)
struct auth_key *peer;
- const char *name;
+ const char *file;
+ int line;
{
- dfree (peer, name);
+ dfree (peer, file, line);
}
-struct permit *new_permit (name)
- const char *name;
+struct permit *new_permit (file, line)
+ const char *file;
+ int line;
{
struct permit *permit = ((struct permit *)
- dmalloc (sizeof (struct permit), name));
+ dmalloc (sizeof (struct permit), file, line));
if (!permit)
return permit;
memset (permit, 0, sizeof *permit);
return permit;
}
-void free_permit (permit, name)
+void free_permit (permit, file, line)
struct permit *permit;
- const char *name;
+ const char *file;
+ int line;
{
- dfree (permit, name);
+ dfree (permit, file, line);
}
pair free_pairs;
-pair new_pair (name)
- const char *name;
+pair new_pair (file, line)
+ const char *file;
+ int line;
{
pair foo;
foo = free_pairs;
free_pairs = foo -> cdr;
memset (foo, 0, sizeof *foo);
+ dmalloc_reuse (foo, file, line, 0);
return foo;
}
- foo = dmalloc (sizeof *foo, name);
+ foo = dmalloc (sizeof *foo, file, line);
if (!foo)
return foo;
memset (foo, 0, sizeof *foo);
return foo;
}
-void free_pair (foo, name)
+void free_pair (foo, file, line)
pair foo;
- const char *name;
+ const char *file;
+ int line;
{
foo -> cdr = free_pairs;
free_pairs = foo;
+ dmalloc_reuse (free_expressions, (char *)0, 0, 0);
}
struct expression *free_expressions;
-int expression_allocate (cptr, name)
+int expression_allocate (cptr, file, line)
struct expression **cptr;
- const char *name;
+ const char *file;
+ int line;
{
struct expression *rval;
rval = free_expressions;
free_expressions = rval -> data.not;
} else {
- rval = dmalloc (sizeof (struct expression), name);
+ rval = dmalloc (sizeof (struct expression), file, line);
if (!rval)
return 0;
}
memset (rval, 0, sizeof *rval);
- return expression_reference (cptr, rval, name);
-}
-
-void free_expression (expr, name)
- struct expression *expr;
- const char *name;
-{
- expr -> data.not = free_expressions;
- free_expressions = expr;
+ return expression_reference (cptr, rval, file, line);
}
-int expression_reference (ptr, src, name)
+int expression_reference (ptr, src, file, line)
struct expression **ptr;
struct expression *src;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
- log_error ("Null pointer in expression_reference: %s", name);
+ log_error ("Null pointer in expression_reference: %s",
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in expression_reference (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = src;
src -> refcnt++;
+ rc_register (file, line, src, src -> refcnt);
+ dmalloc_reuse (src, file, line, 1);
return 1;
}
+void free_expression (expr, file, line)
+ struct expression *expr;
+ const char *file;
+ int line;
+{
+ expr -> data.not = free_expressions;
+ free_expressions = expr;
+ dmalloc_reuse (free_expressions, (char *)0, 0, 0);
+}
+
+
struct option_cache *free_option_caches;
-int option_cache_allocate (cptr, name)
+int option_cache_allocate (cptr, file, line)
struct option_cache **cptr;
- const char *name;
+ const char *file;
+ int line;
{
struct option_cache *rval;
rval = free_option_caches;
free_option_caches =
(struct option_cache *)(rval -> expression);
+ dmalloc_reuse (rval, file, line, 0);
} else {
- rval = dmalloc (sizeof (struct option_cache), name);
+ rval = dmalloc (sizeof (struct option_cache), file, line);
if (!rval)
return 0;
}
memset (rval, 0, sizeof *rval);
- return option_cache_reference (cptr, rval, name);
+ return option_cache_reference (cptr, rval, file, line);
}
-int option_cache_reference (ptr, src, name)
+int option_cache_reference (ptr, src, file, line)
struct option_cache **ptr;
struct option_cache *src;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
- log_error ("Null pointer in option_cache_reference: %s", name);
+ log_error ("Null pointer in option_cache_reference: %s",
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in option_cache_reference (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = src;
src -> refcnt++;
+ rc_register (file, line, src, src -> refcnt);
+ dmalloc_reuse (src, file, line, 1);
return 1;
}
-int buffer_allocate (ptr, len, name)
+int buffer_allocate (ptr, len, file, line)
struct buffer **ptr;
unsigned len;
- const char *name;
+ const char *file;
+ int line;
{
struct buffer *bp;
- bp = dmalloc (len + sizeof *bp, name);
+ bp = dmalloc (len + sizeof *bp, file, line);
if (!bp)
return 0;
memset (bp, 0, sizeof *bp);
bp -> refcnt = 0;
- return buffer_reference (ptr, bp, name);
+ return buffer_reference (ptr, bp, file, line);
}
-int buffer_reference (ptr, bp, name)
+int buffer_reference (ptr, bp, file, line)
struct buffer **ptr;
struct buffer *bp;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
log_error ("Null pointer passed to buffer_reference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
#endif
}
if (*ptr) {
- log_error ("Non-null pointer in buffer_reference (%s)", name);
+ log_error ("Non-null pointer in buffer_reference (%s)",
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = bp;
bp -> refcnt++;
+ rc_register (file, line, bp, bp -> refcnt);
+ dmalloc_reuse (bp, file, line, 1);
return 1;
}
-int buffer_dereference (ptr, name)
+int buffer_dereference (ptr, file, line)
struct buffer **ptr;
- const char *name;
+ const char *file;
+ int line;
{
struct buffer *bp;
if (!ptr) {
log_error ("Null pointer passed to buffer_dereference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (!*ptr) {
- log_error ("Null pointer in buffer_dereference: %s", name);
+ log_error ("Null pointer in buffer_dereference: %s",
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
(*ptr) -> refcnt--;
+ rc_register (name, line, *ptr, (*ptr) -> refcnt);
if (!(*ptr) -> refcnt)
- dfree ((*ptr), name);
+ dfree ((*ptr), file, line);
+ if ((*ptr) -> refcnt < 0) {
+ log_error ("buffer_dereference: negative refcnt!");
+#if defined (DEBUG_RC_HISTORY)
+ dump_rc_history ();
+#endif
+#if defined (POINTER_DEBUG)
+ abort ();
+#else
+ return 0;
+#endif
+ }
*ptr = (struct buffer *)0;
return 1;
}
-int dns_host_entry_allocate (ptr, hostname, name)
+int dns_host_entry_allocate (ptr, hostname, file, line)
struct dns_host_entry **ptr;
const char *hostname;
- const char *name;
+ const char *file;
+ int line;
{
struct dns_host_entry *bp;
- bp = dmalloc (strlen (hostname) + sizeof *bp, name);
+ bp = dmalloc (strlen (hostname) + sizeof *bp, file, line);
if (!bp)
return 0;
memset (bp, 0, sizeof *bp);
bp -> refcnt = 0;
strcpy (bp -> hostname, hostname);
- return dns_host_entry_reference (ptr, bp, name);
+ return dns_host_entry_reference (ptr, bp, file, line);
}
-int dns_host_entry_reference (ptr, bp, name)
+int dns_host_entry_reference (ptr, bp, file, line)
struct dns_host_entry **ptr;
struct dns_host_entry *bp;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
log_error ("Null pointer in dns_host_entry_reference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in dns_host_entry_reference (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = bp;
bp -> refcnt++;
+ rc_register (file, line, bp, bp -> refcnt);
+ dmalloc_reuse (bp, file, line, 1);
return 1;
}
-int dns_host_entry_dereference (ptr, name)
+int dns_host_entry_dereference (ptr, file, line)
struct dns_host_entry **ptr;
- const char *name;
+ const char *file;
+ int line;
{
struct dns_host_entry *bp;
if (!ptr || !*ptr) {
log_error ("Null pointer in dns_host_entry_dereference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
(*ptr) -> refcnt--;
+ rc_register (file, line, bp, bp -> refcnt);
if (!(*ptr) -> refcnt)
- dfree ((*ptr), name);
+ dfree ((*ptr), file, line);
+ if ((*ptr) -> refcnt < 0) {
+ log_error ("dns_host_entry_dereference: negative refcnt!");
+#if defined (DEBUG_RC_HISTORY)
+ dump_rc_history ();
+#endif
+#if defined (POINTER_DEBUG)
+ abort ();
+#else
+ return 0;
+#endif
+ }
*ptr = (struct dns_host_entry *)0;
return 1;
}
-int option_state_allocate (ptr, name)
+int option_state_allocate (ptr, file, line)
struct option_state **ptr;
- const char *name;
+ const char *file;
+ int line;
{
unsigned size;
if (!ptr) {
log_error ("Null pointer passed to option_state_allocate: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in option_state_allocate (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
size = sizeof **ptr + (universe_count - 1) * sizeof (VOIDPTR);
- *ptr = dmalloc (size, name);
+ *ptr = dmalloc (size, file, line);
if (*ptr) {
memset (*ptr, 0, size);
(*ptr) -> universe_count = universe_count;
(*ptr) -> refcnt = 1;
+ rc_register (file, line, *ptr, (*ptr) -> refcnt);
return 1;
}
return 0;
}
-int option_state_reference (ptr, bp, name)
+int option_state_reference (ptr, bp, file, line)
struct option_state **ptr;
struct option_state *bp;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
log_error ("Null pointer in option_state_reference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in option_state_reference (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = bp;
bp -> refcnt++;
+ rc_register (file, line, bp, bp -> refcnt);
+ dmalloc_reuse (bp, file, line, 1);
return 1;
}
-int option_state_dereference (ptr, name)
+int option_state_dereference (ptr, file, line)
struct option_state **ptr;
- const char *name;
+ const char *file;
+ int line;
{
int i;
struct option_state *options;
if (!ptr || !*ptr) {
log_error ("Null pointer in option_state_dereference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
options = *ptr;
*ptr = (struct option_state *)0;
--options -> refcnt;
- if (options -> refcnt)
+ rc_register (file, line, options, options -> refcnt);
+ if (options -> refcnt > 0)
return 1;
+ if (options -> refcnt < 0) {
+ log_error ("option_state_dereference: negative refcnt!");
+#if defined (DEBUG_RC_HISTORY)
+ dump_rc_history ();
+#endif
+#if defined (POINTER_DEBUG)
+ abort ();
+#else
+ return 0;
+#endif
+ }
+
/* Loop through the per-universe state. */
for (i = 0; i < options -> universe_count; i++)
if (options -> universes [i] &&
((*(universes [i] -> option_state_dereference))
(universes [i], options));
- dfree (options, name);
+ dfree (options, file, line);
return 1;
}
-int executable_statement_allocate (ptr, name)
+int executable_statement_allocate (ptr, file, line)
struct executable_statement **ptr;
- const char *name;
+ const char *file;
+ int line;
{
struct executable_statement *bp;
- bp = dmalloc (sizeof *bp, name);
+ bp = dmalloc (sizeof *bp, file, line);
if (!bp)
return 0;
memset (bp, 0, sizeof *bp);
- bp -> refcnt = 0;
- return executable_statement_reference (ptr, bp, name);
+ return executable_statement_reference (ptr, bp, file, line);
}
-int executable_statement_reference (ptr, bp, name)
+int executable_statement_reference (ptr, bp, file, line)
struct executable_statement **ptr;
struct executable_statement *bp;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
log_error ("Null ptr in executable_statement_reference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Nonnull ptr in executable_statement_reference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = bp;
bp -> refcnt++;
+ rc_register (file, line, bp, bp -> refcnt);
+ dmalloc_reuse (bp, file, line, 1);
return 1;
}
static struct packet *free_packets;
-int packet_allocate (ptr, name)
+int packet_allocate (ptr, file, line)
struct packet **ptr;
- const char *name;
+ const char *file;
+ int line;
{
int size;
if (!ptr) {
log_error ("Null pointer passed to packet_allocate: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in packet_allocate (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
#endif
}
- *ptr = dmalloc (sizeof **ptr, name);
+ *ptr = dmalloc (sizeof **ptr, file, line);
if (*ptr) {
memset (*ptr, 0, sizeof **ptr);
(*ptr) -> refcnt = 1;
return 0;
}
-int packet_reference (ptr, bp, name)
+int packet_reference (ptr, bp, file, line)
struct packet **ptr;
struct packet *bp;
- const char *name;
+ const char *file;
+ int line;
{
if (!ptr) {
log_error ("Null pointer in packet_reference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
if (*ptr) {
log_error ("Non-null pointer in packet_reference (%s)",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
}
*ptr = bp;
bp -> refcnt++;
+ rc_register (file, line, bp, bp -> refcnt);
+ dmalloc_reuse (bp, file, line, 1);
return 1;
}
-int packet_dereference (ptr, name)
+int packet_dereference (ptr, file, line)
struct packet **ptr;
- const char *name;
+ const char *file;
+ int line;
{
int i;
struct packet *packet;
if (!ptr || !*ptr) {
log_error ("Null pointer in packet_dereference: %s",
- name);
+ file, line);
#if defined (POINTER_DEBUG)
abort ();
#else
packet = *ptr;
*ptr = (struct packet *)0;
--packet -> refcnt;
- if (packet -> refcnt)
+ rc_register (file, line, packet, packet -> refcnt);
+ if (packet -> refcnt > 0)
return 1;
+ if (packet -> refcnt < 0) {
+ log_error ("option_state_dereference: negative refcnt!");
+#if defined (DEBUG_RC_HISTORY)
+ dump_rc_history ();
+#endif
+#if defined (POINTER_DEBUG)
+ abort ();
+#else
+ return 0;
+#endif
+ }
+
if (packet -> options)
- option_state_dereference (&packet -> options, name);
+ option_state_dereference (&packet -> options, file, line);
packet -> raw = (struct dhcp_packet *)free_packets;
free_packets = packet;
+ dmalloc_reuse (free_packets, (char *)0, 0);
+ return 1;
+}
+
+int binding_scope_allocate (ptr, file, line)
+ struct binding_scope **ptr;
+ const char *file;
+ int line;
+{
+ struct binding_scope *bp;
+
+ if (!ptr) {
+ log_error ("Null pointer in binding_scope_allocate: %s",
+ file, line);
+#if defined (POINTER_DEBUG)
+ abort ();
+#else
+ return 0;
+#endif
+ }
+
+ if (*ptr) {
+ log_error ("Non-null pointer in binding_scope_allocate: %s",
+ file, line);
+#if defined (POINTER_DEBUG)
+ abort ();
+#else
+ return 0;
+#endif
+ }
+
+ bp = dmalloc (sizeof *bp, file, line);
+ if (!bp)
+ return 0;
+ memset (bp, 0, sizeof *bp);
+ *ptr = bp;
return 1;
}
+
+/* Make a copy of the data in data_string, upping the buffer reference
+ count if there's a buffer. */
+
+void data_string_copy (dest, src, file, line)
+ struct data_string *dest;
+ struct data_string *src;
+ const char *name;
+ int line;
+{
+ if (src -> buffer)
+ buffer_reference (&dest -> buffer, src -> buffer, file, line);
+ dest -> data = src -> data;
+ dest -> terminated = src -> terminated;
+ dest -> len = src -> len;
+}
+
+/* Release the reference count to a data string's buffer (if any) and
+ zero out the other information, yielding the null data string. */
+
+void data_string_forget (data, name)
+ struct data_string *data;
+ const char *file;
+ int line;
+{
+ if (data -> buffer)
+ buffer_dereference (&data -> buffer, file, line);
+ memset (data, 0, sizeof *data);
+}
+
+/* Make a copy of the data in data_string, upping the buffer reference
+ count if there's a buffer. */
+
+void data_string_truncate (dp, len)
+ struct data_string *dp;
+ int len;
+{
+ if (len < dp -> len) {
+ dp -> terminated = 0;
+ dp -> len = len;
+ }
+}
projects / thirdparty / dhcp.git / commitdiff
