emileclarkb/hammer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Great Symbol Renaming done; get_domain and set_rr stubbed

Browse source
This commit is contained in:
Meredith L. Patterson 2012-05-26 14:27:12 +02:00
parent 56b8413b6d
commit d7818bb8c4
3 changed files with 147 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

112
examples/dns.c
View file

@ -40,12 +40,12 @@ struct dns_qname get_qname(const HParsedToken *t) {
const HParsedToken *labels = t->seq->elements[0]; const HParsedToken *labels = t->seq->elements[0];
struct dns_qname ret = { struct dns_qname ret = {
.qlen = labels->seq->used, .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 // i is which label we're on
for (size_t i=0; i<labels->seq->used; ++i) { for (size_t i=0; i<labels->seq->used; ++i) {
ret.labels[i].len = labels->seq->elements[i]->seq->used; 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 // j is which char of the label we're on
for (size_t j=0; j<ret.labels[i].len; ++j) for (size_t j=0; j<ret.labels[i].len; ++j)
ret.labels[i].label[j] = labels->seq->elements[i]->seq->elements[j]->uint; 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; return ret;
} }
char* get_name(const HParsedToken *t) { char* get_domain(const HParsedToken *t) {
switch(t->token_type) { switch(t->token_type) {
case TT_UINT: case TT_UINT:
return " "; return " ";
case TT_SEQUENCE: case TT_SEQUENCE:
{ {
// Sequence of subdomains separated by "." // Sequence of subdomains separated by "."
return NULL;
} }
default: default:
return NULL; 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) { 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; 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]; HParsedToken *hdr = p->ast->seq->elements[0];
struct dns_header header = { struct dns_header header = {
@ -92,7 +96,7 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
msg->header = header; msg->header = header;
HParsedToken *qs = p->ast->seq->elements[1]; 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)); sizeof(struct dns_question)*(header.question_count));
for (size_t i=0; i<header.question_count; ++i) { for (size_t i=0; i<header.question_count; ++i) {
// QNAME is a sequence of labels. In the parser, it's defined as // 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; msg->questions = questions;
HParsedToken *rrs = p->ast->seq->elements[2]; HParsedToken *rrs = p->ast->seq->elements[2];
struct dns_rr *answers = arena_malloc(p->arena, struct dns_rr *answers = h_arena_malloc(p->arena,
sizeof(struct dns_rr)*(header.answer_count)); sizeof(struct dns_rr)*(header.answer_count));
for (size_t i=0; i<header.answer_count; ++i) { for (size_t i=0; i<header.answer_count; ++i) {
answers[i].name = get_domain(rrs[i].seq->elements[0]); 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[1]->uint;
@ -116,7 +120,7 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
} }
msg->answers = answers; 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)); sizeof(struct dns_rr)*(header.authority_count));
for (size_t i=0, j=header.answer_count; i<header.authority_count; ++i, ++j) { 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].name = get_domain(rrs[j].seq->elements[0]);
@ -128,8 +132,8 @@ const HParsedToken* pack_dns_struct(const HParseResult *p) {
} }
msg->authority = authority; msg->authority = authority;
struct dns_rr *additional = arena_malloc(p->arena, struct dns_rr *additional = h_arena_malloc(p->arena,
sizeof(struct dns_rr)*(header.additional_count)); 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) { 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].name = get_domain(rrs[j].seq->elements[0]);
additional[i].type = rrs[j].seq->elements[1]->uint; additional[i].type = rrs[j].seq->elements[1]->uint;
@ -151,56 +155,56 @@ const HParser* init_parser() {
const HParser *domain = init_domain(); const HParser *domain = init_domain();
const HParser *dns_header = sequence(bits(16, false), // ID const HParser *dns_header = h_sequence(h_bits(16, false), // ID
bits(1, false), // QR h_bits(1, false), // QR
bits(4, false), // opcode h_bits(4, false), // opcode
bits(1, false), // AA h_bits(1, false), // AA
bits(1, false), // TC h_bits(1, false), // TC
bits(1, false), // RD h_bits(1, false), // RD
bits(1, false), // RA h_bits(1, false), // RA
ignore(attr_bool(bits(3, false), is_zero)), // Z h_ignore(h_attr_bool(h_bits(3, false), is_zero)), // Z
bits(4, false), // RCODE h_bits(4, false), // RCODE
uint16(), // QDCOUNT h_uint16(), // QDCOUNT
uint16(), // ANCOUNT h_uint16(), // ANCOUNT
uint16(), // NSCOUNT h_uint16(), // NSCOUNT
uint16(), // ARCOUNT h_uint16(), // ARCOUNT
NULL); NULL);
const HParser *type = int_range(uint16(), 1, 16); const HParser *type = h_int_range(h_uint16(), 1, 16);
const HParser *qtype = choice(type, const HParser *qtype = h_choice(type,
int_range(uint16(), 252, 255), h_int_range(h_uint16(), 252, 255),
NULL);
const HParser *class = int_range(uint16(), 1, 4);
const HParser *qclass = choice(class,
int_range(uint16(), 255, 255),
NULL); NULL);
const HParser *dns_question = sequence(sequence(many1(length_value(uint8(), const HParser *class = h_int_range(h_uint16(), 1, 4);
uint8())),
ch('\x00'), const HParser *qclass = h_choice(class,
NULL), // QNAME h_int_range(h_uint16(), 255, 255),
qtype, // QTYPE NULL);
qclass, // QCLASS
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 const HParser *dns_rr = h_sequence(domain, // NAME
type, // TYPE type, // TYPE
class, // CLASS class, // CLASS
uint32(), // TTL h_uint32(), // TTL
length_value(uint16(), uint8()), // RDLENGTH+RDATA h_length_value(h_uint16(), h_uint8()), // RDLENGTH+RDATA
NULL); NULL);
dns_message = (HParser*)attr_bool(sequence(dns_header, dns_message = (HParser*)h_attr_bool(h_sequence(dns_header,
many(dns_question), h_many(dns_question),
many(dns_rr), h_many(dns_rr),
end_p(), h_end_p(),
NULL), NULL),
validate_dns); validate_dns);
return dns_message; return dns_message;
} }

62
examples/dns_common.c
View file

@ -7,55 +7,55 @@
/** /**
* A label can't be more than 63 characters. * 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) if (TT_SEQUENCE != p->ast->token_type)
return false; return false;
return (64 > p->ast->seq->used); return (64 > p->ast->seq->used);
} }
const parser_t* init_domain() { const HParser* init_domain() {
static const parser_t *domain = NULL; static const HParser *domain = NULL;
if (domain) if (domain)
return domain; return domain;
const parser_t *letter = choice(ch_range('a', 'z'), const HParser *letter = h_choice(h_ch_range('a', 'z'),
ch_range('A', 'Z'), h_ch_range('A', 'Z'),
NULL);
const parser_t *let_dig = choice(letter,
ch_range('0', '9'),
NULL); NULL);
const parser_t *ldh_str = many1(choice(let_dig, const HParser *let_dig = h_choice(letter,
ch('-'), h_ch_range('0', '9'),
NULL)); NULL);
const parser_t *label = attr_bool(sequence(letter, const HParser *ldh_str = h_many1(h_choice(let_dig,
optional(sequence(optional(ldh_str), h_ch('-'),
let_dig, NULL));
NULL)),
NULL), const HParser *label = h_attr_bool(h_sequence(letter,
validate_label); h_optional(h_sequence(h_optional(ldh_str),
let_dig,
NULL)),
NULL),
validate_label);
/** /**
* You could write it like this ... * You could write it like this ...
* parser_t *indirect_subdomain = indirect(); * HParser *indirect_subdomain = h_indirect();
* const parser_t *subdomain = choice(label, * const HParser *subdomain = h_choice(label,
* sequence(indirect_subdomain, * h_sequence(indirect_subdomain,
* ch('.'), * h_ch('.'),
* label, * label,
* NULL), * NULL),
* NULL); * NULL);
* bind_indirect(indirect_subdomain, subdomain); * h_bind_indirect(indirect_subdomain, subdomain);
* *
* ... but this is easier and equivalent * ... but this is easier and equivalent
*/ */
const HParser *subdomain = sepBy1(label, ch('.')); const HParser *subdomain = h_sepBy1(label, h_ch('.'));
domain = choice(subdomain, domain = h_choice(subdomain,
ch(' '), h_ch(' '),
NULL); NULL);
return domain; return domain;
} }
@ -65,7 +65,7 @@ const HParser* init_character_string() {
if (cstr) if (cstr)
return cstr; return cstr;
cstr = length_value(uint8(), uint8()); cstr = h_length_value(h_uint8(), h_uint8());
return cstr; return cstr;
} }

