New internal consistency checking with assert if right options set.

[adns] / src / event.c

diff --git a/src/event.c b/src/event.c
index 5bdda8f6dd3cc0c3f3846f1f6258d95569d3b661..f84204d9c2c1b80b42e8044f4413bc7f49c1aaed 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -191,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) {
 void adns_firsttimeout(adns_state ads,
                       struct timeval **tv_io, struct timeval *tvbuf,
                       struct timeval now) {

+  adns__consistency(ads,cc_entex);

   adns__timeouts(ads, 0, tv_io,tvbuf, now);
   adns__timeouts(ads, 0, tv_io,tvbuf, now);

+  adns__consistency(ads,cc_entex);

 }
 
 void adns_processtimeouts(adns_state ads, const struct timeval *now) {
   struct timeval tv_buf;
 
 }
 
 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,cc_entex);
+  adns__must_gettimeofday(ads,&now,&tv_buf);
+  if (now) adns__timeouts(ads, 1, 0,0, *now);
+  adns__consistency(ads,cc_entex);

 }
 
 /* fd handling functions.  These are the top-level of the real work of
 }
 
 /* fd handling functions.  These are the top-level of the real work of


@@ -235,6 +239,8 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
   byte udpbuf[DNS_MAXUDP];
   struct sockaddr_in udpaddr;
   
   byte udpbuf[DNS_MAXUDP];
   struct sockaddr_in udpaddr;
   

+  adns__consistency(ads,cc_entex);
+

   switch (ads->tcpstate) {
   case server_disconnected:
   case server_connecting:
   switch (ads->tcpstate) {
   case server_disconnected:
   case server_connecting:


@@ -257,7 +263,7 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
       ads->tcprecv.used -= skip;
       memmove(ads->tcprecv.buf,ads->tcprecv.buf+skip,ads->tcprecv.used);
       skip= 0;
       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,
       assert(ads->tcprecv.used <= ads->tcprecv.avail);
       if (ads->tcprecv.used == ads->tcprecv.avail) continue;
       r= read(ads->tcpsocket,


@@ -267,12 +273,12 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
        ads->tcprecv.used+= r;
       } else {
        if (r) {
        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==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");
        }
        adns__tcp_broken(ads,"read",r?strerror(errno):"closed");

-       return 0;
+       r= 0; goto xit;

       }
     } /* never reached */
   default:
       }
     } /* never reached */
   default:


@@ -284,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) {
       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 == 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));
        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"
       }
       if (udpaddrlen != sizeof(udpaddr)) {
        adns__diag(ads,-1,0,"datagram received with wrong address length %d"


@@ -317,12 +323,17 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) {
       adns__procdgram(ads,udpbuf,r,serv,0,*now);
     }
   }
       adns__procdgram(ads,udpbuf,r,serv,0,*now);
     }
   }

-  return 0;
+  r= 0;
+xit:
+  adns__consistency(ads,cc_entex);
+  return r;

 }
 
 int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
   int r;
   
 }
 
 int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
   int r;
   

+  adns__consistency(ads,cc_entex);
+

   switch (ads->tcpstate) {
   case server_disconnected:
     break;
   switch (ads->tcpstate) {
   case server_disconnected:
     break;


@@ -330,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 (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);
       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");
       }
       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==EINTR) continue;

-      if (errno_resources(errno)) return errno;
+      if (errno_resources(errno)) { r= errno; goto xit; }

       adns__tcp_broken(ads,"connect/read",strerror(errno));
       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;
     } /* not reached */
   case server_ok:
     if (!(ads->tcpsend.used && fd == ads->tcpsocket)) break;


@@ -353,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;
       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));
        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);
       } else if (r>0) {
        ads->tcpsend.used -= r;
        memmove(ads->tcpsend.buf,ads->tcpsend.buf+r,ads->tcpsend.used);


@@ -365,10 +376,14 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) {
   default:
     abort();
   }
   default:
     abort();
   }

-  return 0;
+  r= 0;
+xit:
+  adns__consistency(ads,cc_entex);
+  return r;

 }
   
 int adns_processexceptional(adns_state ads, int fd, const struct timeval *now) {
 }
   
 int adns_processexceptional(adns_state ads, int fd, const struct timeval *now) {

+  adns__consistency(ads,cc_entex);

   switch (ads->tcpstate) {
   case server_disconnected:
     break;
   switch (ads->tcpstate) {
   case server_disconnected:
     break;


@@ -376,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");
   case server_ok:
     if (fd != ads->tcpsocket) break;
     adns__tcp_broken(ads,"poll/select","exceptional condition detected");

-    return 0;
+    break;

   default:
     abort();
   }
   default:
     abort();
   }

+  adns__consistency(ads,cc_entex);

   return 0;
 }
 
   return 0;
 }
 


