isc_result_t dhcp_subnet_destroy (omapi_object_t *h, const char *file, int line)
{
struct subnet *subnet;
isc_result_t status;
if (h -> type != dhcp_type_subnet)
return ISC_R_INVALIDARG;
subnet = (struct subnet *)h;
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
if (subnet -> next_subnet)
subnet_dereference (&subnet -> next_subnet, file, line);
if (subnet -> next_sibling)
subnet_dereference (&subnet -> next_sibling, file, line);
if (subnet -> shared_network)
shared_network_dereference (&subnet -> shared_network,
file, line);
if (subnet -> interface)
interface_dereference (&subnet -> interface, file, line);
if (subnet -> group)
group_dereference (&subnet -> group, file, line);
#endif
return ISC_R_SUCCESS;
}
isc_result_t dhcp_group_destroy (omapi_object_t *h, const char *file, int line)
{
struct group_object *group, *t;
isc_result_t status;
if (h -> type != dhcp_type_group)
return ISC_R_INVALIDARG;
group = (struct group_object *)h;
if (group -> name) {
if (group_name_hash) {
t = (struct group_object *)0;
if (group_hash_lookup (&t, group_name_hash,
group -> name,
strlen (group -> name), MDL)) {
group_hash_delete (group_name_hash,
group -> name,
strlen (group -> name),
MDL);
group_object_dereference (&t, MDL);
}
}
dfree (group -> name, file, line);
group -> name = (char *)0;
}
if (group -> group)
group_dereference (&group -> group, MDL);
return ISC_R_SUCCESS;
}
int clone_group (struct group **gp, struct group *group,
const char *file, int line)
{
struct group *g = (struct group *)0;
/* Normally gp should contain the null pointer, but for convenience
it's permissible to clone a group into itself. */
if (*gp && *gp != group)
return 0;
if (!group_allocate (&g, file, line))
return 0;
if (group == *gp)
*gp = (struct group *)0;
group_reference (gp, g, file, line);
g -> authoritative = group -> authoritative;
group_reference (&g -> next, group, file, line);
group_dereference (&g, file, line);
return 1;
}
isc_result_t dhcp_shared_network_destroy (omapi_object_t *h,
const char *file, int line)
{
/* In this function h should be a (struct shared_network *) */
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
struct shared_network *shared_network;
#endif
if (h -> type != dhcp_type_shared_network)
return DHCP_R_INVALIDARG;
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
shared_network = (struct shared_network *)h;
if (shared_network -> next)
shared_network_dereference (&shared_network -> next,
file, line);
if (shared_network -> name) {
dfree (shared_network -> name, file, line);
shared_network -> name = 0;
}
if (shared_network -> subnets)
subnet_dereference (&shared_network -> subnets, file, line);
if (shared_network -> interface)
interface_dereference (&shared_network -> interface,
file, line);
if (shared_network -> pools)
omapi_object_dereference ((omapi_object_t **)
&shared_network -> pools, file, line);
if (shared_network -> group)
group_dereference (&shared_network -> group, file, line);
#if defined (FAILOVER_PROTOCOL)
if (shared_network -> failover_peer)
omapi_object_dereference ((omapi_object_t **)
&shared_network -> failover_peer,
file, line);
#endif
#endif /* DEBUG_MEMORY_LEAKAGE */
return ISC_R_SUCCESS;
}
isc_result_t delete_group (struct group_object *group, int writep)
{
struct group_object *d;
/* The group should exist and be hashed - if not, it's invalid. */
if (group_name_hash) {
d = (struct group_object *)0;
group_hash_lookup (&d, group_name_hash, group -> name,
strlen (group -> name), MDL);
} else
return ISC_R_INVALIDARG;
if (!d)
return ISC_R_INVALIDARG;
/* Also not okay to delete a group that's not the one in
the hash table. */
if (d != group)
return ISC_R_INVALIDARG;
/* If it's dynamic, and we're deleting it, we can just blow away the
hash table entry. */
if ((group -> flags & GROUP_OBJECT_DYNAMIC) &&
!(group -> flags & GROUP_OBJECT_STATIC)) {
group_hash_delete (group_name_hash,
group -> name, strlen (group -> name), MDL);
} else {
group -> flags |= GROUP_OBJECT_DELETED;
if (group -> group)
group_dereference (&group -> group, MDL);
}
/* Store the group declaration in the lease file. */
if (writep && group_write_hook) {
if (!(*group_write_hook) (group))
return ISC_R_IOERROR;
}
return ISC_R_SUCCESS;
}
