Allow multiple requests per query.

include/rdns.h

@@ -92,25 +92,26 @@ struct rdns_reply_entry {
 
 
 enum dns_rcode {
- DNS_RC_NOERROR = 0,
- DNS_RC_FORMERR = 1,
- DNS_RC_SERVFAIL = 2,
- DNS_RC_NXDOMAIN = 3,
- DNS_RC_NOTIMP = 4,
- DNS_RC_REFUSED = 5,
- DNS_RC_YXDOMAIN = 6,
- DNS_RC_YXRRSET = 7,
- DNS_RC_NXRRSET = 8,
- DNS_RC_NOTAUTH = 9,
- DNS_RC_NOTZONE = 10,
- DNS_RC_TIMEOUT = 11,
- DNS_RC_NETERR = 12
+ RDNS_RC_NOERROR = 0,
+ RDNS_RC_FORMERR = 1,
+ RDNS_RC_SERVFAIL = 2,
+ RDNS_RC_NXDOMAIN = 3,
+ RDNS_RC_NOTIMP = 4,
+ RDNS_RC_REFUSED = 5,
+ RDNS_RC_YXDOMAIN = 6,
+ RDNS_RC_YXRRSET = 7,
+ RDNS_RC_NXRRSET = 8,
+ RDNS_RC_NOTAUTH = 9,
+ RDNS_RC_NOTZONE = 10,
+ RDNS_RC_TIMEOUT = 11,
+ RDNS_RC_NETERR = 12
 };
 
 struct rdns_reply {
  struct rdns_request *request;
  struct rdns_resolver *resolver;
  struct rdns_reply_entry *entries;
+ const char *requested_name;
  enum dns_rcode code;
 };
 
@@ -280,7 +281,6 @@ struct rdns_request* rdns_make_request_full (
  void *cbdata,
  double timeout,
  unsigned int repeats,
- const char *name,
  unsigned int queries,
  ...
  );

src/dns_private.h

@@ -73,7 +73,12 @@ struct rdns_request {
  unsigned int retransmits;
 
  int id;
- const char *requested_name;
+ struct _rdns_request_name {
+ char *name;
+ enum rdns_request_type type;
+ unsigned int len;
+ } *requested_names;
+ unsigned int qcount;
 
  enum {
  RDNS_REQUEST_NEW = 0,

src/packet.c

@@ -39,7 +39,7 @@ rdns_allocate_packet (struct rdns_request* req, unsigned int namelen)
 
 
 void
-rdns_make_dns_header (struct rdns_request *req)
+rdns_make_dns_header (struct rdns_request *req, unsigned int qcount)
 {
  struct dns_header *header;
 
@@ -48,7 +48,7 @@ rdns_make_dns_header (struct rdns_request *req)
  memset (header, 0 , sizeof (struct dns_header));
  header->qid = rdns_permutor_generate_id ();
  header->rd = 1;
- header->qdcount = htons (1);
+ header->qdcount = htons (qcount);
  header->arcount = htons (1);
  req->pos += sizeof (struct dns_header);
  req->id = header->qid;
@@ -182,8 +182,6 @@ rdns_add_rr (struct rdns_request *req, const char *name, enum dns_type type)
  uint16_t *p;
  int len = strlen (name);
 
- rdns_allocate_packet (req, len);
- rdns_make_dns_header (req);
  rdns_format_dns_name (req, name, len);
  p = (uint16_t *)(req->packet + req->pos);
  *p++ = htons (type);

src/packet.h

@@ -38,7 +38,7 @@ void rdns_allocate_packet (struct rdns_request* req, unsigned int namelen);
  * Add basic header to the dns packet
  * @param req
  */
-void rdns_make_dns_header (struct rdns_request *req);
+void rdns_make_dns_header (struct rdns_request *req, unsigned int qcount);
 
 
 /**

src/resolver.c

@@ -457,7 +457,6 @@ rdns_make_request_full (
  void *cbdata,
  double timeout,
  unsigned int repeats,
- const char *name,
  unsigned int queries,
  ...
  )
@@ -466,7 +465,8 @@ rdns_make_request_full (
  struct rdns_request *req;
  struct rdns_server *serv;
  int r, type;
- unsigned int i;
+ unsigned int i, tlen = 0, clen = 0, cur;
+ const char *cur_name, *last_name = NULL;
 
  if (!resolver->initialized) {
  return NULL;
@@ -481,45 +481,85 @@ rdns_make_request_full (
  req->func = cb;
  req->arg = cbdata;
  req->reply = NULL;
- req->requested_name = name;
+ req->qcount = queries;
+ req->requested_names = malloc (queries * sizeof (struct _rdns_request_name));
+ if (req->requested_names == NULL) {
+ free (req);
+ return NULL;
+ }
+
  req->type = 0;
 #ifdef HAVE_SODIUM
  req->curve_plugin_data = NULL;
 #endif
  REF_INIT_RETAIN (req, rdns_request_free);
 
+ /* Calculate packet's total length based on records count */
  va_start (args, queries);
- for (i = 0; i < queries; i ++) {
+ for (i = 0; i < queries * 2; i += 2) {
+ cur = i / 2;
+ cur_name = va_arg (args, const char *);
+ if (cur_name != NULL) {
+ last_name = cur_name;
+ clen = strlen (cur_name);
+ if (clen == 0) {
+ rdns_info ("got empty name to resolve");
+ rdns_request_free (req);
+ return NULL;
+ }
+ tlen += clen;
+ }
+ else if (last_name == NULL) {
+ rdns_info ("got NULL as the first name to resolve");
+ rdns_request_free (req);
+ return NULL;
+ }
+
+ req->requested_names[cur].name = malloc (clen + 1);
+ if (req->requested_names[cur].name == NULL) {
+ rdns_request_free (req);
+ return NULL;
+ }
+ memcpy (req->requested_names[cur].name, last_name, clen);
+ req->requested_names[cur].name[clen] = '\0';
  type = va_arg (args, int);
- req->type |= type;
- switch (type) {
- case DNS_REQUEST_PTR:
- rdns_add_rr (req, name, DNS_T_PTR);
+ req->requested_names[cur].type = type;
+ req->requested_names[cur].len = clen;
+ }
+ va_end (args);
+
+ rdns_allocate_packet (req, tlen);
+ rdns_make_dns_header (req, queries);
+
+ for (i = 0; i < queries; i ++) {
+ cur_name = req->requested_names[i].name;
+ switch (req->requested_names[i].type) {
+ case RDNS_REQUEST_PTR:
+ rdns_add_rr (req, cur_name, DNS_T_PTR);
  break;
- case DNS_REQUEST_MX:
- rdns_add_rr (req, name, DNS_T_MX);
+ case RDNS_REQUEST_MX:
+ rdns_add_rr (req, cur_name, DNS_T_MX);
  break;
- case DNS_REQUEST_A:
- rdns_add_rr (req, name, DNS_T_A);
+ case RDNS_REQUEST_A:
+ rdns_add_rr (req, cur_name, DNS_T_A);
  break;
- case DNS_REQUEST_AAAA:
- rdns_add_rr (req, name, DNS_T_AAAA);
+ case RDNS_REQUEST_AAAA:
+ rdns_add_rr (req, cur_name, DNS_T_AAAA);
  break;
- case DNS_REQUEST_TXT:
- rdns_add_rr (req, name, DNS_T_TXT);
+ case RDNS_REQUEST_TXT:
+ rdns_add_rr (req, cur_name, DNS_T_TXT);
  break;
- case DNS_REQUEST_SPF:
- rdns_add_rr (req, name, DNS_T_SPF);
+ case RDNS_REQUEST_SPF:
+ rdns_add_rr (req, cur_name, DNS_T_SPF);
  break;
- case DNS_REQUEST_SRV:
- rdns_add_rr (req, name, DNS_T_SRV);
+ case RDNS_REQUEST_SRV:
+ rdns_add_rr (req, cur_name, DNS_T_SRV);
  break;
- case DNS_REQUEST_TLSA:
- rdns_add_rr (req, name, DNS_T_TLSA);
+ case RDNS_REQUEST_TLSA:
+ rdns_add_rr (req, cur_name, DNS_T_TLSA);
  break;
  }
  }
- va_end (args);
 
  /* Add EDNS RR */
  rdns_add_edns0 (req);

src/util.c

@@ -290,10 +290,18 @@ rdns_reply_free (struct rdns_reply *rep)
 void
 rdns_request_free (struct rdns_request *req)
 {
+ unsigned int i;
+
  if (req != NULL) {
  if (req->packet != NULL) {
  free (req->packet);
  }
+ for (i = 0; i < req->qcount; i ++) {
+ free (req->requested_names[i].name);
+ }
+ if (req->requested_names != NULL) {
+ free (req->requested_names);
+ }
  if (req->reply != NULL) {
  rdns_reply_free (req->reply);
  }
@@ -446,7 +454,7 @@ rdns_request_has_type (struct rdns_request *req, enum rdns_request_type type)
 const char*
 rdns_request_get_name (struct rdns_request *req)
 {
- return req->requested_name;
+ return NULL;
 }
 
 char *