Skip to content
Snippets Groups Projects
Commit 4e18890d authored by Daniel Salzman's avatar Daniel Salzman
Browse files

contents: code cleanup

parent f54c7469
No related branches found
No related tags found
1 merge request!458Contents cleanup
Hide whitespace changes
Inline Side-by-side
src/knot/zone/contents.c
+ 92
− 204
View file @ 4e18890d
......@@ -23,10 +23,6 @@
#include "libknot/internal/trie/hat-trie.h"
#include "libknot/internal/macros.h"
/*----------------------------------------------------------------------------*/
/* Non-API functions */
/*----------------------------------------------------------------------------*/
typedef struct {
zone_contents_apply_cb_t func;
void *data;
......@@ -38,8 +34,6 @@ typedef struct {
zone_node_t *previous_node;
} zone_adjust_arg_t;
/*----------------------------------------------------------------------------*/
static int tree_apply_cb(zone_node_t **node, void *data)
{
if (node == NULL || data == NULL) {
......@@ -50,7 +44,6 @@ static int tree_apply_cb(zone_node_t **node, void *data)
return f->func(*node, f->data);
}
/*----------------------------------------------------------------------------*/
/*!
* \brief Checks if the given node can be inserted into the given zone.
*
......@@ -65,24 +58,20 @@ static int tree_apply_cb(zone_node_t **node, void *data)
* \retval KNOT_EINVAL if either of the arguments is NULL.
* \retval KNOT_EOUTOFZONE if the node does not belong to the zone.
*/
static int check_node(
const zone_contents_t *contents, const zone_node_t *node)
static int check_node(const zone_contents_t *contents, const zone_node_t *node)
{
if (contents == NULL || node == NULL) {
return KNOT_EINVAL;
}
// assert or just check??
assert(contents->apex != NULL);
if (!knot_dname_is_sub(node->owner,
contents->apex->owner)) {
if (!knot_dname_is_sub(node->owner, contents->apex->owner)) {
return KNOT_EOUTOFZONE;
}
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
/*!
* \brief Destroys all RRSets in a node.
*
......@@ -91,11 +80,11 @@ static int check_node(
* \param node Node to destroy RRSets from.
* \param data Unused parameter.
*/
static int destroy_node_rrsets_from_tree(
zone_node_t **tnode, void *data)
static int destroy_node_rrsets_from_tree(zone_node_t **tnode, void *data)
{
UNUSED(data);
assert(tnode != NULL);
UNUSED(data);
if (*tnode != NULL) {
node_free_rrsets(*tnode, NULL);
node_free(tnode, NULL);
......@@ -104,24 +93,21 @@ static int destroy_node_rrsets_from_tree(
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
static int create_nsec3_name(const zone_contents_t *zone,
const knot_dname_t *name,
knot_dname_t **nsec3_name)
const knot_dname_t *name,
knot_dname_t **nsec3_name)
{
assert(zone != NULL);
assert(nsec3_name != NULL);
*nsec3_name = NULL;
const knot_nsec3_params_t *nsec3_params =
zone_contents_nsec3params(zone);
*nsec3_name = NULL;
const knot_nsec3_params_t *nsec3_params = zone_contents_nsec3params(zone);
if (nsec3_params == NULL) {
return KNOT_ENSEC3PAR;
}
*nsec3_name = knot_create_nsec3_owner(name, zone->apex->owner,
nsec3_params);
*nsec3_name = knot_create_nsec3_owner(name, zone->apex->owner, nsec3_params);
if (*nsec3_name == NULL) {
return KNOT_ERROR;
}
......@@ -130,11 +116,10 @@ static int create_nsec3_name(const zone_contents_t *zone,
}
/*! \brief Link pointers to additional nodes for this RRSet. */
static int discover_additionals(struct rr_data *rr_data,
zone_contents_t *zone)
static int discover_additionals(struct rr_data *rr_data, zone_contents_t *zone)
{
const zone_node_t *node = NULL, *encloser = NULL, *prev = NULL;
const knot_dname_t *dname = NULL;
assert(rr_data != NULL);
const knot_rdataset_t *rrs = &rr_data->rrs;
/* Create new additional nodes. */
......@@ -148,15 +133,15 @@ static int discover_additionals(struct rr_data *rr_data,
}
for (uint16_t i = 0; i < rdcount; i++) {
const knot_dname_t *dname = knot_rdata_name(rrs, i, rr_data->type);
const zone_node_t *node = NULL, *encloser = NULL, *prev = NULL;
/* Try to find node for the dname in the RDATA. */
dname = knot_rdata_name(rrs, i, rr_data->type);
zone_contents_find_dname(zone, dname, &node, &encloser, &prev);
if (node == NULL && encloser
if (node == NULL && encloser != NULL
&& (encloser->flags & NODE_FLAGS_WILDCARD_CHILD)) {
/* Find wildcard child in the zone. */
node = zone_contents_find_wildcard_child(zone,
encloser);
node = zone_contents_find_wildcard_child(zone, encloser);
assert(node != NULL);
}
......@@ -166,12 +151,11 @@ static int discover_additionals(struct rr_data *rr_data,
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
static int adjust_pointers(zone_node_t **tnode, void *data)
{
assert(data != NULL);
assert(tnode != NULL);
assert(data != NULL);
zone_adjust_arg_t *args = (zone_adjust_arg_t *)data;
zone_node_t *node = *tnode;
......@@ -191,7 +175,7 @@ static int adjust_pointers(zone_node_t **tnode, void *data)
// set flags (delegation point, non-authoritative)
if (node->parent &&
((node->parent->flags & NODE_FLAGS_DELEG) ||
(node->parent->flags & NODE_FLAGS_DELEG ||
node->parent->flags & NODE_FLAGS_NONAUTH)) {
node->flags |= NODE_FLAGS_NONAUTH;
} else if (node_rrtype_exists(node, KNOT_RRTYPE_NS) && node != args->zone->apex) {
......@@ -216,8 +200,10 @@ static int adjust_nsec3_pointers(zone_node_t **tnode, void *data)
{
assert(data != NULL);
assert(tnode != NULL);
zone_adjust_arg_t *args = (zone_adjust_arg_t *)data;
zone_node_t *node = *tnode;
// Connect to NSEC3 node (only if NSEC3 tree is not empty)
zone_node_t *nsec3 = NULL;
knot_dname_t *nsec3_name = NULL;
......@@ -232,6 +218,7 @@ static int adjust_nsec3_pointers(zone_node_t **tnode, void *data)
}
knot_dname_free(&nsec3_name, NULL);
return ret;
}
......@@ -249,8 +236,9 @@ static int adjust_nsec3_pointers(zone_node_t **tnode, void *data)
*/
static int adjust_normal_node(zone_node_t **tnode, void *data)
{
assert(data != NULL);
assert(tnode != NULL && *tnode);
assert(data != NULL);
// Do cheap operations first
int ret = adjust_pointers(tnode, data);
if (ret != KNOT_EOK) {
......@@ -261,8 +249,6 @@ static int adjust_normal_node(zone_node_t **tnode, void *data)
return adjust_nsec3_pointers(tnode, data);
}
/*----------------------------------------------------------------------------*/
/*!
* \brief Adjust NSEC3 node.
*
......@@ -282,13 +268,11 @@ static int adjust_nsec3_node(zone_node_t **tnode, void *data)
zone_node_t *node = *tnode;
// remember first node
if (args->first_node == NULL) {
args->first_node = node;
}
// set previous node
node->prev = args->previous_node;
args->previous_node = node;
......@@ -301,7 +285,6 @@ static int adjust_additional(zone_node_t **tnode, void *data)
assert(data != NULL);
assert(tnode != NULL);
int ret = KNOT_EOK;
zone_adjust_arg_t *args = (zone_adjust_arg_t *)data;
zone_node_t *node = *tnode;
......@@ -309,17 +292,16 @@ static int adjust_additional(zone_node_t **tnode, void *data)
for(uint16_t i = 0; i < node->rrset_count; ++i) {
struct rr_data *rr_data = &node->rrs[i];
if (knot_rrtype_additional_needed(rr_data->type)) {
ret = discover_additionals(rr_data, args->zone);
int ret = discover_additionals(rr_data, args->zone);
if (ret != KNOT_EOK) {
break;
return ret;
}
}
}
return ret;
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
/*!
* \brief Tries to find the given domain name in the zone tree.
*
......@@ -336,10 +318,8 @@ static int adjust_additional(zone_node_t **tnode, void *data)
* \retval 0 if the domain name was not found. \a node may hold any (or none)
* node. \a previous is set properly.
*/
static int find_in_tree(zone_tree_t *tree,
const knot_dname_t *name,
zone_node_t **node,
zone_node_t **previous)
static int find_in_tree(zone_tree_t *tree, const knot_dname_t *name,
zone_node_t **node, zone_node_t **previous)
{
assert(tree != NULL);
assert(name != NULL);
......@@ -348,23 +328,21 @@ static int find_in_tree(zone_tree_t *tree,
zone_node_t *found = NULL, *prev = NULL;
int exact_match = zone_tree_get_less_or_equal(tree, name, &found,
&prev);
int exact_match = zone_tree_get_less_or_equal(tree, name, &found, &prev);
assert(exact_match >= 0);
*node = found;
*previous = prev;
return exact_match;
}
/*----------------------------------------------------------------------------*/
static int nsec3_params_match(const knot_rdataset_t *rrs,
const knot_nsec3_params_t *params,
size_t rdata_pos)
static bool nsec3_params_match(const knot_rdataset_t *rrs,
const knot_nsec3_params_t *params,
size_t rdata_pos)
{
assert(rrs != NULL && params != NULL);
assert(rrs != NULL);
assert(params != NULL);
return (knot_nsec3_algorithm(rrs, rdata_pos) == params->algorithm
&& knot_nsec3_iterations(rrs, rdata_pos) == params->iterations
......@@ -373,10 +351,6 @@ static int nsec3_params_match(const knot_rdataset_t *rrs,
params->salt_length) == 0);
}
/*----------------------------------------------------------------------------*/
/* API functions */
/*----------------------------------------------------------------------------*/
zone_contents_t *zone_contents_new(const knot_dname_t *apex_name)
{
if (apex_name == NULL) {
......@@ -412,10 +386,7 @@ cleanup:
return NULL;
}
/*----------------------------------------------------------------------------*/
static zone_node_t *get_node(const zone_contents_t *zone,
const knot_dname_t *name)
static zone_node_t *get_node(const zone_contents_t *zone, const knot_dname_t *name)
{
if (zone == NULL || name == NULL) {
return NULL;
......@@ -430,17 +401,14 @@ static zone_node_t *get_node(const zone_contents_t *zone,
return n;
}
/*----------------------------------------------------------------------------*/
static int add_node(zone_contents_t *zone, zone_node_t *node,
bool create_parents)
static int 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 = check_node(zone, node)) != 0) {
int ret = check_node(zone, node);
if (ret != KNOT_EOK) {
return ret;
}
......@@ -454,8 +422,9 @@ static int add_node(zone_contents_t *zone, zone_node_t *node,
}
/* No parents for root domain. */
if (*node->owner == '\0')
if (*node->owner == '\0') {
return KNOT_EOK;
}
zone_node_t *next_node = NULL;
const uint8_t *parent = knot_wire_next_label(node->owner, NULL);
......@@ -468,8 +437,7 @@ static int add_node(zone_contents_t *zone, zone_node_t *node,
zone->apex->flags |= NODE_FLAGS_WILDCARD_CHILD;
}
} else {
while (parent != NULL &&
!(next_node = get_node(zone, parent))) {
while (parent != NULL && !(next_node = get_node(zone, parent))) {
/* Create a new node. */
next_node = node_new(parent, NULL);
......@@ -503,16 +471,14 @@ static int add_node(zone_contents_t *zone, zone_node_t *node,
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
static int add_nsec3_node(zone_contents_t *zone, zone_node_t *node)
{
if (zone == NULL || node == NULL) {
return KNOT_EINVAL;
}
int ret = 0;
if ((ret = check_node(zone, node)) != 0) {
int ret = check_node(zone, node);
if (ret != KNOT_EOK) {
return ret;
}
......@@ -540,7 +506,7 @@ static int add_nsec3_node(zone_contents_t *zone, zone_node_t *node)
}
static zone_node_t *get_nsec3_node(const zone_contents_t *zone,
const knot_dname_t *name)
const knot_dname_t *name)
{
if (zone == NULL || name == NULL) {
return NULL;
......@@ -555,9 +521,8 @@ static zone_node_t *get_nsec3_node(const zone_contents_t *zone,
return n;
}
static int insert_rr(zone_contents_t *z,
const knot_rrset_t *rr, zone_node_t **n,
bool nsec3)
static int insert_rr(zone_contents_t *z, const knot_rrset_t *rr,
zone_node_t **n, bool nsec3)
{
if (z == NULL || knot_rrset_empty(rr) || n == NULL) {
return KNOT_EINVAL;
......@@ -571,16 +536,14 @@ static int insert_rr(zone_contents_t *z,
int ret = KNOT_EOK;
if (*n == NULL) {
*n = nsec3 ? get_nsec3_node(z, rr->owner) :
get_node(z, rr->owner);
*n = nsec3 ? get_nsec3_node(z, rr->owner) : get_node(z, rr->owner);
if (*n == NULL) {
// Create new, insert
*n = node_new(rr->owner, NULL);
if (*n == NULL) {
return KNOT_ENOMEM;
}
ret = nsec3 ? add_nsec3_node(z, *n) :
add_node(z, *n, true);
ret = nsec3 ? add_nsec3_node(z, *n) : add_node(z, *n, true);
if (ret != KNOT_EOK) {
node_free(n, NULL);
}
......@@ -616,6 +579,7 @@ static int recreate_normal_tree(const zone_contents_t *z, zone_contents_t *out)
if (itt == NULL) {
return KNOT_ENOMEM;
}
while (!hattrie_iter_finished(itt)) {
const zone_node_t *to_cpy = (zone_node_t *)*hattrie_iter_val(itt);
if (to_cpy == z->apex) {
......@@ -662,12 +626,14 @@ static int recreate_nsec3_tree(const zone_contents_t *z, zone_contents_t *out)
hattrie_iter_free(itt);
return KNOT_ENOMEM;
}
int ret = add_nsec3_node(out, to_add);
if (ret != KNOT_EOK) {
hattrie_iter_free(itt);
node_free(&to_add, NULL);
return ret;
}
hattrie_iter_next(itt);
}
......@@ -684,10 +650,9 @@ static bool rrset_is_nsec3rel(const knot_rrset_t *rr)
}
/* Is NSEC3 or non-empty RRSIG covering NSEC3. */
return ((rr->type == KNOT_RRTYPE_NSEC3)
|| (rr->type == KNOT_RRTYPE_RRSIG
&& knot_rrsig_type_covered(&rr->rrs, 0)
== KNOT_RRTYPE_NSEC3));
return ((rr->type == KNOT_RRTYPE_NSEC3) ||
(rr->type == KNOT_RRTYPE_RRSIG
&& knot_rrsig_type_covered(&rr->rrs, 0) == KNOT_RRTYPE_NSEC3));
}
int zone_contents_add_rr(zone_contents_t *z, const knot_rrset_t *rr,
......@@ -700,16 +665,12 @@ int zone_contents_add_rr(zone_contents_t *z, const knot_rrset_t *rr,
return insert_rr(z, rr, n, rrset_is_nsec3rel(rr));
}
/*----------------------------------------------------------------------------*/
const zone_node_t *zone_contents_find_node(const zone_contents_t *zone,
const knot_dname_t *name)
{
return get_node(zone, name);
}
/*----------------------------------------------------------------------------*/
int zone_contents_find_dname(const zone_contents_t *zone,
const knot_dname_t *name,
const zone_node_t **node,
......@@ -724,8 +685,7 @@ int zone_contents_find_dname(const zone_contents_t *zone,
zone_node_t *found = NULL, *prev = NULL;
int exact_match = find_in_tree(zone->nodes, name,
&found, &prev);
int exact_match = find_in_tree(zone->nodes, name, &found, &prev);
assert(exact_match >= 0);
*node = found;
*previous = prev;
......@@ -753,24 +713,18 @@ int zone_contents_find_dname(const zone_contents_t *zone,
*closest_encloser = *previous;
assert(*closest_encloser != NULL);
int matched_labels = knot_dname_matched_labels((*closest_encloser)->owner,
name);
int matched_labels = knot_dname_matched_labels((*closest_encloser)->owner, name);
while (matched_labels < knot_dname_labels((*closest_encloser)->owner, NULL)) {
(*closest_encloser) =
(*closest_encloser)->parent;
*closest_encloser = (*closest_encloser)->parent;
assert(*closest_encloser);
}
}
return (exact_match)
? ZONE_NAME_FOUND
: ZONE_NAME_NOT_FOUND;
return exact_match ? ZONE_NAME_FOUND : ZONE_NAME_NOT_FOUND;
}
/*----------------------------------------------------------------------------*/
static zone_node_t *get_previous(const zone_contents_t *zone,
const knot_dname_t *name)
const knot_dname_t *name)
{
if (zone == NULL || name == NULL) {
return NULL;
......@@ -778,39 +732,32 @@ static zone_node_t *get_previous(const zone_contents_t *zone,
zone_node_t *found = NULL, *prev = NULL;
int exact_match = find_in_tree(zone->nodes, name,
&found, &prev);
int exact_match = find_in_tree(zone->nodes, name, &found, &prev);
assert(exact_match >= 0);
assert(prev != NULL);
return prev;
}
/*----------------------------------------------------------------------------*/
const zone_node_t *zone_contents_find_previous(const zone_contents_t *zone,
const knot_dname_t *name)
{
return get_previous(zone, name);
}
/*----------------------------------------------------------------------------*/
const zone_node_t *zone_contents_find_nsec3_node(const zone_contents_t *zone,
const knot_dname_t *name)
{
return get_nsec3_node(zone, name);
}
/*----------------------------------------------------------------------------*/
int zone_contents_find_nsec3_for_name(const zone_contents_t *zone,
const knot_dname_t *name,
const zone_node_t **nsec3_node,
const zone_node_t **nsec3_previous)
{
if (zone == NULL || name == NULL
|| nsec3_node == NULL || nsec3_previous == NULL) {
if (zone == NULL || name == NULL || nsec3_node == NULL ||
nsec3_previous == NULL) {
return KNOT_EINVAL;
}
......@@ -821,7 +768,6 @@ int zone_contents_find_nsec3_for_name(const zone_contents_t *zone,
knot_dname_t *nsec3_name = NULL;
int ret = create_nsec3_name(zone, name, &nsec3_name);
if (ret != KNOT_EOK) {
return ret;
}
......@@ -829,8 +775,8 @@ int zone_contents_find_nsec3_for_name(const zone_contents_t *zone,
const zone_node_t *found = NULL, *prev = NULL;
// create dummy node to use for lookup
int exact_match = zone_tree_find_less_or_equal(
zone->nsec3_nodes, nsec3_name, &found, &prev);
int exact_match = zone_tree_find_less_or_equal(zone->nsec3_nodes, nsec3_name,
&found, &prev);
assert(exact_match >= 0);
knot_dname_free(&nsec3_name, NULL);
......@@ -852,19 +798,14 @@ int zone_contents_find_nsec3_for_name(const zone_contents_t *zone,
* from the right chain. Check iterations, hash algorithm and salt
* values and compare them to the ones from NSEC3PARAM.
*/
const knot_rdataset_t *nsec3_rrs =
node_rdataset(*nsec3_previous, KNOT_RRTYPE_NSEC3);
const knot_rdataset_t *nsec3_rrs = node_rdataset(*nsec3_previous, KNOT_RRTYPE_NSEC3);
const zone_node_t *original_prev = *nsec3_previous;
int match = 0;
while (nsec3_rrs && !match) {
for (uint16_t i = 0;
i < nsec3_rrs->rr_count && !match;
i++) {
if (nsec3_params_match(nsec3_rrs,
&zone->nsec3_params,
i)) {
for (uint16_t i = 0; i < nsec3_rrs->rr_count && !match; i++) {
if (nsec3_params_match(nsec3_rrs, &zone->nsec3_params, i)) {
/* Matching NSEC3PARAM match at position nr.: i. */
match = 1;
}
......@@ -884,13 +825,9 @@ int zone_contents_find_nsec3_for_name(const zone_contents_t *zone,
}
}
return (exact_match)
? ZONE_NAME_FOUND
: ZONE_NAME_NOT_FOUND;
return exact_match ? ZONE_NAME_FOUND : ZONE_NAME_NOT_FOUND;
}
/*----------------------------------------------------------------------------*/
const zone_node_t *zone_contents_find_wildcard_child(const zone_contents_t *contents,
const zone_node_t *parent)
{
......@@ -903,11 +840,8 @@ const zone_node_t *zone_contents_find_wildcard_child(const zone_contents_t *cont
return zone_contents_find_node(contents, wildcard);
}
/*----------------------------------------------------------------------------*/
static int adjust_nodes(zone_tree_t *nodes,
zone_adjust_arg_t *adjust_arg,
zone_tree_apply_cb_t callback)
static int adjust_nodes(zone_tree_t *nodes, zone_adjust_arg_t *adjust_arg,
zone_tree_apply_cb_t callback)
{
if (zone_tree_is_empty(nodes)) {
return KNOT_EOK;
......@@ -930,28 +864,23 @@ static int adjust_nodes(zone_tree_t *nodes,
return result;
}
/*----------------------------------------------------------------------------*/
static int adjust_nsec3_tree(zone_contents_t *contents)
{
// adjusting parameters
zone_adjust_arg_t adjust_arg = { .first_node = NULL,
.previous_node = NULL,
.zone = contents };
return adjust_nodes(contents->nsec3_nodes,
&adjust_arg,
adjust_nsec3_node);
}
/*----------------------------------------------------------------------------*/
return adjust_nodes(contents->nsec3_nodes, &adjust_arg, adjust_nsec3_node);
}
int zone_contents_adjust_pointers(zone_contents_t *contents)
{
int ret = zone_contents_load_nsec3param(contents);
if (ret != KNOT_EOK) {
log_zone_error(contents->apex->owner,
"failed to load NSEC3 parameters (%s)",
knot_strerror(ret));
"failed to load NSEC3 parameters (%s)",
knot_strerror(ret));
return ret;
}
......@@ -959,8 +888,8 @@ int zone_contents_adjust_pointers(zone_contents_t *contents)
zone_adjust_arg_t adjust_arg = { .first_node = NULL,
.previous_node = NULL,
.zone = contents };
ret = adjust_nodes(contents->nodes, &adjust_arg,
adjust_pointers);
ret = adjust_nodes(contents->nodes, &adjust_arg, adjust_pointers);
if (ret != KNOT_EOK) {
return ret;
}
......@@ -970,12 +899,9 @@ int zone_contents_adjust_pointers(zone_contents_t *contents)
return ret;
}
return adjust_nodes(contents->nodes, &adjust_arg,
adjust_additional);
return adjust_nodes(contents->nodes, &adjust_arg, adjust_additional);
}
/*----------------------------------------------------------------------------*/
int zone_contents_adjust_full(zone_contents_t *zone,
zone_node_t **first_nsec3_node,
zone_node_t **last_nsec3_node)
......@@ -987,38 +913,31 @@ int zone_contents_adjust_full(zone_contents_t *zone,
int result = zone_contents_load_nsec3param(zone);
if (result != KNOT_EOK) {
log_zone_error(zone->apex->owner,
"failed to load NSEC3 parameters (%s)",
knot_strerror(result));
"failed to load NSEC3 parameters (%s)",
knot_strerror(result));
return result;
}
// adjusting parameters
zone_adjust_arg_t adjust_arg = { 0 };
adjust_arg.zone = zone;
// adjust NSEC3 nodes
result = adjust_nodes(zone->nsec3_nodes, &adjust_arg,
adjust_nsec3_node);
result = adjust_nodes(zone->nsec3_nodes, &adjust_arg, adjust_nsec3_node);
if (result != KNOT_EOK) {
return result;
}
// optional output for NSEC3 nodes
if (first_nsec3_node) {
*first_nsec3_node = adjust_arg.first_node;
}
if (last_nsec3_node) {
*last_nsec3_node = adjust_arg.previous_node;
}
// adjust normal nodes
result = adjust_nodes(zone->nodes, &adjust_arg,
adjust_normal_node);
result = adjust_nodes(zone->nodes, &adjust_arg, adjust_normal_node);
if (result != KNOT_EOK) {
return result;
}
......@@ -1029,12 +948,9 @@ int zone_contents_adjust_full(zone_contents_t *zone,
* \note This MUST be done after node adjusting because it needs to
* do full lookup to see through wildcards. */
return adjust_nodes(zone->nodes, &adjust_arg,
adjust_additional);
return adjust_nodes(zone->nodes, &adjust_arg, adjust_additional);
}
/*----------------------------------------------------------------------------*/
int zone_contents_load_nsec3param(zone_contents_t *zone)
{
if (zone == NULL || zone->apex == NULL) {
......@@ -1054,8 +970,6 @@ int zone_contents_load_nsec3param(zone_contents_t *zone)
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
const knot_nsec3_params_t *zone_contents_nsec3params(const zone_contents_t *zone)
{
if (zone == NULL) {
......@@ -1069,8 +983,6 @@ const knot_nsec3_params_t *zone_contents_nsec3params(const zone_contents_t *zone
}
}
/*----------------------------------------------------------------------------*/
int zone_contents_tree_apply_inorder(zone_contents_t *zone,
zone_contents_apply_cb_t function, void *data)
{
......@@ -1085,8 +997,6 @@ int zone_contents_tree_apply_inorder(zone_contents_t *zone,
return zone_tree_apply_inorder(zone->nodes, tree_apply_cb, &f);
}
/*----------------------------------------------------------------------------*/
int zone_contents_nsec3_apply_inorder(zone_contents_t *zone,
zone_contents_apply_cb_t function, void *data)
{
......@@ -1098,12 +1008,9 @@ int zone_contents_nsec3_apply_inorder(zone_contents_t *zone,
f.func = function;
f.data = data;
return zone_tree_apply_inorder(zone->nsec3_nodes,
tree_apply_cb, &f);
return zone_tree_apply_inorder(zone->nsec3_nodes, tree_apply_cb, &f);
}
/*----------------------------------------------------------------------------*/
int zone_contents_shallow_copy(const zone_contents_t *from, zone_contents_t **to)
{
if (from == NULL || to == NULL) {
......@@ -1143,8 +1050,6 @@ int zone_contents_shallow_copy(const zone_contents_t *from, zone_contents_t **to
return KNOT_EOK;
}
/*----------------------------------------------------------------------------*/
void zone_contents_free(zone_contents_t **contents)
{
if (contents == NULL || *contents == NULL) {
......@@ -1161,33 +1066,23 @@ void zone_contents_free(zone_contents_t **contents)
*contents = NULL;
}
/*----------------------------------------------------------------------------*/
void zone_contents_deep_free(zone_contents_t **contents)
{
if (contents == NULL || *contents == NULL) {
return;
}
if ((*contents) != NULL) {
if (*contents != NULL) {
// Delete NSEC3 tree
zone_tree_apply(
(*contents)->nsec3_nodes,
destroy_node_rrsets_from_tree,
(void*)1);
zone_tree_apply((*contents)->nsec3_nodes, destroy_node_rrsets_from_tree, NULL);
// Delete normal tree
zone_tree_apply(
(*contents)->nodes,
destroy_node_rrsets_from_tree,
(void*)1);
zone_tree_apply((*contents)->nodes, destroy_node_rrsets_from_tree, NULL);
}
zone_contents_free(contents);
}
/*----------------------------------------------------------------------------*/
static const knot_rdataset_t *get_soa(const zone_contents_t *zone)
{
if (zone == NULL) {
......@@ -1256,13 +1151,6 @@ zone_node_t *zone_contents_find_node_for_rr(zone_contents_t *zone, const knot_rr
return NULL;
}
zone_node_t *node;
const bool nsec3 = rrset_is_nsec3rel(rrset);
if (!nsec3) {
node = get_node(zone, rrset->owner);
} else {
node = get_nsec3_node(zone, rrset->owner);
}
return node;
return nsec3 ? get_nsec3_node(zone, rrset->owner) : get_node(zone, rrset->owner);
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment