Three more helper functions and the DNS action is done.

examples/dns.c

@@ -33,7 +33,81 @@ bool validate_dns(parse_result_t *p) {
   return true;
 }
 
-const parsed_token_t* pack_dns_struct(const parse_result_t *p);
+
+
+const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
+  parsed_token_t *ret = arena_malloc(p->arena, sizeof(parsed_token_t*));
+  ret->token_type = TT_USER;
+
+  dns_message_t *msg = arena_malloc(p->arena, sizeof(dns_message_t*));
+
+  parsed_token_t *hdr = p->ast->seq->elements[0];
+  struct dns_header header = {
+    .id = hdr->seq->elements[0]->uint,
+    .qr = hdr->seq->elements[1]->uint,
+    .opcode = hdr->seq->elements[2]->uint,
+    .aa = hdr->seq->elements[3]->uint,
+    .tc = hdr->seq->elements[4]->uint,
+    .rd = hdr->seq->elements[5]->uint,
+    .ra = hdr->seq->elements[6]->uint,
+    .rcode = hdr->seq->elements[7]->uint,
+    .question_count = hdr->seq->elements[8]->uint,
+    .answer_count = hdr->seq->elements[9]->uint,
+    .authority_count = hdr->seq->elements[10]->uint,
+    .additional_count = hdr->seq->elements[11]->uint
+  };
+  msg->header = header;
+
+  parsed_token_t *qs = p->ast->seq->elements[1];
+  struct dns_question *questions = arena_malloc(p->arena,
+						sizeof(struct dns_question)*(header.question_count));
+  for (size_t i=0; i<header.question_count; ++i) {
+    questions[i].qname = get_qname(qs->seq->elements[i]->seq->elements[0]);
+    questions[i].qtype = qs->seq->elements[i]->seq->elements[1]->uint;
+    questions[i].qclass = qs->seq->elements[i]->seq->elements[2]->uint;
+  }
+  msg->questions = questions;
+
+  parsed_token_t *rrs = p->ast->seq->elements[2];
+  struct dns_rr *answers = arena_malloc(p->arena,
+					sizeof(struct dns_rr)*(header.answer_count));
+  for (size_t i=0; i<header.answer_count; ++i) {
+    answers[i].name = get_domain(rrs[i].seq->elements[0]);
+    answers[i].type = rrs[i].seq->elements[1]->uint;
+    answers[i].type = rrs[i].seq->elements[2]->uint;
+    answers[i].ttl = rrs[i].seq->elements[3]->uint;
+    answers[i].rdlength = rrs[i].seq->elements[4]->seq->used;
+    set_rr(answers[i], rrs[i].seq->elements[4]->seq);	   
+  }
+  msg->answers = answers;
+
+  struct dns_rr *authority = arena_malloc(p->arena,
+					  sizeof(struct dns_rr)*(header.authority_count));
+  for (size_t i=0, j=header.answer_count; i<header.authority_count; ++i, ++j) {
+    authority[i].name = get_domain(rrs[j].seq->elements[0]);
+    authority[i].type = rrs[j].seq->elements[1]->uint;
+    authority[i].type = rrs[j].seq->elements[2]->uint;
+    authority[i].ttl = rrs[j].seq->elements[3]->uint;
+    authority[i].rdlength = rrs[j].seq->elements[4]->seq->used;
+    set_rr(authority[i], rrs[j].seq->elements[4]->seq);
+  }
+  msg->authority = authority;
+
+  struct dns_rr *additional = arena_malloc(p->arena,
+					   sizeof(struct dns_rr)*(header.additional_count));
+  for (size_t i=0, j=header.answer_count+header.authority_count; i<header.additional_count; ++i, ++j) {
+    additional[i].name = get_domain(rrs[j].seq->elements[0]);
+    additional[i].type = rrs[j].seq->elements[1]->uint;
+    additional[i].type = rrs[j].seq->elements[2]->uint;
+    additional[i].ttl = rrs[j].seq->elements[3]->uint;
+    additional[i].rdlength = rrs[j].seq->elements[4]->seq->used;
+    set_rr(additional[i], rrs[j].seq->elements[4]->seq);
+  }
+  msg->additional = additional;
+
+  ret->user = (void*)msg;
+  return ret;
+}
 
 const parser_t* init_parser() {
   static parser_t *dns_message = NULL;

examples/dns.h

@@ -1,7 +1,8 @@
+typedef int bool;
 struct dns_header {
   uint16_t id;
-  boolean qr, aa, tc, rd, ra;
+  bool qr, aa, tc, rd, ra;
-  char opcode, z, rcode;
+  char opcode, rcode;
   size_t question_count;
   size_t answer_count;
   size_t authority_count;
@@ -19,14 +20,54 @@ struct dns_rr {
   uint32_t ttl; // cmos is also acceptable.
   uint16_t rdlength;
   union {
-    // various types of rdata-specific data here...
+    char* cname;
+    struct {
+      uint8_t* cpu;
+      uint8_t* os;
+    } hinfo;
+    char* mb;
+    char* md;
+    char* mf;
+    char* mg;
+    struct {
+      char* rmailbx;
+      char* emailbx;
+    } minfo;
+    char* mr;
+    struct {
+      uint16_t preference;
+      char* exchange;
+    } mx;
+    uint8_t* null;
+    char* ns;
+    char* ptr;
+    struct {
+      char* mname;
+      char* rname;
+      uint32_t serial;
+      uint32_t refresh;
+      uint32_t retry;
+      uint32_t expire;
+      uint32_t minimum;
+    } soa;
+    struct {
+      size_t count;
+      uint8_t** txt_data;
+    } txt;
+    uint32_t a;
+    struct {
+      uint32_t address;
+      uint8_t protocol;
+      size_t len;
+      uint8_t** bit_map;
+    } wks;
   };
 };
 
 typedef struct dns_message {
   struct dns_header header;
-  struct dns_question *questions; // end all these with null, just to be sure.
+  struct dns_question *questions;
   struct dns_rr *answers;
   struct dns_rr *authority;
   struct dns_rr *additional;
-}
+} dns_message_t;

examples/rr.c

@@ -173,6 +173,7 @@ const parser_t* init_soa() {
 		 uint32(), // REFRESH
 		 uint32(), // RETRY
 		 uint32(), // EXPIRE
+		 uint32(), // MINIMUM
 		 end_p(),
 		 NULL);