* _intstr (mf,csp,cs)
* _manyistr (mf,cs)
* _txt (pa)
- * _inaddr (pa,di,cs +search_sortlist, dip_genaddr)
+ * _inaddr (pa,di,cs
+ * +search_sortlist, dip_genaddr, csp_genaddr)
+ * _in6addr (pa,di,cs)
* _addr (pa,di,div,csp,cs,gsz
* +search_sortlist_sa, dip_sockaddr)
* _domain (pap,csp,cs)
}
/*
- * _inaddr (pa,di,cs +search_sortlist, dip_genaddr)
+ * _inaddr (pa,di,cs +search_sortlist, dip_genaddr, csp_genaddr)
*/
static adns_status pa_inaddr(const parseinfo *pai, int cbyte,
static int search_sortlist(adns_state ads, int af, const void *ad) {
const struct sortlist *slp;
- const struct in_addr *a4;
int i;
- assert(af==AF_INET);
- a4= ad;
for (i=0, slp=ads->sortlist;
i<ads->nsortlist &&
- (assert(slp->af==AF_INET),
- !((a4->s_addr & slp->mask.v4.s_addr) == slp->base.v4.s_addr));
+ !adns__addr_match_p(af,ad, slp->af,&slp->base,&slp->mask);
i++, slp++);
return i;
}
return dip_genaddr(ads,AF_INET,datap_a,datap_b);
}
+static adns_status csp_genaddr(vbuf *vb, int af, const void *p) {
+ char buf[ADNS_ADDR2TEXT_BUFLEN];
+ int len= sizeof(buf);
+ adns_rr_addr a;
+ int err;
+
+ memset(&a, 0, sizeof(a));
+ a.addr.sa.sa_family= af;
+ adns__sockaddr_inject(p, 0, &a.addr.sa);
+ err= adns_addr2text(&a.addr.sa,0, buf,&len, 0); assert(!err);
+ CSP_ADDSTR(buf);
+ return adns_s_ok;
+}
+
static adns_status cs_inaddr(vbuf *vb, const void *datap) {
- const struct in_addr *rrp= datap, rr= *rrp;
- const char *ia;
+ return csp_genaddr(vb, AF_INET,datap);
+}
+
+/*
+ * _in6addr (pa,di,cs)
+ */
+
+static adns_status pa_in6addr(const parseinfo *pai, int cbyte,
+ int max, void *datap) {
+ struct in6_addr *storeto= datap;
- ia= inet_ntoa(rr); assert(ia);
- CSP_ADDSTR(ia);
+ if (max-cbyte != 16) return adns_s_invaliddata;
+ memcpy(storeto->s6_addr, pai->dgram + cbyte, 16);
return adns_s_ok;
}
+static int di_in6addr(adns_state ads,
+ const void *datap_a, const void *datap_b) {
+ return dip_genaddr(ads,AF_INET6,datap_a,datap_b);
+}
+
+static adns_status cs_in6addr(vbuf *vb, const void *datap) {
+ return csp_genaddr(vb,AF_INET6,datap);
+}
+
/*
* _addr (pa,di,div,csp,cs,gsz +search_sortlist_sa, dip_sockaddr)
*/
}
static int search_sortlist_sa(adns_state ads, const struct sockaddr *sa) {
- assert(sa->sa_family == AF_INET);
- return search_sortlist(ads, sa->sa_family,
- &((const struct sockaddr_in *)sa)->sin_addr);
+ union gen_addr a;
+ adns__sockaddr_extract(sa, &a, 0);
+ return search_sortlist(ads, sa->sa_family, &a);
}
+
static int dip_sockaddr(adns_state ads,
const struct sockaddr *sa,
const struct sockaddr *sb) {
}
static adns_status csp_addr(vbuf *vb, const adns_rr_addr *rrp) {
- const char *ia;
- char buf[30];
+ char buf[ADNS_ADDR2TEXT_BUFLEN];
+ int len= sizeof(buf);
+ int err;
switch (rrp->addr.inet.sin_family) {
case AF_INET:
CSP_ADDSTR("INET ");
- ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
- CSP_ADDSTR(ia);
+ goto a2t;
+ case AF_INET6:
+ CSP_ADDSTR("INET6 ");
+ goto a2t;
+ a2t:
+ err= adns_addr2text(&rrp->addr.sa,0, buf,&len, 0); assert(!err);
+ CSP_ADDSTR(buf);
break;
default:
sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
static adns_status ckl_ptr(adns_state ads, adns_queryflags flags,
union checklabel_state *cls, qcontext *ctx,
int labnum, const char *label, int lablen) {
- static const char *const (expectdomain[])= { DNS_INADDR_ARPA };
- char *ep;
- const char *ed;
- char labbuf[4];
- int l;
-
- if (labnum < 4) {
- if (lablen<=0 || lablen>3) return adns_s_querydomainwrong;
- memcpy(labbuf, label, lablen);
- labbuf[lablen]= 0;
- cls->ptr.ipv[3-labnum]= strtoul(labbuf,&ep,10);
- if (*ep) return adns_s_querydomainwrong;
- if (lablen>1 && *label=='0') return adns_s_querydomainwrong;
- } else if (labnum < 4 + sizeof(expectdomain)/sizeof(*expectdomain)) {
- ed= expectdomain[labnum-4];
- l= strlen(ed);
- if (lablen != l || memcmp(label, ed, l)) return adns_s_querydomainwrong;
+ if (lablen) {
+ if (adns__revparse_label(&cls->ptr, labnum, label,lablen))
+ return adns_s_querydomainwrong;
} else {
- if (lablen) return adns_s_querydomainwrong;
- ctx->tinfo.ptr.addr.af= AF_INET;
- ctx->tinfo.ptr.addr.addr.v4.s_addr=
- htonl((cls->ptr.ipv[0]<<24) | (cls->ptr.ipv[1]<<16) |
- (cls->ptr.ipv[2]<< 8) | (cls->ptr.ipv[3]));
+ if (adns__revparse_done(&cls->ptr, labnum,
+ &ctx->tinfo.ptr.rev_rrtype,
+ &ctx->tinfo.ptr.addr))
+ return adns_s_querydomainwrong;
}
return adns_s_ok;
}
}
queried= &parent->ctx.tinfo.ptr.addr;
- assert(queried->af == AF_INET);
- assert(cans->type == adns_r_a);
for (i=0, found=cans->rrs.bytes; i<cans->nrrs; i++, found+=cans->rrsz) {
- if (queried->addr.v4.s_addr == ((const struct in_addr *)found)->s_addr) {
+ if (adns__genaddr_equal_p(queried->af,&queried->addr,
+ parent->ctx.tinfo.ptr.addr.af,found)) {
if (!parent->children.head) {
adns__query_done(parent);
return;
int max, void *datap) {
char **rrp= datap;
adns_status st;
+ adns_rrtype rrtype= pai->qu->ctx.tinfo.ptr.rev_rrtype;
int cbyte, id;
adns_query nqu;
qcontext ctx;
st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
pai->dgram, pai->dglen, dmstart,
- adns_r_a, adns_qf_quoteok_query);
+ rrtype, adns_qf_quoteok_query);
if (st) return st;
ctx.ext= 0;
ctx.callback= icb_ptr;
memset(&ctx.pinfo,0,sizeof(ctx.pinfo));
memset(&ctx.tinfo,0,sizeof(ctx.tinfo));
- st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_a),
- adns_r_a, &pai->qu->vb, id, adns_qf_quoteok_query,
- pai->now, &ctx);
+ st= adns__internal_submit(pai->ads, &nqu, adns__findtype(rrtype),
+ rrtype, &pai->qu->vb, id,
+ adns_qf_quoteok_query, pai->now, &ctx);
if (st) return st;
nqu->parent= pai->qu;
DEEP_TYPE(mx_raw, "MX", "raw",intstr, mx_raw, mx_raw,inthost ),
DEEP_TYPE(txt, "TXT", 0, manyistr, txt, 0, txt ),
DEEP_TYPE(rp_raw, "RP", "raw",strpair, rp, 0, rp ),
+FLAT_TYPE(aaaa, "AAAA", 0, in6addr, in6addr, in6addr,in6addr ),
DEEP_TYPE(srv_raw,"SRV", "raw",srvraw , srvraw, srv, srvraw,
.checklabel= ckl_srv, .postsort= postsort_srv),
~ianmdlvl / adns.git / blobdiff