X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fevent.c;h=684759a727f2cfa5c2e390978950ec49f6b7ac21;hb=73eb26037c46bebeaa30ba38eba887216f0e9a6e;hp=9384085256eb392baf017ee1678001700d8c4b76;hpb=4ae90a83213075b16de83520a2c07402491bb33f;p=adns.git diff --git a/src/event.c b/src/event.c index 9384085..684759a 100644 --- a/src/event.c +++ b/src/event.c @@ -6,10 +6,10 @@ */ /* * This file is - * Copyright (C) 1997-1999 Ian Jackson + * Copyright (C) 1997-2000 Ian Jackson * * It is part of adns, which is - * Copyright (C) 1997-1999 Ian Jackson + * Copyright (C) 1997-2000 Ian Jackson * Copyright (C) 1999 Tony Finch * * This program is free software; you can redistribute it and/or modify @@ -39,40 +39,36 @@ #include #include "internal.h" +#include "tvarith.h" /* TCP connection management. */ -void adns__tcp_closenext(adns_state ads) { +static void tcp_close(adns_state ads) { int serv; serv= ads->tcpserver; close(ads->tcpsocket); ads->tcpsocket= -1; - ads->tcpstate= server_disconnected; ads->tcprecv.used= ads->tcprecv_skip= ads->tcpsend.used= 0; - ads->tcpserver= (serv+1)%ads->nservers; } void adns__tcp_broken(adns_state ads, const char *what, const char *why) { int serv; - adns_query qu, nqu; + adns_query qu; assert(ads->tcpstate == server_connecting || ads->tcpstate == server_ok); serv= ads->tcpserver; - adns__warn(ads,serv,0,"TCP connection lost: %s: %s",what,why); - adns__tcp_closenext(ads); - - for (qu= ads->timew.head; qu; qu= nqu) { - nqu= qu->next; - if (qu->state == query_tosend) continue; - assert(qu->state == query_tcpwait || qu->state == query_tcpsent); - qu->state= query_tcpwait; - qu->tcpfailed |= (1<tcpfailed == (1<nservers)-1) { - LIST_UNLINK(ads->timew,qu); - adns__query_fail(qu,adns_s_allservfail); - } + if (what) adns__warn(ads,serv,0,"TCP connection failed: %s: %s",what,why); + + if (ads->tcpstate == server_connecting) { + /* Counts as a retry for all the queries waiting for TCP. */ + for (qu= ads->tcpw.head; qu; qu= qu->next) + qu->retries++; } + + tcp_close(ads); + ads->tcpstate= server_broken; + ads->tcpserver= (serv+1)%ads->nservers; } static void tcp_connected(adns_state ads, struct timeval now) { @@ -80,11 +76,10 @@ static void tcp_connected(adns_state ads, struct timeval now) { adns__debug(ads,ads->tcpserver,0,"TCP connected"); ads->tcpstate= server_ok; - for (qu= ads->timew.head; qu; qu= nqu) { + for (qu= ads->tcpw.head; qu && ads->tcpstate == server_ok; qu= nqu) { nqu= qu->next; - if (qu->state == query_tosend) continue; - assert (qu->state == query_tcpwait); - adns__query_tcp(qu,now); + assert(qu->state == query_tcpw); + adns__querysend_tcp(qu,now); } } @@ -94,8 +89,17 @@ void adns__tcp_tryconnect(adns_state ads, struct timeval now) { struct protoent *proto; for (tries=0; triesnservers; tries++) { - if (ads->tcpstate == server_connecting || ads->tcpstate == server_ok) return; - assert(ads->tcpstate == server_disconnected); + switch (ads->tcpstate) { + case server_connecting: + case server_ok: + case server_broken: + return; + case server_disconnected: + break; + default: + abort(); + } + assert(!ads->tcpsend.used); assert(!ads->tcprecv.used); assert(!ads->tcprecv_skip); @@ -120,9 +124,14 @@ void adns__tcp_tryconnect(adns_state ads, struct timeval now) { r= connect(fd,(const struct sockaddr*)&addr,sizeof(addr)); ads->tcpsocket= fd; ads->tcpstate= server_connecting; - if (r==0) { tcp_connected(ads,now); continue; } - if (errno == EWOULDBLOCK || errno == EINPROGRESS) return; + if (r==0) { tcp_connected(ads,now); return; } + if (errno == EWOULDBLOCK || errno == EINPROGRESS) { + ads->tcptimeout= now; + timevaladd(&ads->tcptimeout,TCPCONNMS); + return; + } adns__tcp_broken(ads,"connect",strerror(errno)); + ads->tcpstate= server_disconnected; } } @@ -141,6 +150,17 @@ void adns__must_gettimeofday(adns_state ads, const struct timeval **now_io, return; } +static void inter_immed(struct timeval **tv_io, struct timeval *tvbuf) { + struct timeval *rbuf; + + if (!tv_io) return; + + rbuf= *tv_io; + if (!rbuf) { *tv_io= rbuf= tvbuf; } + + timerclear(rbuf); +} + static void inter_maxto(struct timeval **tv_io, struct timeval *tvbuf, struct timeval maxto) { struct timeval *rbuf; @@ -158,6 +178,7 @@ static void inter_maxto(struct timeval **tv_io, struct timeval *tvbuf, static void inter_maxtoabs(struct timeval **tv_io, struct timeval *tvbuf, struct timeval now, struct timeval maxtime) { + /* tv_io may be 0 */ ldiv_t dr; /*fprintf(stderr,"inter_maxtoabs now=%ld.%06ld maxtime=%ld.%06ld\n", @@ -172,28 +193,91 @@ static void inter_maxtoabs(struct timeval **tv_io, struct timeval *tvbuf, inter_maxto(tv_io,tvbuf,maxtime); } -void adns__timeouts(adns_state ads, int act, - struct timeval **tv_io, struct timeval *tvbuf, - struct timeval now) { +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; - - for (qu= ads->timew.head; qu; qu= nqu) { + + for (qu= queue->head; qu; qu= nqu) { nqu= qu->next; 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 (!act) { inter_immed(tv_io,tvbuf); return; } + LIST_UNLINK(*queue,qu); if (qu->state != query_tosend) { adns__query_fail(qu,adns_s_timeout); } else { adns__query_send(qu,now); } - nqu= ads->timew.head; + nqu= queue->head; } } -} +} + +static void tcp_events(adns_state ads, int act, + struct timeval **tv_io, struct timeval *tvbuf, + struct timeval now) { + adns_query qu, nqu; + + for (;;) { + switch (ads->tcpstate) { + case server_broken: + if (!act) { inter_immed(tv_io,tvbuf); return; } + for (qu= ads->tcpw.head; qu; qu= nqu) { + nqu= qu->next; + assert(qu->state == query_tcpw); + if (qu->retries > ads->nservers) { + LIST_UNLINK(ads->tcpw,qu); + adns__query_fail(qu,adns_s_allservfail); + } + } + ads->tcpstate= server_disconnected; + case server_disconnected: /* fall through */ + if (!ads->tcpw.head) return; + if (!act) { inter_immed(tv_io,tvbuf); return; } + adns__tcp_tryconnect(ads,now); + break; + case server_ok: + if (ads->tcpw.head) return; + if (!ads->tcptimeout.tv_sec) { + assert(!ads->tcptimeout.tv_usec); + ads->tcptimeout= now; + timevaladd(&ads->tcptimeout,TCPIDLEMS); + } + case server_connecting: /* fall through */ + if (!act || !timercmp(&now,&ads->tcptimeout,>)) { + inter_maxtoabs(tv_io,tvbuf,now,ads->tcptimeout); + return; + } { + /* TCP timeout has happened */ + switch (ads->tcpstate) { + case server_connecting: /* failed to connect */ + adns__tcp_broken(ads,"unable to make connection","timed out"); + break; + case server_ok: /* idle timeout */ + tcp_close(ads); + ads->tcpstate= server_disconnected; + return; + default: + abort(); + } + } + break; + default: + abort(); + } + } + return; +} + +void adns__timeouts(adns_state ads, int act, + struct timeval **tv_io, struct timeval *tvbuf, + struct timeval now) { + timeouts_queue(ads,act,tv_io,tvbuf,now, &ads->udpw); + timeouts_queue(ads,act,tv_io,tvbuf,now, &ads->tcpw); + tcp_events(ads,act,tv_io,tvbuf,now); +} void adns_firsttimeout(adns_state ads, struct timeval **tv_io, struct timeval *tvbuf, @@ -227,6 +311,7 @@ int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS]) { switch (ads->tcpstate) { case server_disconnected: + case server_broken: return 1; case server_connecting: pollfds_buf[1].events= POLLOUT; @@ -250,12 +335,13 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) { switch (ads->tcpstate) { case server_disconnected: + case server_broken: case server_connecting: break; case server_ok: if (fd != ads->tcpsocket) break; assert(!ads->tcprecv_skip); - for (;;) { + do { if (ads->tcprecv.used >= ads->tcprecv_skip+2) { dgramlen= ((ads->tcprecv.buf[ads->tcprecv_skip]<<8) | ads->tcprecv.buf[ads->tcprecv_skip+1]); @@ -289,9 +375,9 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) { if (errno_resources(errno)) { r= errno; goto xit; } } adns__tcp_broken(ads,"read",r?strerror(errno):"closed"); - r= 0; goto xit; } - } /* never reached */ + } while (ads->tcpstate == server_ok); + r= 0; goto xit; default: abort(); } @@ -309,7 +395,8 @@ int adns_processreadable(adns_state ads, int fd, const struct timeval *now) { } if (udpaddrlen != sizeof(udpaddr)) { adns__diag(ads,-1,0,"datagram received with wrong address length %d" - " (expected %d)", udpaddrlen,sizeof(udpaddr)); + " (expected %lu)", udpaddrlen, + (unsigned long)sizeof(udpaddr)); continue; } if (udpaddr.sin_family != AF_INET) { @@ -347,6 +434,7 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { switch (ads->tcpstate) { case server_disconnected: + case server_broken: break; case server_connecting: if (fd != ads->tcpsocket) break; @@ -369,8 +457,8 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { r= 0; goto xit; } /* not reached */ case server_ok: - if (!(ads->tcpsend.used && fd == ads->tcpsocket)) break; - for (;;) { + if (fd != ads->tcpsocket) break; + while (ads->tcpsend.used) { adns__sigpipe_protect(ads); r= write(ads->tcpsocket,ads->tcpsend.buf,ads->tcpsend.used); adns__sigpipe_unprotect(ads); @@ -384,7 +472,9 @@ int adns_processwriteable(adns_state ads, int fd, const struct timeval *now) { ads->tcpsend.used -= r; memmove(ads->tcpsend.buf,ads->tcpsend.buf+r,ads->tcpsend.used); } - } /* not reached */ + } + r= 0; + goto xit; default: abort(); } @@ -398,6 +488,7 @@ int adns_processexceptional(adns_state ads, int fd, const struct timeval *now) { adns__consistency(ads,0,cc_entex); switch (ads->tcpstate) { case server_disconnected: + case server_broken: break; case server_connecting: case server_ok: @@ -463,8 +554,8 @@ void adns_beforeselect(adns_state ads, int *maxfd_io, fd_set *readfds_io, 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) goto xit; - adns__timeouts(ads, 1, tv_mod,tv_tobuf, *now); + if (!now) { inter_immed(tv_mod,tv_tobuf); goto xit; } + adns__timeouts(ads, 0, tv_mod,tv_tobuf, *now); } npollfds= adns__pollfds(ads,pollfds); @@ -509,16 +600,16 @@ xit: 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); - } + 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); switch (ads->tcpstate) { case server_connecting: case server_ok: - adns__tcp_closenext(ads); + adns__tcp_broken(ads,0,0); break; case server_disconnected: + case server_broken: break; default: abort(); @@ -542,7 +633,7 @@ int adns_processany(adns_state ads) { * likely just to want to do a read on one or two fds anyway. */ npollfds= adns__pollfds(ads,pollfds); - for (i=0; ioutput.head) { qu= ads->output.head; - } else if (ads->timew.head) { + } else if (ads->udpw.head || ads->tcpw.head) { return EAGAIN; } else { return ESRCH; @@ -598,6 +689,7 @@ int adns_wait(adns_state ads, maxfd= 0; tvp= 0; FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); adns_beforeselect(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf,0); + assert(tvp); rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp); if (rsel==-1) { if (errno == EINTR) {