Use compression algorithm for resolving.

src/compression.c

@@ -138,6 +138,8 @@ rdns_write_name_compressed (struct rdns_request *req,
  pos += label_len + 1;
  }
 
+ /* Termination label */
+ *target++ = '\0';
  req->pos = target - req->packet;
 
  return true;

src/packet.c

@@ -27,6 +27,7 @@
 #include "packet.h"
 #include "util.h"
 #include "logger.h"
+#include "compression.h"
 
 void
 rdns_allocate_packet (struct rdns_request* req, unsigned int namelen)
@@ -176,20 +177,24 @@ rdns_format_dns_name (struct rdns_request *req, const char *name, unsigned int n
  req->pos += pos - (req->packet + req->pos) + 1;
 }
 
-void
-rdns_add_rr (struct rdns_request *req, const char *name, enum dns_type type)
+bool
+rdns_add_rr (struct rdns_request *req, const char *name, unsigned int len,
+ enum dns_type type, struct rdns_compression_entry **comp)
 {
  uint16_t *p;
- int len = strlen (name);
 
- rdns_format_dns_name (req, name, len);
+ if (!rdns_write_name_compressed (req, name, len, comp)) {
+ return false;
+ }
  p = (uint16_t *)(req->packet + req->pos);
  *p++ = htons (type);
  *p = htons (DNS_C_IN);
  req->pos += sizeof (uint16_t) * 2;
+
+ return true;
 }
 
-void
+bool
 rdns_add_edns0 (struct rdns_request *req)
 {
  uint8_t *p8;
@@ -208,4 +213,6 @@ rdns_add_edns0 (struct rdns_request *req)
  /* Length */
  *p16 = 0;
  req->pos += sizeof (uint8_t) + sizeof (uint16_t) * 5;
+
+ return true;
 }

src/packet.h

@@ -27,6 +27,8 @@
 #include <stdint.h>
 #include "dns_private.h"
 
+struct rdns_compression_entry;
+
 /**
  * Allocate dns packet suitable to handle up to `namelen` name
  * @param req request
@@ -55,12 +57,13 @@ void rdns_format_dns_name (struct rdns_request *req, const char *name, unsigned
  * @param name requested name
  * @param type type of resource record
  */
-void rdns_add_rr (struct rdns_request *req, const char *name, enum dns_type type);
+bool rdns_add_rr (struct rdns_request *req, const char *name, unsigned int len,
+ enum dns_type type, struct rdns_compression_entry **comp);
 
 /**
  * Add EDNS0 section
  * @param req
  */
-void rdns_add_edns0 (struct rdns_request *req);
+bool rdns_add_edns0 (struct rdns_request *req);
 
 #endif /* PACKET_H_ */

src/resolver.c

@@ -39,6 +39,7 @@
 #include "packet.h"
 #include "parse.h"
 #include "logger.h"
+#include "compression.h"
 
 static int
 rdns_send_request (struct rdns_request *req, int fd, bool new_req)
@@ -427,6 +428,7 @@ rdns_make_request_full (
  int r, type;
  unsigned int i, tlen = 0, clen = 0, cur;
  const char *cur_name, *last_name = NULL;
+ struct rdns_compression_entry *comp = NULL;
 
  if (!resolver->initialized) {
  return NULL;
@@ -493,34 +495,42 @@ rdns_make_request_full (
 
  for (i = 0; i < queries; i ++) {
  cur_name = req->requested_names[i].name;
+ clen = req->requested_names[i].len;
  switch (req->requested_names[i].type) {
  case RDNS_REQUEST_PTR:
- rdns_add_rr (req, cur_name, DNS_T_PTR);
+ type = DNS_T_PTR;
  break;
  case RDNS_REQUEST_MX:
- rdns_add_rr (req, cur_name, DNS_T_MX);
+ type = DNS_T_MX;
  break;
  case RDNS_REQUEST_A:
- rdns_add_rr (req, cur_name, DNS_T_A);
+ type = DNS_T_A;
  break;
  case RDNS_REQUEST_AAAA:
- rdns_add_rr (req, cur_name, DNS_T_AAAA);
+ type = DNS_T_AAAA;
  break;
  case RDNS_REQUEST_TXT:
- rdns_add_rr (req, cur_name, DNS_T_TXT);
+ type = DNS_T_TXT;
  break;
  case RDNS_REQUEST_SPF:
- rdns_add_rr (req, cur_name, DNS_T_SPF);
+ type = DNS_T_SPF;
  break;
  case RDNS_REQUEST_SRV:
- rdns_add_rr (req, cur_name, DNS_T_SRV);
+ type = DNS_T_SRV;
  break;
  case RDNS_REQUEST_TLSA:
- rdns_add_rr (req, cur_name, DNS_T_TLSA);
+ type = DNS_T_TLSA;
  break;
  }
+ if (!rdns_add_rr (req, cur_name, clen, type, &comp)) {
+ REF_RELEASE (req);
+ rnds_compression_free (comp);
+ return NULL;
+ }
  }
 
+ rnds_compression_free (comp);
+
  /* Add EDNS RR */
  rdns_add_edns0 (req);