From 1dfe95d8d1f8f2abaef02f9b0817c720bd955f7b Mon Sep 17 00:00:00 2001 From: ian Date: Sat, 14 Nov 1998 18:58:13 +0000 Subject: [PATCH] Can get addresses from Additional and Authority sections, and return and print them. MX and NS lookups fully done. BUT no re-query for missing addrs. --- client/adnstest.c | 4 +- src/adns.h | 4 +- src/internal.h | 16 ++- src/parse.c | 38 ++--- src/query.c | 8 +- src/reply.c | 18 ++- src/types.c | 352 ++++++++++++++++++++++++++++------------------ 7 files changed, 263 insertions(+), 177 deletions(-) diff --git a/client/adnstest.c b/client/adnstest.c index 95955cb..b4c125a 100644 --- a/client/adnstest.c +++ b/client/adnstest.c @@ -40,9 +40,11 @@ static const adns_rrtype defaulttypes[]= { adns_r_cname, adns_r_ptr_raw, adns_r_mx_raw, - adns_r_rp_raw, adns_r_txt, + adns_r_rp_raw, adns_r_addr, + adns_r_ns, + adns_r_mx, adns_r_none }; diff --git a/src/adns.h b/src/adns.h index 8ad963b..8067a79 100644 --- a/src/adns.h +++ b/src/adns.h @@ -136,7 +136,7 @@ typedef struct { } adns_addr; typedef struct { - char *dm; + char *host; adns_status astatus; int naddrs; /* temp fail => -1, perm fail => 0, s_ok => >0 */ adns_addr *addrs; @@ -148,7 +148,7 @@ typedef struct { typedef struct { int i; - adns_rr_hostaddr hostaddr; + adns_rr_hostaddr ha; } adns_rr_inthostaddr; typedef struct { diff --git a/src/internal.h b/src/internal.h index 7b12237..985da50 100644 --- a/src/internal.h +++ b/src/internal.h @@ -81,9 +81,11 @@ typedef union { } qcontext; typedef struct { + adns_state ads; adns_query qu; + int serv; const byte *dgram; - int serv, dglen, max, nsstart; + int dglen, nsstart, nscount, arcount; } parseinfo; typedef struct { @@ -103,7 +105,7 @@ typedef struct { * and will not be null-terminated by convstring. */ - adns_status (*parse)(const struct parseinfo *pai, int cbyte, void *store_r); + adns_status (*parse)(const parseinfo *pai, int cbyte, int max, void *store_r); /* Parse one RR, in dgram of length dglen, starting at cbyte and * extending until at most max. * @@ -478,11 +480,11 @@ adns_status adns__findrr(adns_query qu, int serv, * If an error is returned then *type_r will be undefined too. */ -static adns_status findrr_anychk(adns_query qu, int serv, - const byte *dgram, int dglen, int *cbyte_io, - int *type_r, int *class_r, int *rdlen_r, int *rdstart_r, - const byte *eo_dgram, int eo_dglen, int eo_cbyte, - int *eo_matched_r); +adns_status adns__findrr_anychk(adns_query qu, int serv, + const byte *dgram, int dglen, int *cbyte_io, + int *type_r, int *class_r, int *rdlen_r, int *rdstart_r, + const byte *eo_dgram, int eo_dglen, int eo_cbyte, + int *eo_matched_r); /* Like adns__findrr_checked, except that the datagram and * owner to compare with can be specified explicitly. * diff --git a/src/parse.c b/src/parse.c index bb08883..f2521d6 100644 --- a/src/parse.c +++ b/src/parse.c @@ -146,11 +146,11 @@ adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu, return adns_s_ok; } -static adns_status findrr_anychk(adns_query qu, int serv, - const byte *dgram, int dglen, int *cbyte_io, - int *type_r, int *class_r, int *rdlen_r, int *rdstart_r, - const byte *eo_dgram, int eo_dglen, int eo_cbyte, - int *eo_matched_r) { +adns_status adns__findrr_anychk(adns_query qu, int serv, + const byte *dgram, int dglen, int *cbyte_io, + int *type_r, int *class_r, int *rdlen_r, int *rdstart_r, + const byte *eo_dgram, int eo_dglen, int eo_cbyte, + int *eo_matched_r) { findlabel_state fls, eo_fls; int cbyte; @@ -209,21 +209,21 @@ adns_status adns__findrr(adns_query qu, int serv, int *type_r, int *class_r, int *rdlen_r, int *rdstart_r, int *ownermatchedquery_r) { if (!ownermatchedquery_r) { - return findrr_anychk(qu,serv, - dgram,dglen,cbyte_io, - type_r,class_r,rdlen_r,rdstart_r, - 0,0,0, 0); + return adns__findrr_anychk(qu,serv, + dgram,dglen,cbyte_io, + type_r,class_r,rdlen_r,rdstart_r, + 0,0,0, 0); } else if (!qu->cname_dgram) { - return findrr_anychk(qu,serv, - dgram,dglen,cbyte_io, - type_r,class_r,rdlen_r,rdstart_r, - qu->query_dgram,qu->query_dglen,DNS_HDRSIZE, - ownermatchedquery_r); + return adns__findrr_anychk(qu,serv, + dgram,dglen,cbyte_io, + type_r,class_r,rdlen_r,rdstart_r, + qu->query_dgram,qu->query_dglen,DNS_HDRSIZE, + ownermatchedquery_r); } else { - return findrr_anychk(qu,serv, - dgram,dglen,cbyte_io, - type_r,class_r,rdlen_r,rdstart_r, - qu->cname_dgram,qu->cname_dglen,qu->cname_begin, - ownermatchedquery_r); + return adns__findrr_anychk(qu,serv, + dgram,dglen,cbyte_io, + type_r,class_r,rdlen_r,rdstart_r, + qu->cname_dgram,qu->cname_dglen,qu->cname_begin, + ownermatchedquery_r); } } diff --git a/src/query.c b/src/query.c index 9c7fffe..a794e54 100644 --- a/src/query.c +++ b/src/query.c @@ -211,16 +211,16 @@ static void free_query_allocs(adns_query qu) { adns__vbuf_free(&qu->vb); } -void adns_cancel(adns_query query) { +void adns_cancel(adns_query qu) { switch (qu->state) { case query_udp: case query_tcpwait: case query_tcpsent: - LIST_UNLINK(ads->timew,qu); + LIST_UNLINK(qu->ads->timew,qu); break; case query_child: - LIST_UNLINK(ads->childw,qu); + LIST_UNLINK(qu->ads->childw,qu); break; case query_done: - LIST_UNLINK(ads->output,qu); + LIST_UNLINK(qu->ads->output,qu); break; default: abort(); diff --git a/src/reply.c b/src/reply.c index c0772b9..ceeacee 100644 --- a/src/reply.c +++ b/src/reply.c @@ -39,6 +39,7 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen, adns_status st; vbuf tempvb; byte *newquery, *rrsdata; + parseinfo pai; if (dglentypei; cbyte= anstart; rrsdata= qu->answer->rrs.bytes; - - nrrs= 0; - for (rri=0; rriads; + pai.qu= qu; + pai.serv= serv; + pai.dgram= dgram; + pai.dglen= dglen; + pai.nsstart= nsstart; + pai.nscount= nscount; + pai.arcount= arcount; + + for (rri=0, nrrs=0; rritypei->type & adns__rrt_typemask) || !ownermatched) continue; - st= typei->parse(qu,serv, dgram,dglen, rdstart,rdstart+rdlength, - nsstart,&arstart, rrsdata+nrrs*typei->rrsz); + st= typei->parse(&pai, rdstart,rdstart+rdlength, rrsdata+nrrs*typei->rrsz); if (st) { adns__query_fail(qu,st); return; } if (rdstart==-1) goto x_truncated; nrrs++; diff --git a/src/types.c b/src/types.c index 8993451..9450efa 100644 --- a/src/types.c +++ b/src/types.c @@ -27,18 +27,19 @@ #include "internal.h" +#define R_NOMEM return adns_s_nolocalmem +#define CSP_ADDSTR(s) if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else; + static int dip_inaddr(struct in_addr a, struct in_addr b) { /* fixme implement sortlist */ return 0; } -static adns_status pa_inaddr(adns_query qu, int serv, - const byte *dgram, int dglen, int cbyte, int max, - int nsstart, int *arstart_io, void *datap) { +static adns_status pa_inaddr(const parseinfo *pai, int cbyte, int max, void *datap) { struct in_addr *storeto= datap; if (max-cbyte != 4) return adns_s_invaliddata; - memcpy(storeto,dgram+cbyte,4); + memcpy(storeto, pai->dgram + cbyte, 4); return adns_s_ok; } @@ -53,13 +54,13 @@ static adns_status cs_inaddr(vbuf *vb, const void *datap) { const char *ia; ia= inet_ntoa(rr); assert(ia); - return adns__vbuf_appendstr(vb,ia) ? adns_s_ok : adns_s_nolocalmem; + CSP_ADDSTR(ia); + return adns_s_ok; } -static adns_status pa_addr(adns_query qu, int serv, - const byte *dgram, int dglen, int cbyte, int max, - void *datap) { +static adns_status pa_addr(const parseinfo *pai, int cbyte, int max, void *datap) { adns_addr *storeto= datap; + const byte *dgram= pai->dgram; if (max-cbyte != 4) return adns_s_invaliddata; storeto->len= sizeof(storeto->addr.inet); @@ -73,66 +74,68 @@ static adns_status pa_addr(adns_query qu, int serv, static int di_addr(const void *datap_a, const void *datap_b) { const adns_addr *ap= datap_a, *bp= datap_b; + assert(ap->addr.sa.sa_family == AF_INET); return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr); } -static adns_status cs_addr(vbuf *vb, const void *datap) { - const adns_addr *rrp= datap; +static adns_status csp_addr(vbuf *vb, const adns_addr *rrp) { const char *ia; static char buf[30]; switch (rrp->addr.inet.sin_family) { case AF_INET: - if (!adns__vbuf_appendstr(vb,"AF_INET ")) return adns_s_nolocalmem; + CSP_ADDSTR("AF_INET "); ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia); - if (!adns__vbuf_appendstr(vb,ia)) return adns_s_nolocalmem; + CSP_ADDSTR(ia); break; default: sprintf(buf,"AF=%u",rrp->addr.sa.sa_family); - if (!adns__vbuf_appendstr(vb,buf)) return adns_s_nolocalmem; + CSP_ADDSTR(buf); break; } return adns_s_ok; } -static adns_status pap_domain(adns_query qu, int serv, parsedomain_flags flags, - const byte *dgram, int dglen, int *cbyte_io, int max, - char **domain_r) { +static adns_status cs_addr(vbuf *vb, const void *datap) { + const adns_addr *rrp= datap; + + return csp_addr(vb,rrp); +} + +static adns_status pap_domain(const parseinfo *pai, int *cbyte_io, int max, + char **domain_r, parsedomain_flags flags) { adns_status st; char *dm; - st= adns__parse_domain(qu->ads,serv,qu,&qu->vb,flags, dgram,dglen, cbyte_io,max); + st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags, + pai->dgram,pai->dglen, cbyte_io, max); if (st) return st; - if (!qu->vb.used) return adns_s_invaliddata; + if (!pai->qu->vb.used) return adns_s_invaliddata; - dm= adns__alloc_interim(qu,qu->vb.used+1); - if (!dm) return adns_s_nolocalmem; + dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1); + if (!dm) R_NOMEM; - dm[qu->vb.used]= 0; - memcpy(dm,qu->vb.buf,qu->vb.used); + dm[pai->qu->vb.used]= 0; + memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used); *domain_r= dm; return adns_s_ok; } -static adns_status pa_host_raw(adns_query qu, int serv, - const byte *dgram, int dglen, int cbyte, int max, - int nsstart, int *arstart_io, void *datap) { +static adns_status pa_host_raw(const parseinfo *pai, int cbyte, int max, void *datap) { char **rrp= datap; adns_status st; - st= pap_domain(qu,serv, - qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, - dgram,dglen,&cbyte,max,rrp); + st= pap_domain(pai, &cbyte, max, rrp, + pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0); if (st) return st; if (cbyte != max) return adns_s_invaliddata; return adns_s_ok; } -static adns_status pa_mx_raw(adns_query qu, int serv, - const byte *dgram, int dglen, int cbyte, int max, - int nsstart, int *arstart_io, void *datap) { +static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *datap) { + const byte *dgram= pai->dgram; adns_rr_intstr *rrp= datap; adns_status st; int pref; @@ -140,9 +143,8 @@ static adns_status pa_mx_raw(adns_query qu, int serv, if (cbyte+2 > max) return adns_s_invaliddata; GET_W(cbyte,pref); rrp->i= pref; - st= pap_domain(qu,serv, - qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, - dgram,dglen,&cbyte,max,&rrp->str); + st= pap_domain(pai, &cbyte, max, &rrp->str, + pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0); if (st) return st; if (cbyte != max) return adns_s_invaliddata; @@ -150,52 +152,48 @@ static adns_status pa_mx_raw(adns_query qu, int serv, } -static adns_status pap_findaddrs(adns_query qu, int serv, adns_rr_hostaddr *ha, - const byte *dgram, int dglen, int *cbyte_io, - int dmstart, int count) { - int rri, nrrs; +static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha, + int *cbyte_io, int count, int dmstart) { + int rri, naddrs; int type, class, rdlen, rdstart, ownermatched; + adns_status st; - for (rri=0, nrrs=-1; rriqu, pai->serv, pai->dgram, pai->dglen, cbyte_io, + &type, &class, &rdlen, &rdstart, + pai->dgram, pai->dglen, dmstart, &ownermatched); if (st) return st; - if (class != DNS_CLASS_IN) continue; - if (type != adns_r_a) continue; - if (nrrs == -1) { - qu->vb.used= 0; - nrrs= 0; + if (!ownermatched || class != DNS_CLASS_IN || type != adns_r_a) { + if (naddrs>0) break; else continue; + } + if (naddrs == -1) { + naddrs= 0; } - if (!adns__vbuf_ensure(&qu->vb,qu->vb.used+sizeof(adns_addr))) - return adns_s_nolocalmem; - st= pa_addr(qu,serv, dgram,dglen, rdstart,rdstart+rdlen, - qu->vb.buf + qu->vb.used); + if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_addr))) R_NOMEM; + st= pa_addr(pai, rdstart,rdstart+rdlen, pai->qu->vb.buf + naddrs*sizeof(adns_addr)); if (st) return st; - qu->vb.used += sizeof(adns_addr); - nrrs++; + naddrs++; } - if (nrrs >= 0) { - ha->rrs= adns__alloc_interim(qu,qu->vb.used); - if (!ha->rrs) return adns_s_nolocalmem; - ha->nrrs= nrrs; + if (naddrs >= 0) { + ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_addr)); + if (!ha->addrs) R_NOMEM; + memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_addr)); + ha->naddrs= naddrs; ha->astatus= adns_s_ok; + + adns__isort(ha->addrs, naddrs, sizeof(adns_addr), pai->qu->vb.buf, di_addr); } return adns_s_ok; } -static adns_status pap_hostaddr(adns_query qu, int serv, - const byte *dgram, int dglen, int *cbyte_io, int max, - int nsstart, int nscount, int arcount, void *datap) { - adns_rr_hostaddr **rrp= datap; +static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io, + int max, adns_rr_hostaddr *rrp) { adns_status st; int dmstart, cbyte; dmstart= cbyte= *cbyte_io; - st= pap_domain(qu,serv, - qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, - dgram,dglen,&cbyte,max,&rrp->dm); + st= pap_domain(pai, &cbyte, max, &rrp->host, + pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0); if (st) return st; *cbyte_io= cbyte; @@ -203,46 +201,62 @@ static adns_status pap_hostaddr(adns_query qu, int serv, rrp->naddrs= -1; rrp->addrs= 0; - cbyte= nsstart; + cbyte= pai->nsstart; - st= pap_findaddrs(qu, rrp, dgram,dglen,&cbyte, dmstart); + st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart); if (st) return st; if (rrp->naddrs != -1) return adns_s_ok; - st= pap_findaddrs(qu, rrp, dgram,dglen,&cbyte, dmstart); + st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart); if (st) return st; if (rrp->naddrs != -1) return adns_s_ok; + + rrp->naddrs= 0; /* fixme additional section didn't have required data */ + rrp->astatus= adns_s_notimplemented; + + return adns_s_ok; } -static adns_status pa_hostaddr(adns_query qu, int serv, - const byte *dgram, int dglen, int cbyte, int max, - int nsstart, void *datap) { - adns_rr_hostaddr **rrp= datap; +static adns_status pa_hostaddr(const parseinfo *pai, int cbyte, int max, void *datap) { + adns_rr_hostaddr *rrp= datap; adns_status st; - int dmstart; - dmstart= cbyte; - st= pap_domain(qu,serv, - qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, - dgram,dglen,&cbyte,max,&rrp->dm); + st= pap_hostaddr(pai, &cbyte, max, rrp); if (st) return st; if (cbyte != max) return adns_s_invaliddata; - rrp->astatus= adns_s_ok; - rrp->naddrs= -1; - rrp->addrs= 0; + return adns_s_ok; +} - cbyte= nsstart; +static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap) { + const byte *dgram= pai->dgram; + adns_rr_inthostaddr *rrp= datap; + adns_status st; + int pref; - st= pap_findaddrs(qu, rrp, dgram,dglen, dmstart,&cbyte); + if (cbyte+2 > max) return adns_s_invaliddata; + GET_W(cbyte,pref); + rrp->i= pref; + st= pap_hostaddr(pai, &cbyte, max, &rrp->ha); if (st) return st; - if (rrp->naddrs != -1) return adns_s_ok; + + if (cbyte != max) return adns_s_invaliddata; + return adns_s_ok; +} - st= pap_findaddrs(qu, rrp, dgram,dglen, dmstart,&cbyte); - if (st) return st; - if (rrp->naddrs != -1) return adns_s_ok; +static int dip_hostaddr(const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) { + if (ap->astatus != bp->astatus) return ap->astatus; + if (ap->astatus) return 0; - assert(!"additional section didn't have required data"); + assert(ap->addrs[0].addr.sa.sa_family == AF_INET); + assert(bp->addrs[0].addr.sa.sa_family == AF_INET); + return dip_inaddr(ap->addrs[0].addr.inet.sin_addr, bp->addrs[0].addr.inet.sin_addr); +} + +static int di_hostaddr(const void *datap_a, const void *datap_b) { + const adns_rr_hostaddr *ap= datap_a, *bp= datap_b; + + return dip_hostaddr(ap,bp); } static int di_mx_raw(const void *datap_a, const void *datap_b) { @@ -253,13 +267,20 @@ static int di_mx_raw(const void *datap_a, const void *datap_b) { return 0; } -static adns_status pa_txt(adns_query qu, int serv, - const byte *dgram, int dglen, int startbyte, int max, - int nsstart, int *arstart_io, void *datap) { +static int di_mx(const void *datap_a, const void *datap_b) { + const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b; + + if (ap->i < bp->i) return 0; + if (ap->i > bp->i) return 1; + return dip_hostaddr(&ap->ha,&bp->ha); +} + +static adns_status pa_txt(const parseinfo *pai, int cbyte, int max, void *datap) { adns_rr_intstr **rrp= datap, *table, *te; - int ti, tc, cbyte, l; + const byte *dgram= pai->dgram; + int ti, tc, l, startbyte; - cbyte= startbyte; + startbyte= cbyte; if (cbyte >= max) return adns_s_invaliddata; tc= 0; while (cbyte < max) { @@ -268,13 +289,13 @@ static adns_status pa_txt(adns_query qu, int serv, } if (cbyte != max) return adns_s_invaliddata; - table= adns__alloc_interim(qu,sizeof(*table)*(tc+1)); - if (!table) return adns_s_nolocalmem; + table= adns__alloc_interim(pai->qu,sizeof(*table)*(tc+1)); + if (!table) R_NOMEM; for (cbyte=startbyte, ti=0, te=table; tistr= adns__alloc_interim(qu,l+1); - if (!te->str) return adns_s_nolocalmem; + te->str= adns__alloc_interim(pai->qu, l+1); + if (!te->str) R_NOMEM; te->str[l]= 0; memcpy(te->str,dgram+cbyte,l); te->i= l; @@ -288,35 +309,34 @@ static adns_status pa_txt(adns_query qu, int serv, return adns_s_ok; } -static int csp_textdata(vbuf *vb, const char *dp, int len) { +static adns_status csp_textdata(vbuf *vb, const char *dp, int len) { unsigned char ch; char buf[10]; int cn; - if (!adns__vbuf_append(vb,"\"",1)) return 0; - + CSP_ADDSTR("\""); for (cn=0; cn= 32 && ch <= 126 && ch != '"' && ch != '\\') { - if (!adns__vbuf_append(vb,&ch,1)) return 0; + if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM; } else { sprintf(buf,"\\%02x",ch); - if (!adns__vbuf_appendstr(vb,buf)) return 0; + CSP_ADDSTR(buf); } } + CSP_ADDSTR("\""); - if (!adns__vbuf_append(vb,"\"",1)) return 0; - return 1; + return adns_s_ok; } -static int csp_qstring(vbuf *vb, const char *dp) { +static adns_status csp_qstring(vbuf *vb, const char *dp) { return csp_textdata(vb, dp, strlen(dp)); } static adns_status cs_str(vbuf *vb, const void *datap) { const char *const *rrp= datap; - return csp_qstring(vb,*rrp) ? adns_s_ok : adns_s_nolocalmem; + return csp_qstring(vb,*rrp); } static adns_status cs_intstr(vbuf *vb, const void *datap) { @@ -324,24 +344,21 @@ static adns_status cs_intstr(vbuf *vb, const void *datap) { char buf[10]; sprintf(buf,"%u ",rrp->i); - return (adns__vbuf_appendstr(vb,buf) && - csp_qstring(vb,rrp->str)) ? adns_s_ok : adns_s_nolocalmem; + CSP_ADDSTR(buf); + return csp_qstring(vb,rrp->str); } static adns_status cs_manyistr(vbuf *vb, const void *datap) { const adns_rr_intstr *const *rrp= datap; const adns_rr_intstr *current; + adns_status st; int spc; for (spc=0, current= *rrp; current->i >= 0; current++) { - if (spc) - if (!adns__vbuf_append(vb," ",1)) goto x_nomem; - if (!csp_textdata(vb,current->str,current->i)) goto x_nomem; + if (spc) CSP_ADDSTR(" "); + st= csp_textdata(vb,current->str,current->i); if (st) return st; } return adns_s_ok; - - x_nomem: - return adns_s_nolocalmem; } static void mf_str(adns_query qu, void *datap) { @@ -356,6 +373,63 @@ static void mf_intstr(adns_query qu, void *datap) { adns__makefinal_str(qu,&rrp->str); } +static adns_status csp_hostaddr(vbuf *vb, const adns_rr_hostaddr *rrp) { + const char *to_add; + adns_status st; + int i; + + st= csp_qstring(vb,rrp->host); if (st) return st; + + if (rrp->astatus) { + CSP_ADDSTR(" - "); + CSP_ADDSTR(adns_strerror(rrp->astatus)); + } else { + assert(rrp->naddrs > 0); + for (i=0, to_add= ": "; inaddrs; i++, to_add= ", ") { + CSP_ADDSTR(to_add); + st= csp_addr(vb,&rrp->addrs[i]); + } + } + return adns_s_ok; +} + +static adns_status cs_hostaddr(vbuf *vb, const void *datap) { + const adns_rr_hostaddr *rrp= datap; + + return csp_hostaddr(vb,rrp); +} + +static adns_status cs_inthostaddr(vbuf *vb, const void *datap) { + const adns_rr_inthostaddr *rrp= datap; + char buf[10]; + + sprintf(buf,"%u ",rrp->i); + CSP_ADDSTR(buf); + + return csp_hostaddr(vb,&rrp->ha); +} + +static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) { + void *tablev; + + adns__makefinal_str(qu,&rrp->host); + tablev= rrp->addrs; + adns__makefinal_block(qu, &tablev, rrp->naddrs*sizeof(*rrp->addrs)); + rrp->addrs= tablev; +} + +static void mf_hostaddr(adns_query qu, void *datap) { + adns_rr_hostaddr *rrp= datap; + + mfp_hostaddr(qu,rrp); +} + +static void mf_inthostaddr(adns_query qu, void *datap) { + adns_rr_inthostaddr *rrp= datap; + + mfp_hostaddr(qu,&rrp->ha); +} + static void mf_manyistr(adns_query qu, void *datap) { adns_rr_intstr **rrp= datap; adns_rr_intstr *te, *table; @@ -390,34 +464,34 @@ static void mf_flat(adns_query qu, void *data) { } static const typeinfo typeinfos[] = { /* Must be in ascending order of rrtype ! */ - /* rr type code rrt fmt mem.mgmt member parser comparer */ - - { adns_r_a, "A", 0, FLAT_MEMB(inaddr), pa_inaddr, di_inaddr }, - { adns_r_ns_raw, "NS", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, - { adns_r_cname, "CNAME", 0, DEEP_MEMB(str), pa_host_raw, 0 }, -#if 0 /*fixme*/ - { adns_r_soa_raw, "SOA", "raw", DEEP_MEMB(soa), pa_soa, 0 }, -#endif - { adns_r_ptr_raw, "PTR", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, -#if 0 /*fixme*/ - { adns_r_hinfo, "HINFO", 0, DEEP_MEMB(strpair), pa_hinfo, 0 }, -#endif - { adns_r_mx_raw, "MX", "raw", DEEP_MEMB(intstr), pa_mx_raw, di_mx_raw }, - { adns_r_txt, "TXT", 0, DEEP_MEMB(manyistr), pa_txt, 0 }, -#if 0 /*fixme*/ - { adns_r_rp_raw, "RP", "raw", DEEP_MEMB(strpair), pa_rp, 0 }, -#endif - - { adns_r_addr, "A", "addr", FLAT_MEMB(addr), pa_addr, di_addr }, - { adns_r_ns, "NS", "+addr", DEEP_MEMB(dmaddr), pa_hostaddr, di_hostaddr }, -#if 0 /*fixme*/ - { adns_r_ptr, "PTR","checked", DEEP_MEMB(str), pa_ptr, 0 }, - { adns_r_mx, "MX", "+addr", DEEP_MEMB(intdmaddr), pa_mx, di_mx }, - + /* rr type code rrt fmt mem.mgmt member parser comparer */ + + { adns_r_a, "A", 0, FLAT_MEMB(inaddr), pa_inaddr, di_inaddr }, + { adns_r_ns_raw, "NS", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, + { adns_r_cname, "CNAME", 0, DEEP_MEMB(str), pa_host_raw, 0 }, +#if 0 /*fixme*/ + { adns_r_soa_raw, "SOA", "raw", DEEP_MEMB(soa), pa_soa, 0 }, +#endif + { adns_r_ptr_raw, "PTR", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, +#if 0 /*fixme*/ + { adns_r_hinfo, "HINFO", 0, DEEP_MEMB(strpair), pa_hinfo, 0 }, +#endif + { adns_r_mx_raw, "MX", "raw", DEEP_MEMB(intstr), pa_mx_raw, di_mx_raw }, + { adns_r_txt, "TXT", 0, DEEP_MEMB(manyistr), pa_txt, 0 }, +#if 0 /*fixme*/ + { adns_r_rp_raw, "RP", "raw", DEEP_MEMB(strpair), pa_rp, 0 }, +#endif + + { adns_r_addr, "A", "addr", FLAT_MEMB(addr), pa_addr, di_addr }, + { adns_r_ns, "NS", "+addr", DEEP_MEMB(hostaddr), pa_hostaddr, di_hostaddr }, +#if 0 /*fixme*/ + { adns_r_ptr, "PTR","checked", DEEP_MEMB(str), pa_ptr, 0 }, #endif + { adns_r_mx, "MX", "+addr", DEEP_MEMB(inthostaddr), pa_mx, di_mx }, + #if 0 /*fixme*/ - { adns_r_soa, "SOA","822", DEEP_MEMB(soa), pa_soa, 0 }, - { adns_r_rp, "RP", "822", DEEP_MEMB(strpair), pa_rp, 0 }, + { adns_r_soa, "SOA","822", DEEP_MEMB(soa), pa_soa, 0 }, + { adns_r_rp, "RP", "822", DEEP_MEMB(strpair), pa_rp, 0 }, #endif }; -- 2.30.2