Do not scramble innards when a query on the output queue is cancelled.

[adns.git] / src / event.c

diff --git a/src/event.c b/src/event.c
index d54d8479c38151b36e914f298b99e99af1922491..7702fe1d6d773c55818c16345fe8a527641e4555 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -22,7 +22,6 @@
  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
  */
 
-#include <string.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -59,7 +58,7 @@ void adns__tcp_broken(adns_state ads, const char *what, const char *why) {
   
   for (qu= ads->timew.head; qu; qu= nqu) {
     nqu= qu->next;
-    if (qu->state == query_udp) continue;
+    if (qu->state == query_tosend) continue;
     assert(qu->state == query_tcpwait || qu->state == query_tcpsent);
     qu->state= query_tcpwait;
     qu->tcpfailed |= (1<<serv);
@@ -77,7 +76,7 @@ static void tcp_connected(adns_state ads, struct timeval now) {
   ads->tcpstate= server_ok;
   for (qu= ads->timew.head; qu; qu= nqu) {
     nqu= qu->next;
-    if (qu->state == query_udp) continue;
+    if (qu->state == query_tosend) continue;
     assert (qu->state == query_tcpwait);
     adns__query_tcp(qu,now);
   }
@@ -173,16 +172,16 @@ void adns__timeouts(adns_state ads, int act,
 
   for (qu= ads->timew.head; qu; qu= nqu) {
     nqu= qu->next;
-    if (timercmp(&now,&qu->timeout,<=)) {
+    if (!timercmp(&now,&qu->timeout,>)) {
       if (!tv_io) continue;
       inter_maxtoabs(tv_io,tvbuf,now,qu->timeout);
     } else {
       if (!act) continue;
       LIST_UNLINK(ads->timew,qu);
-      if (qu->state != query_udp) {
+      if (qu->state != query_tosend) {
        adns__query_fail(qu,adns_s_timeout);
       } else {
-       adns__query_udp(qu,now);
+       adns__query_send(qu,now);
       }
       nqu= ads->timew.head;
     }
@@ -192,14 +191,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__timeouts(ads, 0, tv_io,tvbuf, now);
+  adns__consistency(ads,0,cc_entex);
 }
 
 void adns_processtimeouts(adns_state ads, const struct timeval *now) {
   struct timeval tv_buf;
 
-  adns__must_gettimeofday(ads,&now,&tv_buf); if (!now) return;
-  adns__timeouts(ads, 1, 0,0, *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);
 }
 
 /* fd handling functions.  These are the top-level of the real work of
@@ -228,7 +231,6 @@ int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS]) {
     abort();
   }
   pollfds_buf[1].fd= ads->tcpsocket;
-  pollfds_buf[1].revents= 0;
   return 2;
 }
 
@@ -237,6 +239,8 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
   byte udpbuf[DNS_MAXUDP];
   struct sockaddr_in udpaddr;
   
+  adns__consistency(ads,0,cc_entex);
+
   switch (ads->tcpstate) {
   case server_disconnected:
   case server_connecting:
@@ -252,14 +256,14 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
        if (ads->tcprecv.used<skip+2+dgramlen) {
          want= 2+dgramlen;
        } else {
-         adns__procdgram(ads,ads->tcprecv.buf+skip+2,dgramlen,ads->tcpserver,*now);
+         adns__procdgram(ads,ads->tcprecv.buf+skip+2,dgramlen,ads->tcpserver,1,*now);
          skip+= 2+dgramlen; continue;
        }
       }
       ads->tcprecv.used -= skip;
       memmove(ads->tcprecv.buf,ads->tcprecv.buf+skip,ads->tcprecv.used);
       skip= 0;
-      if (!adns__vbuf_ensure(&ads->tcprecv,want)) return ENOMEM;
+      if (!adns__vbuf_ensure(&ads->tcprecv,want)) { r= ENOMEM; goto xit; }
       assert(ads->tcprecv.used <= ads->tcprecv.avail);
       if (ads->tcprecv.used == ads->tcprecv.avail) continue;
       r= read(ads->tcpsocket,
@@ -269,12 +273,12 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
        ads->tcprecv.used+= r;
       } else {
        if (r) {
-         if (errno==EAGAIN || errno==EWOULDBLOCK) return 0;
+         if (errno==EAGAIN || errno==EWOULDBLOCK) { r= 0; goto xit; }
          if (errno==EINTR) continue;
-         if (errno_resources(errno)) return errno;
+         if (errno_resources(errno)) { r= errno; goto xit; }
        }
        adns__tcp_broken(ads,"read",r?strerror(errno):"closed");
-       return 0;
+       r= 0; goto xit;
       }
     } /* never reached */
   default:
@@ -286,11 +290,11 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
       r= recvfrom(ads->udpsocket,udpbuf,sizeof(udpbuf),0,
                  (struct sockaddr*)&udpaddr,&udpaddrlen);
       if (r<0) {
-       if (errno == EAGAIN || errno == EWOULDBLOCK) return 0;
+       if (errno == EAGAIN || errno == EWOULDBLOCK) { r= 0; goto xit; }
        if (errno == EINTR) continue;
-       if (errno_resources(errno)) return errno;
+       if (errno_resources(errno)) { r= errno; goto xit; }
        adns__warn(ads,-1,0,"datagram receive error: %s",strerror(errno));
-       return 0;
+       r= 0; goto xit;
       }
       if (udpaddrlen != sizeof(udpaddr)) {
        adns__diag(ads,-1,0,"datagram received with wrong address length %d"
@@ -316,15 +320,20 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
                   inet_ntoa(udpaddr.sin_addr));
        continue;
       }
-      adns__procdgram(ads,udpbuf,r,serv,*now);
+      adns__procdgram(ads,udpbuf,r,serv,0,*now);
     }
   }
-  return 0;
+  r= 0;
+xit:
+  adns__consistency(ads,0,cc_entex);
+  return r;
 }
 
 int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
   int r;
   
+  adns__consistency(ads,0,cc_entex);
+
   switch (ads->tcpstate) {
   case server_disconnected:
     break;
@@ -332,20 +341,20 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
     if (fd != ads->tcpsocket) break;
     assert(ads->tcprecv.used==0);
     for (;;) {
-      if (!adns__vbuf_ensure(&ads->tcprecv,1)) return ENOMEM;
+      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))) {
        tcp_connected(ads,*now);
-       return 0;
+       r= 0; goto xit;
       }
       if (r>0) {
        adns__tcp_broken(ads,"connect/read","sent data before first request");
-       return 0;
+       r= 0; goto xit;
       }
       if (errno==EINTR) continue;
-      if (errno_resources(errno)) return errno;
+      if (errno_resources(errno)) { r= errno; goto xit; }
       adns__tcp_broken(ads,"connect/read",strerror(errno));
-      return 0;
+      r= 0; goto xit;
     } /* not reached */
   case server_ok:
     if (!(ads->tcpsend.used && fd == ads->tcpsocket)) break;
