/* append interface to interface array (names, udp, tcp) */
void
add_interface(char*** nodes, struct nsd* nsd, char* ip)
{
/* realloc the arrays */
if(nsd->ifs == 0) {
*nodes = xalloc_zero(sizeof(*nodes));
nsd->udp = xalloc_zero(sizeof(*nsd->udp));
nsd->tcp = xalloc_zero(sizeof(*nsd->udp));
} else {
region_remove_cleanup(nsd->region, free, *nodes);
region_remove_cleanup(nsd->region, free, nsd->udp);
region_remove_cleanup(nsd->region, free, nsd->tcp);
*nodes = xrealloc(*nodes, (nsd->ifs+1)*sizeof(*nodes));
nsd->udp = xrealloc(nsd->udp, (nsd->ifs+1)*sizeof(*nsd->udp));
nsd->tcp = xrealloc(nsd->tcp, (nsd->ifs+1)*sizeof(*nsd->udp));
(*nodes)[nsd->ifs] = NULL;
memset(&nsd->udp[nsd->ifs], 0, sizeof(*nsd->udp));
memset(&nsd->tcp[nsd->ifs], 0, sizeof(*nsd->tcp));
}
region_add_cleanup(nsd->region, free, *nodes);
region_add_cleanup(nsd->region, free, nsd->udp);
region_add_cleanup(nsd->region, free, nsd->tcp);
/* add it */
(*nodes)[nsd->ifs] = ip;
++nsd->ifs;
}
struct state_pretty_rr*
create_pretty_rr(struct region* region)
{
struct state_pretty_rr* state = (struct state_pretty_rr*)
region_alloc(region, sizeof(struct state_pretty_rr));
state->previous_owner_region = region_create(xalloc, free);
state->previous_owner = NULL;
state->previous_owner_origin = NULL;
region_add_cleanup(region, cleanup_region,
state->previous_owner_region);
return state;
}
buffer_type *
buffer_create(region_type *region, size_t capacity)
{
buffer_type *buffer
= (buffer_type *) region_alloc(region, sizeof(buffer_type));
if (!buffer)
return NULL;
buffer->_data = (uint8_t *) xalloc(capacity);
buffer->_position = 0;
buffer->_limit = buffer->_capacity = capacity;
buffer->_fixed = 0;
buffer_invariant(buffer);
region_add_cleanup(region, buffer_cleanup, buffer);
return buffer;
}
static void
initialize_dname_compression_tables(struct nsd *nsd)
{
size_t needed = domain_table_count(nsd->db->domains) + 1;
needed += EXTRA_DOMAIN_NUMBERS;
if(compression_table_capacity < needed) {
if(compressed_dname_offsets) {
region_remove_cleanup(nsd->db->region,
cleanup_dname_compression_tables,
compressed_dname_offsets);
free(compressed_dname_offsets);
}
compressed_dname_offsets = (uint16_t *) xalloc(
needed * sizeof(uint16_t));
region_add_cleanup(nsd->db->region, cleanup_dname_compression_tables,
compressed_dname_offsets);
compression_table_capacity = needed;
compression_table_size=domain_table_count(nsd->db->domains)+1;
}
memset(compressed_dname_offsets, 0, needed * sizeof(uint16_t));
compressed_dname_offsets[0] = QHEADERSZ; /* The original query name */
}
void *
region_alloc(region_type *region, size_t size)
{
size_t aligned_size;
void *result;
if (size == 0) {
size = 1;
}
aligned_size = REGION_ALIGN_UP(size, ALIGNMENT);
if (aligned_size >= region->large_object_size) {
result = region->allocator(size + sizeof(struct large_elem));
if (!result)
return NULL;
((struct large_elem*)result)->prev = NULL;
((struct large_elem*)result)->next = region->large_list;
if(region->large_list)
region->large_list->prev = (struct large_elem*)result;
region->large_list = (struct large_elem*)result;
region->total_allocated += size;
++region->large_objects;
return result + sizeof(struct large_elem);
}
if (region->recycle_bin && region->recycle_bin[aligned_size]) {
result = (void*)region->recycle_bin[aligned_size];
region->recycle_bin[aligned_size] = region->recycle_bin[aligned_size]->next;
region->recycle_size -= aligned_size;
region->unused_space += aligned_size - size;
return result;
}
if (region->allocated + aligned_size > region->chunk_size) {
void *chunk = region->allocator(region->chunk_size);
size_t wasted;
if (!chunk)
return NULL;
wasted = (region->chunk_size - region->allocated) & (~(ALIGNMENT-1));
if(
#ifndef PACKED_STRUCTS
wasted >= ALIGNMENT
#else
wasted >= SIZEOF_VOIDP
#endif
) {
/* put wasted part in recycle bin for later use */
region->total_allocated += wasted;
++region->small_objects;
region_recycle(region, region->data+region->allocated, wasted);
region->allocated += wasted;
}
++region->chunk_count;
region->unused_space += region->chunk_size - region->allocated;
if(!region_add_cleanup(region, region->deallocator, chunk)) {
region->deallocator(chunk);
region->chunk_count--;
region->unused_space -=
region->chunk_size - region->allocated;
return NULL;
}
region->allocated = 0;
region->data = (char *) chunk;
}
result = region->data + region->allocated;
region->allocated += aligned_size;
region->total_allocated += aligned_size;
region->unused_space += aligned_size - size;
++region->small_objects;
return result;
}
