const HParsedToken* act_minfo(const HParseResult *p) {
dns_rr_minfo_t *minfo = H_ALLOC(dns_rr_minfo_t);
minfo->rmailbx = *H_FIELD(dns_domain_t, 0);
minfo->emailbx = *H_FIELD(dns_domain_t, 1);
return H_MAKE(dns_rr_minfo_t, minfo);
}
const HParsedToken* act_mx(const HParseResult *p) {
dns_rr_mx_t *mx = H_ALLOC(dns_rr_mx_t);
mx->preference = H_FIELD_UINT(0);
mx->exchange = *H_FIELD(dns_domain_t, 1);
return H_MAKE(dns_rr_mx_t, mx);
}
const HParsedToken* act_hinfo(const HParseResult *p) {
dns_rr_hinfo_t *hinfo = H_ALLOC(dns_rr_hinfo_t);
hinfo->cpu = *H_FIELD(dns_cstr_t, 0);
hinfo->os = *H_FIELD(dns_cstr_t, 1);
return H_MAKE(dns_rr_hinfo_t, hinfo);
}
static HParsedToken *act_notime(const HParseResult *p, void *user)
{
DNP3_Object *o = H_ALLOC(DNP3_Object);
// p = (cs, status)
o->cmdev.status = H_FIELD_UINT(0);
o->cmdev.cs = H_FIELD_UINT(1);
return H_MAKE(DNP3_Object, o);
}
static HParsedToken *act_ctr_flag(const HParseResult *p, void *user)
{
DNP3_Object *o = H_ALLOC(DNP3_Object);
// p = (flags, value)
o->ctr.flags = H_FIELD(DNP3_Object, 0)->flags;
o->ctr.value = H_FIELD_UINT(1);
return H_MAKE(DNP3_Object, o);
}
const HParsedToken *act_null(const HParseResult *p) {
dns_rr_null_t *null = H_ALLOC(dns_rr_null_t);
size_t len = h_seq_len(p->ast);
uint8_t *buf = h_arena_malloc(p->arena, sizeof(uint8_t)*len);
for (size_t i=0; i<len; ++i)
buf[i] = H_FIELD_UINT(i);
return H_MAKE(dns_rr_null_t, null);
}
const HParsedToken* act_wks(const HParseResult *p) {
dns_rr_wks_t *wks = H_ALLOC(dns_rr_wks_t);
wks->address = H_FIELD_UINT(0);
wks->protocol = H_FIELD_UINT(1);
wks->len = H_FIELD_SEQ(2)->used;
wks->bit_map = h_arena_malloc(p->arena, sizeof(uint8_t)*wks->len);
for (size_t i=0; i<wks->len; ++i)
wks->bit_map[i] = H_INDEX_UINT(p->ast, 2, i);
return H_MAKE(dns_rr_wks_t, wks);
}
const HParsedToken* act_cstr(const HParseResult *p) {
dns_cstr_t *cs = H_ALLOC(dns_cstr_t);
const HCountedArray *arr = H_CAST_SEQ(p->ast);
uint8_t *ret = h_arena_malloc(arr->arena, sizeof(uint8_t)*arr->used);
for (size_t i=0; i<arr->used; ++i)
ret[i] = H_CAST_UINT(arr->elements[i]);
assert(ret[arr->used-1] == '\0'); // XXX Is this right?! If so, shouldn't it be a validation?
*cs = ret;
return H_MAKE(dns_cstr_t, cs);
}
static HParsedToken *act_flags(const HParseResult *p, void *user)
{
DNP3_Object *o = H_ALLOC(DNP3_Object);
o->flags.online = H_FIELD_UINT(0);
o->flags.restart = H_FIELD_UINT(1);
o->flags.comm_lost = H_FIELD_UINT(2);
o->flags.remote_forced = H_FIELD_UINT(3);
o->flags.local_forced = H_FIELD_UINT(4);
o->flags.discontinuity = H_FIELD_UINT(5);
return H_MAKE(DNP3_Object, o);
}
const HParsedToken* act_soa(const HParseResult *p) {
dns_rr_soa_t *soa = H_ALLOC(dns_rr_soa_t);
soa->mname = *H_FIELD(dns_domain_t, 0);
soa->rname = *H_FIELD(dns_domain_t, 1);
soa->serial = H_FIELD_UINT(2);
soa->refresh = H_FIELD_UINT(3);
soa->retry = H_FIELD_UINT(4);
soa->expire = H_FIELD_UINT(5);
soa->minimum = H_FIELD_UINT(6);
return H_MAKE(dns_rr_soa_t, soa);
}
static HParsedToken *act_bytes(const HParseResult *p, void *user)
{
DNP3_Object *o = H_ALLOC(DNP3_Object);
HCountedArray *a = H_CAST_SEQ(p->ast);
size_t n = a->used;
o->applid.len = n;
o->applid.str = h_arena_malloc(p->arena, n+1); // null-terminate
for(size_t i=0; i<n; i++)
o->applid.str[i] = H_CAST_UINT(a->elements[i]);
o->applid.str[n] = '\0';
return H_MAKE(DNP3_Object, o);
}
static HParsedToken *act_crob(const HParseResult *p, void *user)
{
DNP3_Object *o = H_ALLOC(DNP3_Object);
// p = (optype,qu,cr,tcc,count,on,off,status)
o->cmd.optype = H_FIELD_UINT(0);
o->cmd.queue = H_FIELD_UINT(1);
o->cmd.clear = H_FIELD_UINT(2);
o->cmd.tcc = H_FIELD_UINT(3);
o->cmd.count = H_FIELD_UINT(4);
o->cmd.on = H_FIELD_UINT(5);
o->cmd.off = H_FIELD_UINT(6);
o->cmd.status = H_FIELD_UINT(7);
return H_MAKE(DNP3_Object, o);
}
static HParsedToken *act_segment(const HParseResult *p, void *user)
{
DNP3_Segment *s = H_ALLOC(DNP3_Segment);
s->fin = H_FIELD_UINT(0, 0);
s->fir = H_FIELD_UINT(0, 1);
s->seq = H_FIELD_UINT(0, 2);
HCountedArray *a = H_FIELD_SEQ(1);
s->len = a->used;
s->payload = h_arena_malloc(p->arena, s->len);
assert(s->payload != NULL);
for(size_t i=0; i<s->len; i++) {
s->payload[i] = H_CAST_UINT(a->elements[i]);
}
return H_MAKE(DNP3_Segment, s);
}
const HParsedToken *act_txt(const HParseResult *p) {
dns_rr_txt_t *txt = H_ALLOC(dns_rr_txt_t);
const HCountedArray *arr = H_CAST_SEQ(p->ast);
uint8_t **ret = h_arena_malloc(arr->arena, sizeof(uint8_t*)*arr->used);
for (size_t i=0; i<arr->used; ++i) {
size_t len = h_seq_len(arr->elements[i]);
uint8_t *tmp = h_arena_malloc(arr->arena, sizeof(uint8_t)*len);
for (size_t j=0; j<len; ++j)
tmp[j] = H_INDEX_UINT(arr->elements[i], j);
ret[i] = tmp;
}
txt->count = arr->used;
txt->txt_data = ret;
return H_MAKE(dns_rr_txt_t, txt);
}
HParsedToken* act_domain(const HParseResult *p, void* user_data) {
HParsedToken *ret = NULL;
char *arr = NULL;
switch(p->ast->token_type) {
case TT_UINT:
arr = " ";
break;
case TT_SEQUENCE:
// Sequence of subdomains separated by "."
// Each subdomain is a label, which can be no more than 63 chars.
arr = h_arena_malloc(p->arena, 64*p->ast->seq->used);
size_t count = 0;
for (size_t i=0; i<p->ast->seq->used; ++i) {
HParsedToken *tmp = p->ast->seq->elements[i];
for (size_t j=0; j<tmp->seq->used; ++j) {
arr[count] = tmp->seq->elements[i]->uint;
++count;
}
arr[count] = '.';
++count;
}
arr[count-1] = '\x00';
break;
default:
arr = NULL;
ret = NULL;
}
if(arr) {
dns_domain_t *val = H_ALLOC(dns_domain_t); // dns_domain_t is char*
*val = arr;
ret = H_MAKE(dns_domain_t, val);
}
return ret;
}
static HParsedToken *act_packed(const HParseResult *p, void *user)
{
DNP3_Object *o = H_ALLOC(DNP3_Object);
o->bit = H_CAST_UINT(p->ast);
return H_MAKE(DNP3_Object, o);
}