@@ -355,10 +364,10 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
       adns__sigpipe_unprotect(ads);
       if (r<0) {
        if (errno==EINTR) continue;
-       if (errno==EAGAIN || errno==EWOULDBLOCK) return 0;
-       if (errno_resources(errno)) return errno;
+       if (errno==EAGAIN || errno==EWOULDBLOCK) { r= 0; goto xit; }
+       if (errno_resources(errno)) { r= errno; goto xit; }
        adns__tcp_broken(ads,"write",strerror(errno));
-       return 0;
+       r= 0; goto xit;
       } else if (r>0) {
        ads->tcpsend.used -= r;
        memmove(ads->tcpsend.buf,ads->tcpsend.buf+r,ads->tcpsend.used);
@@ -367,10 +376,14 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
   default:
     abort();
   }
-  return 0;
+  r= 0;
+xit:
+  adns__consistency(ads,0,cc_entex);
+  return r;
 }
   
 int adns_processexceptional(adns_state ads, int fd, const struct timeval *now) {
+  adns__consistency(ads,0,cc_entex);
   switch (ads->tcpstate) {
   case server_disconnected:
     break;
@@ -378,10 +391,11 @@ int adns_processexceptional(adns_state ads, int fd, const struct timeval *now) {
   case server_ok:
     if (fd != ads->tcpsocket) break;
     adns__tcp_broken(ads,"poll/select","exceptional condition detected");
-    return 0;
+    break;
   default:
     abort();
   }
+  adns__consistency(ads,0,cc_entex);
   return 0;
 }
 
@@ -432,10 +446,12 @@ 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);
+
   if (tv_mod && (!*tv_mod || (*tv_mod)->tv_sec || (*tv_mod)->tv_usec)) {
     /* The caller is planning to sleep. */
     adns__must_gettimeofday(ads,&now,&tv_nowbuf);
-    if (!now) return;
+    if (!now) goto xit;
     adns__timeouts(ads, 1, tv_mod,tv_tobuf, *now);
   }
 
