for (ti=0; ti<tc; ti++) {
fprintf(stdout,"%s type %d",domlist[qi],types[ti]);
r= adns_submit(ads,domlist[qi],types[ti],0,0,&qus[qi*tc+ti]);
- if (r == adns_s_notimplemented) {
+ if (r == adns_s_unknownrrtype) {
fprintf(stdout," not implemented\n");
qus[qi*tc+ti]= 0;
} else if (r) {
*/
typedef enum {
- /* fixme: think about error codes */
adns_s_ok,
+
+ /* locally induced errors */
+ adns_s_nomemory,
+ adns_s_unknownrrtype,
+
+ /* remotely induced errors, detected locally */
adns_s_timeout,
- adns_s_nolocalmem,
adns_s_allservfail,
- adns_s_servfail,
- adns_s_notimplemented,
- adns_s_refused,
- adns_s_reasonunknown,
adns_s_norecurse,
- adns_s_serverfaulty,
- adns_s_unknownreply,
- adns_s_invaliddata,
+ adns_s_invalidresponse,
+ adns_s_unknownformat,
+
+ /* remotely induced errors, reported by remote server to us */
+ adns_s_rcodeservfail,
+ adns_s_rcodeformaterror,
+ adns_s_rcodenotimplemented,
+ adns_s_rcoderefused,
+ adns_s_rcodeunknown,
+
adns_s_max_tempfail= 99,
- adns_s_inconsistent, /* PTR gives domain whose A does not match */
- adns_s_cname, /* CNAME found where data eg A expected (not if _qf_loosecname) */
- adns_s_invalidanswerdomain,
+
+ /* remote configuration errors */
+ adns_s_inconsistent, /* PTR gives domain whose A does not exist and match */
+ adns_s_prohibitedcname, /* CNAME found where eg A expected (not if _qf_loosecname) */
+ adns_s_answerdomaininvalid,
+ adns_s_answerdomaintoolong,
+ adns_s_invaliddata,
+
+ adns_s_max_misconfig= 199,
+
/* fixme: implement _s_cname */
- adns_s_max_remotemisconfig= 199,
+
+ /* permanent problems with the query */
+ adns_s_querydomainwrong,
+ adns_s_querydomaininvalid,
+ adns_s_querydomaintoolong,
+
+ adns_s_max_misquery= 299,
+
+ /* permanent errors */
adns_s_nxdomain,
adns_s_nodata,
- adns_s_invalidquerydomain,
- adns_s_domaintoolong,
+
} adns_status;
typedef struct {
*
* Usually this routine will succeed. Possible errors include:
* adns_s_nomemory
- * adns_s_notimplemented (RR type not known)
+ * adns_s_rrtypeunknown
* adns_s_invaliddata (*datap contained garbage)
* If an error occurs then no memory has been allocated,
* and *rrtname_r, *fmtname_r, *len_r and *data_r are undefined.
adns_status st;
st= adns__parse_domain(ads,serv,qu,vb, pdf_quoteok, dgram,dglen,&cbyte,dglen);
- if (st == adns_s_nolocalmem) {
+ if (st == adns_s_nomemory) {
return "<cannot report domain... out of memory>";
}
if (st) {
adns_status st;
typei= adns__findtype(type);
- if (!typei) return adns_s_notimplemented;
+ if (!typei) return adns_s_unknownrrtype;
if (rrtname_r) *rrtname_r= typei->rrtname;
if (fmtname_r) *fmtname_r= typei->fmtname;
adns__vbuf_init(&vb);
st= typei->convstring(&vb,datap);
if (st) goto x_freevb;
- if (!adns__vbuf_append(&vb,"",1)) { st= adns_s_nolocalmem; goto x_freevb; }
+ if (!adns__vbuf_append(&vb,"",1)) { st= adns_s_nomemory; goto x_freevb; }
assert(strlen(vb.buf) == vb.used-1);
*data_r= realloc(vb.buf,vb.used);
if (!*data_r) *data_r= vb.buf;
adns_status st;
const char *string;
} sinfos[]= {
- SINFO( ok, "OK" ),
- SINFO( timeout, "Timed out" ),
- SINFO( nolocalmem, "Out of memory" ),
- SINFO( allservfail, "No working nameservers" ),
- SINFO( servfail, "Nameserver failure" ),
- SINFO( notimplemented, "Query not implemented" ),
- SINFO( refused, "Refused by nameserver" ),
- SINFO( reasonunknown, "Reason unknown" ),
- SINFO( norecurse, "Recursion denied by nameserver" ),
- SINFO( serverfaulty, "Nameserver sent bad data" ),
- SINFO( unknownreply, "Reply from nameserver not understood" ),
- SINFO( invaliddata, "Invalid data" ),
- SINFO( inconsistent, "Inconsistent data" ),
- SINFO( cname, "RR refers to an alias" ),
- SINFO( invalidanswerdomain, "Received syntactically invalid domain" ),
- SINFO( nxdomain, "No such domain" ),
- SINFO( nodata, "No such data" ),
- SINFO( invalidquerydomain, "Query domain invalid" ),
- SINFO( domaintoolong, "Domain name too long" )
+ SINFO( ok, "OK" ),
+
+ SINFO( nomemory, "Out of memory" ),
+ SINFO( unknownrrtype, "Query not implemented in DNS library" ),
+
+ SINFO( timeout, "DNS query timed out" ),
+ SINFO( allservfail, "All nameservers failed" ),
+ SINFO( norecurse, "Recursion denied by nameserver" ),
+ SINFO( invalidresponse, "Nameserver sent bad response" ),
+ SINFO( unknownformat, "Nameserver used unknown format" ),
+
+ SINFO( rcodeservfail, "Nameserver reports failure" ),
+ SINFO( rcodeformaterror, "Query not understood by nameserver" ),
+ SINFO( rcodenotimplemented, "Query not implemented by nameserver" ),
+ SINFO( rcoderefused, "Query refused by nameserver" ),
+ SINFO( rcodeunknown, "Nameserver sent unknown response code" ),
+
+ SINFO( inconsistent, "Inconsistent resource records in DNS" ),
+ SINFO( prohibitedcname, "DNS data refers to an alias" ),
+ SINFO( answerdomaininvalid, "Found syntactically invalid domain name" ),
+ SINFO( answerdomaintoolong, "Found overly-long domain name" ),
+ SINFO( invaliddata, "Found invalid DNS data" ),
+
+ SINFO( querydomainwrong, "Domain invalid for particular DNS query type" ),
+ SINFO( querydomaininvalid, "Domain name is syntactically invalid" ),
+ SINFO( querydomaintoolong, "Domain name is too long" ),
+
+ SINFO( nxdomain, "No such domain" ),
+ SINFO( nodata, "No such data" ),
};
static int si_compar(const void *key, const void *elem) {
dgram= fls->dgram;
for (;;) {
if (fls->cbyte >= fls->dglen) goto x_truncated;
- if (fls->cbyte >= fls->max) goto x_serverfaulty;
+ if (fls->cbyte >= fls->max) goto x_badresponse;
GET_B(fls->cbyte,lablen);
if (!(lablen & 0x0c0)) break;
- if ((lablen & 0x0c0) != 0x0c0) return adns_s_unknownreply;
+ if ((lablen & 0x0c0) != 0x0c0) return adns_s_unknownformat;
if (jumped++) {
adns__diag(fls->ads,fls->serv,fls->qu,"compressed datagram contains loop");
- return adns_s_serverfaulty;
+ return adns_s_invalidresponse;
}
if (fls->cbyte >= fls->dglen) goto x_truncated;
- if (fls->cbyte >= fls->max) goto x_serverfaulty;
+ if (fls->cbyte >= fls->max) goto x_badresponse;
GET_B(fls->cbyte,jumpto);
jumpto |= (lablen&0x3f)<<8;
if (fls->dmend_r) *(fls->dmend_r)= fls->cbyte;
if (lablen) {
if (fls->namelen) fls->namelen++;
fls->namelen+= lablen;
- if (fls->namelen > DNS_MAXDOMAIN) return adns_s_domaintoolong;
+ if (fls->namelen > DNS_MAXDOMAIN) return adns_s_answerdomaintoolong;
fls->cbyte+= lablen;
if (fls->cbyte > fls->dglen) goto x_truncated;
- if (fls->cbyte > fls->max) goto x_serverfaulty;
+ if (fls->cbyte > fls->max) goto x_badresponse;
} else {
if (fls->dmend_r) *(fls->dmend_r)= fls->cbyte;
}
*lablen_r= -1;
return adns_s_ok;
- x_serverfaulty:
+ x_badresponse:
adns__diag(fls->ads,fls->serv,fls->qu,"label in domain runs beyond end of domain");
- return adns_s_serverfaulty;
+ return adns_s_invalidresponse;
}
adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu,
if (lablen<0) { vb->used=0; return adns_s_ok; }
if (!lablen) break;
if (vb->used)
- if (!adns__vbuf_append(vb,".",1)) return adns_s_nolocalmem;
+ if (!adns__vbuf_append(vb,".",1)) return adns_s_nomemory;
if (flags & pdf_quoteok) {
if (!vbuf__append_quoted1035(vb,dgram+labstart,lablen))
- return adns_s_nolocalmem;
+ return adns_s_nomemory;
} else {
ch= dgram[labstart];
- if (!ctype_alpha(ch) && !ctype_digit(ch)) return adns_s_invalidanswerdomain;
+ if (!ctype_alpha(ch) && !ctype_digit(ch)) return adns_s_answerdomaininvalid;
for (i= labstart+1; i<labstart+lablen; i++) {
ch= dgram[i];
if (ch != '-' && !ctype_alpha(ch) && !ctype_digit(ch))
- return adns_s_invalidanswerdomain;
+ return adns_s_answerdomaininvalid;
}
if (!adns__vbuf_append(vb,dgram+labstart,lablen))
- return adns_s_nolocalmem;
+ return adns_s_nomemory;
}
}
- if (!adns__vbuf_append(vb,"",1)) return adns_s_nolocalmem;
+ if (!adns__vbuf_append(vb,"",1)) return adns_s_nomemory;
return adns_s_ok;
}
if (qumsg_vb->used) {
qu->query_dgram= malloc(qumsg_vb->used);
if (!qu->query_dgram) {
- adns__query_fail(qu,adns_s_nolocalmem);
+ adns__query_fail(qu,adns_s_nomemory);
return adns_s_ok;
}
memcpy(qu->query_dgram,qumsg_vb->buf,qumsg_vb->used);
free(qu);
x_nomemory:
adns__vbuf_free(qumsg_vb);
- return adns_s_nolocalmem;
+ return adns_s_nomemory;
}
int adns_submit(adns_state ads,
struct timeval now;
typei= adns__findtype(type);
- if (!typei) return adns_s_notimplemented;
+ if (!typei) return adns_s_unknownrrtype;
ctx.ext= context;
ctx.callback= 0;
adns__vbuf_init(&vb);
ol= strlen(owner);
- if (ol<=1 || ol>DNS_MAXDOMAIN+1) { stat= adns_s_domaintoolong; goto xit; }
+ if (ol<=1 || ol>DNS_MAXDOMAIN+1) { stat= adns_s_querydomaintoolong; goto xit; }
if (owner[ol-1]=='.' && owner[ol-2]!='\\') { flags &= ~adns_qf_search; ol--; }
return;
x_nomem:
- qu->answer->status= adns_s_nolocalmem;
+ qu->answer->status= adns_s_nomemory;
qu->answer->cname= 0;
adns__reset_cnameonly(qu);
free_query_allocs(qu);
if (ans->nrrs && qu->typei->diff_needswap) {
if (!adns__vbuf_ensure(&qu->vb,qu->typei->rrsz)) {
- adns__query_fail(qu,adns_s_nolocalmem);
+ adns__query_fail(qu,adns_s_nomemory);
return;
}
adns__isort(ans->rrs.bytes, ans->nrrs, ans->rrsz,
break;
case rcode_formaterror:
adns__warn(ads,serv,qu,"server cannot understand our query (Format Error)");
- adns__query_fail(qu,adns_s_serverfaulty);
+ adns__query_fail(qu,adns_s_rcodeformaterror);
return;
case rcode_servfail:
- adns__query_fail(qu,adns_s_servfail);
+ adns__query_fail(qu,adns_s_rcodeservfail);
return;
case rcode_notimp:
adns__warn(ads,serv,qu,"server claims not to implement our query");
- adns__query_fail(qu,adns_s_notimplemented);
+ adns__query_fail(qu,adns_s_rcodenotimplemented);
return;
case rcode_refused:
adns__warn(ads,serv,qu,"server refused our query");
- adns__query_fail(qu,adns_s_refused);
+ adns__query_fail(qu,adns_s_rcoderefused);
return;
default:
adns__warn(ads,serv,qu,"server gave unknown response code %d",rcode);
- adns__query_fail(qu,adns_s_reasonunknown);
+ adns__query_fail(qu,adns_s_rcodeunknown);
return;
}
if (st) { adns__query_fail(qu,st); return; }
l= strlen(qu->vb.buf)+1;
qu->answer->cname= adns__alloc_interim(qu,l);
- if (!qu->answer->cname) { adns__query_fail(qu,adns_s_nolocalmem); return; }
+ if (!qu->answer->cname) { adns__query_fail(qu,adns_s_nomemory); return; }
qu->cname_dgram= adns__alloc_mine(qu,dglen);
memcpy(qu->cname_dgram,dgram,dglen);
adns__query_fail(qu,adns_s_norecurse);
} else {
adns__diag(ads,serv,qu,"server claims to do recursion, but gave us a referral");
- adns__query_fail(qu,adns_s_serverfaulty);
+ adns__query_fail(qu,adns_s_invalidresponse);
}
return;
}
/* Now, we have some RRs which we wanted. */
qu->answer->rrs.untyped= adns__alloc_interim(qu,qu->typei->rrsz*wantedrrs);
- if (!qu->answer->rrs.untyped) { adns__query_fail(qu,adns_s_nolocalmem); return; }
+ if (!qu->answer->rrs.untyped) { adns__query_fail(qu,adns_s_nomemory); return; }
typei= qu->typei;
cbyte= anstart;
if (!flg_tc) {
adns__diag(ads,serv,qu,"server sent datagram which points outside itself");
- adns__query_fail(qu,adns_s_serverfaulty);
+ adns__query_fail(qu,adns_s_invalidresponse);
return;
}
qu->flags |= adns_qf_usevc;
if (st) { adns__query_fail(qu,st); return; }
newquery= realloc(qu->query_dgram,qu->vb.used);
- if (!newquery) { adns__query_fail(qu,adns_s_nolocalmem); return; }
+ if (!newquery) { adns__query_fail(qu,adns_s_nomemory); return; }
qu->query_dgram= newquery;
qu->query_dglen= qu->vb.used;
int id;
byte *rqp;
- if (!adns__vbuf_ensure(vb,DNS_HDRSIZE+qdlen+4)) return adns_s_nolocalmem;
+ if (!adns__vbuf_ensure(vb,DNS_HDRSIZE+qdlen+4)) return adns_s_nomemory;
*id_r= id= (ads->nextid++) & 0x0ffff;
p= owner; pe= owner+ol;
nlabs= 0;
- if (!*p) return adns_s_invalidquerydomain;
+ if (!*p) return adns_s_querydomaininvalid;
do {
ll= 0;
while (p!=pe && (c= *p++)!='.') {
if (c=='\\') {
- if (!(flags & adns_qf_quoteok_query)) return adns_s_invalidquerydomain;
+ if (!(flags & adns_qf_quoteok_query)) return adns_s_querydomaininvalid;
if (ctype_digit(p[0])) {
if (ctype_digit(p[1]) && ctype_digit(p[2])) {
c= (*p++ - '0')*100 + (*p++ - '0')*10 + (*p++ - '0');
- if (c >= 256) return adns_s_invalidquerydomain;
+ if (c >= 256) return adns_s_querydomaininvalid;
} else {
- return adns_s_invalidquerydomain;
+ return adns_s_querydomaininvalid;
}
} else if (!(c= *p++)) {
- return adns_s_invalidquerydomain;
+ return adns_s_querydomaininvalid;
}
}
if (!(flags & adns_qf_quoteok_query)) {
if (c == '-') {
- if (!ll) return adns_s_invalidquerydomain;
+ if (!ll) return adns_s_querydomaininvalid;
} else if (!ctype_alpha(c) && !ctype_digit(c)) {
- return adns_s_invalidquerydomain;
+ return adns_s_querydomaininvalid;
}
}
- if (ll == sizeof(label)) return adns_s_invalidquerydomain;
+ if (ll == sizeof(label)) return adns_s_querydomaininvalid;
label[ll++]= c;
}
- if (!ll) return adns_s_invalidquerydomain;
- if (nlabs++ > 63) return adns_s_domaintoolong;
+ if (!ll) return adns_s_querydomaininvalid;
+ if (nlabs++ > 63) return adns_s_querydomaintoolong;
MKQUERY_ADDB(ll);
memcpy(rqp,label,ll); rqp+= ll;
} while (p!=pe);
#include "internal.h"
-#define R_NOMEM return adns_s_nolocalmem
+#define R_NOMEM return adns_s_nomemory
#define CSP_ADDSTR(s) if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;
/*
pai->qu->query_dglen, DNS_HDRSIZE, 0);
for (i=0; i<4; i++) {
st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
- if (lablen<=0 || lablen>3) return adns_s_invalidquerydomain;
+ if (lablen<=0 || lablen>3) return adns_s_querydomainwrong;
memcpy(labbuf, pai->qu->query_dgram + labstart, lablen); labbuf[lablen]= 0;
- ipv[3-i]= strtoul(labbuf,&ep,10); if (*ep) return adns_s_invalidquerydomain;
+ ipv[3-i]= strtoul(labbuf,&ep,10); if (*ep) return adns_s_querydomainwrong;
if (lablen>1 && pai->qu->query_dgram[labstart]=='0')
- return adns_s_invalidquerydomain;
+ return adns_s_querydomainwrong;
}
for (i=0; i<sizeof(expectdomain)/sizeof(*expectdomain); i++) {
st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
l= strlen(expectdomain[i]);
if (lablen != l || memcmp(pai->qu->query_dgram + labstart, expectdomain[i], l))
- return adns_s_invalidquerydomain;
+ return adns_s_querydomainwrong;
}
st= adns__findlabel_next(&fls,&lablen,0); assert(!st);
- if (lablen) return adns_s_invalidquerydomain;
+ if (lablen) return adns_s_querydomainwrong;
ap->len= sizeof(struct sockaddr_in);
memset(&ap->addr,0,sizeof(ap->addr.inet));
~ianmdlvl / adns.git / commitdiff