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); }