X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fsetup.c;h=8ff92d284e5bf4a89955f336795479417d28ade1;hb=7ba7a232de0516d2cce934bdc91627b33b46ef47;hp=38be6217670df8f073e68d341ab5fa3b04b6a133;hpb=2d23048790f0db14cfd5e2c60a40ef88f547d066;p=adns.git diff --git a/src/setup.c b/src/setup.c index 38be621..8ff92d2 100644 --- a/src/setup.c +++ b/src/setup.c @@ -4,16 +4,16 @@ * - management of global state */ /* - * This file is - * Copyright (C) 1997-1999 Ian Jackson - * - * It is part of adns, which is - * Copyright (C) 1997-2000 Ian Jackson - * Copyright (C) 1999-2000 Tony Finch + * This file is part of adns, which is + * Copyright (C) 1997-2000,2003,2006,2014-2016 Ian Jackson + * Copyright (C) 2014 Mark Wooding + * Copyright (C) 1999-2000,2003,2006 Tony Finch + * Copyright (C) 1991 Massachusetts Institute of Technology + * (See the file INSTALL for full details.) * * 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 - * the Free Software Foundation; either version 2, or (at your option) + * the Free Software Foundation; either version 3, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, @@ -22,8 +22,7 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * along with this program; if not, write to the Free Software Foundation. */ #include @@ -42,24 +41,29 @@ static void readconfig(adns_state ads, const char *filename, int warnmissing); -static void addserver(adns_state ads, struct in_addr addr) { +static void addserver(adns_state ads, const struct sockaddr *sa, int salen) { int i; - struct server *ss; + adns_rr_addr *ss; + char buf[ADNS_ADDR2TEXT_BUFLEN]; for (i=0; inservers; i++) { - if (ads->servers[i].addr.s_addr == addr.s_addr) { - adns__debug(ads,-1,0,"duplicate nameserver %s ignored",inet_ntoa(addr)); + if (adns__sockaddrs_equal(sa, &ads->servers[i].addr.sa)) { + adns__debug(ads,-1,0,"duplicate nameserver %s ignored", + adns__sockaddr_ntoa(sa, buf)); return; } } if (ads->nservers>=MAXSERVERS) { - adns__diag(ads,-1,0,"too many nameservers, ignoring %s",inet_ntoa(addr)); + adns__diag(ads,-1,0,"too many nameservers, ignoring %s", + adns__sockaddr_ntoa(sa, buf)); return; } ss= ads->servers+ads->nservers; - ss->addr= addr; + assert(salen <= sizeof(ss->addr)); + ss->len = salen; + memcpy(&ss->addr, sa, salen); ads->nservers++; } @@ -77,14 +81,14 @@ static void configparseerr(adns_state ads, const char *fn, int lno, va_list al; saveerr(ads,EINVAL); - if (!ads->diagfile || (ads->iflags & adns_if_noerrprint)) return; + if (!ads->logfn || (ads->iflags & adns_if_noerrprint)) return; - if (lno==-1) fprintf(ads->diagfile,"adns: %s: ",fn); - else fprintf(ads->diagfile,"adns: %s:%d: ",fn,lno); + if (lno==-1) adns__lprintf(ads,"adns: %s: ",fn); + else adns__lprintf(ads,"adns: %s:%d: ",fn,lno); va_start(al,fmt); - vfprintf(ads->diagfile,fmt,al); + adns__vlprintf(ads,fmt,al); va_end(al); - fputc('\n',ads->diagfile); + adns__lprintf(ads,"\n"); } static int nextword(const char **bufp_io, const char **word_r, int *l_r) { @@ -106,14 +110,28 @@ static int nextword(const char **bufp_io, const char **word_r, int *l_r) { static void ccf_nameserver(adns_state ads, const char *fn, int lno, const char *buf) { - struct in_addr ia; - - if (!inet_aton(buf,&ia)) { + adns_rr_addr a; + char addrbuf[ADNS_ADDR2TEXT_BUFLEN]; + int err; + socklen_t salen; + + salen= sizeof(a.addr); + err= adns_text2addr(buf,DNS_PORT, 0, &a.addr.sa,&salen); + a.len= salen; + switch (err) { + case 0: + break; + case EINVAL: configparseerr(ads,fn,lno,"invalid nameserver address `%s'",buf); return; + default: + configparseerr(ads,fn,lno,"failed to parse nameserver address `%s': %s", + buf,strerror(err)); + return; } - adns__debug(ads,-1,0,"using nameserver %s",inet_ntoa(ia)); - addserver(ads,ia); + adns__debug(ads,-1,0,"using nameserver %s", + adns__sockaddr_ntoa(&a.addr.sa, addrbuf)); + addserver(ads,&a.addr.sa,salen); } static void ccf_search(adns_state ads, const char *fn, @@ -149,13 +167,26 @@ static void ccf_search(adns_state ads, const char *fn, ads->searchlist= newptrs; } +static int gen_pton(const char *text, int want_af, adns_sockaddr *a) { + int err; + socklen_t len; + + len= sizeof(*a); + err= adns_text2addr(text,0, adns_qf_addrlit_scope_forbid, + &a->sa, &len); + if (err) { assert(err == EINVAL); return 0; } + if (want_af != AF_UNSPEC && a->sa.sa_family != want_af) return 0; + return 1; +} + static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *buf) { const char *word; char tbuf[200], *slash, *ep; - struct in_addr base, mask; + const char *maskwhat; + struct sortlist *sl; int l; - unsigned long initial, baselocal; + int initial= -1; if (!buf) return; @@ -175,94 +206,151 @@ static void ccf_sortlist(adns_state ads, const char *fn, memcpy(tbuf,word,l); tbuf[l]= 0; slash= strchr(tbuf,'/'); if (slash) *slash++= 0; - - if (!inet_aton(tbuf,&base)) { + + sl= &ads->sortlist[ads->nsortlist]; + if (!gen_pton(tbuf, AF_UNSPEC, &sl->base)) { configparseerr(ads,fn,lno,"invalid address `%s' in sortlist",tbuf); continue; } if (slash) { - if (strchr(slash,'.')) { - if (!inet_aton(slash,&mask)) { + if (slash[strspn(slash, "0123456789")]) { + maskwhat = "mask"; + if (!gen_pton(slash, sl->base.sa.sa_family, &sl->mask)) { configparseerr(ads,fn,lno,"invalid mask `%s' in sortlist",slash); continue; } - if (base.s_addr & ~mask.s_addr) { - configparseerr(ads,fn,lno, "mask `%s' in sortlist" - " overlaps address `%s'",slash,tbuf); - continue; - } } else { + maskwhat = "prefix length"; initial= strtoul(slash,&ep,10); - if (*ep || initial>32) { + if (*ep || initial>adns__addr_width(sl->base.sa.sa_family)) { configparseerr(ads,fn,lno,"mask length `%s' invalid",slash); continue; } - mask.s_addr= htonl((0x0ffffffffUL) << (32-initial)); + sl->mask.sa.sa_family= sl->base.sa.sa_family; + adns__prefix_mask(&sl->mask, initial); } } else { - baselocal= ntohl(base.s_addr); - if (!baselocal & 0x080000000UL) /* class A */ - mask.s_addr= htonl(0x0ff000000UL); - else if ((baselocal & 0x0c0000000UL) == 0x080000000UL) - mask.s_addr= htonl(0x0ffff0000UL); /* class B */ - else if ((baselocal & 0x0f0000000UL) == 0x0e0000000UL) - mask.s_addr= htonl(0x0ff000000UL); /* class C */ - else { + maskwhat = "implied prefix length"; + initial= adns__guess_prefix_length(&sl->base); + if (initial < 0) { configparseerr(ads,fn,lno, "network address `%s'" " in sortlist is not in classed ranges," " must specify mask explicitly", tbuf); continue; } + sl->mask.sa.sa_family= sl->base.sa.sa_family; + adns__prefix_mask(&sl->mask, initial); + } + + if (!adns__addr_matches(sl->base.sa.sa_family, + adns__sockaddr_addr(&sl->base.sa), + &sl->base,&sl->mask)) { + if (initial >= 0) { + configparseerr(ads,fn,lno, "%s %d in sortlist" + " overlaps address `%s'",maskwhat,initial,tbuf); + } else { + configparseerr(ads,fn,lno, "%s `%s' in sortlist" + " overlaps address `%s'",maskwhat,slash,tbuf); + } + continue; } - ads->sortlist[ads->nsortlist].base= base; - ads->sortlist[ads->nsortlist].mask= mask; ads->nsortlist++; } } static void ccf_options(adns_state ads, const char *fn, int lno, const char *buf) { - const char *word; + const char *opt, *word, *endword, *endopt; char *ep; unsigned long v; int l; if (!buf) return; +#define WORD__IS(s,op) ((endword-word) op (sizeof(s)-1) && \ + !memcmp(word,s,(sizeof(s)-1))) +#define WORD_IS(s) (WORD__IS(s,==)) +#define WORD_STARTS(s) (WORD__IS(s,>=) ? ((word+=sizeof(s)-1)) : 0) + while (nextword(&buf,&word,&l)) { - if (l==5 && !memcmp(word,"debug",5)) { + opt=word; + endopt=endword=word+l; + if (WORD_IS("debug")) { ads->iflags |= adns_if_debug; continue; } - if (l>=6 && !memcmp(word,"ndots:",6)) { - v= strtoul(word+6,&ep,10); - if (l==6 || ep != word+l || v > INT_MAX) { + if (WORD_STARTS("ndots:")) { + v= strtoul(word,&ep,10); + if (ep==word || ep != endword || v > INT_MAX) { configparseerr(ads,fn,lno,"option `%.*s' malformed" - " or has bad value",l,word); + " or has bad value",l,opt); continue; } ads->searchndots= v; continue; } - if (l>=12 && !memcmp(word,"adns_checkc:",12)) { - if (!strcmp(word+12,"none")) { + if (WORD_STARTS("adns_checkc:")) { + if (WORD_IS("none")) { ads->iflags &= ~adns_if_checkc_freq; ads->iflags |= adns_if_checkc_entex; - } else if (!strcmp(word+12,"entex")) { + } else if (WORD_IS("entex")) { ads->iflags &= ~adns_if_checkc_freq; ads->iflags |= adns_if_checkc_entex; - } else if (!strcmp(word+12,"freq")) { + } else if (WORD_IS("freq")) { ads->iflags |= adns_if_checkc_freq; } else { configparseerr(ads,fn,lno, "option adns_checkc has bad value `%s' " - "(must be none, entex or freq", word+12); + "(must be none, entex or freq", word); + } + continue; + } + if (WORD_STARTS("adns_af:")) { + ads->iflags &= ~adns_if_afmask; + if (!WORD_IS("any")) for (;;) { + const char *comma= memchr(word,',',endopt-word); + endword=comma?comma:endopt; + if (WORD_IS("ipv4")) + ads->iflags |= adns_if_permit_ipv4; + else if (WORD_IS("ipv6")) + ads->iflags |= adns_if_permit_ipv6; + else { + if (ads->config_report_unknown) + adns__diag(ads,-1,0,"%s:%d: " + "option adns_af has bad value or entry `%.*s' " + "(option must be `any', or list of `ipv4',`ipv6')", + fn,lno, (int)(endword-word),word); + break; + } + if (!comma) break; + word= comma+1; } continue; } - adns__diag(ads,-1,0,"%s:%d: unknown option `%.*s'", fn,lno, l,word); + if (WORD_IS("adns_ignoreunkcfg")) { + ads->config_report_unknown=0; + continue; + } + if (/* adns's query strategy is not configurable */ + WORD_STARTS("timeout:") || + WORD_STARTS("attempts:") || + WORD_IS("rotate") || + /* adns provides the application with knob for this */ + WORD_IS("no-check-names") || + /* adns normally does IPv6 if the application wants it; control + * this with the adns_af: option if you like */ + WORD_IS("inet6") || + /* adns does not do edns0 and this is not a problem */ + WORD_IS("edns0")) + continue; + if (ads->config_report_unknown) + adns__diag(ads,-1,0,"%s:%d: unknown option `%.*s'", fn,lno, l,opt); } + +#undef WORD__IS +#undef WORD_IS +#undef WORD_STARTS } static void ccf_clearnss(adns_state ads, const char *fn, @@ -299,8 +387,9 @@ static void ccf_lookup(adns_state ads, const char *fn, int lno, adns__diag(ads,-1,0,"%s:%d: yp lookups not supported by adns", fn,lno); found_bind=-1; } else { - adns__diag(ads,-1,0,"%s:%d: unknown `lookup' database `%.*s'", - fn,lno, l,word); + if (ads->config_report_unknown) + adns__diag(ads,-1,0,"%s:%d: unknown `lookup' database `%.*s'", + fn,lno, l,word); found_bind=-1; } } @@ -308,6 +397,10 @@ static void ccf_lookup(adns_state ads, const char *fn, int lno, adns__diag(ads,-1,0,"%s:%d: `lookup' specified, but not `bind'", fn,lno); } +static void ccf_ignore(adns_state ads, const char *fn, int lno, + const char *buf) { +} + static const struct configcommandinfo { const char *name; void (*fn)(adns_state ads, const char *fn, int lno, const char *buf); @@ -320,6 +413,7 @@ static const struct configcommandinfo { { "clearnameservers", ccf_clearnss }, { "include", ccf_include }, { "lookup", ccf_lookup }, /* OpenBSD */ + { "lwserver", ccf_ignore }, /* BIND9 lwresd */ { 0 } }; @@ -425,8 +519,9 @@ static void readconfiggeneric(adns_state ads, const char *filename, !(strlen(ccip->name)==dirl && !memcmp(ccip->name,p,q-p)); ccip++); if (!ccip->name) { - adns__diag(ads,-1,0,"%s:%d: unknown configuration directive `%.*s'", - filename,lno,q-p,p); + if (ads->config_report_unknown) + adns__diag(ads,-1,0,"%s:%d: unknown configuration directive `%.*s'", + filename,lno,(int)(q-p),p); continue; } while (ctype_whitespace(*q)) q++; @@ -507,21 +602,29 @@ int adns__setnonblock(adns_state ads, int fd) { } static int init_begin(adns_state *ads_r, adns_initflags flags, - FILE *diagfile) { + adns_logcallbackfn *logfn, void *logfndata) { adns_state ads; + pid_t pid; + if (flags & ~(adns_initflags)(0x4fff)) + /* 0x4000 is reserved for `harmless' future expansion */ + return ENOSYS; + ads= malloc(sizeof(*ads)); if (!ads) return errno; ads->iflags= flags; - ads->diagfile= diagfile; + ads->logfn= logfn; + ads->logfndata= logfndata; ads->configerrno= 0; LIST_INIT(ads->udpw); LIST_INIT(ads->tcpw); LIST_INIT(ads->childw); LIST_INIT(ads->output); + LIST_INIT(ads->intdone); ads->forallnext= 0; ads->nextid= 0x311f; - ads->udpsocket= ads->tcpsocket= -1; + ads->nudpsockets= 0; + ads->tcpsocket= -1; adns__vbuf_init(&ads->tcpsend); adns__vbuf_init(&ads->tcprecv); ads->tcprecv_skip= 0; @@ -530,34 +633,53 @@ static int init_begin(adns_state *ads_r, adns_initflags flags, ads->tcpstate= server_disconnected; timerclear(&ads->tcptimeout); ads->searchlist= 0; + ads->config_report_unknown=1; + + pid= getpid(); + ads->rand48xsubi[0]= pid; + ads->rand48xsubi[1]= (unsigned long)pid >> 16; + ads->rand48xsubi[2]= pid ^ ((unsigned long)pid >> 16); *ads_r= ads; return 0; } static int init_finish(adns_state ads) { - struct in_addr ia; + struct sockaddr_in sin; struct protoent *proto; + struct udpsocket *udp; + int i; int r; if (!ads->nservers) { - if (ads->diagfile && ads->iflags & adns_if_debug) - fprintf(ads->diagfile,"adns: no nameservers, using localhost\n"); - ia.s_addr= htonl(INADDR_LOOPBACK); - addserver(ads,ia); + if (ads->logfn && ads->iflags & adns_if_debug) + adns__lprintf(ads,"adns: no nameservers, using IPv4 localhost\n"); + memset(&sin, 0, sizeof(sin)); + sin.sin_family = AF_INET; + sin.sin_port = htons(DNS_PORT); + sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + addserver(ads,(struct sockaddr *)&sin, sizeof(sin)); } proto= getprotobyname("udp"); if (!proto) { r= ENOPROTOOPT; goto x_free; } - ads->udpsocket= socket(AF_INET,SOCK_DGRAM,proto->p_proto); - if (ads->udpsocket<0) { r= errno; goto x_free; } - - r= adns__setnonblock(ads,ads->udpsocket); - if (r) { r= errno; goto x_closeudp; } + ads->nudpsockets= 0; + for (i=0; inservers; i++) { + if (adns__udpsocket_by_af(ads, ads->servers[i].addr.sa.sa_family)) + continue; + assert(ads->nudpsockets < MAXUDP); + udp= &ads->udpsockets[ads->nudpsockets]; + udp->af= ads->servers[i].addr.sa.sa_family; + udp->fd= socket(udp->af,SOCK_DGRAM,proto->p_proto); + if (udp->fd < 0) { r= errno; goto x_free; } + ads->nudpsockets++; + r= adns__setnonblock(ads,udp->fd); + if (r) { r= errno; goto x_closeudp; } + } return 0; x_closeudp: - close(ads->udpsocket); + for (i=0; inudpsockets; i++) close(ads->udpsockets[i].fd); x_free: free(ads); return r; @@ -571,12 +693,18 @@ static void init_abort(adns_state ads) { free(ads); } -int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) { +static void logfn_file(adns_state ads, void *logfndata, + const char *fmt, va_list al) { + vfprintf(logfndata,fmt,al); +} + +static int init_files(adns_state *ads_r, adns_initflags flags, + adns_logcallbackfn *logfn, void *logfndata) { adns_state ads; const char *res_options, *adns_res_options; int r; - r= init_begin(&ads, flags, diagfile ? diagfile : stderr); + r= init_begin(&ads, flags, logfn, logfndata); if (r) return r; res_options= instrum_getenv(ads,"RES_OPTIONS"); @@ -612,12 +740,18 @@ int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) { return 0; } -int adns_init_strcfg(adns_state *ads_r, adns_initflags flags, - FILE *diagfile, const char *configtext) { +int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) { + return init_files(ads_r, flags, logfn_file, diagfile ? diagfile : stderr); +} + +static int init_strcfg(adns_state *ads_r, adns_initflags flags, + adns_logcallbackfn *logfn, void *logfndata, + const char *configtext) { adns_state ads; int r; - r= init_begin(&ads, flags, diagfile); if (r) return r; + r= init_begin(&ads, flags, logfn, logfndata); + if (r) return r; readconfigtext(ads,configtext,""); if (ads->configerrno) { @@ -632,17 +766,37 @@ int adns_init_strcfg(adns_state *ads_r, adns_initflags flags, return 0; } +int adns_init_strcfg(adns_state *ads_r, adns_initflags flags, + FILE *diagfile, const char *configtext) { + return init_strcfg(ads_r, flags, + diagfile ? logfn_file : 0, diagfile, + configtext); +} + +int adns_init_logfn(adns_state *newstate_r, adns_initflags flags, + const char *configtext /*0=>use default config files*/, + adns_logcallbackfn *logfn /*0=>logfndata is a FILE* */, + void *logfndata /*0 with logfn==0 => discard*/) { + if (!logfn && logfndata) + logfn= logfn_file; + if (configtext) + return init_strcfg(newstate_r, flags, logfn, logfndata, configtext); + else + return init_files(newstate_r, flags, logfn, logfndata); +} void adns_finish(adns_state ads) { + int i; adns__consistency(ads,0,cc_entex); for (;;) { - if (ads->udpw.head) adns_cancel(ads->udpw.head); - else if (ads->tcpw.head) adns_cancel(ads->tcpw.head); - else if (ads->childw.head) adns_cancel(ads->childw.head); - else if (ads->output.head) adns_cancel(ads->output.head); + if (ads->udpw.head) adns__cancel(ads->udpw.head); + else if (ads->tcpw.head) adns__cancel(ads->tcpw.head); + else if (ads->childw.head) adns__cancel(ads->childw.head); + else if (ads->output.head) adns__cancel(ads->output.head); + else if (ads->intdone.head) adns__cancel(ads->output.head); else break; } - close(ads->udpsocket); + for (i=0; inudpsockets; i++) close(ads->udpsockets[i].fd); if (ads->tcpsocket >= 0) close(ads->tcpsocket); adns__vbuf_free(&ads->tcpsend); adns__vbuf_free(&ads->tcprecv);