X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fevent.c;h=10d64b1da0c356575b7e5a50452e02f845ec1030;hb=fc440c64836370db9d8cb1a25f09c9df0786f865;hp=ee4e5f7a8553c6c1c2c3cee138f662988b4d412d;hpb=f930c455a13d7d30ee94bdbfc460bc6227cda111;p=adns.git diff --git a/src/event.c b/src/event.c index ee4e5f7..10d64b1 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,2020 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 @@ -209,11 +209,16 @@ static void timeouts_queue(adns_state ads, int act, struct timeval **tv_io, struct timeval *tvbuf, struct timeval now, struct query_queue *queue) { adns_query qu, nqu; + struct timeval expires; for (qu= queue->head; qu; qu= nqu) { nqu= qu->next; - if (!timercmp(&now,&qu->timeout,>)) { - inter_maxtoabs(tv_io,tvbuf,now,qu->timeout); + if (timercmp(&now,&qu->timeout_started,<)) /* clock rewound */ + qu->timeout_started= now; + expires= qu->timeout_started; + timevaladd(&expires, qu->timeout_ms); + if (!timercmp(&now,&expires,>)) { + inter_maxtoabs(tv_io,tvbuf,now,expires); } else { if (!act) { inter_immed(tv_io,tvbuf); return; } LIST_UNLINK(*queue,qu); @@ -284,18 +289,18 @@ void adns__timeouts(adns_state ads, int act, void adns_firsttimeout(adns_state ads, struct timeval **tv_io, struct timeval *tvbuf, struct timeval now) { - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); 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) { struct timeval tv_buf; - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); 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,37 +309,49 @@ 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) - assert(MAX_POLLFDS==2); + int i; - pollfds_buf[0].fd= ads->udpsocket; - pollfds_buf[0].events= POLLIN; - pollfds_buf[0].revents= 0; + assert(MAX_POLLFDS == MAXUDP + 1); + + 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); + adns__consistency(ads,0,cc_enter); switch (ads->tcpstate) { case server_disconnected: @@ -385,11 +402,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,46 +415,30 @@ 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; } int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { int r; - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); switch (ads->tcpstate) { case server_disconnected: @@ -447,8 +449,24 @@ 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); + r= read(ads->tcpsocket,ads->tcprecv.buf,1); if (r==0 || (r<0 && (errno==EAGAIN || errno==EWOULDBLOCK))) { tcp_connected(ads,*now); r= 0; goto xit; @@ -475,6 +493,7 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { adns__tcp_broken(ads,"write",strerror(errno)); r= 0; goto xit; } else if (r>0) { + assert(r <= ads->tcpsend.used); ads->tcpsend.used -= r; memmove(ads->tcpsend.buf,ads->tcpsend.buf+r,ads->tcpsend.used); } @@ -486,13 +505,13 @@ 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; } int adns_processexceptional(adns_state ads, int fd, const struct timeval *now) { - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); switch (ads->tcpstate) { case server_disconnected: case server_broken: @@ -505,7 +524,7 @@ int adns_processexceptional(adns_state ads, int fd, default: abort(); } - adns__consistency(ads,0,cc_entex); + adns__returning(ads,0); return 0; } @@ -561,7 +580,7 @@ void adns_beforeselect(adns_state ads, int *maxfd_io, fd_set *readfds_io, struct pollfd pollfds[MAX_POLLFDS]; int i, fd, maxfd, npollfds; - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); if (tv_mod && (!*tv_mod || (*tv_mod)->tv_sec || (*tv_mod)->tv_usec)) { /* The caller is planning to sleep. */ @@ -582,7 +601,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, @@ -592,7 +611,7 @@ void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds, struct pollfd pollfds[MAX_POLLFDS]; int npollfds, i; - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); adns__must_gettimeofday(ads,&now,&tv_buf); if (!now) goto xit; adns_processtimeouts(ads,now); @@ -604,16 +623,30 @@ 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. */ void adns_globalsystemfailure(adns_state ads) { - adns__consistency(ads,0,cc_entex); + /* Must not be called by adns during actual processing of a + * particular query, since it reenters adns. Only safe to call in + * situations where it would be safe to call adns_returning. */ + adns__consistency(ads,0,cc_enter); - while (ads->udpw.head) adns__query_fail(ads->udpw.head, adns_s_systemfail); - while (ads->tcpw.head) adns__query_fail(ads->tcpw.head, adns_s_systemfail); + for (;;) { + adns_query qu; +#define GSF_QQ(QQ) \ + if ((qu= ads->QQ.head)) { \ + LIST_UNLINK(ads->QQ,qu); \ + adns__query_fail(qu, adns_s_systemfail); \ + continue; \ + } + GSF_QQ(udpw); + GSF_QQ(tcpw); +#undef GSF_QQ + break; + } switch (ads->tcpstate) { case server_connecting: @@ -626,7 +659,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) { @@ -635,7 +668,7 @@ int adns_processany(adns_state ads) { struct pollfd pollfds[MAX_POLLFDS]; int npollfds; - adns__consistency(ads,0,cc_entex); + adns__consistency(ads,0,cc_enter); r= gettimeofday(&now,0); if (!r) adns_processtimeouts(ads,&now); @@ -651,7 +684,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; } @@ -694,7 +727,7 @@ int adns_wait(adns_state ads, fd_set readfds, writefds, exceptfds; struct timeval tvbuf, *tvp; - adns__consistency(ads,*query_io,cc_entex); + adns__consistency(ads,*query_io,cc_enter); for (;;) { r= adns__internal_check(ads,query_io,answer_r,context_r); if (r != EAGAIN) break; @@ -715,7 +748,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; } @@ -726,11 +759,11 @@ int adns_check(adns_state ads, struct timeval now; int r; - adns__consistency(ads,*query_io,cc_entex); + adns__consistency(ads,*query_io,cc_enter); r= gettimeofday(&now,0); 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; }