mirror of https://github.com/getdnsapi/getdns.git
Replace ldns_rbtree with getdns_rbtree
As much as possible. In dnssec ldns_rbtree is inderectly used via the dnssec_zone struct This change forces use to embed the data in the nodes as getdns_rbtree does not have a data attribute. This is good because lesser allocs and free's and thus slightly faster and less likely to leak memory.
This commit is contained in:
Willem Toorop
parent
432092311e
commit
4a3d7fd8b2
334
src/context.c
334
src/context.c
|
|
@ -54,14 +54,16 @@
|
|||
|
||||
void *plain_mem_funcs_user_arg = MF_PLAIN;
|
||||
|
||||
struct host_name_addr_type {
|
||||
ldns_rdf * host_name;
|
||||
ldns_rr_type addr_type;
|
||||
};
|
||||
typedef struct host_name_addrs {
|
||||
getdns_rbnode_t node;
|
||||
ldns_rdf *host_name;
|
||||
ldns_rr_list *ipv4addrs;
|
||||
ldns_rr_list *ipv6addrs;
|
||||
} host_name_addrs;
|
||||
|
||||
/* Private functions */
|
||||
getdns_return_t create_default_namespaces(struct getdns_context *context);
|
||||
getdns_return_t create_local_hosts(struct getdns_context *context);
|
||||
static void create_local_hosts(struct getdns_context *context);
|
||||
getdns_return_t destroy_local_hosts(struct getdns_context *context);
|
||||
static struct getdns_list *create_default_root_servers(void);
|
||||
static getdns_return_t set_os_defaults(struct getdns_context *);
|
||||
|
|
@ -85,14 +87,14 @@ static void set_ub_edns_maximum_udp_payload_size(struct getdns_context*,
|
|||
/* Stuff to make it compile pedantically */
|
||||
#define RETURN_IF_NULL(ptr, code) if(ptr == NULL) return code;
|
||||
|
||||
static void destroy_local_host(ldns_rbnode_t * node, void *arg)
|
||||
static void destroy_local_host(getdns_rbnode_t * node, void *arg)
|
||||
{
|
||||
struct getdns_context *context = (struct getdns_context *) arg;
|
||||
|
||||
struct host_name_addr_type *lh = (struct host_name_addr_type *) node->key;
|
||||
ldns_rdf_free(lh->host_name);
|
||||
ldns_rr_list_deep_free((ldns_rr_list *)node->data);
|
||||
GETDNS_FREE(context->mf, node);
|
||||
getdns_context *context = (getdns_context *)arg;
|
||||
host_name_addrs *hnas = (host_name_addrs *)node;
|
||||
ldns_rdf_free(hnas->host_name);
|
||||
ldns_rr_list_deep_free(hnas->ipv4addrs);
|
||||
ldns_rr_list_deep_free(hnas->ipv6addrs);
|
||||
GETDNS_FREE(context->my_mf, hnas);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -116,54 +118,58 @@ create_default_namespaces(struct getdns_context *context)
|
|||
/**
|
||||
* Helper to get contents from hosts file
|
||||
*/
|
||||
getdns_return_t
|
||||
static void
|
||||
create_local_hosts(struct getdns_context *context)
|
||||
{
|
||||
ldns_rr_list *host_names = ldns_get_rr_list_hosts_frm_file(NULL);
|
||||
size_t i;
|
||||
ldns_rr *rr;
|
||||
host_name_addrs *hnas;
|
||||
|
||||
ldns_rr_list * host_names = ldns_get_rr_list_hosts_frm_file(NULL);
|
||||
if (host_names == NULL)
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
if (host_names == NULL)
|
||||
return;
|
||||
|
||||
/* We have a 1:1 list of name -> ip address where there is an
|
||||
underlying many to many relationship. Need to create a lookup of
|
||||
(unique name + A/AAAA)-> list of IPV4/IPv6 ip addresses*/
|
||||
for (int i = 0 ; i<ldns_rr_list_rr_count(host_names) ; i++) {
|
||||
/* We have a 1:1 list of name -> ip address where there is an
|
||||
underlying many to many relationship. Need to create a lookup of
|
||||
(unique name + A/AAAA)-> list of IPV4/IPv6 ip addresses*/
|
||||
for (i = 0; i < ldns_rr_list_rr_count(host_names); i++) {
|
||||
rr = ldns_rr_list_rr(host_names, i);
|
||||
|
||||
ldns_rr *rr = ldns_rr_list_rr(host_names, i);
|
||||
ldns_rdf *owner = ldns_rdf_clone(ldns_rr_owner(rr));
|
||||
if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_A &&
|
||||
ldns_rr_get_type(rr) != LDNS_RR_TYPE_AAAA)
|
||||
continue;
|
||||
|
||||
/*Check to see if we already have an entry*/
|
||||
struct host_name_addr_type *lh_key =
|
||||
GETDNS_MALLOC(context->my_mf, struct host_name_addr_type);
|
||||
if (lh_key == NULL)
|
||||
return GETDNS_RETURN_MEMORY_ERROR;
|
||||
lh_key->host_name = owner;
|
||||
lh_key->addr_type = ldns_rr_get_type(rr);
|
||||
ldns_rbnode_t *result_node = ldns_rbtree_search(context->local_hosts, lh_key);
|
||||
if (result_node) {
|
||||
if (!ldns_rr_list_push_rr ((ldns_rr_list *)result_node->data, ldns_rr_clone(rr)))
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
}
|
||||
else {
|
||||
ldns_rr_list *address_list = ldns_rr_list_new ();
|
||||
if (!ldns_rr_list_push_rr (address_list, ldns_rr_clone(rr)))
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
/*Check to see if we already have an entry*/
|
||||
hnas = (host_name_addrs *)getdns_rbtree_search(
|
||||
&context->local_hosts, ldns_rr_owner(rr));
|
||||
if (!hnas) {
|
||||
if (!(hnas = GETDNS_MALLOC(
|
||||
context->my_mf, host_name_addrs)))
|
||||
break;
|
||||
|
||||
ldns_rbnode_t *node = GETDNS_MALLOC(context->my_mf, ldns_rbnode_t);
|
||||
if (!node) {
|
||||
return GETDNS_RETURN_MEMORY_ERROR;
|
||||
}
|
||||
node->key = lh_key;
|
||||
node->data = address_list;
|
||||
if (!ldns_rbtree_insert(context->local_hosts, node)) {
|
||||
GETDNS_FREE(context->my_mf, node);
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!(hnas->host_name =
|
||||
ldns_rdf_clone(ldns_rr_owner(rr))) ||
|
||||
!(hnas->ipv4addrs = ldns_rr_list_new()) ||
|
||||
!(hnas->ipv6addrs = ldns_rr_list_new())) {
|
||||
|
||||
ldns_rr_list_deep_free(host_names);
|
||||
return GETDNS_RETURN_GOOD;
|
||||
ldns_rdf_free(hnas->host_name);
|
||||
ldns_rr_list_free(hnas->ipv4addrs);
|
||||
ldns_rr_list_free(hnas->ipv6addrs);
|
||||
GETDNS_FREE(context->my_mf, hnas);
|
||||
break;
|
||||
}
|
||||
(void) getdns_rbtree_insert(
|
||||
&context->local_hosts, &hnas->node);
|
||||
}
|
||||
if (!(rr = ldns_rr_clone(rr)))
|
||||
break;
|
||||
if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_A) {
|
||||
if (!ldns_rr_list_push_rr(hnas->ipv4addrs, rr))
|
||||
ldns_rr_free(rr);
|
||||
} else if (!ldns_rr_list_push_rr(hnas->ipv6addrs, rr))
|
||||
ldns_rr_free(rr);
|
||||
}
|
||||
ldns_rr_list_deep_free(host_names);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -512,33 +518,8 @@ transaction_id_cmp(const void *id1, const void *id2)
|
|||
static int
|
||||
local_host_cmp(const void *id1, const void *id2)
|
||||
{
|
||||
if (id1 == NULL && id2 == NULL) {
|
||||
return 0;
|
||||
} else if (id1 == NULL && id2 != NULL) {
|
||||
return 1;
|
||||
} else if (id1 != NULL && id2 == NULL) {
|
||||
return -1;
|
||||
} else {
|
||||
const struct host_name_addr_type *hn1 = (const struct host_name_addr_type*) id1;
|
||||
const struct host_name_addr_type *hn2 = (const struct host_name_addr_type*) id2;
|
||||
if ((ldns_rr_type) hn1->addr_type < (ldns_rr_type) hn2->addr_type)
|
||||
return -1;
|
||||
if ((ldns_rr_type) hn1->addr_type > (ldns_rr_type) hn2->addr_type)
|
||||
return 1;
|
||||
return (ldns_rdf_compare((const ldns_rdf *) hn1->host_name,
|
||||
(const ldns_rdf *) hn2->host_name));
|
||||
}
|
||||
}
|
||||
|
||||
static ldns_rbtree_t*
|
||||
create_ldns_rbtree(getdns_context * context,
|
||||
int(*cmpf)(const void *, const void *)) {
|
||||
ldns_rbtree_t* result = GETDNS_MALLOC(context->mf, ldns_rbtree_t);
|
||||
if (!result) {
|
||||
return NULL;
|
||||
}
|
||||
ldns_rbtree_init(result, cmpf);
|
||||
return result;
|
||||
return (ldns_rdf_compare((const ldns_rdf *)id1,
|
||||
(const ldns_rdf *)id2));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -588,13 +569,8 @@ getdns_context_create_with_extended_memory_functions(
|
|||
|
||||
result->resolution_type_set = 0;
|
||||
|
||||
result->outbound_requests = create_ldns_rbtree(result, transaction_id_cmp);
|
||||
result->local_hosts = create_ldns_rbtree(result, local_host_cmp);
|
||||
|
||||
if (!result->outbound_requests || !result->local_hosts) {
|
||||
r = GETDNS_RETURN_MEMORY_ERROR;
|
||||
goto error;
|
||||
}
|
||||
getdns_rbtree_init(&result->outbound_requests, transaction_id_cmp);
|
||||
getdns_rbtree_init(&result->local_hosts, local_host_cmp);
|
||||
|
||||
result->resolution_type = GETDNS_RESOLUTION_RECURSING;
|
||||
if ((r = create_default_namespaces(result)))
|
||||
|
|
@ -635,8 +611,7 @@ getdns_context_create_with_extended_memory_functions(
|
|||
if ((r = rebuild_ub_ctx(result)))
|
||||
goto error;
|
||||
|
||||
if ((r = create_local_hosts(result)))
|
||||
goto error;
|
||||
create_local_hosts(result);
|
||||
|
||||
*context = result;
|
||||
return GETDNS_RETURN_GOOD;
|
||||
|
|
@ -724,14 +699,9 @@ getdns_context_destroy(struct getdns_context *context)
|
|||
/* destroy the contexts */
|
||||
if (context->unbound_ctx)
|
||||
ub_ctx_delete(context->unbound_ctx);
|
||||
if (context->outbound_requests)
|
||||
GETDNS_FREE(context->my_mf, context->outbound_requests);
|
||||
if (context->local_hosts) {
|
||||
ldns_traverse_postorder(context->local_hosts,
|
||||
destroy_local_host, context);
|
||||
GETDNS_FREE(context->my_mf, context->local_hosts);
|
||||
}
|
||||
|
||||
traverse_postorder(&context->local_hosts,
|
||||
destroy_local_host, context);
|
||||
upstreams_dereference(context->upstreams);
|
||||
|
||||
GETDNS_FREE(context->my_mf, context);
|
||||
|
|
@ -774,8 +744,8 @@ static void
|
|||
getdns_context_request_count_changed(getdns_context *context)
|
||||
{
|
||||
DEBUG_SCHED("getdns_context_request_count_changed(%d)\n",
|
||||
(int) context->outbound_requests->count);
|
||||
if (context->outbound_requests->count) {
|
||||
(int) context->outbound_requests.count);
|
||||
if (context->outbound_requests.count) {
|
||||
if (context->ub_event.ev) return;
|
||||
|
||||
DEBUG_SCHED("gc_request_count_changed "
|
||||
|
|
@ -1432,40 +1402,29 @@ cancel_dns_req(getdns_dns_req *req)
|
|||
}
|
||||
|
||||
getdns_return_t
|
||||
getdns_context_cancel_request(struct getdns_context *context,
|
||||
getdns_context_cancel_request(getdns_context *context,
|
||||
getdns_transaction_t transaction_id, int fire_callback)
|
||||
{
|
||||
getdns_dns_req *req = NULL;
|
||||
RETURN_IF_NULL(context, GETDNS_RETURN_INVALID_PARAMETER);
|
||||
getdns_dns_req *dnsreq;
|
||||
|
||||
/* delete the node from the tree */
|
||||
ldns_rbnode_t *node = ldns_rbtree_delete(context->outbound_requests,
|
||||
&transaction_id);
|
||||
if (!context)
|
||||
return GETDNS_RETURN_INVALID_PARAMETER;
|
||||
|
||||
if (!node) {
|
||||
return GETDNS_RETURN_UNKNOWN_TRANSACTION;
|
||||
}
|
||||
req = (getdns_dns_req *) node->data;
|
||||
/* do the cancel */
|
||||
/* delete the node from the tree */
|
||||
if (!(dnsreq = (getdns_dns_req *)getdns_rbtree_delete(
|
||||
&context->outbound_requests, &transaction_id)))
|
||||
return GETDNS_RETURN_UNKNOWN_TRANSACTION;
|
||||
|
||||
cancel_dns_req(req);
|
||||
/* do the cancel */
|
||||
cancel_dns_req(dnsreq);
|
||||
|
||||
if (fire_callback) {
|
||||
getdns_callback_t cb = NULL;
|
||||
void *user_pointer = NULL;
|
||||
if (fire_callback)
|
||||
dnsreq->user_callback(context, GETDNS_CALLBACK_CANCEL,
|
||||
NULL, dnsreq->user_pointer, transaction_id);
|
||||
|
||||
cb = req->user_callback;
|
||||
user_pointer = req->user_pointer;
|
||||
|
||||
/* fire callback */
|
||||
cb(context,
|
||||
GETDNS_CALLBACK_CANCEL,
|
||||
NULL, user_pointer, transaction_id);
|
||||
}
|
||||
/* clean up */
|
||||
GETDNS_FREE(context->my_mf, node);
|
||||
dns_req_free(req);
|
||||
return GETDNS_RETURN_GOOD;
|
||||
/* clean up */
|
||||
dns_req_free(dnsreq);
|
||||
return GETDNS_RETURN_GOOD;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1640,41 +1599,31 @@ getdns_context_prepare_for_resolution(struct getdns_context *context,
|
|||
} /* getdns_context_prepare_for_resolution */
|
||||
|
||||
getdns_return_t
|
||||
getdns_context_track_outbound_request(getdns_dns_req * req)
|
||||
getdns_context_track_outbound_request(getdns_dns_req *dnsreq)
|
||||
{
|
||||
ldns_rbnode_t *node;
|
||||
|
||||
if (!req)
|
||||
if (!dnsreq)
|
||||
return GETDNS_RETURN_INVALID_PARAMETER;
|
||||
|
||||
if (!(node = GETDNS_MALLOC(req->context->my_mf, ldns_rbnode_t)))
|
||||
return GETDNS_RETURN_MEMORY_ERROR;
|
||||
|
||||
node->key = &(req->trans_id);
|
||||
node->data = req;
|
||||
if (! ldns_rbtree_insert(req->context->outbound_requests, node)) {
|
||||
GETDNS_FREE(req->context->my_mf, node);
|
||||
dnsreq->node.key = &(dnsreq->trans_id);
|
||||
if (!getdns_rbtree_insert(
|
||||
&dnsreq->context->outbound_requests, &dnsreq->node))
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
}
|
||||
getdns_context_request_count_changed(req->context);
|
||||
|
||||
getdns_context_request_count_changed(dnsreq->context);
|
||||
return GETDNS_RETURN_GOOD;
|
||||
}
|
||||
|
||||
getdns_return_t
|
||||
getdns_context_clear_outbound_request(getdns_dns_req * req)
|
||||
getdns_context_clear_outbound_request(getdns_dns_req *dnsreq)
|
||||
{
|
||||
ldns_rbnode_t *node;
|
||||
|
||||
if (!req)
|
||||
if (!dnsreq)
|
||||
return GETDNS_RETURN_INVALID_PARAMETER;
|
||||
|
||||
node = ldns_rbtree_delete(
|
||||
req->context->outbound_requests, &req->trans_id);
|
||||
if (!node)
|
||||
if (!getdns_rbtree_delete(
|
||||
&dnsreq->context->outbound_requests, &dnsreq->trans_id))
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
|
||||
GETDNS_FREE(req->context->my_mf, node);
|
||||
getdns_context_request_count_changed(req->context);
|
||||
getdns_context_request_count_changed(dnsreq->context);
|
||||
return GETDNS_RETURN_GOOD;
|
||||
}
|
||||
|
||||
|
|
@ -1759,14 +1708,14 @@ getdns_context_get_num_pending_requests(struct getdns_context* context,
|
|||
|
||||
RETURN_IF_NULL(context, GETDNS_RETURN_INVALID_PARAMETER);
|
||||
|
||||
if (context->outbound_requests->count)
|
||||
if (context->outbound_requests.count)
|
||||
context->extension->vmt->run_once(context->extension, 0);
|
||||
|
||||
/* TODO: Remove this when next_timeout is gone */
|
||||
getdns_handle_timeouts(context->mini_event.base,
|
||||
&context->mini_event.time_tv, next_timeout ? next_timeout : &dispose);
|
||||
|
||||
return context->outbound_requests->count;
|
||||
return context->outbound_requests.count;
|
||||
}
|
||||
|
||||
/* process async reqs */
|
||||
|
|
@ -1801,7 +1750,7 @@ typedef struct timeout_accumulator {
|
|||
} timeout_accumulator;
|
||||
|
||||
static void
|
||||
accumulate_outstanding_transactions(ldns_rbnode_t* node, void* arg) {
|
||||
accumulate_outstanding_transactions(getdns_rbnode_t* node, void* arg) {
|
||||
timeout_accumulator* acc = (timeout_accumulator*) arg;
|
||||
acc->ids[acc->idx] = *((getdns_transaction_t*) node->key);
|
||||
acc->idx++;
|
||||
|
|
@ -1809,12 +1758,12 @@ accumulate_outstanding_transactions(ldns_rbnode_t* node, void* arg) {
|
|||
|
||||
static void
|
||||
cancel_outstanding_requests(struct getdns_context* context, int fire_callback) {
|
||||
if (context->outbound_requests->count > 0) {
|
||||
if (context->outbound_requests.count > 0) {
|
||||
timeout_accumulator acc;
|
||||
int i;
|
||||
acc.idx = 0;
|
||||
acc.ids = GETDNS_XMALLOC(context->my_mf, getdns_transaction_t, context->outbound_requests->count);
|
||||
ldns_traverse_postorder(context->outbound_requests, accumulate_outstanding_transactions, &acc);
|
||||
acc.ids = GETDNS_XMALLOC(context->my_mf, getdns_transaction_t, context->outbound_requests.count);
|
||||
traverse_postorder(&context->outbound_requests, accumulate_outstanding_transactions, &acc);
|
||||
for (i = 0; i < acc.idx; ++i) {
|
||||
getdns_context_cancel_request(context, acc.ids[i], fire_callback);
|
||||
}
|
||||
|
|
@ -1971,58 +1920,43 @@ getdns_context_set_use_threads(getdns_context* context, int use_threads) {
|
|||
}
|
||||
|
||||
getdns_return_t
|
||||
getdns_context_local_namespace_resolve(getdns_dns_req* req,
|
||||
struct getdns_dict **response,
|
||||
struct getdns_context *context)
|
||||
getdns_context_local_namespace_resolve(
|
||||
getdns_dns_req *dnsreq, getdns_dict **response)
|
||||
{
|
||||
getdns_context *context = dnsreq->context;
|
||||
ldns_rr_list *result_list = NULL;
|
||||
host_name_addrs *hnas;
|
||||
ldns_rdf *query_name;
|
||||
int ipv4 = dnsreq->first_req->request_type == GETDNS_RRTYPE_A ||
|
||||
(dnsreq->first_req->next &&
|
||||
dnsreq->first_req->next->request_type == GETDNS_RRTYPE_A);
|
||||
int ipv6 = dnsreq->first_req->request_type == GETDNS_RRTYPE_AAAA ||
|
||||
(dnsreq->first_req->next &&
|
||||
dnsreq->first_req->next->request_type == GETDNS_RRTYPE_AAAA);
|
||||
|
||||
if (!ipv4 && !ipv6)
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
|
||||
ldns_rr_list *result_list = NULL;
|
||||
struct host_name_addr_type *lh_key =
|
||||
GETDNS_MALLOC(context->my_mf, struct host_name_addr_type);
|
||||
if (lh_key == NULL)
|
||||
return GETDNS_RETURN_MEMORY_ERROR;
|
||||
/*Do the lookup*/
|
||||
if (!(query_name = ldns_rdf_new_frm_str(
|
||||
LDNS_RDF_TYPE_DNAME, dnsreq->name)))
|
||||
return GETDNS_RETURN_MEMORY_ERROR;
|
||||
|
||||
getdns_network_req *netreq = req->first_req;
|
||||
while (netreq) {
|
||||
if (netreq->request_type != GETDNS_RRTYPE_A &&
|
||||
netreq->request_type != GETDNS_RRTYPE_AAAA) {
|
||||
netreq = netreq->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
/*Do the lookup*/
|
||||
ldns_rdf *query_name = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, req->name);
|
||||
if (!query_name) {
|
||||
GETDNS_FREE(context->my_mf, lh_key);
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
}
|
||||
lh_key->host_name = query_name;
|
||||
lh_key->addr_type = netreq->request_type;
|
||||
ldns_rbnode_t *result_node = ldns_rbtree_search(context->local_hosts, lh_key);
|
||||
if (result_node) {
|
||||
if (result_list == NULL)
|
||||
result_list =
|
||||
ldns_rr_list_clone((ldns_rr_list *)result_node->data);
|
||||
else {
|
||||
if (!ldns_rr_list_cat(result_list, (ldns_rr_list *)result_node->data)) {
|
||||
GETDNS_FREE(context->my_mf, lh_key);
|
||||
ldns_rdf_deep_free(query_name);
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ldns_rdf_deep_free(query_name);
|
||||
netreq = netreq->next;
|
||||
}
|
||||
|
||||
GETDNS_FREE(context->my_mf, lh_key);
|
||||
if (result_list == NULL)
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
|
||||
*response = create_getdns_response_from_rr_list(req, result_list);
|
||||
return response ? GETDNS_RETURN_GOOD : GETDNS_RETURN_GENERIC_ERROR;
|
||||
if ((hnas = (host_name_addrs *)getdns_rbtree_search(
|
||||
&context->local_hosts, query_name))) {
|
||||
|
||||
result_list = ldns_rr_list_new();
|
||||
if (ipv4)
|
||||
(void) ldns_rr_list_cat(result_list, hnas->ipv4addrs);
|
||||
if (ipv6)
|
||||
(void) ldns_rr_list_cat(result_list, hnas->ipv6addrs);
|
||||
}
|
||||
ldns_rdf_deep_free(query_name);
|
||||
if (!result_list)
|
||||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
*response = create_getdns_response_from_rr_list(dnsreq, result_list);
|
||||
ldns_rr_list_deep_free(result_list);
|
||||
return *response ? GETDNS_RETURN_GOOD : GETDNS_RETURN_GENERIC_ERROR;
|
||||
}
|
||||
|
||||
struct mem_funcs *
|
||||
|
|
|
|||
|
|
@ -45,7 +45,6 @@
|
|||
#include "util/rbtree.h"
|
||||
|
||||
struct getdns_dns_req;
|
||||
struct ldns_rbtree_t;
|
||||
struct ub_ctx;
|
||||
|
||||
#define GETDNS_FN_RESOLVCONF "/etc/resolv.conf"
|
||||
|
|
@ -132,7 +131,7 @@ struct getdns_context {
|
|||
struct ub_ctx *unbound_ctx;
|
||||
|
||||
/* A tree to hold local host information*/
|
||||
struct ldns_rbtree_t *local_hosts;
|
||||
getdns_rbtree_t local_hosts;
|
||||
int has_ta; /* No DNSSEC without trust anchor */
|
||||
int return_dnssec_status;
|
||||
|
||||
|
|
@ -144,7 +143,7 @@ struct getdns_context {
|
|||
/*
|
||||
* outbound requests -> transaction to getdns_dns_req
|
||||
*/
|
||||
struct ldns_rbtree_t *outbound_requests;
|
||||
getdns_rbtree_t outbound_requests;
|
||||
|
||||
/* Event loop extension. */
|
||||
getdns_eventloop *extension;
|
||||
|
|
@ -197,9 +196,8 @@ void getdns_bindata_destroy(
|
|||
struct getdns_bindata *bindata);
|
||||
|
||||
/* perform name resolution in /etc/hosts */
|
||||
getdns_return_t getdns_context_local_namespace_resolve(getdns_dns_req* req,
|
||||
struct getdns_dict **response,
|
||||
struct getdns_context *context);
|
||||
getdns_return_t getdns_context_local_namespace_resolve(
|
||||
getdns_dns_req* req, struct getdns_dict **response);
|
||||
|
||||
int filechg_check(struct getdns_context *context, struct filechg *fchg);
|
||||
|
||||
|
|
|
|||
33
src/dict.c
33
src/dict.c
|
|
@ -1,7 +1,7 @@
|
|||
/**
|
||||
*
|
||||
* getdns dict management functions, note that the internal storage is
|
||||
* accomplished via an ldns_rbtree_t
|
||||
* accomplished via an getdns_rbtree_t
|
||||
*
|
||||
* Interfaces originally taken from the getdns API description pseudo implementation.
|
||||
*
|
||||
|
|
@ -59,7 +59,7 @@ struct getdns_dict_item *
|
|||
getdns_dict_find(const struct getdns_dict *dict, const char *key)
|
||||
{
|
||||
return (struct getdns_dict_item *)
|
||||
ldns_rbtree_search((ldns_rbtree_t *)&(dict->root), key);
|
||||
getdns_rbtree_search((getdns_rbtree_t *)&(dict->root), key);
|
||||
} /* getdns_dict_find */
|
||||
|
||||
struct getdns_dict_item *
|
||||
|
|
@ -68,14 +68,14 @@ getdns_dict_find_and_add(struct getdns_dict *dict, const char *key)
|
|||
struct getdns_dict_item *item;
|
||||
|
||||
item = (struct getdns_dict_item *)
|
||||
ldns_rbtree_search(&(dict->root), key);
|
||||
getdns_rbtree_search(&(dict->root), key);
|
||||
|
||||
if (!item) {
|
||||
/* add a node */
|
||||
item = GETDNS_MALLOC(dict->mf, struct getdns_dict_item);
|
||||
item->node.key = getdns_strdup(&dict->mf, key);
|
||||
item->data.n = 0;
|
||||
ldns_rbtree_insert(&(dict->root), (ldns_rbnode_t *) item);
|
||||
getdns_rbtree_insert(&(dict->root), (getdns_rbnode_t *) item);
|
||||
}
|
||||
return item;
|
||||
} /* getdns_dict_find_and_add */
|
||||
|
|
@ -100,8 +100,8 @@ getdns_dict_get_names(const struct getdns_dict * dict,
|
|||
if (!*answer)
|
||||
return GETDNS_RETURN_NO_SUCH_DICT_NAME;
|
||||
|
||||
LDNS_RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
(ldns_rbtree_t *)&(dict->root)) {
|
||||
RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
(getdns_rbtree_t *)&(dict->root)) {
|
||||
if (getdns_list_add_item(*answer, &index) != GETDNS_RETURN_GOOD)
|
||||
continue;
|
||||
bindata.size = strlen(item->node.key) + 1;
|
||||
|
|
@ -240,7 +240,7 @@ getdns_dict_create_with_extended_memory_functions(
|
|||
dict->mf.mf.ext.realloc = realloc;
|
||||
dict->mf.mf.ext.free = free;
|
||||
|
||||
ldns_rbtree_init(&(dict->root),
|
||||
getdns_rbtree_init(&(dict->root),
|
||||
(int (*)(const void *, const void *)) strcmp);
|
||||
return dict;
|
||||
}
|
||||
|
|
@ -310,8 +310,8 @@ getdns_dict_copy(const struct getdns_dict * srcdict,
|
|||
return GETDNS_RETURN_GENERIC_ERROR;
|
||||
|
||||
retval = GETDNS_RETURN_GOOD;
|
||||
LDNS_RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
(struct ldns_rbtree_t *)&(srcdict->root)) {
|
||||
RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
(struct getdns_rbtree_t *)&(srcdict->root)) {
|
||||
key = (char *) item->node.key;
|
||||
switch (item->dtype) {
|
||||
case t_bindata:
|
||||
|
|
@ -352,7 +352,7 @@ getdns_dict_copy(const struct getdns_dict * srcdict,
|
|||
* @return void
|
||||
*/
|
||||
void
|
||||
getdns_dict_item_free(ldns_rbnode_t * node, void *arg)
|
||||
getdns_dict_item_free(getdns_rbnode_t * node, void *arg)
|
||||
{
|
||||
struct getdns_dict_item *item = (struct getdns_dict_item *) node;
|
||||
struct getdns_dict *dict = (struct getdns_dict *)arg;
|
||||
|
|
@ -382,11 +382,8 @@ getdns_dict_item_free(ldns_rbnode_t * node, void *arg)
|
|||
void
|
||||
getdns_dict_destroy(struct getdns_dict *dict)
|
||||
{
|
||||
if (!dict)
|
||||
return;
|
||||
|
||||
ldns_traverse_postorder(&(dict->root),
|
||||
getdns_dict_item_free, dict);
|
||||
if (!dict) return;
|
||||
traverse_postorder(&(dict->root), getdns_dict_item_free, dict);
|
||||
GETDNS_FREE(dict->mf, dict);
|
||||
} /* getdns_dict_destroy */
|
||||
|
||||
|
|
@ -758,8 +755,8 @@ getdns_pp_dict(ldns_buffer * buf, size_t indent,
|
|||
|
||||
i = 0;
|
||||
indent += 2;
|
||||
LDNS_RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
(ldns_rbtree_t *)&(dict->root)) {
|
||||
RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
(getdns_rbtree_t *)&(dict->root)) {
|
||||
if (ldns_buffer_printf(buf, "%s\n%s\"%s\":", (i ? "," : "")
|
||||
, getdns_indent(indent)
|
||||
, item->node.key) < 0)
|
||||
|
|
@ -902,7 +899,7 @@ getdns_dict_remove_name(struct getdns_dict *this_dict, const char *name)
|
|||
return GETDNS_RETURN_NO_SUCH_DICT_NAME;
|
||||
|
||||
/* cleanup */
|
||||
ldns_rbtree_delete(&this_dict->root, name);
|
||||
getdns_rbtree_delete(&this_dict->root, name);
|
||||
getdns_dict_item_free(&item->node, this_dict);
|
||||
|
||||
return GETDNS_RETURN_GOOD;
|
||||
|
|
|
|||
|
|
@ -35,8 +35,8 @@
|
|||
#ifndef _GETDNS_DICT_H_
|
||||
#define _GETDNS_DICT_H_
|
||||
|
||||
#include <ldns/rbtree.h>
|
||||
#include "getdns/getdns.h"
|
||||
#include "util/rbtree.h"
|
||||
#include "types-internal.h"
|
||||
|
||||
union getdns_item
|
||||
|
|
@ -52,7 +52,7 @@ union getdns_item
|
|||
*/
|
||||
struct getdns_dict_item
|
||||
{
|
||||
ldns_rbnode_t node;
|
||||
getdns_rbnode_t node;
|
||||
getdns_data_type dtype;
|
||||
union getdns_item data;
|
||||
};
|
||||
|
|
@ -66,7 +66,7 @@ struct getdns_dict_item
|
|||
*/
|
||||
struct getdns_dict
|
||||
{
|
||||
ldns_rbtree_t root;
|
||||
getdns_rbtree_t root;
|
||||
struct mem_funcs mf;
|
||||
};
|
||||
|
||||
|
|
|
|||
23
src/dnssec.c
23
src/dnssec.c
|
|
@ -51,7 +51,7 @@
|
|||
void priv_getdns_call_user_callback(getdns_dns_req *, struct getdns_dict *);
|
||||
|
||||
struct validation_chain {
|
||||
ldns_rbtree_t root;
|
||||
getdns_rbtree_t root;
|
||||
struct mem_funcs mf;
|
||||
getdns_dns_req *dns_req;
|
||||
size_t lock;
|
||||
|
|
@ -68,7 +68,7 @@ struct chain_response {
|
|||
};
|
||||
|
||||
struct chain_link {
|
||||
ldns_rbnode_t node;
|
||||
getdns_rbnode_t node;
|
||||
struct chain_response DNSKEY;
|
||||
struct chain_response DS;
|
||||
};
|
||||
|
|
@ -85,8 +85,8 @@ static void callback_on_complete_chain(struct validation_chain *chain)
|
|||
ldns_rr_list *keys;
|
||||
struct getdns_list *getdns_keys;
|
||||
|
||||
LDNS_RBTREE_FOR(link, struct chain_link *,
|
||||
(ldns_rbtree_t *)&(chain->root)) {
|
||||
RBTREE_FOR(link, struct chain_link *,
|
||||
(getdns_rbtree_t *)&(chain->root)) {
|
||||
if (link->DNSKEY.result == NULL && link->DNSKEY.err == 0)
|
||||
ongoing++;
|
||||
if (link->DS.result == NULL && link->DS.err == 0 &&
|
||||
|
|
@ -99,8 +99,8 @@ static void callback_on_complete_chain(struct validation_chain *chain)
|
|||
response = create_getdns_response(chain->dns_req);
|
||||
|
||||
keys = ldns_rr_list_new();
|
||||
LDNS_RBTREE_FOR(link, struct chain_link *,
|
||||
(ldns_rbtree_t *)&(chain->root)) {
|
||||
RBTREE_FOR(link, struct chain_link *,
|
||||
(getdns_rbtree_t *)&(chain->root)) {
|
||||
(void) ldns_rr_list_cat(keys, link->DNSKEY.result);
|
||||
(void) ldns_rr_list_cat(keys, link->DS.result);
|
||||
}
|
||||
|
|
@ -203,7 +203,7 @@ launch_chain_link_lookup(struct validation_chain *chain, char *name)
|
|||
{
|
||||
int r;
|
||||
struct chain_link *link = (struct chain_link *)
|
||||
ldns_rbtree_search((ldns_rbtree_t *)&(chain->root), name);
|
||||
getdns_rbtree_search((getdns_rbtree_t *)&(chain->root), name);
|
||||
|
||||
if (link) {
|
||||
free(name);
|
||||
|
|
@ -215,7 +215,7 @@ launch_chain_link_lookup(struct validation_chain *chain, char *name)
|
|||
chain_response_init(chain, &link->DNSKEY);
|
||||
chain_response_init(chain, &link->DS);
|
||||
|
||||
ldns_rbtree_insert(&(chain->root), (ldns_rbnode_t *)link);
|
||||
getdns_rbtree_insert(&(chain->root), (getdns_rbnode_t *)link);
|
||||
|
||||
chain->lock++;
|
||||
r = resolve(name, LDNS_RR_TYPE_DNSKEY, &link->DNSKEY);
|
||||
|
|
@ -239,7 +239,7 @@ static struct validation_chain *create_chain(getdns_dns_req *dns_req,
|
|||
if (! chain)
|
||||
return NULL;
|
||||
|
||||
ldns_rbtree_init(&(chain->root),
|
||||
getdns_rbtree_init(&(chain->root),
|
||||
(int (*)(const void *, const void *)) strcmp);
|
||||
chain->mf.mf_arg = dns_req->context->mf.mf_arg;
|
||||
chain->mf.mf.ext.malloc = dns_req->context->mf.mf.ext.malloc;
|
||||
|
|
@ -251,7 +251,7 @@ static struct validation_chain *create_chain(getdns_dns_req *dns_req,
|
|||
return chain;
|
||||
}
|
||||
|
||||
static void destroy_chain_link(ldns_rbnode_t * node, void *arg)
|
||||
static void destroy_chain_link(getdns_rbnode_t * node, void *arg)
|
||||
{
|
||||
struct chain_link *link = (struct chain_link*) node;
|
||||
struct validation_chain *chain = (struct validation_chain*) arg;
|
||||
|
|
@ -264,8 +264,7 @@ static void destroy_chain_link(ldns_rbnode_t * node, void *arg)
|
|||
|
||||
static void destroy_chain(struct validation_chain *chain)
|
||||
{
|
||||
ldns_traverse_postorder(&(chain->root),
|
||||
destroy_chain_link, chain);
|
||||
traverse_postorder(&(chain->root), destroy_chain_link, chain);
|
||||
GETDNS_FREE(chain->mf, chain);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -208,7 +208,7 @@ getdns_general_ns(getdns_context *context, getdns_eventloop *loop,
|
|||
if (context->namespaces[i] == GETDNS_NAMESPACE_LOCALNAMES) {
|
||||
|
||||
if (!(r = getdns_context_local_namespace_resolve(
|
||||
req, &localnames_response, context))) {
|
||||
req, &localnames_response))) {
|
||||
|
||||
priv_getdns_call_user_callback
|
||||
( req, localnames_response);
|
||||
|
|
|
|||
|
|
@ -213,8 +213,10 @@ typedef struct getdns_network_req
|
|||
* dns request - manages a number of network requests and
|
||||
* the initial data passed to getdns_general
|
||||
*/
|
||||
typedef struct getdns_dns_req
|
||||
{
|
||||
typedef struct getdns_dns_req {
|
||||
/* For storage in context->outbound_requests */
|
||||
getdns_rbnode_t node;
|
||||
|
||||
/* name */
|
||||
char *name;
|
||||
|
||||
|
|
|
|||
|
|
@ -836,9 +836,9 @@ validate_extensions(struct getdns_dict * extensions)
|
|||
getdns_extension_format *extformat;
|
||||
|
||||
if (extensions)
|
||||
LDNS_RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
&(extensions->root))
|
||||
{
|
||||
RBTREE_FOR(item, struct getdns_dict_item *,
|
||||
&(extensions->root)) {
|
||||
|
||||
getdns_extension_format key;
|
||||
key.extstring = (char *) item->node.key;
|
||||
extformat = bsearch(&key, extformats,
|
||||
|
|
|
|||
Loading…
Reference in New Issue