116
examples/rr.c
View file

@ -10,9 +10,9 @@ const HParser* init_cname() {
if (cname) if (cname)
return cname; return cname;
cname = sequence(init_domain(), cname = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return cname; return cname;
} }
@ -24,10 +24,10 @@ const HParser* init_hinfo() {
const HParser* cstr = init_character_string(); const HParser* cstr = init_character_string();
hinfo = sequence(cstr, hinfo = h_sequence(cstr,
cstr, cstr,
end_p(), h_end_p(),
NULL); NULL);
return hinfo; return hinfo;
} }
@ -37,9 +37,9 @@ const HParser* init_mb() {
if (mb) if (mb)
return mb; return mb;
mb = sequence(init_domain(), mb = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mb; return mb;
} }
@ -49,9 +49,9 @@ const HParser* init_md() {
if (md) if (md)
return md; return md;
md = sequence(init_domain(), md = h_sequence(init_domain(),
end_p, h_end_p,
NULL); NULL);
return md; return md;
} }
@ -61,9 +61,9 @@ const HParser* init_mf() {
if (mf) if (mf)
return mf; return mf;
mf = sequence(init_domain(), mf = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mf; return mf;
} }
@ -73,9 +73,9 @@ const HParser* init_mg() {
if (mg) if (mg)
return mg; return mg;
mg = sequence(init_domain(), mg = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mg; return mg;
} }
@ -87,10 +87,10 @@ const HParser* init_minfo() {
const HParser* domain = init_domain(); const HParser* domain = init_domain();
minfo = sequence(domain, minfo = h_sequence(domain,
domain, domain,
end_p(), h_end_p(),
NULL); NULL);
return minfo; return minfo;
} }
@ -100,9 +100,9 @@ const HParser* init_mr() {
if (mr) if (mr)
return mr; return mr;
mr = sequence(init_domain(), mr = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mr; return mr;
} }
@ -112,15 +112,15 @@ const HParser* init_mx() {
if (mx) if (mx)
return mx; return mx;
mx = sequence(uint16(), mx = h_sequence(h_uint16(),
init_domain(), init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mx; return mx;
} }
bool validate_null(parse_result_t *p) { bool validate_null(HParseResult *p) {
if (TT_SEQUENCE != p->ast->token_type) if (TT_SEQUENCE != p->ast->token_type)
return false; return false;
return (65536 > p->ast->seq->used); return (65536 > p->ast->seq->used);
@ -131,7 +131,7 @@ const HParser* init_null() {
if (null_) if (null_)
return null_; return null_;
null_ = attr_bool(uint8(), validate_null); null_ = h_attr_bool(h_many(h_uint8()), validate_null);
return null_; return null_;
} }
@ -141,9 +141,9 @@ const HParser* init_ns() {
if (ns) if (ns)
return ns; return ns;
ns = sequence(init_domain(), ns = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return ns; return ns;
} }
@ -153,9 +153,9 @@ const HParser* init_ptr() {
if (ptr) if (ptr)
return ptr; return ptr;
ptr = sequence(init_domain(), ptr = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return ptr; return ptr;
} }
@ -167,15 +167,15 @@ const HParser* init_soa() {
const HParser *domain = init_domain(); const HParser *domain = init_domain();
soa = sequence(domain, // MNAME soa = h_sequence(domain, // MNAME
domain, // RNAME domain, // RNAME
uint32(), // SERIAL h_uint32(), // SERIAL
uint32(), // REFRESH h_uint32(), // REFRESH
uint32(), // RETRY h_uint32(), // RETRY
uint32(), // EXPIRE h_uint32(), // EXPIRE
uint32(), // MINIMUM h_uint32(), // MINIMUM
end_p(), h_end_p(),
NULL); NULL);
return soa; return soa;
} }
@ -185,9 +185,9 @@ const HParser* init_txt() {
if (txt) if (txt)
return txt; return txt;
txt = sequence(many1(init_character_string()), txt = h_sequence(h_many1(init_character_string()),
end_p(), h_end_p(),
NULL); NULL);
return txt; return txt;
} }
@ -197,9 +197,9 @@ const HParser* init_a() {
if (a) if (a)
return a; return a;
a = sequence(uint32(), a = h_sequence(h_uint32(),
end_p(), h_end_p(),
NULL); NULL);
return a; return a;
} }
@ -209,11 +209,11 @@ const HParser* init_wks() {
if (wks) if (wks)
return wks; return wks;
wks = sequence(uint32(), wks = h_sequence(h_uint32(),
uint8(), h_uint8(),
many(uint8()), h_many(h_uint8()),
end_p(), h_end_p(),
NULL); NULL);
return wks; return wks;
} }