Store dnsreq->name in wire format

src/context.c

@@ -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))
+	(void)memcpy(lookup, dnsreq->name, dnsreq->name_len);
-		return GETDNS_RETURN_GENERIC_ERROR;
-
-	(void)memcpy(lookup, query_name, query_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.size = dnsreq->name_len;
-	bindata.data = query_name;
+	bindata.data = dnsreq->name;
 	if (getdns_dict_set_bindata(*response, "canonical_name", &bindata))
 		goto error;
 

src/dnssec.c

@@ -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;

src/general.c

@@ -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;
 	}

src/request-internal.c

@@ -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;

src/stub.c

@@ -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],
+	uint8_t starttls_name_space[256], *starttls_name;
-	       *starttls_name = starttls_name_space;
 	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(
+		if ((starttls_name = priv_getdns_rdf_if_or_as_decompressed(
-		    rdf_iter,starttls_name_space,&starttls_name_len);
+		    rdf_iter, starttls_name_space, &starttls_name_len)) &&
-		if (priv_getdns_dname_equal(starttls_name, owner_name)) 
+		    priv_getdns_dname_equal(starttls_name, owner_name)) 
 			return 1;
-		else
+
-			return 0;
+		return 0;
-		continue;
 	}
 	return 0;
 }

src/types-internal.h

@@ -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;

src/util-internal.c

@@ -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(
+	canonical_name = req->owner->name;
-	    req->owner->name, canonical_name_space, &canonical_name_len);
 
 	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;
+	(void) memcpy( netreq->response + GLDNS_HEADER_SIZE
-	if (gldns_str2wire_dname_buf(netreq->owner->name,
+	             , netreq->owner->name, netreq->owner->name_len);
-	    netreq->response + GLDNS_HEADER_SIZE, &dname_len))
-		return GETDNS_RETURN_GENERIC_ERROR;
 
-	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;
 }