void knot_zone_free(knot_zone_t **zone)
{
if (zone == NULL || *zone == NULL) {
return;
}
dbg_zone("zone_free().\n");
if ((*zone)->contents
&& !knot_zone_contents_gen_is_old((*zone)->contents)) {
// zone is in the middle of an update, report
dbg_zone("Destroying zone that is in the middle of an "
"update.\n");
}
knot_dname_release((*zone)->name);
/* Call zone data destructor if exists. */
if ((*zone)->dtor) {
(*zone)->dtor(*zone);
}
knot_zone_contents_free(&(*zone)->contents);
free(*zone);
*zone = NULL;
dbg_zone("Done.\n");
}
knot_zone_t *knot_zone_new_empty(knot_dname_t *name)
{
if (!name) {
return 0;
}
dbg_zone("Creating new zone!\n");
knot_zone_t *zone = malloc(sizeof(knot_zone_t));
if (zone == NULL) {
ERR_ALLOC_FAILED;
return NULL;
}
memset(zone, 0, sizeof(knot_zone_t));
// save the zone name
dbg_zone("Setting zone name.\n");
zone->name = name;
/* Initialize reference counting. */
ref_init(&zone->ref, knot_zone_dtor);
/* Set reference counter to 1, caller should release it after use. */
knot_zone_retain(zone);
return zone;
}
void knot_zone_deep_free(knot_zone_t **zone)
{
if (zone == NULL || *zone == NULL) {
return;
}
if ((*zone)->contents
&& !knot_zone_contents_gen_is_old((*zone)->contents)) {
// zone is in the middle of an update, report
dbg_zone("Destroying zone that is in the middle of an "
"update.\n");
}
dbg_zone_exec(
char *name = knot_dname_to_str((*zone)->name);
dbg_zone("Destroying zone %p, name: %s.\n", *zone, name);
free(name);
);
static int zone_contents_add_nsec3_node(zone_contents_t *zone, zone_node_t *node)
{
if (zone == NULL || node == NULL) {
return KNOT_EINVAL;
}
int ret = 0;
if ((ret = zone_contents_check_node(zone, node)) != 0) {
dbg_zone("Failed node check: %s\n", knot_strerror(ret));
return ret;
}
/* Create NSEC3 tree if not exists. */
if (zone->nsec3_nodes == NULL) {
zone->nsec3_nodes = zone_tree_create();
if (zone->nsec3_nodes == NULL) {
return KNOT_ENOMEM;
}
}
// how to know if this is successfull??
ret = zone_tree_insert(zone->nsec3_nodes, node);
if (ret != KNOT_EOK) {
dbg_zone("Failed to insert node into NSEC3 tree: %s.\n",
knot_strerror(ret));
return ret;
}
// no parents to be created, the only parent is the zone apex
// set the apex as the parent of the node
node_set_parent(node, zone->apex);
// cannot be wildcard child, so nothing to be done
return KNOT_EOK;
}
zone_contents_t *zone_contents_new(const knot_dname_t *apex_name)
{
dbg_zone("%s(%p)\n", __func__, apex_name);
if (apex_name == NULL) {
return NULL;
}
zone_contents_t *contents = malloc(sizeof(zone_contents_t));
if (contents == NULL) {
return NULL;
}
memset(contents, 0, sizeof(zone_contents_t));
contents->apex = node_new(apex_name, NULL);
if (contents->apex == NULL) {
goto cleanup;
}
contents->nodes = zone_tree_create();
if (contents->nodes == NULL) {
goto cleanup;
}
if (zone_tree_insert(contents->nodes, contents->apex) != KNOT_EOK) {
goto cleanup;
}
return contents;
cleanup:
dbg_zone("%s: failure to initialize contents %p\n", __func__, contents);
free(contents->nodes);
free(contents->nsec3_nodes);
free(contents);
return NULL;
}
static zone_node_t *zone_contents_get_node(const zone_contents_t *zone,
const knot_dname_t *name)
{
if (zone == NULL || name == NULL) {
return NULL;
}
zone_node_t *n;
int ret = zone_tree_get(zone->nodes, name, &n);
if (ret != KNOT_EOK) {
dbg_zone("Failed to find name in the zone tree.\n");
return NULL;
}
return n;
}
knot_zone_t *knot_zone_new(knot_node_t *apex)
{
knot_zone_t *zone = knot_zone_new_empty(
knot_dname_deep_copy(knot_node_owner(apex)));
if (zone == NULL) {
return NULL;
}
dbg_zone("Creating zone contents.\n");
zone->contents = knot_zone_contents_new(apex, zone);
if (zone->contents == NULL) {
knot_dname_release(zone->name);
free(zone);
return NULL;
}
zone->contents->zone = zone;
return zone;
}
static int zone_contents_add_node(zone_contents_t *zone, zone_node_t *node,
bool create_parents)
{
if (zone == NULL || node == NULL) {
return KNOT_EINVAL;
}
int ret = 0;
if ((ret = zone_contents_check_node(zone, node)) != 0) {
dbg_zone("Node check failed.\n");
return ret;
}
ret = zone_tree_insert(zone->nodes, node);
if (ret != KNOT_EOK) {
dbg_zone("Failed to insert node into zone tree.\n");
return ret;
}
if (!create_parents) {
return KNOT_EOK;
}
dbg_zone_detail("Creating parents of the node.\n");
/* No parents for root domain. */
if (*node->owner == '\0')
return KNOT_EOK;
zone_node_t *next_node = NULL;
const uint8_t *parent = knot_wire_next_label(node->owner, NULL);
if (knot_dname_cmp(zone->apex->owner, parent) == 0) {
dbg_zone_detail("Zone apex is the parent.\n");
node_set_parent(node, zone->apex);
// check if the node is not wildcard child of the parent
if (knot_dname_is_wildcard(node->owner)) {
zone->apex->flags |= NODE_FLAGS_WILDCARD_CHILD;
}
} else {
while (parent != NULL &&
!(next_node = zone_contents_get_node(zone, parent))) {
/* Create a new node. */
dbg_zone_detail("Creating new node.\n");
next_node = node_new(parent, NULL);
if (next_node == NULL) {
return KNOT_ENOMEM;
}
/* Insert node to a tree. */
dbg_zone_detail("Inserting new node to zone tree.\n");
ret = zone_tree_insert(zone->nodes, next_node);
if (ret != KNOT_EOK) {
node_free(&next_node, NULL);
return ret;
}
/* Update node pointers. */
node_set_parent(node, next_node);
if (knot_dname_is_wildcard(node->owner)) {
next_node->flags |= NODE_FLAGS_WILDCARD_CHILD;
}
dbg_zone_detail("Next parent.\n");
node = next_node;
parent = knot_wire_next_label(parent, NULL);
}
// set the found parent (in the zone) as the parent of the last
// inserted node
assert(node->parent == NULL);
node_set_parent(node, next_node);
dbg_zone_detail("Created all parents.\n");
}
return KNOT_EOK;
}
