interesting
/
getdns
mirror of https://github.com/getdnsapi/getdns.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Store dnsreq->name in wire format

This commit is contained in:
Willem Toorop 2015-06-29 23:32:49 +02:00
parent 407ecffb67
commit 8d5ac3afde
7 changed files with 38 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/context.c
View File

@ -2302,8 +2302,6 @@ getdns_context_local_namespace_resolve(
{
getdns_context *context = dnsreq->context;
host_name_addrs *hnas;
uint8_t query_name[256];
size_t query_name_len = sizeof(query_name);
uint8_t lookup[256];
getdns_list empty_list = { 0 };
getdns_bindata bindata;
@ -2321,10 +2319,7 @@ getdns_context_local_namespace_resolve(
return GETDNS_RETURN_GENERIC_ERROR;
/*Do the lookup*/
if (gldns_str2wire_dname_buf(dnsreq->name,query_name,&query_name_len))
return GETDNS_RETURN_GENERIC_ERROR;
(void)memcpy(lookup, query_name, query_name_len);
(void)memcpy(lookup, dnsreq->name, dnsreq->name_len);
canonicalize_dname(lookup);
if (!(hnas = (host_name_addrs *)
@ -2340,8 +2335,8 @@ getdns_context_local_namespace_resolve(
if (!(*response = getdns_dict_create_with_context(context)))
return GETDNS_RETURN_GENERIC_ERROR;
bindata.size = query_name_len;
bindata.data = query_name;
bindata.size = dnsreq->name_len;
bindata.data = dnsreq->name;
if (getdns_dict_set_bindata(*response, "canonical_name", &bindata))
goto error;

4
src/dnssec.c
View File

@ -1760,7 +1760,7 @@ static void add_netreq2val_chain(
if (GLDNS_ANCOUNT(netreq->response) == 0 &&
GLDNS_NSCOUNT(netreq->response) == 0) {
empty_rrset.name = netreq->query + GLDNS_HEADER_SIZE;
empty_rrset.name = netreq->owner->name;
empty_rrset.rr_class = GETDNS_RRCLASS_IN;
empty_rrset.rr_type = 0;
empty_rrset.pkt = netreq->response;
@ -1798,7 +1798,7 @@ static void add_netreq2val_chain(
*/
/* First find the canonical name for the question */
q_rrset.name = netreq->query + GLDNS_HEADER_SIZE;
q_rrset.name = netreq->owner->name;
q_rrset.rr_type = GETDNS_RRTYPE_CNAME;
q_rrset.rr_class = netreq->request_class;
q_rrset.pkt = netreq->response;

6
src/general.c
View File

@ -39,6 +39,7 @@
#include <string.h>
#include <unbound.h>
#include "config.h"
#include "gldns/wire2str.h"
#include "context.h"
#include "types-internal.h"
#include "util-internal.h"
@ -136,6 +137,7 @@ submit_network_request(getdns_network_req *netreq)
{
getdns_return_t r;
getdns_dns_req *dns_req = netreq->owner;
char name[1024];
if (dns_req->context->resolution_type == GETDNS_RESOLUTION_RECURSING
/* TODO: Until DNSSEC with the new async stub resolver is finished,
@ -159,9 +161,11 @@ submit_network_request(getdns_network_req *netreq)
dns_req->context->timeout, &dns_req->timeout)))
return r;
}
(void) gldns_wire2str_dname_buf(dns_req->name,
dns_req->name_len, name, sizeof(name));
return ub_resolve_async(dns_req->context->unbound_ctx,
dns_req->name, netreq->request_type, netreq->request_class,
name, netreq->request_type, netreq->request_class,
netreq, ub_resolve_callback, &(netreq->unbound_id)) ?
GETDNS_RETURN_GENERIC_ERROR : GETDNS_RETURN_GOOD;
}

9
src/request-internal.c
View File

@ -203,8 +203,6 @@ dns_req_free(getdns_dns_req * req)
req->timeout.timeout_cb = NULL;
}
/* free strduped name */
GETDNS_FREE(req->my_mf, req->name);
GETDNS_FREE(req->my_mf, req);
}
@ -358,7 +356,12 @@ dns_req_new(getdns_context *context, getdns_eventloop *loop,
result->netreqs[1] = NULL;
result->my_mf = context->mf;
result->name = getdns_strdup(&(result->my_mf), name);
result->name_len = sizeof(result->name);
if (gldns_str2wire_dname_buf(name, result->name, &result->name_len)) {
GETDNS_FREE(result->my_mf, result);
return NULL;
}
result->context = context;
result->loop = loop;
result->canceled = 0;

27
src/stub.c
View File

@ -272,10 +272,10 @@ is_starttls_response(getdns_network_req *netreq)
priv_getdns_rdf_iter rdf_iter_storage, *rdf_iter;
uint16_t rr_type;
gldns_pkt_section section;
uint8_t starttls_name_space[256],
*starttls_name = starttls_name_space;
uint8_t starttls_name_space[256], *starttls_name;
uint8_t owner_name_space[256], *owner_name;
size_t starttls_name_len = 256, owner_name_len;
size_t starttls_name_len = sizeof(starttls_name_space);
size_t owner_name_len = sizeof(owner_name_space);;
/* Servers that are not STARTTLS aware will refuse the CH query*/
if (GLDNS_RCODE_NOERROR != GLDNS_RCODE_WIRE(netreq->response))
@ -284,9 +284,6 @@ is_starttls_response(getdns_network_req *netreq)
if (GLDNS_ANCOUNT(netreq->response) != 1)
return 0;
(void) gldns_str2wire_dname_buf(
netreq->owner->name, starttls_name_space, &starttls_name_len);
for ( rr_iter = priv_getdns_rr_iter_init(&rr_iter_storage
, netreq->response
, netreq->response_len)
@ -295,25 +292,25 @@ is_starttls_response(getdns_network_req *netreq)
section = priv_getdns_rr_iter_section(rr_iter);
rr_type = gldns_read_uint16(rr_iter->rr_type);
if (section != GLDNS_SECTION_ANSWER || rr_type != GETDNS_RRTYPE_TXT)
if (section != GLDNS_SECTION_ANSWER
|| rr_type != GETDNS_RRTYPE_TXT)
continue;
owner_name = priv_getdns_owner_if_or_as_decompressed(
rr_iter, owner_name_space, &owner_name_len);
if (!priv_getdns_dname_equal(starttls_name, owner_name))
if (!priv_getdns_dname_equal(netreq->owner->name, owner_name))
continue;
if (!(rdf_iter = priv_getdns_rdf_iter_init(
&rdf_iter_storage, rr_iter)))
continue;
/* re-use the starttls_name for the response dname*/
starttls_name = priv_getdns_rdf_if_or_as_decompressed(
rdf_iter,starttls_name_space,&starttls_name_len);
if (priv_getdns_dname_equal(starttls_name, owner_name))
if ((starttls_name = priv_getdns_rdf_if_or_as_decompressed(
rdf_iter, starttls_name_space, &starttls_name_len)) &&
priv_getdns_dname_equal(starttls_name, owner_name))
return 1;
else
return 0;
continue;
return 0;
}
return 0;
}

3
src/types-internal.h
View File

@ -237,7 +237,8 @@ typedef struct getdns_dns_req {
getdns_rbnode_t node;
/* name */
char *name;
uint8_t name[256];
size_t name_len;
/* canceled flag */
int canceled;

19
src/util-internal.c
View File

@ -544,8 +544,7 @@ priv_getdns_create_reply_dict(getdns_context *context, getdns_network_req *req,
if ((r = getdns_dict_set_dict(result, "header", header)))
goto error;
(void) gldns_str2wire_dname_buf(
req->owner->name, canonical_name_space, &canonical_name_len);
canonical_name = req->owner->name;
for ( rr_iter = priv_getdns_rr_iter_init(&rr_iter_storage
, req->response
@ -863,8 +862,6 @@ getdns_return_t
getdns_apply_network_result(getdns_network_req* netreq,
struct ub_result* ub_res)
{
size_t dname_len;
if (ub_res->bogus)
netreq->dnssec_status = GETDNS_DNSSEC_BOGUS;
else if (ub_res->secure)
@ -909,17 +906,17 @@ getdns_apply_network_result(getdns_network_req* netreq,
GLDNS_RA_SET(netreq->response);
GLDNS_RCODE_SET(netreq->response, ub_res->rcode);
dname_len = netreq->max_udp_payload_size - GLDNS_HEADER_SIZE;
if (gldns_str2wire_dname_buf(netreq->owner->name,
netreq->response + GLDNS_HEADER_SIZE, &dname_len))
return GETDNS_RETURN_GENERIC_ERROR;
(void) memcpy( netreq->response + GLDNS_HEADER_SIZE
, netreq->owner->name, netreq->owner->name_len);
gldns_write_uint16( netreq->response + GLDNS_HEADER_SIZE + dname_len
gldns_write_uint16( netreq->response + GLDNS_HEADER_SIZE
+ netreq->owner->name_len
, netreq->request_type);
gldns_write_uint16( netreq->response + GLDNS_HEADER_SIZE + dname_len + 2
gldns_write_uint16( netreq->response + GLDNS_HEADER_SIZE
+ netreq->owner->name_len + 2
, netreq->request_class);
netreq->response_len = GLDNS_HEADER_SIZE + dname_len + 4;
netreq->response_len = GLDNS_HEADER_SIZE + netreq->owner->name_len + 4;
return GETDNS_RETURN_GOOD;
}