X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fquery.c;h=3c98040ace1ef57d02910a18259db0f6f5a90dc8;hb=3b3e6ba1d88ceec9d67a739d4fe2f26ba9a6278c;hp=3fab80c02f06f37cb2d897669642e52222d8c1b4;hpb=d8c062faeda8147546f1e709171f7f0767331954;p=adns.git diff --git a/src/query.c b/src/query.c index 3fab80c..3c98040 100644 --- a/src/query.c +++ b/src/query.c @@ -5,7 +5,12 @@ * - query submission and cancellation (user-visible and internal) */ /* - * This file is part of adns, which is Copyright (C) 1997-1999 Ian Jackson + * This file is + * Copyright (C) 1997-2000 Ian Jackson + * + * It is part of adns, which is + * Copyright (C) 1997-2000 Ian Jackson + * Copyright (C) 1999-2000 Tony Finch * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -27,7 +32,6 @@ #include #include #include -#include #include @@ -39,7 +43,8 @@ static adns_query query_alloc(adns_state ads, const typeinfo *typei, adns_query qu; qu= malloc(sizeof(*qu)); if (!qu) return 0; - qu->answer= malloc(sizeof(*qu->answer)); if (!qu->answer) { free(qu); return 0; } + qu->answer= malloc(sizeof(*qu->answer)); + if (!qu->answer) { free(qu); return 0; } qu->ads= ads; qu->state= query_tosend; @@ -62,11 +67,11 @@ static adns_query query_alloc(adns_state ads, const typeinfo *typei, adns__vbuf_init(&qu->search_vb); qu->search_origlen= qu->search_pos= qu->search_doneabs= 0; - qu->id= 0; + qu->id= -2; /* will be overwritten with real id before we leave adns */ qu->flags= flags; - qu->udpretries= 0; + qu->retries= 0; qu->udpnextserver= 0; - qu->udpsent= qu->tcpfailed= 0; + qu->udpsent= 0; timerclear(&qu->timeout); qu->expires= now.tv_sec + MAXTTLBELIEVE; @@ -87,7 +92,7 @@ static void query_submit(adns_state ads, adns_query qu, const typeinfo *typei, vbuf *qumsg_vb, int id, adns_queryflags flags, struct timeval now) { /* Fills in the query message in for a previously-allocated query, - * and submits it. Cannot fail. + * and submits it. Cannot fail. Takes over the memory for qumsg_vb. */ qu->vb= *qumsg_vb; @@ -101,11 +106,11 @@ static void query_submit(adns_state ads, adns_query qu, memcpy(qu->query_dgram,qu->vb.buf,qu->vb.used); adns__query_send(qu,now); - adns__autosys(ads,now); } adns_status adns__internal_submit(adns_state ads, adns_query *query_r, - const typeinfo *typei, vbuf *qumsg_vb, int id, + const typeinfo *typei, vbuf *qumsg_vb, + int id, adns_queryflags flags, struct timeval now, const qcontext *ctx) { adns_query qu; @@ -124,16 +129,24 @@ static void query_simple(adns_state ads, adns_query qu, const char *owner, int ol, const typeinfo *typei, adns_queryflags flags, struct timeval now) { - vbuf vb; + vbuf vb_new; int id; adns_status stat; - adns__vbuf_init(&vb); - - stat= adns__mkquery(ads,&vb,&id, owner,ol, typei,flags); - if (stat) { adns__query_fail(qu,stat); return; } + stat= adns__mkquery(ads,&qu->vb,&id, owner,ol, typei,flags); + if (stat) { + if (stat == adns_s_querydomaintoolong && (flags & adns_qf_search)) { + adns__search_next(ads,qu,now); + return; + } else { + adns__query_fail(qu,stat); + return; + } + } - query_submit(ads,qu, typei,&vb,id, flags,now); + vb_new= qu->vb; + adns__vbuf_init(&qu->vb); + query_submit(ads,qu, typei,&vb_new,id, flags,now); } void adns__search_next(adns_state ads, adns_query qu, struct timeval now) { @@ -146,8 +159,8 @@ void adns__search_next(adns_state ads, adns_query qu, struct timeval now) { } else { if (qu->search_pos >= ads->nsearchlist) { if (qu->search_doneabs) { + qu->search_vb.used= qu->search_origlen; stat= adns_s_nxdomain; goto x_fail; - return; } else { nextentry= 0; qu->search_doneabs= 1; @@ -160,17 +173,19 @@ void adns__search_next(adns_state ads, adns_query qu, struct timeval now) { qu->search_vb.used= qu->search_origlen; if (nextentry) { if (!adns__vbuf_append(&qu->search_vb,".",1) || - !adns__vbuf_appendstr(&qu->search_vb,nextentry)) { - stat= adns_s_nomemory; goto x_fail; - } + !adns__vbuf_appendstr(&qu->search_vb,nextentry)) + goto x_nomemory; } free(qu->query_dgram); qu->query_dgram= 0; qu->query_dglen= 0; - query_simple(ads,qu, qu->search_vb.buf, qu->search_vb.used, qu->typei, qu->flags, now); + query_simple(ads,qu, qu->search_vb.buf, qu->search_vb.used, + qu->typei, qu->flags, now); return; - + +x_nomemory: + stat= adns_s_nomemory; x_fail: adns__query_fail(qu,stat); } @@ -179,6 +194,8 @@ static int save_owner(adns_query qu, const char *owner, int ol) { /* Returns 1 if OK, otherwise there was no memory. */ adns_answer *ans; + if (!(qu->flags & adns_qf_owner)) return 1; + ans= qu->answer; assert(!ans->owner); @@ -202,8 +219,10 @@ int adns_submit(adns_state ads, adns_query qu; const char *p; + adns__consistency(ads,0,cc_entex); + typei= adns__findtype(type); - if (!typei) return adns_s_unknownrrtype; + if (!typei) return ENOSYS; r= gettimeofday(&now,0); if (r) goto x_errno; qu= query_alloc(ads,typei,flags,now); if (!qu) goto x_errno; @@ -220,6 +239,7 @@ int adns_submit(adns_state ads, if (ol>=1 && owner[ol-1]=='.' && (ol<2 || owner[ol-2]!='\\')) { flags &= ~adns_qf_search; + qu->flags= flags; ol--; } @@ -237,18 +257,67 @@ int adns_submit(adns_state ads, } query_simple(ads,qu, owner,ol, typei,flags, now); } + adns__autosys(ads,now); + adns__consistency(ads,qu,cc_entex); return 0; x_adnsfail: adns__query_fail(qu,stat); + adns__consistency(ads,qu,cc_entex); return 0; x_errno: r= errno; assert(r); + adns__consistency(ads,0,cc_entex); return r; } +int adns_submit_reverse_any(adns_state ads, + const struct sockaddr *addr, + const char *zone, + adns_rrtype type, + adns_queryflags flags, + void *context, + adns_query *query_r) { + const unsigned char *iaddr; + char *buf, *buf_free; + char shortbuf[100]; + int r, lreq; + + flags &= ~adns_qf_search; + + if (addr->sa_family != AF_INET) return ENOSYS; + iaddr= (const unsigned char*) + &(((const struct sockaddr_in*)addr) -> sin_addr); + + lreq= strlen(zone) + 4*4 + 1; + if (lreq > sizeof(shortbuf)) { + buf= malloc(strlen(zone) + 4*4 + 1); + if (!buf) return errno; + buf_free= buf; + } else { + buf= shortbuf; + buf_free= 0; + } + sprintf(buf, "%d.%d.%d.%d.%s", iaddr[3], iaddr[2], iaddr[1], iaddr[0], zone); + + r= adns_submit(ads,buf,type,flags,context,query_r); + free(buf_free); + return r; +} + +int adns_submit_reverse(adns_state ads, + const struct sockaddr *addr, + adns_rrtype type, + adns_queryflags flags, + void *context, + adns_query *query_r) { + if (type != adns_r_ptr && type != adns_r_ptr_raw) return EINVAL; + return adns_submit_reverse_any(ads,addr,"in-addr.arpa", + type,flags,context,query_r); +} + int adns_synchronous(adns_state ads, const char *owner, adns_rrtype type, @@ -301,7 +370,8 @@ void *adns__alloc_mine(adns_query qu, size_t sz) { return alloc_common(qu,MEM_ROUND(sz)); } -void adns__transfer_interim(adns_query from, adns_query to, void *block, size_t sz) { +void adns__transfer_interim(adns_query from, adns_query to, + void *block, size_t sz) { allocnode *an; if (!block) return; @@ -313,6 +383,7 @@ void adns__transfer_interim(adns_query from, adns_query to, void *block, size_t LIST_UNLINK(from->allocations,an); LIST_LINK_TAIL(to->allocations,an); + sz= MEM_ROUND(sz); from->interim_allocd -= sz; to->interim_allocd += sz; @@ -342,7 +413,6 @@ static void cancel_children(adns_query qu) { ncqu= cqu->siblings.next; adns_cancel(cqu); } - LIST_INIT(qu->children); } void adns__reset_preserved(adns_query qu) { @@ -358,19 +428,31 @@ static void free_query_allocs(adns_query qu) { cancel_children(qu); for (an= qu->allocations.head; an; an= ann) { ann= an->next; free(an); } + LIST_INIT(qu->allocations); adns__vbuf_free(&qu->vb); + adns__vbuf_free(&qu->search_vb); + free(qu->query_dgram); + qu->query_dgram= 0; } void adns_cancel(adns_query qu) { + adns_state ads; + + ads= qu->ads; + adns__consistency(ads,qu,cc_entex); + if (qu->parent) LIST_UNLINK_PART(qu->parent->children,qu,siblings.); switch (qu->state) { - case query_tosend: case query_tcpwait: case query_tcpsent: - LIST_UNLINK(qu->ads->timew,qu); + case query_tosend: + LIST_UNLINK(ads->udpw,qu); + break; + case query_tcpw: + LIST_UNLINK(ads->tcpw,qu); break; - case query_child: - LIST_UNLINK(qu->ads->childw,qu); + case query_childw: + LIST_UNLINK(ads->childw,qu); break; case query_done: - LIST_UNLINK(qu->ads->output,qu); + LIST_UNLINK(ads->output,qu); break; default: abort(); @@ -378,9 +460,11 @@ void adns_cancel(adns_query qu) { free_query_allocs(qu); free(qu->answer); free(qu); + adns__consistency(ads,0,cc_entex); } -void adns__update_expires(adns_query qu, unsigned long ttl, struct timeval now) { +void adns__update_expires(adns_query qu, unsigned long ttl, + struct timeval now) { time_t max; assert(ttl <= MAXTTLBELIEVE); @@ -396,7 +480,8 @@ static void makefinal_query(adns_query qu) { ans= qu->answer; if (qu->interim_allocd) { - ans= realloc(qu->answer, MEM_ROUND(MEM_ROUND(sizeof(*ans)) + qu->interim_allocd)); + ans= realloc(qu->answer, + MEM_ROUND(MEM_ROUND(sizeof(*ans)) + qu->interim_allocd)); if (!ans) goto x_nomem; qu->answer= ans; } @@ -434,8 +519,7 @@ void adns__query_done(adns_query qu) { qu->id= -1; ans= qu->answer; - if (qu->flags & adns_qf_owner && qu->flags & adns_qf_search && - ans->status != adns_s_nomemory) { + if (qu->flags & adns_qf_search && ans->status != adns_s_nomemory) { if (!save_owner(qu, qu->search_vb.buf, qu->search_vb.used)) { adns__query_fail(qu,adns_s_nomemory); return; @@ -449,7 +533,8 @@ void adns__query_done(adns_query qu) { } adns__isort(ans->rrs.bytes, ans->nrrs, ans->rrsz, qu->vb.buf, - (int(*)(void*, const void*, const void*))qu->typei->diff_needswap, + (int(*)(void*, const void*, const void*)) + qu->typei->diff_needswap, qu->ads); } @@ -460,10 +545,12 @@ void adns__query_done(adns_query qu) { LIST_UNLINK(qu->ads->childw,parent); qu->ctx.callback(parent,qu); free_query_allocs(qu); + free(qu->answer); free(qu); } else { makefinal_query(qu); LIST_LINK_TAIL(qu->ads->output,qu); + qu->state= query_done; } }