@@ -430,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;
   
   struct pollfd pollfds[MAX_POLLFDS];
   int i, fd, maxfd, npollfds;
   

+  adns__consistency(ads,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 (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);
   }
 
     adns__timeouts(ads, 1, tv_mod,tv_tobuf, *now);
   }
 


@@ -447,6 +465,9 @@ 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;
     if (pollfds[i].events & POLLPRI) FD_SET(fd,exceptfds_io);
   }
   *maxfd_io= maxfd;

+
+xit:
+  adns__consistency(ads,cc_entex);

 }
 
 void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds,
 }
 
 void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds,


@@ -456,8 +477,9 @@ void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds,
   struct pollfd pollfds[MAX_POLLFDS];
   int npollfds, i;
 
   struct pollfd pollfds[MAX_POLLFDS];
   int npollfds, i;
 

+  adns__consistency(ads,cc_entex);

   adns__must_gettimeofday(ads,&now,&tv_buf);
   adns__must_gettimeofday(ads,&now,&tv_buf);

-  if (!now) return;
+  if (!now) goto xit;

   adns_processtimeouts(ads,now);
 
   npollfds= adns__pollfds(ads,pollfds);
   adns_processtimeouts(ads,now);
 
   npollfds= adns__pollfds(ads,pollfds);


@@ -466,11 +488,15 @@ void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds,
                 pollfds,npollfds,
                 maxfd,readfds,writefds,exceptfds,
                 *now, 0);
                 pollfds,npollfds,
                 maxfd,readfds,writefds,exceptfds,
                 *now, 0);

+xit:
+  adns__consistency(ads,cc_entex);

 }
 
 /* General helpful functions. */
 
 void adns_globalsystemfailure(adns_state ads) {
 }
 
 /* General helpful functions. */
 
 void adns_globalsystemfailure(adns_state ads) {

+  adns__consistency(ads,cc_entex);
+

   while (ads->timew.head) {
     adns__query_fail(ads->timew.head, adns_s_systemfail);
   }
   while (ads->timew.head) {
     adns__query_fail(ads->timew.head, adns_s_systemfail);
   }


@@ -485,6 +511,7 @@ void adns_globalsystemfailure(adns_state ads) {
   default:
     abort();
   }
   default:
     abort();
   }

+  adns__consistency(ads,cc_entex);

 }
 
 int adns_processany(adns_state ads) {
 }
 
 int adns_processany(adns_state ads) {


@@ -493,6 +520,8 @@ int adns_processany(adns_state ads) {
   struct pollfd pollfds[MAX_POLLFDS];
   int npollfds;
 
   struct pollfd pollfds[MAX_POLLFDS];
   int npollfds;
 

+  adns__consistency(ads,cc_entex);
+

   r= gettimeofday(&now,0);
   if (!r) adns_processtimeouts(ads,&now);
 
   r= gettimeofday(&now,0);
   if (!r) adns_processtimeouts(ads,&now);
 


@@ -501,6 +530,8 @@ int adns_processany(adns_state ads) {
                 pollfds,npollfds,
                 0,0,0,0,
                 now,&r);
                 pollfds,npollfds,
                 0,0,0,0,
                 now,&r);

+
+  adns__consistency(ads,cc_entex);

   return r;
 }
 
   return r;
 }
 


@@ -538,16 +569,17 @@ int adns_wait(adns_state ads,
   fd_set readfds, writefds, exceptfds;
   struct timeval tvbuf, *tvp;
   
   fd_set readfds, writefds, exceptfds;
   struct timeval tvbuf, *tvp;
   

+  adns__consistency(ads,cc_entex);

   for (;;) {
     r= internal_check(ads,query_io,answer_r,context_r);
   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) {
     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);
       } else {
        adns__diag(ads,-1,0,"select failed in wait: %s",strerror(errno));
        adns_globalsystemfailure(ads);


@@ -557,6 +589,8 @@ int adns_wait(adns_state ads,
       adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,0);
     }
   }
       adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,0);
     }
   }

+  adns__consistency(ads,cc_entex);
+  return r;

 }
 
 int adns_check(adns_state ads,
 }
 
 int adns_check(adns_state ads,


@@ -566,8 +600,11 @@ int adns_check(adns_state ads,
   struct timeval now;
   int r;
   
   struct timeval now;
   int r;
   

+  adns__consistency(ads,cc_entex);

   r= gettimeofday(&now,0);
   if (!r) adns__autosys(ads,now);
   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,cc_entex);
+  return r;

 }
 }