From 595404e1753b863624ccb88a2606ef96e96f5e30 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Sat, 26 May 2012 13:16:34 +0200
Subject: [PATCH 1/5] Three more helper functions and the DNS action is done.

---
 examples/dns.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++-
 examples/dns.h | 51 +++++++++++++++++++++++++++++----
 examples/rr.c  |  1 +
 3 files changed, 122 insertions(+), 6 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index f3903c4..9f5712b 100644
--- a/examples/dns.c
+++ b/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;
diff --git a/examples/dns.h b/examples/dns.h
index 17d9540..ab0a86f 100644
--- a/examples/dns.h
+++ b/examples/dns.h
@@ -1,7 +1,8 @@
+typedef int bool;
 struct dns_header {
   uint16_t id;
-  boolean qr, aa, tc, rd, ra;
-  char opcode, z, rcode;
+  bool qr, aa, tc, rd, ra;
+  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;
diff --git a/examples/rr.c b/examples/rr.c
index e59f7e0..7278a04 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -173,6 +173,7 @@ const parser_t* init_soa() {
 		 uint32(), // REFRESH
 		 uint32(), // RETRY
 		 uint32(), // EXPIRE
+		 uint32(), // MINIMUM
 		 end_p(),
 		 NULL);
 

From 5163f002cfbd20cec2edfab0ac37c23e0728c118 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Sat, 26 May 2012 13:23:00 +0200
Subject: [PATCH 2/5] Great Symbol Renaming: types.

---
 examples/dns.c        | 42 +++++++++++++-------------
 examples/dns_common.c |  6 ++--
 examples/dns_common.h |  4 +--
 examples/rr.c         | 70 +++++++++++++++++++++----------------------
 examples/rr.h         | 32 ++++++++++----------
 5 files changed, 77 insertions(+), 77 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index 9f5712b..ca0f473 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -5,7 +5,7 @@
 #define false 0
 #define true 1
 
-bool is_zero(parse_result_t *p) {
+bool is_zero(HParseResult *p) {
   if (TT_UINT != p->ast->token_type)
     return false;
   return (0 == p->ast->uint);
@@ -15,19 +15,19 @@ bool is_zero(parse_result_t *p) {
  * Every DNS message should have QDCOUNT entries in the question
  * section, and ANCOUNT+NSCOUNT+ARCOUNT resource records.
  */
-bool validate_dns(parse_result_t *p) {
+bool validate_dns(HParseResult *p) {
   if (TT_SEQUENCE != p->ast->token_type)
     return false;
   // The header holds the counts as its last 4 elements.
-  parsed_token_t **elems = p->ast->seq->elements[0]->seq->elements;
+  HParsedToken **elems = p->ast->seq->elements[0]->seq->elements;
   size_t qd = elems[8]->uint;
   size_t an = elems[9]->uint;
   size_t ns = elems[10]->uint;
   size_t ar = elems[11]->uint;
-  parsed_token_t *questions = p->ast->seq->elements[1];
+  HParsedToken *questions = p->ast->seq->elements[1];
   if (questions->seq->used != qd)
     return false;
-  parsed_token_t *rrs = p->ast->seq->elements[2];
+  HParsedToken *rrs = p->ast->seq->elements[2];
   if (an+ns+ar != rrs->seq->used)
     return false;
   return true;
@@ -35,13 +35,13 @@ bool validate_dns(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*));
+const HParsedToken* pack_dns_struct(const HParseResult *p) {
+  HParsedToken *ret = arena_malloc(p->arena, sizeof(HParsedToken*));
   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];
+  HParsedToken *hdr = p->ast->seq->elements[0];
   struct dns_header header = {
     .id = hdr->seq->elements[0]->uint,
     .qr = hdr->seq->elements[1]->uint,
@@ -58,7 +58,7 @@ const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
   };
   msg->header = header;
 
-  parsed_token_t *qs = p->ast->seq->elements[1];
+  HParsedToken *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) {
@@ -68,7 +68,7 @@ const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
   }
   msg->questions = questions;
 
-  parsed_token_t *rrs = p->ast->seq->elements[2];
+  HParsedToken *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) {
@@ -109,14 +109,14 @@ const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
   return ret;
 }
 
-const parser_t* init_parser() {
-  static parser_t *dns_message = NULL;
+const HParser* init_parser() {
+  static HParser *dns_message = NULL;
   if (dns_message)
     return dns_message;
 
-  const parser_t *domain = init_domain();
+  const HParser *domain = init_domain();
 
-  const parser_t *dns_header = sequence(bits(16, false), // ID
+  const HParser *dns_header = sequence(bits(16, false), // ID
 					bits(1, false),  // QR
 					bits(4, false),  // opcode
 					bits(1, false),  // AA
@@ -131,19 +131,19 @@ const parser_t* init_parser() {
 					uint16(), // ARCOUNT
 					NULL);
 
-  const parser_t *type = int_range(uint16(), 1, 16);
+  const HParser *type = int_range(uint16(), 1, 16);
 
-  const parser_t *qtype = choice(type, 
+  const HParser *qtype = choice(type, 
 				 int_range(uint16(), 252, 255),
 				 NULL);
 
-  const parser_t *class = int_range(uint16(), 1, 4);
+  const HParser *class = int_range(uint16(), 1, 4);
   
-  const parser_t *qclass = choice(class,
+  const HParser *qclass = choice(class,
 				  int_range(uint16(), 255, 255),
 				  NULL);
 
-  const parser_t *dns_question = sequence(sequence(many1(length_value(uint8(), 
+  const HParser *dns_question = sequence(sequence(many1(length_value(uint8(), 
 								      uint8())), 
 						   ch('\x00'),
 						   NULL),  // QNAME
@@ -152,7 +152,7 @@ const parser_t* init_parser() {
 					  NULL);
  
 
-  const parser_t *dns_rr = sequence(domain,                          // NAME
+  const HParser *dns_rr = sequence(domain,                          // NAME
 				    type,                            // TYPE
 				    class,                           // CLASS
 				    uint32(),                        // TTL
@@ -160,7 +160,7 @@ const parser_t* init_parser() {
 				    NULL);
 
 
-  dns_message = (parser_t*)attr_bool(sequence(dns_header,
+  dns_message = (HParser*)attr_bool(sequence(dns_header,
 					      many(dns_question),
 					      many(dns_rr),
 					      end_p(),
diff --git a/examples/dns_common.c b/examples/dns_common.c
index a07efdf..2d7e018 100644
--- a/examples/dns_common.c
+++ b/examples/dns_common.c
@@ -51,7 +51,7 @@ const parser_t* init_domain() {
    * ... but this is easier and equivalent
    */
 
-  const parser_t *subdomain = sepBy1(label, ch('.'));
+  const HParser *subdomain = sepBy1(label, ch('.'));
 
   domain = choice(subdomain, 
 		  ch(' '), 
@@ -60,8 +60,8 @@ const parser_t* init_domain() {
   return domain;
 }
 
-const parser_t* init_character_string() {
-  static const parser_t *cstr = NULL;
+const HParser* init_character_string() {
+  static const HParser *cstr = NULL;
   if (cstr)
     return cstr;
 
diff --git a/examples/dns_common.h b/examples/dns_common.h
index 311b5be..41d73f0 100644
--- a/examples/dns_common.h
+++ b/examples/dns_common.h
@@ -3,7 +3,7 @@
 
 #include "../src/hammer.h"
 
-const parser_t* init_domain();
-const parser_t* init_character_string();
+const HParser* init_domain();
+const HParser* init_character_string();
 
 #endif
diff --git a/examples/rr.c b/examples/rr.c
index 7278a04..3a3cdda 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -5,8 +5,8 @@
 #define false 0
 #define true 1
 
-const parser_t* init_cname() {
-  static const parser_t *cname = NULL;
+const HParser* init_cname() {
+  static const HParser *cname = NULL;
   if (cname)
     return cname;
   
@@ -17,12 +17,12 @@ const parser_t* init_cname() {
   return cname;
 }
 
-const parser_t* init_hinfo() {
-  static const parser_t *hinfo = NULL;
+const HParser* init_hinfo() {
+  static const HParser *hinfo = NULL;
   if (hinfo)
     return hinfo;
 
-  const parser_t* cstr = init_character_string();
+  const HParser* cstr = init_character_string();
   
   hinfo = sequence(cstr,
 		   cstr,
@@ -32,8 +32,8 @@ const parser_t* init_hinfo() {
   return hinfo;
 }
 
-const parser_t* init_mb() {
-  static const parser_t *mb = NULL;
+const HParser* init_mb() {
+  static const HParser *mb = NULL;
   if (mb)
     return mb;
   
@@ -44,8 +44,8 @@ const parser_t* init_mb() {
   return mb;
 }
 
-const parser_t* init_md() {
-  static const parser_t *md = NULL;
+const HParser* init_md() {
+  static const HParser *md = NULL;
   if (md)
     return md;
   
@@ -56,8 +56,8 @@ const parser_t* init_md() {
   return md;
 }
 
-const parser_t* init_mf() {
-  static const parser_t *mf = NULL;
+const HParser* init_mf() {
+  static const HParser *mf = NULL;
   if (mf)
     return mf;
   
@@ -68,8 +68,8 @@ const parser_t* init_mf() {
   return mf;
 }
 
-const parser_t* init_mg() {
-  static const parser_t *mg = NULL;
+const HParser* init_mg() {
+  static const HParser *mg = NULL;
   if (mg)
     return mg;
   
@@ -80,12 +80,12 @@ const parser_t* init_mg() {
   return mg;
 }
 
-const parser_t* init_minfo() {
-  static const parser_t *minfo = NULL;
+const HParser* init_minfo() {
+  static const HParser *minfo = NULL;
   if (minfo)
     return minfo;
 
-  const parser_t* domain = init_domain();
+  const HParser* domain = init_domain();
 
   minfo = sequence(domain,
 		   domain,
@@ -95,8 +95,8 @@ const parser_t* init_minfo() {
   return minfo;
 }
 
-const parser_t* init_mr() {
-  static const parser_t *mr = NULL;
+const HParser* init_mr() {
+  static const HParser *mr = NULL;
   if (mr)
     return mr;
   
@@ -107,8 +107,8 @@ const parser_t* init_mr() {
   return mr;
 }
 
-const parser_t* init_mx() {
-  static const parser_t *mx = NULL;
+const HParser* init_mx() {
+  static const HParser *mx = NULL;
   if (mx)
     return mx;
   
@@ -126,8 +126,8 @@ bool validate_null(parse_result_t *p) {
   return (65536 > p->ast->seq->used);
 }
 
-const parser_t* init_null() {
-  static const parser_t *null_ = NULL;
+const HParser* init_null() {
+  static const HParser *null_ = NULL;
   if (null_)
     return null_;
 
@@ -136,8 +136,8 @@ const parser_t* init_null() {
   return null_;
 }
 
-const parser_t* init_ns() {
-  static const parser_t *ns = NULL;
+const HParser* init_ns() {
+  static const HParser *ns = NULL;
   if (ns)
     return ns;
 
@@ -148,8 +148,8 @@ const parser_t* init_ns() {
   return ns;
 }
 
-const parser_t* init_ptr() {
-  static const parser_t *ptr = NULL;
+const HParser* init_ptr() {
+  static const HParser *ptr = NULL;
   if (ptr)
     return ptr;
   
@@ -160,12 +160,12 @@ const parser_t* init_ptr() {
   return ptr;
 }
 
-const parser_t* init_soa() {
-  static const parser_t *soa = NULL;
+const HParser* init_soa() {
+  static const HParser *soa = NULL;
   if (soa)
     return soa;
 
-  const parser_t *domain = init_domain();
+  const HParser *domain = init_domain();
 
   soa = sequence(domain,   // MNAME
 		 domain,   // RNAME
@@ -180,8 +180,8 @@ const parser_t* init_soa() {
   return soa;
 }
 
-const parser_t* init_txt() {
-  static const parser_t *txt = NULL;
+const HParser* init_txt() {
+  static const HParser *txt = NULL;
   if (txt)
     return txt;
 
@@ -192,8 +192,8 @@ const parser_t* init_txt() {
   return txt;
 }
 
-const parser_t* init_a() {
-  static const parser_t *a = NULL;
+const HParser* init_a() {
+  static const HParser *a = NULL;
   if (a)
     return a;
 
@@ -204,8 +204,8 @@ const parser_t* init_a() {
   return a;
 }
 
-const parser_t* init_wks() {
-  static const parser_t *wks = NULL;
+const HParser* init_wks() {
+  static const HParser *wks = NULL;
   if (wks)
     return wks;
 
diff --git a/examples/rr.h b/examples/rr.h
index c0673d8..54172f8 100644
--- a/examples/rr.h
+++ b/examples/rr.h
@@ -3,21 +3,21 @@
 
 #include "../src/hammer.h"
 
-const parser_t* init_cname();
-const parser_t* init_hinfo();
-const parser_t* init_mb();
-const parser_t* init_md();
-const parser_t* init_mf();
-const parser_t* init_mg();
-const parser_t* init_minfo();
-const parser_t* init_mr();
-const parser_t* init_mx();
-const parser_t* init_null();
-const parser_t* init_ns();
-const parser_t* init_ptr();
-const parser_t* init_soa();
-const parser_t* init_txt();
-const parser_t* init_a();
-const parser_t* init_wks();
+const HParser* init_cname();
+const HParser* init_hinfo();
+const HParser* init_mb();
+const HParser* init_md();
+const HParser* init_mf();
+const HParser* init_mg();
+const HParser* init_minfo();
+const HParser* init_mr();
+const HParser* init_mx();
+const HParser* init_null();
+const HParser* init_ns();
+const HParser* init_ptr();
+const HParser* init_soa();
+const HParser* init_txt();
+const HParser* init_a();
+const HParser* init_wks();
 
 #endif

From a07725194796d9823c5cd70df6c81aa030e511a2 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Sat, 26 May 2012 14:10:09 +0200
Subject: [PATCH 3/5] get_qname done, starting get_domain, going to finish
 Great Symbol Renaming first

---
 examples/dns.c | 39 +++++++++++++++++++++++++++++++++++++--
 examples/dns.h |  9 ++++++++-
 2 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index ca0f473..9515a58 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -33,7 +33,40 @@ bool validate_dns(HParseResult *p) {
   return true;
 }
 
+struct dns_qname get_qname(const HParsedToken *t) {
+  // The qname parser parses at least 1 length-value pair, then a NULL.
+  // So, t->seq->elements[0] is a sequence of at least 1 such pair,
+  // and t->seq->elements[1] is the null.
+  const HParsedToken *labels = t->seq->elements[0];
+  struct dns_qname ret = {
+    .qlen = labels->seq->used,
+    .labels = arena_malloc(t->seq->arena, sizeof(ret.labels)*ret.qlen)
+  };
+  // i is which label we're on
+  for (size_t i=0; i<labels->seq->used; ++i) {
+    ret.labels[i].len = labels->seq->elements[i]->seq->used;
+    ret.labels[i].label = arena_malloc(t->seq->arena, sizeof(uint8_t)*ret.labels[i].len);
+    // j is which char of the label we're on
+    for (size_t j=0; j<ret.labels[i].len; ++j)
+      ret.labels[i].label[j] = labels->seq->elements[i]->seq->elements[j]->uint;
+  }
+  return ret;
+}
 
+char* get_name(const HParsedToken *t) {
+  switch(t->token_type) {
+  case TT_UINT:
+    return " ";
+  case TT_SEQUENCE:
+    {
+      // Sequence of subdomains separated by "."
+      
+    }
+  default:
+    return NULL;
+  }
+
+}
 
 const HParsedToken* pack_dns_struct(const HParseResult *p) {
   HParsedToken *ret = arena_malloc(p->arena, sizeof(HParsedToken*));
@@ -62,6 +95,8 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
   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) {
+    // QNAME is a sequence of labels. In the parser, it's defined as
+    // sequence(many1(length_value(...)), ch('\x00'), NULL).
     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;
@@ -145,8 +180,8 @@ const HParser* init_parser() {
 
   const HParser *dns_question = sequence(sequence(many1(length_value(uint8(), 
 								      uint8())), 
-						   ch('\x00'),
-						   NULL),  // QNAME
+						  ch('\x00'),
+						  NULL),  // QNAME
 					  qtype,           // QTYPE
 					  qclass,          // QCLASS
 					  NULL);
diff --git a/examples/dns.h b/examples/dns.h
index ab0a86f..1d36103 100644
--- a/examples/dns.h
+++ b/examples/dns.h
@@ -8,8 +8,15 @@ struct dns_header {
   size_t authority_count;
   size_t additional_count;
 };
+struct dns_qname {
+  size_t qlen;
+  struct {
+    size_t len;
+    uint8_t *label;
+  } *labels;
+};
 struct dns_question {
-  char** qname; // change to whatever format you want; I'm assuming you'll keep the length-prefixed terms.
+  struct dns_qname qname;
   uint16_t qtype;
   uint16_t qclass;
 };

From d7818bb8c4cefc65aba7e38eae64b9229aeadc7e Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Sat, 26 May 2012 14:27:12 +0200
Subject: [PATCH 4/5] Great Symbol Renaming done; get_domain and set_rr stubbed

---
 examples/dns.c        | 112 ++++++++++++++++++++--------------------
 examples/dns_common.c |  62 +++++++++++-----------
 examples/rr.c         | 116 +++++++++++++++++++++---------------------
 3 files changed, 147 insertions(+), 143 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index 9515a58..faf9124 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -40,12 +40,12 @@ struct dns_qname get_qname(const HParsedToken *t) {
   const HParsedToken *labels = t->seq->elements[0];
   struct dns_qname ret = {
     .qlen = labels->seq->used,
-    .labels = arena_malloc(t->seq->arena, sizeof(ret.labels)*ret.qlen)
+    .labels = h_arena_malloc(t->seq->arena, sizeof(ret.labels)*ret.qlen)
   };
   // i is which label we're on
   for (size_t i=0; i<labels->seq->used; ++i) {
     ret.labels[i].len = labels->seq->elements[i]->seq->used;
-    ret.labels[i].label = arena_malloc(t->seq->arena, sizeof(uint8_t)*ret.labels[i].len);
+    ret.labels[i].label = h_arena_malloc(t->seq->arena, sizeof(uint8_t)*ret.labels[i].len);
     // j is which char of the label we're on
     for (size_t j=0; j<ret.labels[i].len; ++j)
       ret.labels[i].label[j] = labels->seq->elements[i]->seq->elements[j]->uint;
@@ -53,14 +53,14 @@ struct dns_qname get_qname(const HParsedToken *t) {
   return ret;
 }
 
-char* get_name(const HParsedToken *t) {
+char* get_domain(const HParsedToken *t) {
   switch(t->token_type) {
   case TT_UINT:
     return " ";
   case TT_SEQUENCE:
     {
       // Sequence of subdomains separated by "."
-      
+      return NULL;
     }
   default:
     return NULL;
@@ -68,11 +68,15 @@ char* get_name(const HParsedToken *t) {
 
 }
 
+void set_rr(struct dns_rr rr, HCountedArray *rdata) {
+
+}
+
 const HParsedToken* pack_dns_struct(const HParseResult *p) {
-  HParsedToken *ret = arena_malloc(p->arena, sizeof(HParsedToken*));
+  HParsedToken *ret = h_arena_malloc(p->arena, sizeof(HParsedToken*));
   ret->token_type = TT_USER;
 
-  dns_message_t *msg = arena_malloc(p->arena, sizeof(dns_message_t*));
+  dns_message_t *msg = h_arena_malloc(p->arena, sizeof(dns_message_t*));
 
   HParsedToken *hdr = p->ast->seq->elements[0];
   struct dns_header header = {
@@ -92,7 +96,7 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
   msg->header = header;
 
   HParsedToken *qs = p->ast->seq->elements[1];
-  struct dns_question *questions = arena_malloc(p->arena,
+  struct dns_question *questions = h_arena_malloc(p->arena,
 						sizeof(struct dns_question)*(header.question_count));
   for (size_t i=0; i<header.question_count; ++i) {
     // QNAME is a sequence of labels. In the parser, it's defined as
@@ -104,8 +108,8 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
   msg->questions = questions;
 
   HParsedToken *rrs = p->ast->seq->elements[2];
-  struct dns_rr *answers = arena_malloc(p->arena,
-					sizeof(struct dns_rr)*(header.answer_count));
+  struct dns_rr *answers = h_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;
@@ -116,7 +120,7 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
   }
   msg->answers = answers;
 
-  struct dns_rr *authority = arena_malloc(p->arena,
+  struct dns_rr *authority = h_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]);
@@ -128,8 +132,8 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
   }
   msg->authority = authority;
 
-  struct dns_rr *additional = arena_malloc(p->arena,
-					   sizeof(struct dns_rr)*(header.additional_count));
+  struct dns_rr *additional = h_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;
@@ -151,56 +155,56 @@ const HParser* init_parser() {
 
   const HParser *domain = init_domain();
 
-  const HParser *dns_header = sequence(bits(16, false), // ID
-					bits(1, false),  // QR
-					bits(4, false),  // opcode
-					bits(1, false),  // AA
-					bits(1, false),  // TC
-					bits(1, false),  // RD
-					bits(1, false),  // RA
-					ignore(attr_bool(bits(3, false), is_zero)), // Z
-					bits(4, false),  // RCODE
-					uint16(), // QDCOUNT
-					uint16(), // ANCOUNT
-					uint16(), // NSCOUNT
-					uint16(), // ARCOUNT
-					NULL);
+  const HParser *dns_header = h_sequence(h_bits(16, false), // ID
+					 h_bits(1, false),  // QR
+					 h_bits(4, false),  // opcode
+					 h_bits(1, false),  // AA
+					 h_bits(1, false),  // TC
+					 h_bits(1, false),  // RD
+					 h_bits(1, false),  // RA
+					 h_ignore(h_attr_bool(h_bits(3, false), is_zero)), // Z
+					 h_bits(4, false),  // RCODE
+					 h_uint16(), // QDCOUNT
+					 h_uint16(), // ANCOUNT
+					 h_uint16(), // NSCOUNT
+					 h_uint16(), // ARCOUNT
+					 NULL);
 
-  const HParser *type = int_range(uint16(), 1, 16);
+  const HParser *type = h_int_range(h_uint16(), 1, 16);
 
-  const HParser *qtype = choice(type, 
-				 int_range(uint16(), 252, 255),
-				 NULL);
-
-  const HParser *class = int_range(uint16(), 1, 4);
-  
-  const HParser *qclass = choice(class,
-				  int_range(uint16(), 255, 255),
+  const HParser *qtype = h_choice(type, 
+				  h_int_range(h_uint16(), 252, 255),
 				  NULL);
 
-  const HParser *dns_question = sequence(sequence(many1(length_value(uint8(), 
-								      uint8())), 
-						  ch('\x00'),
-						  NULL),  // QNAME
-					  qtype,           // QTYPE
-					  qclass,          // QCLASS
-					  NULL);
+  const HParser *class = h_int_range(h_uint16(), 1, 4);
+  
+  const HParser *qclass = h_choice(class,
+				   h_int_range(h_uint16(), 255, 255),
+				   NULL);
+
+  const HParser *dns_question = h_sequence(h_sequence(h_many1(h_length_value(h_uint8(), 
+									     h_uint8())), 
+						      h_ch('\x00'),
+						      NULL),  // QNAME
+					   qtype,           // QTYPE
+					   qclass,          // QCLASS
+					   NULL);
  
 
-  const HParser *dns_rr = sequence(domain,                          // NAME
-				    type,                            // TYPE
-				    class,                           // CLASS
-				    uint32(),                        // TTL
-				    length_value(uint16(), uint8()), // RDLENGTH+RDATA
-				    NULL);
+  const HParser *dns_rr = h_sequence(domain,                          // NAME
+				     type,                            // TYPE
+				     class,                           // CLASS
+				     h_uint32(),                        // TTL
+				     h_length_value(h_uint16(), h_uint8()), // RDLENGTH+RDATA
+				     NULL);
 
 
-  dns_message = (HParser*)attr_bool(sequence(dns_header,
-					      many(dns_question),
-					      many(dns_rr),
-					      end_p(),
-					      NULL),
-				     validate_dns);
+  dns_message = (HParser*)h_attr_bool(h_sequence(dns_header,
+						 h_many(dns_question),
+						 h_many(dns_rr),
+						 h_end_p(),
+						 NULL),
+				      validate_dns);
 
   return dns_message;
 }
diff --git a/examples/dns_common.c b/examples/dns_common.c
index 2d7e018..3d349f1 100644
--- a/examples/dns_common.c
+++ b/examples/dns_common.c
@@ -7,55 +7,55 @@
 /**
  * A label can't be more than 63 characters.
  */
-bool validate_label(parse_result_t *p) {
+bool validate_label(HParseResult *p) {
   if (TT_SEQUENCE != p->ast->token_type)
     return false;
   return (64 > p->ast->seq->used);
 }
 
-const parser_t* init_domain() {
-  static const parser_t *domain = NULL;
+const HParser* init_domain() {
+  static const HParser *domain = NULL;
   if (domain)
     return domain;
 
-  const parser_t *letter = choice(ch_range('a', 'z'),
-				  ch_range('A', 'Z'),
-				  NULL);
-
-  const parser_t *let_dig = choice(letter,
-				   ch_range('0', '9'),
+  const HParser *letter = h_choice(h_ch_range('a', 'z'),
+				   h_ch_range('A', 'Z'),
 				   NULL);
 
-  const parser_t *ldh_str = many1(choice(let_dig,
-					 ch('-'),
-					 NULL));
+  const HParser *let_dig = h_choice(letter,
+				    h_ch_range('0', '9'),
+				    NULL);
 
-  const parser_t *label = attr_bool(sequence(letter,
-					     optional(sequence(optional(ldh_str),
-							       let_dig,
-							       NULL)),
-					     NULL),
-				    validate_label);
+  const HParser *ldh_str = h_many1(h_choice(let_dig,
+					    h_ch('-'),
+					    NULL));
+
+  const HParser *label = h_attr_bool(h_sequence(letter,
+						h_optional(h_sequence(h_optional(ldh_str),
+								      let_dig,
+								      NULL)),
+						NULL),
+				     validate_label);
 
   /**
    * You could write it like this ...
-   *   parser_t *indirect_subdomain = indirect();
-   *   const parser_t *subdomain = choice(label,
-   *				          sequence(indirect_subdomain,
-   *					           ch('.'),
-   *					           label,
-   *					           NULL),
-   *				          NULL);
-   *   bind_indirect(indirect_subdomain, subdomain);
+   *   HParser *indirect_subdomain = h_indirect();
+   *   const HParser *subdomain = h_choice(label,
+   *				           h_sequence(indirect_subdomain,
+   *					              h_ch('.'),
+   *					              label,
+   *					              NULL),
+   *				           NULL);
+   *   h_bind_indirect(indirect_subdomain, subdomain);
    *
    * ... but this is easier and equivalent
    */
 
-  const HParser *subdomain = sepBy1(label, ch('.'));
+  const HParser *subdomain = h_sepBy1(label, h_ch('.'));
 
-  domain = choice(subdomain, 
-		  ch(' '), 
-		  NULL); 
+  domain = h_choice(subdomain, 
+		    h_ch(' '), 
+		    NULL); 
 
   return domain;
 }
@@ -65,7 +65,7 @@ const HParser* init_character_string() {
   if (cstr)
     return cstr;
 
-  cstr = length_value(uint8(), uint8());
+  cstr = h_length_value(h_uint8(), h_uint8());
 
   return cstr;
 }
diff --git a/examples/rr.c b/examples/rr.c
index 3a3cdda..8dae885 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -10,9 +10,9 @@ const HParser* init_cname() {
   if (cname)
     return cname;
   
-  cname = sequence(init_domain(),
-		   end_p(),
-		   NULL);
+  cname = h_sequence(init_domain(),
+		     h_end_p(),
+		     NULL);
   
   return cname;
 }
@@ -24,10 +24,10 @@ const HParser* init_hinfo() {
 
   const HParser* cstr = init_character_string();
   
-  hinfo = sequence(cstr,
-		   cstr,
-		   end_p(),
-		   NULL);
+  hinfo = h_sequence(cstr,
+		     cstr,
+		     h_end_p(),
+		     NULL);
 
   return hinfo;
 }
@@ -37,9 +37,9 @@ const HParser* init_mb() {
   if (mb)
     return mb;
   
-  mb = sequence(init_domain(),
-		end_p(),
-		NULL);
+  mb = h_sequence(init_domain(),
+		  h_end_p(),
+		  NULL);
 
   return mb;
 }
@@ -49,9 +49,9 @@ const HParser* init_md() {
   if (md)
     return md;
   
-  md = sequence(init_domain(),
-		end_p,
-		NULL);
+  md = h_sequence(init_domain(),
+		  h_end_p,
+		  NULL);
 
   return md;
 }
@@ -61,9 +61,9 @@ const HParser* init_mf() {
   if (mf)
     return mf;
   
-  mf = sequence(init_domain(),
-		end_p(),
-		NULL);
+  mf = h_sequence(init_domain(),
+		  h_end_p(),
+		  NULL);
 
   return mf;
 }
@@ -73,9 +73,9 @@ const HParser* init_mg() {
   if (mg)
     return mg;
   
-  mg = sequence(init_domain(),
-		end_p(),
-		NULL);
+  mg = h_sequence(init_domain(),
+		  h_end_p(),
+		  NULL);
 
   return mg;
 }
@@ -87,10 +87,10 @@ const HParser* init_minfo() {
 
   const HParser* domain = init_domain();
 
-  minfo = sequence(domain,
-		   domain,
-		   end_p(),
-		   NULL);
+  minfo = h_sequence(domain,
+		     domain,
+		     h_end_p(),
+		     NULL);
 
   return minfo;
 }
@@ -100,9 +100,9 @@ const HParser* init_mr() {
   if (mr)
     return mr;
   
-  mr = sequence(init_domain(),
-		end_p(),
-		NULL);
+  mr = h_sequence(init_domain(),
+		  h_end_p(),
+		  NULL);
 
   return mr;
 }
@@ -112,15 +112,15 @@ const HParser* init_mx() {
   if (mx)
     return mx;
   
-  mx = sequence(uint16(),
-		init_domain(),
-		end_p(),
-		NULL);
+  mx = h_sequence(h_uint16(),
+		  init_domain(),
+		  h_end_p(),
+		  NULL);
 
   return mx;
 }
 
-bool validate_null(parse_result_t *p) {
+bool validate_null(HParseResult *p) {
   if (TT_SEQUENCE != p->ast->token_type)
     return false;
   return (65536 > p->ast->seq->used);
@@ -131,7 +131,7 @@ const HParser* init_null() {
   if (null_)
     return null_;
 
-  null_ = attr_bool(uint8(), validate_null);
+  null_ = h_attr_bool(h_many(h_uint8()), validate_null);
 
   return null_;
 }
@@ -141,9 +141,9 @@ const HParser* init_ns() {
   if (ns)
     return ns;
 
-  ns = sequence(init_domain(),
-		end_p(),
-		NULL);
+  ns = h_sequence(init_domain(),
+		  h_end_p(),
+		  NULL);
 
   return ns;
 }
@@ -153,9 +153,9 @@ const HParser* init_ptr() {
   if (ptr)
     return ptr;
   
-  ptr = sequence(init_domain(),
-		end_p(),
-		NULL);
+  ptr = h_sequence(init_domain(),
+		   h_end_p(),
+		   NULL);
 
   return ptr;
 }
@@ -167,15 +167,15 @@ const HParser* init_soa() {
 
   const HParser *domain = init_domain();
 
-  soa = sequence(domain,   // MNAME
-		 domain,   // RNAME
-		 uint32(), // SERIAL
-		 uint32(), // REFRESH
-		 uint32(), // RETRY
-		 uint32(), // EXPIRE
-		 uint32(), // MINIMUM
-		 end_p(),
-		 NULL);
+  soa = h_sequence(domain,   // MNAME
+		   domain,   // RNAME
+		   h_uint32(), // SERIAL
+		   h_uint32(), // REFRESH
+		   h_uint32(), // RETRY
+		   h_uint32(), // EXPIRE
+		   h_uint32(), // MINIMUM
+		   h_end_p(),
+		   NULL);
 
   return soa;
 }
@@ -185,9 +185,9 @@ const HParser* init_txt() {
   if (txt)
     return txt;
 
-  txt = sequence(many1(init_character_string()),
-		 end_p(),
-		 NULL);
+  txt = h_sequence(h_many1(init_character_string()),
+		   h_end_p(),
+		   NULL);
 
   return txt;
 }
@@ -197,9 +197,9 @@ const HParser* init_a() {
   if (a)
     return a;
 
-  a = sequence(uint32(),
-	       end_p(),
-	       NULL);
+  a = h_sequence(h_uint32(),
+		 h_end_p(),
+		 NULL);
 
   return a;
 }
@@ -209,11 +209,11 @@ const HParser* init_wks() {
   if (wks)
     return wks;
 
-  wks = sequence(uint32(),
-		 uint8(),
-		 many(uint8()),
-		 end_p(),
-		 NULL);
+  wks = h_sequence(h_uint32(),
+		   h_uint8(),
+		   h_many(h_uint8()),
+		   h_end_p(),
+		   NULL);
 
   return wks;
 }

From fa0b73dd5e73dd8324426896b10824db4ef1ce71 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Sat, 26 May 2012 14:40:12 +0200
Subject: [PATCH 5/5] Fixed possible NULL dereference; fixed setupLR to use
 arena properly

---
 src/hammer.c | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/hammer.c b/src/hammer.c
index 34f413f..6d64cd0 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -45,9 +45,9 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
   } else { // Some heads found
     if (!cached && head->head_parser != k->parser && !g_slist_find(head->involved_set, k->parser)) {
       // Nothing in the cache, and the key parser is not involved
-      HParseResult *tmp = g_new(HParseResult, 1);
+      HParseResult *tmp = a_new(HParseResult, 1);
       tmp->ast = NULL; tmp->arena = state->arena;
-      HParserCacheValue *ret = g_new(HParserCacheValue, 1);
+      HParserCacheValue *ret = a_new(HParserCacheValue, 1);
       ret->value_type = PC_RIGHT; ret->right = tmp;
       return ret;
     }
@@ -58,6 +58,8 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
       if (tmp_res)
 	tmp_res->arena = state->arena;
       // we know that cached has an entry here, modify it
+      if (!cached)
+	cached = a_new(HParserCacheValue, 1);
       cached->value_type = PC_RIGHT;
       cached->right = tmp_res;
     }
@@ -70,14 +72,14 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
  * see the current parser again.
  */
 
-void setupLR(const HParser *p, GQueue *stack, HLeftRec *rec_detect) {
+void setupLR(const HParser *p, HParseState *state, HLeftRec *rec_detect) {
   if (!rec_detect->head) {
-    HRecursionHead *some = g_new(HRecursionHead, 1);
+    HRecursionHead *some = a_new(HRecursionHead, 1);
     some->head_parser = p; some->involved_set = NULL; some->eval_set = NULL;
     rec_detect->head = some;
   }
   size_t i = 0;
-  HLeftRec *lr = g_queue_peek_nth(stack, i);
+  HLeftRec *lr = g_queue_peek_nth(state->lr_stack, i);
   while (lr && lr->rule != p) {
     lr->head = rec_detect->head;
     lr->head->involved_set = g_slist_prepend(lr->head->involved_set, (gpointer)lr->rule);
@@ -108,7 +110,7 @@ HParseResult* grow(HParserCacheKey *k, HParseState *state, HRecursionHead *head)
   if (tmp_res) {
     if ((old_res->ast->index < tmp_res->ast->index) || 
 	(old_res->ast->index == tmp_res->ast->index && old_res->ast->bit_offset < tmp_res->ast->bit_offset)) {
-      HParserCacheValue *v = g_new(HParserCacheValue, 1);
+      HParserCacheValue *v = a_new(HParserCacheValue, 1);
       v->value_type = PC_RIGHT; v->right = tmp_res;
       g_hash_table_replace(state->cache, k, v);
       return grow(k, state, head);
@@ -136,7 +138,7 @@ HParseResult* lr_answer(HParserCacheKey *k, HParseState *state, HLeftRec *growab
     }
     else {
       // update cache
-      HParserCacheValue *v = g_new(HParserCacheValue, 1);
+      HParserCacheValue *v = a_new(HParserCacheValue, 1);
       v->value_type = PC_RIGHT; v->right = growable->seed;
       g_hash_table_replace(state->cache, k, v);
       if (!growable->seed)
@@ -206,7 +208,7 @@ HParseResult* h_do_parse(const HParser* parser, HParseState *state) {
   } else {
     // it exists!
     if (PC_LEFT == m->value_type) {
-      setupLR(parser, state->lr_stack, m->left);
+      setupLR(parser, state, m->left);
       return m->left->seed; // BUG: this might not be correct
     } else {
       return m->right;