X-Git-Url: https://git.distorted.org.uk/~mdw/adns/blobdiff_plain/f930c455a13d7d30ee94bdbfc460bc6227cda111..HEAD:/src/event.c diff --git a/src/event.c b/src/event.c index ee4e5f7..dcc49e9 100644 --- a/src/event.c +++ b/src/event.c @@ -6,14 +6,15 @@ */ /* * This file is part of adns, which is - * Copyright (C) 1997-2000,2003,2006 Ian Jackson + * 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 +23,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 @@ -286,7 +286,7 @@ void adns_firsttimeout(adns_state ads, struct timeval now) { adns__consistency(ads,0,cc_entex); adns__timeouts(ads, 0, tv_io,tvbuf, now); - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); } void adns_processtimeouts(adns_state ads, const struct timeval *now) { @@ -295,7 +295,7 @@ void adns_processtimeouts(adns_state ads, const struct timeval *now) { adns__consistency(ads,0,cc_entex); adns__must_gettimeofday(ads,&now,&tv_buf); if (now) adns__timeouts(ads, 1, 0,0, *now); - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); } /* fd handling functions. These are the top-level of the real work of @@ -304,35 +304,47 @@ void adns_processtimeouts(adns_state ads, const struct timeval *now) { int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS]) { /* Returns the number of entries filled in. Always zeroes revents. */ + int nwanted=0; +#define ADD_POLLFD(wantfd, wantevents) do{ \ + pollfds_buf[nwanted].fd= (wantfd); \ + pollfds_buf[nwanted].events= (wantevents); \ + pollfds_buf[nwanted].revents= 0; \ + nwanted++; \ + }while(0) + + int i; - assert(MAX_POLLFDS==2); + assert(MAX_POLLFDS == MAXUDP + 1); - pollfds_buf[0].fd= ads->udpsocket; - pollfds_buf[0].events= POLLIN; - pollfds_buf[0].revents= 0; + for (i=0; inudpsockets; i++) + ADD_POLLFD(ads->udpsockets[i].fd, POLLIN); switch (ads->tcpstate) { case server_disconnected: case server_broken: - return 1; + break; case server_connecting: - pollfds_buf[1].events= POLLOUT; + ADD_POLLFD(ads->tcpsocket, POLLOUT); break; case server_ok: - pollfds_buf[1].events= - ads->tcpsend.used ? POLLIN|POLLOUT|POLLPRI : POLLIN|POLLPRI; + ADD_POLLFD(ads->tcpsocket, + ads->tcpsend.used ? POLLIN|POLLOUT|POLLPRI : POLLIN|POLLPRI); break; default: abort(); } - pollfds_buf[1].fd= ads->tcpsocket; - return 2; + assert(nwanted<=MAX_POLLFDS); +#undef ADD_POLLFD + return nwanted; } int adns_processreadable(adns_state ads, int fd, const struct timeval *now) { - int want, dgramlen, r, udpaddrlen, serv, old_skip; + int want, dgramlen, r, i, serv, old_skip; + socklen_t udpaddrlen; byte udpbuf[DNS_MAXUDP]; - struct sockaddr_in udpaddr; + char addrbuf[ADNS_ADDR2TEXT_BUFLEN]; + struct udpsocket *udp; + adns_sockaddr udpaddr; adns__consistency(ads,0,cc_entex); @@ -385,11 +397,12 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) { default: abort(); } - if (fd == ads->udpsocket) { + for (i=0; inudpsockets; i++) { + udp= &ads->udpsockets[i]; + if (fd != udp->fd) continue; for (;;) { udpaddrlen= sizeof(udpaddr); - r= recvfrom(ads->udpsocket,udpbuf,sizeof(udpbuf),0, - (struct sockaddr*)&udpaddr,&udpaddrlen); + r= recvfrom(fd,udpbuf,sizeof(udpbuf),0, &udpaddr.sa,&udpaddrlen); if (r<0) { if (errno == EAGAIN || errno == EWOULDBLOCK) { r= 0; goto xit; } if (errno == EINTR) continue; @@ -397,39 +410,23 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) { adns__warn(ads,-1,0,"datagram receive error: %s",strerror(errno)); r= 0; goto xit; } - if (udpaddrlen != sizeof(udpaddr)) { - adns__diag(ads,-1,0,"datagram received with wrong address length %d" - " (expected %lu)", udpaddrlen, - (unsigned long)sizeof(udpaddr)); - continue; - } - if (udpaddr.sin_family != AF_INET) { - adns__diag(ads,-1,0,"datagram received with wrong protocol family" - " %u (expected %u)",udpaddr.sin_family,AF_INET); - continue; - } - if (ntohs(udpaddr.sin_port) != DNS_PORT) { - adns__diag(ads,-1,0,"datagram received from wrong port" - " %u (expected %u)", ntohs(udpaddr.sin_port),DNS_PORT); - continue; - } for (serv= 0; serv < ads->nservers && - (assert(ads->servers[serv].addr.sa.sa_family==AF_INET), - ads->servers[serv].addr.inet.sin_addr.s_addr != - udpaddr.sin_addr.s_addr); + !adns__sockaddrs_equal(&udpaddr.sa, + &ads->servers[serv].addr.sa); serv++); if (serv >= ads->nservers) { adns__warn(ads,-1,0,"datagram received from unknown nameserver %s", - inet_ntoa(udpaddr.sin_addr)); + adns__sockaddr_ntoa(&udpaddr.sa, addrbuf)); continue; } adns__procdgram(ads,udpbuf,r,serv,0,*now); } + break; } r= 0; xit: - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return r; } @@ -447,6 +444,22 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { assert(ads->tcprecv.used==0); assert(ads->tcprecv_skip==0); for (;;) { + /* This function can be called even if the fd wasn't actually + * flagged as writeable. For asynch tcp connect we have to + * actually use the writeability to tell us the connect has + * completed (or failed), so we need to double check. */ + fd_set writeable; + struct timeval timeout = { 0,0 }; + FD_ZERO(&writeable); + FD_SET(ads->tcpsocket,&writeable); + r= select(ads->tcpsocket+1,0,&writeable,0,&timeout); + if (r==0) break; + if (r<0) { + if (errno==EINTR) continue; + adns__tcp_broken(ads,"select","failed connecting writeability check"); + r= 0; goto xit; + } + assert(FD_ISSET(ads->tcpsocket,&writeable)); if (!adns__vbuf_ensure(&ads->tcprecv,1)) { r= ENOMEM; goto xit; } r= read(ads->tcpsocket,&ads->tcprecv.buf,1); if (r==0 || (r<0 && (errno==EAGAIN || errno==EWOULDBLOCK))) { @@ -486,7 +499,7 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { } r= 0; xit: - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return r; } @@ -505,7 +518,7 @@ int adns_processexceptional(adns_state ads, int fd, default: abort(); } - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return 0; } @@ -582,7 +595,7 @@ void adns_beforeselect(adns_state ads, int *maxfd_io, fd_set *readfds_io, *maxfd_io= maxfd; xit: - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); } void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds, @@ -604,7 +617,7 @@ void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds, maxfd,readfds,writefds,exceptfds, *now, 0); xit: - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); } /* General helpful functions. */ @@ -626,7 +639,7 @@ void adns_globalsystemfailure(adns_state ads) { default: abort(); } - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); } int adns_processany(adns_state ads) { @@ -651,7 +664,7 @@ int adns_processany(adns_state ads) { 0,0,0,0, now,&r); - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return 0; } @@ -715,7 +728,7 @@ int adns_wait(adns_state ads, adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,0); } } - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return r; } @@ -731,6 +744,6 @@ int adns_check(adns_state ads, if (!r) adns__autosys(ads,now); r= adns__internal_check(ads,query_io,answer_r,context_r); - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return r; }