Author: Mark
Date: Sun Apr 3 04:28:29 2005
New Revision: 2430
Modified:
trunk/lib/adns/check.c
trunk/lib/adns/event.c
trunk/lib/adnswin32/event.c
Log:
complete merge of adns and adnswin32
Modified: trunk/lib/adns/check.c
==============================================================================
--- trunk/lib/adns/check.c (original)
+++ trunk/lib/adns/check.c Sun Apr 3 04:28:29 2005
@@ -36,6 +36,8 @@
adns__consistency(ads, qu, cc_user);
}
+/* The original macro. Too gnuish for other compilers */
+#if 0
#define DLIST_CHECK(list, nodevar, part, body) \
if ((list).head) { \
assert(! (list).head->part back); \
@@ -46,6 +48,29 @@
body \
} \
}
+#endif /* 0 */
+
+#define DLIST_CHECK1(list, nodevar, body) \
+ if ((list).head) { \
+ assert(! (list).head->back); \
+ for ((nodevar)= (list).head; (nodevar); (nodevar)= (nodevar)->next) { \
+ assert((nodevar)->next \
+ ? (nodevar) == (nodevar)->next->back \
+ : (nodevar) == (list).tail); \
+ body \
+ } \
+ }
+
+#define DLIST_CHECK2(list, nodevar, part, body) \
+ if ((list).head) { \
+ assert(! (list).head->part.back); \
+ for ((nodevar)= (list).head; (nodevar); (nodevar)= (nodevar)->part.next) { \
+ assert((nodevar)->part.next \
+ ? (nodevar) == (nodevar)->part.next->part.back \
+ : (nodevar) == (list).tail); \
+ body \
+ } \
+ }
#define DLIST_ASSERTON(node, nodevar, list, part) \
do { \
@@ -60,7 +85,8 @@
{
allocnode *an;
- DLIST_CHECK(qu->allocations, an,, {
+
+ DLIST_CHECK1(qu->allocations, an, {
});
}
@@ -120,7 +146,7 @@
{
adns_query qu;
- DLIST_CHECK(ads->udpw, qu,, {
+ DLIST_CHECK1(ads->udpw, qu, {
assert(qu->state == query_tosend);
assert(qu->retries <= UDPMAXRETRIES);
assert(qu->udpsent);
@@ -134,7 +160,7 @@
{
adns_query qu;
- DLIST_CHECK(ads->tcpw, qu,, {
+ DLIST_CHECK1(ads->tcpw, qu, {
assert(qu->state == query_tcpw);
assert(!qu->children.head && !qu->children.tail);
assert(qu->retries <= ads->nservers + 1);
@@ -147,10 +173,10 @@
{
adns_query parent, child;
- DLIST_CHECK(ads->childw, parent,, {
+ DLIST_CHECK1(ads->childw, parent, {
assert(parent->state == query_childw);
assert(parent->children.head);
- DLIST_CHECK(parent->children, child, siblings., {
+ DLIST_CHECK2(parent->children, child, siblings, {
assert(child->parent == parent);
assert(child->state != query_done);
});
@@ -163,7 +189,7 @@
{
adns_query qu;
- DLIST_CHECK(ads->output, qu,, {
+ DLIST_CHECK1(ads->output, qu, {
assert(qu->state == query_done);
assert(!qu->children.head && !qu->children.tail);
assert(!qu->parent);
Modified: trunk/lib/adns/event.c
==============================================================================
--- trunk/lib/adns/event.c (original)
+++ trunk/lib/adns/event.c Sun Apr 3 04:28:29 2005
@@ -58,7 +58,7 @@
if (ads->fdfunc)
ads->fdfunc(ads->tcpsocket, -1);
- close(ads->tcpsocket);
+ adns_socket_close(ads->tcpsocket);
ads->tcpsocket = -1;
ads->tcprecv.used = ads->tcprecv_skip = ads->tcpsend.used = 0;
}
@@ -103,9 +103,9 @@
}
}
-void adns__tcp_tryconnect(adns_state ads, struct timeval now)
-{
- int r, fd, tries;
+void adns__tcp_tryconnect(adns_state ads, struct timeval now) {
+ int r, tries;
+ ADNS_SOCKET fd;
struct sockaddr_in addr;
struct protoent *proto;
@@ -126,12 +126,10 @@
assert(!ads->tcprecv_skip);
proto = getprotobyname("tcp");
- if (!proto) {
- adns__diag(ads, -1, 0,
- "unable to find protocol no. for TCP !");
- return;
- }
+ if (!proto) { adns__diag(ads,-1,0,"unable to find protocol no. for TCP !"); return; }
+ ADNS_CLEAR_ERRNO
fd = socket(AF_INET, SOCK_STREAM, proto->p_proto);
+ ADNS_CAPTURE_ERRNO;
if (fd < 0) {
adns__diag(ads, -1, 0,
"cannot create TCP socket: %s",
@@ -143,15 +141,16 @@
adns__diag(ads, -1, 0,
"cannot make TCP socket nonblocking: %s",
strerror(r));
- close(fd);
+ adns_socket_close(fd);
return;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(DNS_PORT);
addr.sin_addr = ads->servers[ads->tcpserver].addr;
- r = connect(fd, (const struct sockaddr *) &addr,
- sizeof(addr));
+ ADNS_CLEAR_ERRNO;
+ r= connect(fd,(const struct sockaddr*)&addr,sizeof(addr));
+ ADNS_CAPTURE_ERRNO;
ads->tcpsocket = fd;
ads->tcpstate = server_connecting;
if (r == 0) {
@@ -405,8 +404,7 @@
return 2;
}
-int adns_processreadable(adns_state ads, ADNS_SOCKET fd, const struct timeval *now)
-{
+int adns_processreadable(adns_state ads, ADNS_SOCKET fd, const struct timeval *now) {
int want, dgramlen, r, udpaddrlen, serv, old_skip;
byte udpbuf[DNS_MAXUDP];
struct sockaddr_in udpaddr;
@@ -457,9 +455,10 @@
assert(ads->tcprecv.used <= ads->tcprecv.avail);
if (ads->tcprecv.used == ads->tcprecv.avail)
continue;
- r = read(ads->tcpsocket,
+ r = adns_socket_read(ads->tcpsocket,
ads->tcprecv.buf + ads->tcprecv.used,
ads->tcprecv.avail - ads->tcprecv.used);
+ ADNS_CAPTURE_ERRNO;
if (r > 0) {
ads->tcprecv.used += r;
} else {
@@ -489,10 +488,10 @@
if (fd == ads->udpsocket) {
for (;;) {
udpaddrlen = sizeof(udpaddr);
- r = recvfrom(ads->udpsocket, udpbuf,
- sizeof(udpbuf), 0,
- (struct sockaddr *) &udpaddr,
- &udpaddrlen);
+ ADNS_CLEAR_ERRNO;
+ r= recvfrom(ads->udpsocket,udpbuf,sizeof(udpbuf),0,
+ (struct sockaddr*)&udpaddr,&udpaddrlen);
+ ADNS_CAPTURE_ERRNO;
if (r < 0) {
if (errno == EAGAIN
|| errno == EWOULDBLOCK) {
@@ -569,15 +568,11 @@
assert(ads->tcprecv.used == 0);
assert(ads->tcprecv_skip == 0);
for (;;) {
- 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))) {
+ if (!adns__vbuf_ensure(&ads->tcprecv,1)) { r= ENOMEM; goto xit; }
+ ADNS_CLEAR_ERRNO;
+ r = adns_socket_read(ads->tcpsocket, &ads->tcprecv.buf, 1);
+ ADNS_CAPTURE_ERRNO;
+ if (r==0 || (r<0 && (errno==EAGAIN || errno==EWOULDBLOCK))) {
tcp_connected(ads, *now);
r = 0;
goto xit;
@@ -604,8 +599,9 @@
break;
while (ads->tcpsend.used) {
adns__sigpipe_protect(ads);
- r = write(ads->tcpsocket, ads->tcpsend.buf,
- ads->tcpsend.used);
+ ADNS_CLEAR_ERRNO;
+ r= adns_socket_write(ads->tcpsocket,ads->tcpsend.buf,ads->tcpsend.used);
+ ADNS_CAPTURE_ERRNO;
adns__sigpipe_unprotect(ads);
if (r < 0) {
if (errno == EINTR)
@@ -663,13 +659,11 @@
return 0;
}
-static void fd_event(adns_state ads, int fd,
+static void fd_event(adns_state ads, ADNS_SOCKET fd,
int revent, int pollflag,
int maxfd, const fd_set * fds,
- int (*func) (adns_state, int fd,
- const struct timeval * now),
- struct timeval now, int *r_r)
-{
+ int (*func)(adns_state, ADNS_SOCKET fd, const struct timeval *now),
+ struct timeval now, int *r_r) {
int r;
if (!(revent & pollflag))
@@ -693,9 +687,9 @@
const struct pollfd *pollfds, int npollfds,
int maxfd, const fd_set * readfds,
const fd_set * writefds, const fd_set * exceptfds,
- struct timeval now, int *r_r)
-{
- int i, fd, revents;
+ struct timeval now, int *r_r) {
+ int i, revents;
+ ADNS_SOCKET fd;
for (i = 0; i < npollfds; i++) {
fd = pollfds[i].fd;
@@ -720,7 +714,8 @@
{
struct timeval tv_nowbuf;
struct pollfd pollfds[MAX_POLLFDS];
- int i, fd, maxfd, npollfds;
+ int i, maxfd, npollfds;
+ ADNS_SOCKET fd;
adns__consistency(ads, 0, cc_entex);
@@ -743,14 +738,10 @@
maxfd = *maxfd_io;
for (i = 0; i < npollfds; i++) {
fd = pollfds[i].fd;
- if (fd >= maxfd)
- maxfd = fd + 1;
- if (pollfds[i].events & POLLIN)
- FD_SET(fd, readfds_io);
- if (pollfds[i].events & POLLOUT)
- FD_SET(fd, writefds_io);
- if (pollfds[i].events & POLLPRI)
- FD_SET(fd, exceptfds_io);
+ if ((int)fd >= maxfd) maxfd= fd+1;
+ if (pollfds[i].events & POLLIN) FD_SET(fd,readfds_io);
+ if (pollfds[i].events & POLLOUT) FD_SET(fd,writefds_io);
+ if (pollfds[i].events & POLLPRI) FD_SET(fd,exceptfds_io);
}
*maxfd_io = maxfd;
#if 0
@@ -823,7 +814,7 @@
/* We just use adns__fdevents to loop over the fd's trying them.
* This seems more sensible than calling select, since we're most
- * likely just to want to do a read on one or two fds anyway.
+ * likely just to want to do a adns_socket_read on one or two fds anyway.
*/
npollfds = adns__pollfds(ads, pollfds);
for (i = 0; i < npollfds; i++)
@@ -865,7 +856,7 @@
if (context_r)
*context_r = qu->ctx.ext;
*query_io = qu;
- free(qu);
+ adns_free(qu);
return 0;
}
@@ -891,7 +882,9 @@
adns_beforeselect(ads, &maxfd, &readfds, &writefds,
&exceptfds, &tvp, &tvbuf, 0);
assert(tvp);
+ ADNS_CLEAR_ERRNO;
rsel = select(maxfd, &readfds, &writefds, &exceptfds, tvp);
+ ADNS_CAPTURE_ERRNO;
if (rsel == -1) {
if (errno == EINTR) {
if (ads->iflags & adns_if_eintr) {
Modified: trunk/lib/adnswin32/event.c
==============================================================================
--- trunk/lib/adnswin32/event.c (original)
+++ trunk/lib/adnswin32/event.c Sun Apr 3 04:28:29 2005
@@ -53,36 +53,41 @@
int serv;
serv= ads->tcpserver;
+
+/* EVNT: Delsock */
+ if (ads->fdfunc)
+ ads->fdfunc(ads->tcpsocket, -1);
+
adns_socket_close(ads->tcpsocket);
ads->tcpsocket= -1;
ads->tcprecv.used= ads->tcprecv_skip= ads->tcpsend.used= 0;
}
-void adns__tcp_broken(adns_state ads, const char *what, const char *why) {
+void adns__tcp_broken(adns_state ads, const char *what, const char *why)
+{
int serv;
adns_query qu;
- assert(ads->tcpstate == server_connecting || ads->tcpstate == server_ok);
+ assert(ads->tcpstate == server_connecting
+ || ads->tcpstate == server_ok);
serv= ads->tcpserver;
- if (what) adns__warn(ads,serv,0,"TCP connection failed: %s: %s",what,why);
+ 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++;
}
-
-/* EVNT: Delsock */
- if (ads->fdfunc)
- ads->fdfunc(ads->tcpsocket, -1);
-
tcp_close(ads);
ads->tcpstate= server_broken;
ads->tcpserver= (serv+1)%ads->nservers;
}
-static void tcp_connected(adns_state ads, struct timeval now) {
+static void tcp_connected(adns_state ads, struct timeval now)
+{
adns_query qu, nqu;
adns__debug(ads,ads->tcpserver,0,"TCP connected");
@@ -90,7 +95,8 @@
/* EVNT Read */
if (ads->fdfunc)
ads->fdfunc(ads->tcpsocket, POLLIN);
- for (qu= ads->tcpw.head; qu && ads->tcpstate == server_ok; qu= nqu) {
+ for (qu = ads->tcpw.head; qu && ads->tcpstate == server_ok;
+ qu = nqu) {
nqu= qu->next;
assert(qu->state == query_tcpw);
adns__querysend_tcp(qu,now);
@@ -125,12 +131,16 @@
fd= socket(AF_INET,SOCK_STREAM,proto->p_proto);
ADNS_CAPTURE_ERRNO;
if (fd<0) {
- adns__diag(ads,-1,0,"cannot create TCP socket: %s",strerror(errno));
+ adns__diag(ads, -1, 0,
+ "cannot create TCP socket: %s",
+ strerror(errno));
return;
}
r= adns__setnonblock(ads,fd);
if (r) {
- adns__diag(ads,-1,0,"cannot make TCP socket nonblocking: %s",strerror(r));
+ adns__diag(ads, -1, 0,
+ "cannot make TCP socket nonblocking: %s",
+ strerror(r));
adns_socket_close(fd);
return;
}
@@ -143,13 +153,15 @@
ADNS_CAPTURE_ERRNO;
ads->tcpsocket= fd;
ads->tcpstate= server_connecting;
- if (r==0) { tcp_connected(ads,now); return; }
+ if (r == 0) {
+ tcp_connected(ads, now);
+ return;
+ }
if (errno == EWOULDBLOCK || errno == EINPROGRESS) {
ads->tcptimeout= now;
/* EVNT addsock write */
if (ads->fdfunc)
- ads->fdfunc(ads->tcpsocket, POLLOUT);
-
+ ads->fdfunc(ads->tcpsocket, POLLOUT);
timevaladd(&ads->tcptimeout,TCPCONNMS);
return;
}
@@ -161,64 +173,82 @@
/* Timeout handling functions. */
void adns__must_gettimeofday(adns_state ads, const struct timeval **now_io,
- struct timeval *tv_buf) {
+ struct timeval *tv_buf)
+{
const struct timeval *now;
int r;
now= *now_io;
- if (now) return;
- r= gettimeofday(tv_buf,0); if (!r) { *now_io= tv_buf; return; }
+ if (now)
+ return;
+ r = gettimeofday(tv_buf, 0);
+ if (!r) {
+ *now_io = tv_buf;
+ return;
+ }
adns__diag(ads,-1,0,"gettimeofday failed: %s",strerror(errno));
adns_globalsystemfailure(ads);
return;
}
-static void inter_immed(struct timeval **tv_io, struct timeval *tvbuf) {
+static void inter_immed(struct timeval **tv_io, struct timeval *tvbuf)
+{
struct timeval *rbuf;
- if (!tv_io) return;
+ if (!tv_io)
+ return;
rbuf= *tv_io;
- if (!rbuf) { *tv_io= rbuf= tvbuf; }
+ if (!rbuf) {
+ *tv_io = rbuf = tvbuf;
+ }
timerclear(rbuf);
}
static void inter_maxto(struct timeval **tv_io, struct timeval *tvbuf,
- struct timeval maxto) {
+ struct timeval maxto)
+{
struct timeval *rbuf;
- if (!tv_io) return;
+ if (!tv_io)
+ return;
rbuf= *tv_io;
if (!rbuf) {
- *tvbuf= maxto; *tv_io= tvbuf;
+ *tvbuf = maxto;
+ *tv_io = tvbuf;
} else {
- if (timercmp(rbuf,&maxto,>)) *rbuf= maxto;
+ if (timercmp(rbuf, &maxto, >))
+ *rbuf = maxto;
}
/*fprintf(stderr,"inter_maxto maxto=%ld.%06ld result=%ld.%06ld\n",
maxto.tv_sec,maxto.tv_usec,(**tv_io).tv_sec,(**tv_io).tv_usec);*/
}
static void inter_maxtoabs(struct timeval **tv_io, struct timeval *tvbuf,
- struct timeval now, struct timeval maxtime) {
+ 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",
now.tv_sec,now.tv_usec,maxtime.tv_sec,maxtime.tv_usec);*/
- if (!tv_io) return;
+ if (!tv_io)
+ return;
maxtime.tv_sec -= (now.tv_sec+2);
maxtime.tv_usec -= (now.tv_usec-2000000);
dr= ldiv(maxtime.tv_usec,1000000);
maxtime.tv_sec += dr.quot;
maxtime.tv_usec -= dr.quot*1000000;
- if (maxtime.tv_sec<0) timerclear(&maxtime);
+ if (maxtime.tv_sec < 0)
+ timerclear(&maxtime);
inter_maxto(tv_io,tvbuf,maxtime);
}
static void timeouts_queue(adns_state ads, int act,
struct timeval **tv_io, struct timeval *tvbuf,
- struct timeval now, struct query_queue *queue) {
+ struct timeval now, struct query_queue *queue)
+{
adns_query qu, nqu;
for (qu= queue->head; qu; qu= nqu) {
@@ -226,7 +256,10 @@
if (!timercmp(&now,&qu->timeout,>)) {
inter_maxtoabs(tv_io,tvbuf,now,qu->timeout);
} else {
- if (!act) { inter_immed(tv_io,tvbuf); return; }
+ if (!act) {
+ inter_immed(tv_io, tvbuf);
+ return;
+ }
LIST_UNLINK(*queue,qu);
if (qu->state != query_tosend) {
adns__query_fail(qu,adns_s_timeout);
@@ -240,29 +273,39 @@
static void tcp_events(adns_state ads, int act,
struct timeval **tv_io, struct timeval *tvbuf,
- struct timeval now) {
+ struct timeval now)
+{
adns_query qu, nqu;
for (;;) {
switch (ads->tcpstate) {
case server_broken:
- if (!act) { inter_immed(tv_io,tvbuf); return; }
+ 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);
+ 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; }
+ 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->tcpw.head)
+ return;
if (!ads->tcptimeout.tv_sec) {
assert(!ads->tcptimeout.tv_usec);
ads->tcptimeout= now;
@@ -270,17 +313,22 @@
}
case server_connecting: /* fall through */
if (!act || !timercmp(&now,&ads->tcptimeout,>)) {
- inter_maxtoabs(tv_io,tvbuf,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");
+ adns__tcp_broken(ads,
+ "unable to make connection",
+ "timed out");
break;
case server_ok: /* idle timeout */
tcp_close(ads);
- ads->tcpstate= server_disconnected;
+ ads->tcpstate =
+ server_disconnected;
return;
default:
abort();
@@ -296,7 +344,8 @@
void adns__timeouts(adns_state ads, int act,
struct timeval **tv_io, struct timeval *tvbuf,
- struct timeval now) {
+ 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);
@@ -304,18 +353,21 @@
void adns_firsttimeout(adns_state ads,
struct timeval **tv_io, struct timeval *tvbuf,
- struct timeval now) {
+ 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) {
+void adns_processtimeouts(adns_state ads, const struct timeval *now)
+{
struct timeval tv_buf;
adns__consistency(ads,0,cc_entex);
adns__must_gettimeofday(ads,&now,&tv_buf);
- if (now) adns__timeouts(ads, 1, 0,0, *now);
+ if (now)
+ adns__timeouts(ads, 1, 0, 0, *now);
adns__consistency(ads,0,cc_entex);
}
@@ -323,7 +375,8 @@
* reception and often transmission.
*/
-int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS]) {
+int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS])
+{
/* Returns the number of entries filled in. Always zeroes revents. */
assert(MAX_POLLFDS==2);
@@ -340,7 +393,9 @@
pollfds_buf[1].events= POLLOUT;
break;
case server_ok:
- pollfds_buf[1].events= ads->tcpsend.used ? POLLIN|POLLOUT|POLLPRI : POLLIN|POLLPRI;
+ pollfds_buf[1].events =
+ ads->tcpsend.
+ used ? POLLIN | POLLOUT | POLLPRI : POLLIN | POLLPRI;
break;
default:
abort();
@@ -362,17 +417,25 @@
case server_connecting:
break;
case server_ok:
- if (fd != ads->tcpsocket) break;
+ if (fd != ads->tcpsocket)
+ break;
assert(!ads->tcprecv_skip);
do {
if (ads->tcprecv.used >= ads->tcprecv_skip+2) {
- dgramlen= ((ads->tcprecv.buf[ads->tcprecv_skip]<<8) |
- ads->tcprecv.buf[ads->tcprecv_skip+1]);
- if (ads->tcprecv.used >= ads->tcprecv_skip+2+dgramlen) {
+ dgramlen =
+ ((ads->tcprecv.
+ buf[ads->tcprecv_skip] << 8) | ads->
+ tcprecv.buf[ads->tcprecv_skip + 1]);
+ if (ads->tcprecv.used >=
+ ads->tcprecv_skip + 2 + dgramlen) {
old_skip= ads->tcprecv_skip;
ads->tcprecv_skip += 2+dgramlen;
- adns__procdgram(ads, ads->tcprecv.buf+old_skip+2,
- dgramlen, ads->tcpserver, 1,*now);
+ adns__procdgram(ads,
+ ads->tcprecv.buf +
+ old_skip + 2,
+ dgramlen,
+ ads->tcpserver, 1,
+ *now);
continue;
} else {
want= 2+dgramlen;
@@ -381,12 +444,17 @@
want= 2;
}
ads->tcprecv.used -= ads->tcprecv_skip;
- memmove(ads->tcprecv.buf,ads->tcprecv.buf+ads->tcprecv_skip,ads->tcprecv.used);
+ memmove(ads->tcprecv.buf,
+ ads->tcprecv.buf + ads->tcprecv_skip,
+ ads->tcprecv.used);
ads->tcprecv_skip= 0;
- if (!adns__vbuf_ensure(&ads->tcprecv,want)) { r= ENOMEM; goto xit; }
+ 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;
- ADNS_CLEAR_ERRNO;
+ if (ads->tcprecv.used == ads->tcprecv.avail)
+ continue;
r= adns_socket_read(ads->tcpsocket,
ads->tcprecv.buf+ads->tcprecv.used,
ads->tcprecv.avail-ads->tcprecv.used);
@@ -395,14 +463,25 @@
ads->tcprecv.used+= r;
} else {
if (r) {
- if (errno==EAGAIN || errno==EWOULDBLOCK) { r= 0; goto xit; }
- if (errno==EINTR) continue;
- if (errno_resources(errno)) { r= errno; goto xit; }
+ if (errno == EAGAIN
+ || errno == EWOULDBLOCK) {
+ r = 0;
+ goto xit;
+ }
+ if (errno == EINTR)
+ continue;
+ if (errno_resources(errno)) {
+ r = errno;
+ goto xit;
+ }
}
- adns__tcp_broken(ads,"adns_socket_read",r?strerror(errno):"closed");
+ adns__tcp_broken(ads, "read",
+ r ? strerror(errno) :
+ "closed");
}
} while (ads->tcpstate == server_ok);
- r= 0; goto xit;
+ r = 0;
+ goto xit;
default:
abort();
}
@@ -414,34 +493,52 @@
(struct sockaddr*)&udpaddr,&udpaddrlen);
ADNS_CAPTURE_ERRNO;
if (r<0) {
- if (errno == EAGAIN || errno == EWOULDBLOCK) { r= 0; goto xit; }
- if (errno == EINTR) continue;
- if (errno_resources(errno)) { r= errno; goto xit; }
- adns__warn(ads,-1,0,"datagram receive error: %s",strerror(errno));
- r= 0; goto xit;
+ if (errno == EAGAIN
+ || errno == EWOULDBLOCK) {
+ r = 0;
+ goto xit;
+ }
+ if (errno == EINTR)
+ continue;
+ if (errno_resources(errno)) {
+ r = errno;
+ goto xit;
+ }
+ 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"
+ adns__diag(ads, -1, 0,
+ "datagram received with wrong address length %d"
" (expected %lu)", udpaddrlen,
- (unsigned long)sizeof(udpaddr));
+ (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);
+ 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);
+ 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 &&
- ads->servers[serv].addr.s_addr != udpaddr.sin_addr.s_addr;
- serv++);
+ ads->servers[serv].addr.s_addr !=
+ udpaddr.sin_addr.s_addr; serv++);
if (serv >= ads->nservers) {
- adns__warn(ads,-1,0,"datagram received from unknown nameserver %s",
+ adns__warn(ads, -1, 0,
+ "datagram received from unknown nameserver %s",
inet_ntoa(udpaddr.sin_addr));
continue;
}
@@ -454,7 +551,9 @@
return r;
}
-int adns_processwriteable(adns_state ads, ADNS_SOCKET fd, const struct timeval *now) {
+int adns_processwriteable(adns_state ads, ADNS_SOCKET fd,
+ const struct timeval *now)
+{
int r;
adns__consistency(ads,0,cc_entex);
@@ -464,7 +563,8 @@
case server_broken:
break;
case server_connecting:
- if (fd != ads->tcpsocket) break;
+ if (fd != ads->tcpsocket)
+ break;
assert(ads->tcprecv.used==0);
assert(ads->tcprecv_skip==0);
for (;;) {
@@ -474,19 +574,29 @@
ADNS_CAPTURE_ERRNO;
if (r==0 || (r<0 && (errno==EAGAIN || errno==EWOULDBLOCK))) {
tcp_connected(ads,*now);
- r= 0; goto xit;
+ r = 0;
+ goto xit;
}
if (r>0) {
- adns__tcp_broken(ads,"connect/adns_socket_read","sent data before first request");
- r= 0; goto xit;
- }
- if (errno==EINTR) continue;
- if (errno_resources(errno)) { r= errno; goto xit; }
- adns__tcp_broken(ads,"connect/adns_socket_read",strerror(errno));
- r= 0; goto xit;
+ adns__tcp_broken(ads, "connect/read",
+ "sent data before first request");
+ r = 0;
+ goto xit;
+ }
+ if (errno == EINTR)
+ continue;
+ if (errno_resources(errno)) {
+ r = errno;
+ goto xit;
+ }
+ adns__tcp_broken(ads, "connect/read",
+ strerror(errno));
+ r = 0;
+ goto xit;
} /* not reached */
case server_ok:
- if (fd != ads->tcpsocket) break;
+ if (fd != ads->tcpsocket)
+ break;
while (ads->tcpsend.used) {
adns__sigpipe_protect(ads);
ADNS_CLEAR_ERRNO;
@@ -494,14 +604,26 @@
ADNS_CAPTURE_ERRNO;
adns__sigpipe_unprotect(ads);
if (r<0) {
- if (errno==EINTR) continue;
- if (errno==EAGAIN || errno==EWOULDBLOCK) { r= 0; goto xit; }
- if (errno_resources(errno)) { r= errno; goto xit; }
- adns__tcp_broken(ads,"adns_socket_write",strerror(errno));
- r= 0; goto xit;
+ if (errno == EINTR)
+ continue;
+ if (errno == EAGAIN
+ || errno == EWOULDBLOCK) {
+ r = 0;
+ goto xit;
+ }
+ if (errno_resources(errno)) {
+ r = errno;
+ goto xit;
+ }
+ adns__tcp_broken(ads, "write",
+ strerror(errno));
+ r = 0;
+ goto xit;
} else if (r>0) {
ads->tcpsend.used -= r;
- memmove(ads->tcpsend.buf,ads->tcpsend.buf+r,ads->tcpsend.used);
+ memmove(ads->tcpsend.buf,
+ ads->tcpsend.buf + r,
+ ads->tcpsend.used);
}
}
r= 0;
@@ -515,7 +637,9 @@
return r;
}
-int adns_processexceptional(adns_state ads, ADNS_SOCKET fd, const struct timeval *now) {
+int adns_processexceptional(adns_state ads, ADNS_SOCKET fd,
+ const struct timeval *now)
+{
adns__consistency(ads,0,cc_entex);
switch (ads->tcpstate) {
case server_disconnected:
@@ -523,8 +647,10 @@
break;
case server_connecting:
case server_ok:
- if (fd != ads->tcpsocket) break;
- adns__tcp_broken(ads,"poll/select","exceptional condition detected");
+ if (fd != ads->tcpsocket)
+ break;
+ adns__tcp_broken(ads, "poll/select",
+ "exceptional condition detected");
break;
default:
abort();
@@ -540,14 +666,18 @@
struct timeval now, int *r_r) {
int r;
- if (!(revent & pollflag)) return;
- if (fds && !((int)fd<maxfd && FD_ISSET(fd,fds))) return;
+ if (!(revent & pollflag))
+ return;
+ if (fds && !(fd < maxfd && FD_ISSET(fd, fds)))
+ return;
r= func(ads,fd,&now);
if (r) {
if (r_r) {
*r_r= r;
} else {
- adns__diag(ads,-1,0,"process fd failed after select: %s",strerror(errno));
+ adns__diag(ads, -1, 0,
+ "process fd failed after select: %s",
+ strerror(errno));
adns_globalsystemfailure(ads);
}
}
@@ -563,11 +693,15 @@
for (i=0; i<npollfds; i++) {
fd= pollfds[i].fd;
- if ((int)fd >= maxfd) maxfd= fd+1;
+ if (fd >= maxfd)
+ maxfd = fd + 1;
revents= pollfds[i].revents;
- fd_event(ads,fd, revents,POLLIN, maxfd,readfds, adns_processreadable,now,r_r);
- fd_event(ads,fd, revents,POLLOUT, maxfd,writefds, adns_processwriteable,now,r_r);
- fd_event(ads,fd, revents,POLLPRI, maxfd,exceptfds, adns_processexceptional,now,r_r);
+ fd_event(ads, fd, revents, POLLIN, maxfd, readfds,
+ adns_processreadable, now, r_r);
+ fd_event(ads, fd, revents, POLLOUT, maxfd, writefds,
+ adns_processwriteable, now, r_r);
+ fd_event(ads, fd, revents, POLLPRI, maxfd, exceptfds,
+ adns_processexceptional, now, r_r);
}
}
@@ -576,7 +710,8 @@
void adns_beforeselect(adns_state ads, int *maxfd_io, fd_set *readfds_io,
fd_set *writefds_io, fd_set *exceptfds_io,
struct timeval **tv_mod, struct timeval *tv_tobuf,
- const struct timeval *now) {
+ const struct timeval *now)
+{
struct timeval tv_nowbuf;
struct pollfd pollfds[MAX_POLLFDS];
int i, maxfd, npollfds;
@@ -584,10 +719,18 @@
adns__consistency(ads,0,cc_entex);
- if (tv_mod && (!*tv_mod || (*tv_mod)->tv_sec || (*tv_mod)->tv_usec)) {
+ 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) { inter_immed(tv_mod,tv_tobuf); goto xit; }
+ if (!now) {
+ inter_immed(tv_mod, tv_tobuf);
+ adns__consistency(ads, 0, cc_entex);
+ return;
+#if 0
+ goto xit;
+#endif
+ }
adns__timeouts(ads, 0, tv_mod,tv_tobuf, *now);
}
@@ -601,40 +744,46 @@
if (pollfds[i].events & POLLPRI) FD_SET(fd,exceptfds_io);
}
*maxfd_io= maxfd;
-
+#if 0
xit:
+#endif
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) {
+ const struct timeval *now)
+{
struct timeval tv_buf;
struct pollfd pollfds[MAX_POLLFDS];
int npollfds, i;
adns__consistency(ads,0,cc_entex);
adns__must_gettimeofday(ads,&now,&tv_buf);
- if (!now) goto xit;
+ 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;
+ for (i = 0; i < npollfds; i++)
+ pollfds[i].revents = POLLIN | POLLOUT | POLLPRI;
adns__fdevents(ads,
pollfds,npollfds,
- maxfd,readfds,writefds,exceptfds,
- *now, 0);
+ maxfd, readfds, writefds, exceptfds, *now, 0);
xit:
adns__consistency(ads,0,cc_entex);
}
/* General helpful functions. */
-void adns_globalsystemfailure(adns_state ads) {
+void adns_globalsystemfailure(adns_state ads)
+{
adns__consistency(ads,0,cc_entex);
- 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);
+ 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:
@@ -650,7 +799,8 @@
adns__consistency(ads,0,cc_entex);
}
-int adns_processany(adns_state ads) {
+int adns_processany(adns_state ads)
+{
int r, i;
struct timeval now;
struct pollfd pollfds[MAX_POLLFDS];
@@ -659,32 +809,33 @@
adns__consistency(ads,0,cc_entex);
r= gettimeofday(&now,0);
- if (!r) adns_processtimeouts(ads,&now);
+ if (!r)
+ adns_processtimeouts(ads, &now);
/* We just use adns__fdevents to loop over the fd's trying them.
* This seems more sensible than calling select, since we're most
* likely just to want to do a adns_socket_read on one or two fds anyway.
*/
npollfds= adns__pollfds(ads,pollfds);
- for (i=0; i<npollfds; i++) pollfds[i].revents= pollfds[i].events & ~POLLPRI;
- adns__fdevents(ads,
- pollfds,npollfds,
- 0,0,0,0,
- now,&r);
+ for (i = 0; i < npollfds; i++)
+ pollfds[i].revents = pollfds[i].events & ~POLLPRI;
+ adns__fdevents(ads, pollfds, npollfds, 0, 0, 0, 0, now, &r);
adns__consistency(ads,0,cc_entex);
return 0;
}
-void adns__autosys(adns_state ads, struct timeval now) {
- if (ads->iflags & adns_if_noautosys) return;
+void adns__autosys(adns_state ads, struct timeval now)
+{
+ if (ads->iflags & adns_if_noautosys)
+ return;
adns_processany(ads);
}
int adns__internal_check(adns_state ads,
adns_query *query_io,
- adns_answer **answer,
- void **context_r) {
+ adns_answer ** answer, void **context_r)
+{
adns_query qu;
qu= *query_io;
@@ -697,11 +848,13 @@
return ESRCH;
}
} else {
- if (qu->id>=0) return EAGAIN;
+ if (qu->id >= 0)
+ return EAGAIN;
}
LIST_UNLINK(ads->output,qu);
*answer= qu->answer;
- if (context_r) *context_r= qu->ctx.ext;
+ if (context_r)
+ *context_r = qu->ctx.ext;
*query_io= qu;
adns_free(qu);
return 0;
@@ -709,33 +862,45 @@
int adns_wait(adns_state ads,
adns_query *query_io,
- adns_answer **answer_r,
- void **context_r) {
+ adns_answer ** answer_r, void **context_r)
+{
int r, maxfd, rsel;
fd_set readfds, writefds, exceptfds;
struct timeval tvbuf, *tvp;
adns__consistency(ads,*query_io,cc_entex);
for (;;) {
- r= adns__internal_check(ads,query_io,answer_r,context_r);
- if (r != EAGAIN) break;
- maxfd= 0; tvp= 0;
- FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
- adns_beforeselect(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf,0);
+ r = adns__internal_check(ads, query_io, answer_r,
+ context_r);
+ if (r != EAGAIN)
+ break;
+ 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);
ADNS_CLEAR_ERRNO;
rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp);
ADNS_CAPTURE_ERRNO;
if (rsel==-1) {
if (errno == EINTR) {
- if (ads->iflags & adns_if_eintr) { r= EINTR; break; }
+ if (ads->iflags & adns_if_eintr) {
+ r = EINTR;
+ break;
+ }
} else {
- adns__diag(ads,-1,0,"select failed in wait: %s",strerror(errno));
+ adns__diag(ads, -1, 0,
+ "select failed in wait: %s",
+ strerror(errno));
adns_globalsystemfailure(ads);
}
} else {
assert(rsel >= 0);
- adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,0);
+ adns_afterselect(ads, maxfd, &readfds, &writefds,
+ &exceptfds, 0);
}
}
adns__consistency(ads,0,cc_entex);
@@ -744,14 +909,15 @@
int adns_check(adns_state ads,
adns_query *query_io,
- adns_answer **answer_r,
- void **context_r) {
+ adns_answer ** answer_r, void **context_r)
+{
struct timeval now;
int r;
adns__consistency(ads,*query_io,cc_entex);
r= gettimeofday(&now,0);
- if (!r) adns__autosys(ads,now);
+ if (!r)
+ adns__autosys(ads, now);
r= adns__internal_check(ads,query_io,answer_r,context_r);
adns__consistency(ads,0,cc_entex);
lmpx.com only provides a reader for public news (NNTP) servers. It is not
affiliated with the servers or forums shown here and is not responsible for
the content of articles, which is written by their respective authors.