@@ -449,26 +465,38 @@ void adns_beforeselect(adns_state ads, int *maxfd_io, fd_set *readfds_io,
     if (pollfds[i].events & POLLPRI) FD_SET(fd,exceptfds_io);
   }
   *maxfd_io= maxfd;
+
+xit:
+  adns__consistency(ads,0,cc_entex);
 }
 
 void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds,
                      const fd_set *writefds, const fd_set *exceptfds,
                      const struct timeval *now) {
+  struct timeval tv_buf;
   struct pollfd pollfds[MAX_POLLFDS];
-  int npollfds;
+  int npollfds, i;
 
+  adns__consistency(ads,0,cc_entex);
+  adns__must_gettimeofday(ads,&now,&tv_buf);
+  if (!now) goto xit;
   adns_processtimeouts(ads,now);
 
   npollfds= adns__pollfds(ads,pollfds);
+  for (i=0; i<npollfds; i++) pollfds[i].revents= POLLIN|POLLOUT|POLLPRI;
   adns__fdevents(ads,
                 pollfds,npollfds,
                 maxfd,readfds,writefds,exceptfds,
                 *now, 0);
+xit:
+  adns__consistency(ads,0,cc_entex);
 }
 
 /* General helpful functions. */
 
 void adns_globalsystemfailure(adns_state ads) {
+  adns__consistency(ads,0,cc_entex);
+
   while (ads->timew.head) {
     adns__query_fail(ads->timew.head, adns_s_systemfail);
   }
@@ -483,6 +511,7 @@ void adns_globalsystemfailure(adns_state ads) {
   default:
     abort();
   }
+  adns__consistency(ads,0,cc_entex);
 }
 
 int adns_processany(adns_state ads) {
@@ -491,6 +520,8 @@ int adns_processany(adns_state ads) {
   struct pollfd pollfds[MAX_POLLFDS];
   int npollfds;
 
+  adns__consistency(ads,0,cc_entex);
+
   r= gettimeofday(&now,0);
   if (!r) adns_processtimeouts(ads,&now);
 
@@ -499,6 +530,8 @@ int adns_processany(adns_state ads) {
                 pollfds,npollfds,
                 0,0,0,0,
                 now,&r);
+
+  adns__consistency(ads,0,cc_entex);
   return r;
 }
 
@@ -523,6 +556,7 @@ static int internal_check(adns_state ads,
   LIST_UNLINK(ads->output,qu);
   *answer= qu->answer;
   if (context_r) *context_r= qu->ctx.ext;
+  *query_io= qu;
   free(qu);
   return 0;
 }
@@ -535,16 +569,17 @@ int adns_wait(adns_state ads,
   fd_set readfds, writefds, exceptfds;
   struct timeval tvbuf, *tvp;
   
+  adns__consistency(ads,*query_io,cc_entex);
   for (;;) {
     r= internal_check(ads,query_io,answer_r,context_r);
-    if (r != EWOULDBLOCK) return r;
+    if (r != EWOULDBLOCK) break;
     maxfd= 0; tvp= 0;
     FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
     adns_beforeselect(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf,0);
     rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp);
     if (rsel==-1) {
       if (errno == EINTR) {
-       if (ads->iflags & adns_if_eintr) return EINTR;
+       if (ads->iflags & adns_if_eintr) { r= EINTR; break; }
       } else {
        adns__diag(ads,-1,0,"select failed in wait: %s",strerror(errno));
        adns_globalsystemfailure(ads);
@@ -554,6 +589,8 @@ int adns_wait(adns_state ads,
       adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,0);
     }
   }
+  adns__consistency(ads,0,cc_entex);
+  return r;
 }
 
 int adns_check(adns_state ads,
@@ -563,8 +600,11 @@ int adns_check(adns_state ads,
   struct timeval now;
   int r;
   
+  adns__consistency(ads,*query_io,cc_entex);
   r= gettimeofday(&now,0);
   if (!r) adns__autosys(ads,now);
-  
-  return internal_check(ads,query_io,answer_r,context_r);
+
+  r= internal_check(ads,query_io,answer_r,context_r);
+  adns__consistency(ads,0,cc_entex);
+  return r;
 }