daemon/net.c

   1 /*
   2  *  Dolda Connect - Modular multiuser Direct Connect-style client
   3  *  Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.com)
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 /* XXX: Implement SOCKS proxyability */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/socket.h>
  30 #include <sys/un.h>
  31 #include <sys/poll.h>
  32 #include <arpa/inet.h>
  33 #include <netinet/in.h>
  34 #include <netdb.h>
  35 #include <sys/signal.h>
  36 #include <printf.h>
  37 #ifdef HAVE_LINUX_SOCKIOS_H
  38 #include <linux/sockios.h>
  39 #endif
  40 #include <errno.h>
  41 #include <net/if.h>
  42
  43 #include "conf.h"
  44 #include "net.h"
  45 #include "module.h"
  46 #include "log.h"
  47 #include "utils.h"
  48 #include "sysevents.h"
  49
  50 static struct configvar myvars[] =
  51 {
  52     /* 0 = Direct mode, 1 = Passive mode, 2 = SOCKS proxy */
  53     {CONF_VAR_INT, "mode", {.num = 0}},
  54     /* Only for direct mode */
  55     {CONF_VAR_IPV4, "visibleipv4", {.ipv4 = {0}}},
  56     {CONF_VAR_STRING, "publicif", {.str = L""}},
  57     {CONF_VAR_END}
  58 };
  59
  60 static struct socket *sockets = NULL;
  61 int numsocks = 0;
  62
  63 /* XXX: Get autoconf for all this... */
  64 int getpublicaddr(int af, struct sockaddr **addr, socklen_t *lenbuf)
  65 {
  66     struct sockaddr_in *ipv4;
  67     struct configvar *var;
  68     void *bufend;
  69     int sock;
  70     struct ifconf conf;
  71     struct ifreq *ifr, req;
  72     char *pif;
  73
  74     if(af == AF_INET)
  75     {
  76         var = confgetvar("net", "visibleipv4");
  77         if(var->val.ipv4.s_addr != 0)
  78         {
  79             ipv4 = smalloc(sizeof(*ipv4));
  80             ipv4->sin_family = AF_INET;
  81             ipv4->sin_addr.s_addr = var->val.ipv4.s_addr;
  82             *addr = (struct sockaddr *)ipv4;
  83             *lenbuf = sizeof(*ipv4);
  84             return(0);
  85         }
  86         if((pif = icwcstombs(confgetstr("net", "publicif"), NULL)) == NULL)
  87         {
  88             flog(LOG_ERR, "could not convert net.publicif into local charset: %s", strerror(errno));
  89             return(-1);
  90         }
  91         if((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  92             return(-1);
  93         conf.ifc_buf = smalloc(conf.ifc_len = 65536);
  94         if(ioctl(sock, SIOCGIFCONF, &conf) < 0)
  95         {
  96             free(conf.ifc_buf);
  97             close(sock);
  98             return(-1);
  99         }
 100         bufend = ((char *)conf.ifc_buf) + conf.ifc_len;
 101         ipv4 = NULL;
 102         for(ifr = conf.ifc_ifcu.ifcu_req; (void *)ifr < bufend; ifr++)
 103         {
 104             memset(&req, 0, sizeof(req));
 105             memcpy(req.ifr_name, ifr->ifr_name, sizeof(ifr->ifr_name));
 106             if(ioctl(sock, SIOCGIFFLAGS, &req) < 0)
 107             {
 108                 free(conf.ifc_buf);
 109                 close(sock);
 110                 return(-1);
 111             }
 112             if(!(req.ifr_flags & IFF_UP))
 113                 continue;
 114             if(ifr->ifr_addr.sa_family == AF_INET)
 115             {
 116                 if(ntohl(((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr.s_addr) == 0x7f000001)
 117                     continue;
 118                 if(ipv4 == NULL)
 119                 {
 120                     ipv4 = smalloc(sizeof(*ipv4));
 121                     memcpy(ipv4, &ifr->ifr_addr, sizeof(ifr->ifr_addr));
 122                 } else {
 123                     free(ipv4);
 124                     flog(LOG_WARNING, "could not locate an unambiguous interface for determining your public IP address - set net.publicif");
 125                     errno = ENFILE; /* XXX: There's no appropriate one for this... */
 126                     return(-1);
 127                 }
 128             }
 129         }
 130         close(sock);
 131         if(ipv4 != NULL)
 132         {
 133             *addr = (struct sockaddr *)ipv4;
 134             *lenbuf = sizeof(*ipv4);
 135             return(0);
 136         }
 137         errno = ENETDOWN;
 138         return(-1);
 139     }
 140     errno = EPFNOSUPPORT;
 141     return(-1);
 142 }
 143
 144 static struct socket *newsock(int type)
 145 {
 146     struct socket *new;
 147
 148     new = smalloc(sizeof(*new));
 149     new->refcount = 2;
 150     new->fd = -1;
 151     new->isrealsocket = 1;
 152     new->family = -1;
 153     new->tos = 0;
 154     new->type = type;
 155     new->state = -1;
 156     new->ignread = 0;
 157     new->close = 0;
 158     new->remote = NULL;
 159     new->remotelen = 0;
 160     switch(type)
 161     {
 162     case SOCK_STREAM:
 163         new->outbuf.s.buf = NULL;
 164         new->outbuf.s.bufsize = 0;
 165         new->outbuf.s.datasize = 0;
 166         new->inbuf.s.buf = NULL;
 167         new->inbuf.s.bufsize = 0;
 168         new->inbuf.s.datasize = 0;
 169         break;
 170     case SOCK_DGRAM:
 171         new->outbuf.d.f = new->outbuf.d.l = NULL;
 172         new->inbuf.d.f = new->inbuf.d.l = NULL;
 173         break;
 174     }
 175     new->conncb = NULL;
 176     new->errcb = NULL;
 177     new->readcb = NULL;
 178     new->writecb = NULL;
 179     new->acceptcb = NULL;
 180     new->next = sockets;
 181     new->prev = NULL;
 182     if(sockets != NULL)
 183         sockets->prev = new;
 184     sockets = new;
 185     numsocks++;
 186     return(new);
 187 }
 188
 189 static struct socket *mksock(int domain, int type)
 190 {
 191     int fd;
 192     struct socket *new;
 193
 194     if((fd = socket(domain, type, 0)) < 0)
 195     {
 196         flog(LOG_CRIT, "could not create socket: %s", strerror(errno));
 197         return(NULL);
 198     }
 199     new = newsock(type);
 200     new->fd = fd;
 201     new->family = domain;
 202     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 203     return(new);
 204 }
 205
 206 struct socket *wrapsock(int fd)
 207 {
 208     struct socket *new;
 209
 210     new = newsock(SOCK_STREAM);
 211     new->fd = fd;
 212     new->state = SOCK_EST;
 213     new->isrealsocket = 0;
 214     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 215     return(new);
 216 }
 217
 218 static void unlinksock(struct socket *sk)
 219 {
 220     if(sk->prev != NULL)
 221         sk->prev->next = sk->next;
 222     if(sk->next != NULL)
 223         sk->next->prev = sk->prev;
 224     if(sk == sockets)
 225         sockets = sk->next;
 226     putsock(sk);
 227     numsocks--;
 228 }
 229
 230 void getsock(struct socket *sk)
 231 {
 232     sk->refcount++;
 233 }
 234
 235 void putsock(struct socket *sk)
 236 {
 237     struct dgrambuf *buf;
 238
 239     if(--(sk->refcount) == 0)
 240     {
 241         switch(sk->type)
 242         {
 243         case SOCK_STREAM:
 244             if(sk->outbuf.s.buf != NULL)
 245                 free(sk->outbuf.s.buf);
 246             if(sk->inbuf.s.buf != NULL)
 247                 free(sk->inbuf.s.buf);
 248             break;
 249         case SOCK_DGRAM:
 250             while((buf = sk->outbuf.d.f) != NULL)
 251             {
 252                 sk->outbuf.d.f = buf->next;
 253                 free(buf->data);
 254                 free(buf);
 255             }
 256             while((buf = sk->inbuf.d.f) != NULL)
 257             {
 258                 sk->inbuf.d.f = buf->next;
 259                 free(buf->data);
 260                 free(buf);
 261             }
 262             break;
 263         }
 264         if(sk->fd >= 0)
 265             close(sk->fd);
 266         if(sk->remote != NULL)
 267             free(sk->remote);
 268         free(sk);
 269     }
 270 }
 271
 272 void *sockgetinbuf(struct socket *sk, size_t *size)
 273 {
 274     void *buf;
 275     struct dgrambuf *dbuf;
 276
 277     switch(sk->type)
 278     {
 279     case SOCK_STREAM:
 280         if((sk->inbuf.s.buf == NULL) || (sk->inbuf.s.datasize == 0))
 281         {
 282             *size = 0;
 283             return(NULL);
 284         }
 285         buf = sk->inbuf.s.buf;
 286         *size = sk->inbuf.s.datasize;
 287         sk->inbuf.s.buf = NULL;
 288         sk->inbuf.s.bufsize = sk->inbuf.s.datasize = 0;
 289         return(buf);
 290     case SOCK_DGRAM:
 291         if((dbuf = sk->inbuf.d.f) == NULL)
 292             return(NULL);
 293         sk->inbuf.d.f = dbuf->next;
 294         if(dbuf->next == NULL)
 295             sk->inbuf.d.l = NULL;
 296         buf = dbuf->data;
 297         *size = dbuf->size;
 298         free(dbuf->addr);
 299         free(dbuf);
 300         return(buf);
 301     }
 302     return(NULL);
 303 }
 304
 305 static void sockrecv(struct socket *sk)
 306 {
 307     int ret, inq;
 308     struct dgrambuf *dbuf;
 309
 310     switch(sk->type)
 311     {
 312     case SOCK_STREAM:
 313 #if defined(HAVE_LINUX_SOCKIOS_H) && defined(SIOCINQ)
 314         /* SIOCINQ is Linux-specific AFAIK, but I really have no idea
 315          * how to read the inqueue size on other OSs */
 316         if(ioctl(sk->fd, SIOCINQ, &inq))
 317         {
 318             /* I don't really know what could go wrong here, so let's
 319              * assume it's transient. */
 320             flog(LOG_WARNING, "SIOCINQ return %s on socket %i, falling back to 2048 bytes", strerror(errno), sk->fd);
 321             inq = 2048;
 322         }
 323 #else
 324         inq = 2048;
 325 #endif
 326         if(inq > 65536)
 327             inq = 65536;
 328         sizebuf(&sk->inbuf.s.buf, &sk->inbuf.s.bufsize, sk->inbuf.s.datasize + inq, 1, 1);
 329         ret = read(sk->fd, sk->inbuf.s.buf + sk->inbuf.s.datasize, inq);
 330         if(ret < 0)
 331         {
 332             if((errno == EINTR) || (errno == EAGAIN))
 333                 return;
 334             if(sk->errcb != NULL)
 335                 sk->errcb(sk, errno, sk->data);
 336             closesock(sk);
 337             return;
 338         }
 339         if(ret == 0)
 340         {
 341             if(sk->errcb != NULL)
 342                 sk->errcb(sk, 0, sk->data);
 343             closesock(sk);
 344             return;
 345         }
 346         sk->inbuf.s.datasize += ret;
 347         if(sk->readcb != NULL)
 348             sk->readcb(sk, sk->data);
 349         break;
 350     case SOCK_DGRAM:
 351         if(ioctl(sk->fd, SIOCINQ, &inq))
 352         {
 353             /* I don't really know what could go wrong here, so let's
 354              * assume it's transient. */
 355             flog(LOG_WARNING, "SIOCINQ return %s on socket %i", strerror(errno), sk->fd);
 356             return;
 357         }
 358         dbuf = smalloc(sizeof(*dbuf));
 359         dbuf->data = smalloc(inq);
 360         dbuf->addr = smalloc(dbuf->addrlen = sizeof(struct sockaddr_storage));
 361         ret = recvfrom(sk->fd, dbuf->data, inq, 0, dbuf->addr, &dbuf->addrlen);
 362         if(ret < 0)
 363         {
 364             free(dbuf->addr);
 365             free(dbuf->data);
 366             free(dbuf);
 367             if((errno == EINTR) || (errno == EAGAIN))
 368                 return;
 369             if(sk->errcb != NULL)
 370                 sk->errcb(sk, errno, sk->data);
 371             closesock(sk);
 372             return;
 373         }
 374         /* On UDP/IPv[46], ret == 0 doesn't mean EOF (since UDP can't
 375          * have EOF), but rather an empty packet. I don't know if any
 376          * other potential DGRAM protocols might have an EOF
 377          * condition, so let's play safe. */
 378         if(ret == 0)
 379         {
 380             free(dbuf->addr);
 381             free(dbuf->data);
 382             free(dbuf);
 383             if(!((sk->family == AF_INET) || (sk->family == AF_INET6)))
 384             {
 385                 if(sk->errcb != NULL)
 386                     sk->errcb(sk, 0, sk->data);
 387                 closesock(sk);
 388             }
 389             return;
 390         }
 391         dbuf->addr = srealloc(dbuf->addr, dbuf->addrlen);
 392         dbuf->data = srealloc(dbuf->data, dbuf->size = ret);
 393         dbuf->next = NULL;
 394         if(sk->inbuf.d.l != NULL)
 395             sk->inbuf.d.l->next = dbuf;
 396         else
 397             sk->inbuf.d.f = dbuf;
 398         sk->inbuf.d.l = dbuf;
 399         if(sk->readcb != NULL)
 400             sk->readcb(sk, sk->data);
 401         break;
 402     }
 403 }
 404
 405 static void sockflush(struct socket *sk)
 406 {
 407     int ret;
 408     struct dgrambuf *dbuf;
 409
 410     switch(sk->type)
 411     {
 412     case SOCK_STREAM:
 413         if(sk->isrealsocket)
 414             ret = send(sk->fd, sk->outbuf.s.buf, sk->outbuf.s.datasize, MSG_DONTWAIT | MSG_NOSIGNAL);
 415         else
 416             ret = write(sk->fd, sk->outbuf.s.buf, sk->outbuf.s.datasize);
 417         if(ret < 0)
 418         {
 419             /* For now, assume transient error, since
 420              * the socket is polled for errors */
 421             break;
 422         }
 423         if(ret > 0)
 424         {
 425             memmove(sk->outbuf.s.buf, ((char *)sk->outbuf.s.buf) + ret, sk->outbuf.s.datasize -= ret);
 426             if(sk->writecb != NULL)
 427                 sk->writecb(sk, sk->data);
 428         }
 429         break;
 430     case SOCK_DGRAM:
 431         dbuf = sk->outbuf.d.f;
 432         if((sk->outbuf.d.f = dbuf->next) == NULL)
 433             sk->outbuf.d.l = NULL;
 434         sendto(sk->fd, dbuf->data, dbuf->size, MSG_DONTWAIT | MSG_NOSIGNAL, dbuf->addr, dbuf->addrlen);
 435         free(dbuf->data);
 436         free(dbuf->addr);
 437         free(dbuf);
 438         if(sk->writecb != NULL)
 439             sk->writecb(sk, sk->data);
 440         break;
 441     }
 442 }
 443
 444 void closesock(struct socket *sk)
 445 {
 446     sk->state = SOCK_STL;
 447     close(sk->fd);
 448     sk->fd = -1;
 449     sk->close = 0;
 450 }
 451
 452 void sockqueue(struct socket *sk, void *data, size_t size)
 453 {
 454     struct dgrambuf *new;
 455
 456     if(sk->state == SOCK_STL)
 457         return;
 458     switch(sk->type)
 459     {
 460     case SOCK_STREAM:
 461         sizebuf(&(sk->outbuf.s.buf), &(sk->outbuf.s.bufsize), sk->outbuf.s.datasize + size, 1, 1);
 462         memcpy(sk->outbuf.s.buf + sk->outbuf.s.datasize, data, size);
 463         sk->outbuf.s.datasize += size;
 464         break;
 465     case SOCK_DGRAM:
 466         if(sk->remote == NULL)
 467             return;
 468         new = smalloc(sizeof(*new));
 469         new->next = NULL;
 470         memcpy(new->data = smalloc(size), data, new->size = size);
 471         memcpy(new->addr = smalloc(sk->remotelen), sk->remote, new->addrlen = sk->remotelen);
 472         if(sk->outbuf.d.l == NULL)
 473         {
 474             sk->outbuf.d.l = sk->outbuf.d.f = new;
 475         } else {
 476             sk->outbuf.d.l->next = new;
 477             sk->outbuf.d.l = new;
 478         }
 479         break;
 480     }
 481 }
 482
 483 size_t sockgetdatalen(struct socket *sk)
 484 {
 485     struct dgrambuf *b;
 486     size_t ret;
 487
 488     switch(sk->type)
 489     {
 490     case SOCK_STREAM:
 491         ret = sk->inbuf.s.datasize;
 492         break;
 493     case SOCK_DGRAM:
 494         ret = 0;
 495         for(b = sk->inbuf.d.f; b != NULL; b = b->next)
 496             ret += b->size;
 497         break;
 498     }
 499     return(ret);
 500 }
 501
 502 size_t sockqueuesize(struct socket *sk)
 503 {
 504     struct dgrambuf *b;
 505     size_t ret;
 506
 507     switch(sk->type)
 508     {
 509     case SOCK_STREAM:
 510         ret = sk->outbuf.s.datasize;
 511         break;
 512     case SOCK_DGRAM:
 513         ret = 0;
 514         for(b = sk->outbuf.d.f; b != NULL; b = b->next)
 515             ret += b->size;
 516         break;
 517     }
 518     return(ret);
 519 }
 520
 521 struct socket *netcslisten(int type, struct sockaddr *name, socklen_t namelen, void (*func)(struct socket *, struct socket *, void *), void *data)
 522 {
 523     struct socket *sk;
 524
 525     if(confgetint("net", "mode") == 1)
 526     {
 527         errno = EOPNOTSUPP;
 528         return(NULL);
 529     }
 530     /* I don't know if this is actually correct (it probably isn't),
 531      * but since, at on least Linux systems, PF_* are specifically
 532      * #define'd to their AF_* counterparts, it allows for a severely
 533      * smoother implementation. If it breaks something on your
 534      * platform, please tell me so.
 535      */
 536     if(confgetint("net", "mode") == 0)
 537     {
 538         if((sk = mksock(name->sa_family, type)) == NULL)
 539             return(NULL);
 540         sk->state = SOCK_LST;
 541         if(bind(sk->fd, name, namelen) < 0)
 542         {
 543             putsock(sk);
 544             return(NULL);
 545         }
 546         if(listen(sk->fd, 16) < 0)
 547         {
 548             putsock(sk);
 549             return(NULL);
 550         }
 551         sk->acceptcb = func;
 552         sk->data = data;
 553         return(sk);
 554     }
 555     errno = EOPNOTSUPP;
 556     return(NULL);
 557 }
 558
 559 /*
 560  * The difference between netcslisten() and netcslistenlocal() is that
 561  * netcslistenlocal() always listens on the local host, instead of
 562  * following proxy/passive mode directions. It is suitable for eg. the
 563  * UI channel, while the file sharing networks should, naturally, use
 564  * netcslisten() instead.
 565 */
 566
 567 struct socket *netcslistenlocal(int type, struct sockaddr *name, socklen_t namelen, void (*func)(struct socket *, struct socket *, void *), void *data)
 568 {
 569     struct socket *sk;
 570
 571     /* I don't know if this is actually correct (it probably isn't),
 572      * but since, at on least Linux systems, PF_* are specifically
 573      * #define'd to their AF_* counterparts, it allows for a severely
 574      * smoother implementation. If it breaks something on your
 575      * platform, please tell me so.
 576      */
 577     if((sk = mksock(name->sa_family, type)) == NULL)
 578         return(NULL);
 579     sk->state = SOCK_LST;
 580     if(bind(sk->fd, name, namelen) < 0)
 581     {
 582         putsock(sk);
 583         return(NULL);
 584     }
 585     if(listen(sk->fd, 16) < 0)
 586     {
 587         putsock(sk);
 588         return(NULL);
 589     }
 590     sk->acceptcb = func;
 591     sk->data = data;
 592     return(sk);
 593 }
 594
 595 struct socket *netcsdgram(struct sockaddr *name, socklen_t namelen)
 596 {
 597     struct socket *sk;
 598     int mode;
 599
 600     mode = confgetint("net", "mode");
 601     if((mode == 0) || (mode == 1))
 602     {
 603         if((sk = mksock(name->sa_family, SOCK_DGRAM)) == NULL)
 604             return(NULL);
 605         if(bind(sk->fd, name, namelen) < 0)
 606         {
 607             putsock(sk);
 608             return(NULL);
 609         }
 610         sk->state = SOCK_EST;
 611         return(sk);
 612     }
 613     errno = EOPNOTSUPP;
 614     return(NULL);
 615 }
 616
 617 struct socket *netdupsock(struct socket *sk)
 618 {
 619     struct socket *newsk;
 620
 621     newsk = newsock(sk->type);
 622     if((newsk->fd = dup(sk->fd)) < 0)
 623     {
 624         flog(LOG_WARNING, "could not dup() socket: %s", strerror(errno));
 625         putsock(newsk);
 626         return(NULL);
 627     }
 628     newsk->state = sk->state;
 629     newsk->ignread = sk->ignread;
 630     if(sk->remote != NULL)
 631         memcpy(newsk->remote = smalloc(sk->remotelen), sk->remote, newsk->remotelen = sk->remotelen);
 632     return(newsk);
 633 }
 634
 635 void netdgramconn(struct socket *sk, struct sockaddr *addr, socklen_t addrlen)
 636 {
 637     if(sk->remote != NULL)
 638         free(sk->remote);
 639     memcpy(sk->remote = smalloc(addrlen), addr, sk->remotelen = addrlen);
 640     sk->ignread = 1;
 641 }
 642
 643 struct socket *netcsconn(struct sockaddr *addr, socklen_t addrlen, void (*func)(struct socket *, int, void *), void *data)
 644 {
 645     struct socket *sk;
 646     int mode;
 647
 648     mode = confgetint("net", "mode");
 649     if((mode == 0) || (mode == 1))
 650     {
 651         if((sk = mksock(addr->sa_family, SOCK_STREAM)) == NULL)
 652             return(NULL);
 653         memcpy(sk->remote = smalloc(addrlen), addr, sk->remotelen = addrlen);
 654         if(!connect(sk->fd, addr, addrlen))
 655         {
 656             sk->state = SOCK_EST;
 657             func(sk, 0, data);
 658             return(sk);
 659         }
 660         if(errno == EINPROGRESS)
 661         {
 662             sk->state = SOCK_SYN;
 663             sk->conncb = func;
 664             sk->data = data;
 665             return(sk);
 666         }
 667         putsock(sk);
 668         return(NULL);
 669     }
 670     errno = EOPNOTSUPP;
 671     return(NULL);
 672 }
 673
 674 int pollsocks(int timeout)
 675 {
 676     int i, num, ret, retlen;
 677     int newfd;
 678     struct pollfd *pfds;
 679     struct socket *sk, *next, *newsk;
 680     struct sockaddr_storage ss;
 681     socklen_t sslen;
 682
 683     pfds = smalloc(sizeof(*pfds) * (num = numsocks));
 684     for(i = 0, sk = sockets; i < num; sk = sk->next)
 685     {
 686         if(sk->state == SOCK_STL)
 687         {
 688             num--;
 689             continue;
 690         }
 691         pfds[i].fd = sk->fd;
 692         pfds[i].events = 0;
 693         if(!sk->ignread)
 694             pfds[i].events |= POLLIN;
 695         if((sk->state == SOCK_SYN) || (sockqueuesize(sk) > 0))
 696             pfds[i].events |= POLLOUT;
 697         pfds[i].revents = 0;
 698         i++;
 699     }
 700     ret = poll(pfds, num, timeout);
 701     if(ret < 0)
 702     {
 703         if(errno != EINTR)
 704         {
 705             flog(LOG_CRIT, "pollsocks: poll errored out: %s", strerror(errno));
 706             /* To avoid CPU hogging in case it's bad, which it
 707              * probably is. */
 708             sleep(1);
 709         }
 710         free(pfds);
 711         return(1);
 712     }
 713     for(sk = sockets; sk != NULL; sk = next)
 714     {
 715         next = sk->next;
 716         for(i = 0; i < num; i++)
 717         {
 718             if(pfds[i].fd == sk->fd)
 719                 break;
 720         }
 721         if(i == num)
 722             continue;
 723         switch(sk->state)
 724         {
 725         case SOCK_LST:
 726             if(pfds[i].revents & POLLIN)
 727             {
 728                 sslen = sizeof(ss);
 729                 if((newfd = accept(sk->fd, (struct sockaddr *)&ss, &sslen)) < 0)
 730                 {
 731                     if(sk->errcb != NULL)
 732                         sk->errcb(sk, errno, sk->data);
 733                 }
 734                 newsk = newsock(sk->type);
 735                 newsk->fd = newfd;
 736                 newsk->family = sk->family;
 737                 newsk->state = SOCK_EST;
 738                 memcpy(newsk->remote = smalloc(sslen), &ss, sslen);
 739                 newsk->remotelen = sslen;
 740                 putsock(newsk);
 741                 if(sk->acceptcb != NULL)
 742                     sk->acceptcb(sk, newsk, sk->data);
 743             }
 744             if(pfds[i].revents & POLLERR)
 745             {
 746                 retlen = sizeof(ret);
 747                 getsockopt(sk->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
 748                 if(sk->errcb != NULL)
 749                     sk->errcb(sk, ret, sk->data);
 750                 continue;
 751             }
 752             break;
 753         case SOCK_SYN:
 754             if(pfds[i].revents & POLLERR)
 755             {
 756                 retlen = sizeof(ret);
 757                 getsockopt(sk->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
 758                 if(sk->conncb != NULL)
 759                     sk->conncb(sk, ret, sk->data);
 760                 closesock(sk);
 761                 continue;
 762             }
 763             if(pfds[i].revents & (POLLIN | POLLOUT))
 764             {
 765                 sk->state = SOCK_EST;
 766                 if(sk->conncb != NULL)
 767                     sk->conncb(sk, 0, sk->data);
 768             }
 769             break;
 770         case SOCK_EST:
 771             if(pfds[i].revents & POLLERR)
 772             {
 773                 retlen = sizeof(ret);
 774                 getsockopt(sk->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
 775                 if(sk->errcb != NULL)
 776                     sk->errcb(sk, ret, sk->data);
 777                 closesock(sk);
 778                 continue;
 779             }
 780             if(pfds[i].revents & POLLIN)
 781                 sockrecv(sk);
 782             if(pfds[i].revents & POLLOUT)
 783             {
 784                 if(sockqueuesize(sk) > 0)
 785                     sockflush(sk);
 786             }
 787             break;
 788         }
 789         if(pfds[i].revents & POLLNVAL)
 790         {
 791             flog(LOG_CRIT, "BUG: stale socket struct on fd %i", sk->fd);
 792             sk->state = SOCK_STL;
 793             unlinksock(sk);
 794             continue;
 795         }
 796         if(pfds[i].revents & POLLHUP)
 797         {
 798             if(sk->errcb != NULL)
 799                 sk->errcb(sk, 0, sk->data);
 800             closesock(sk);
 801             unlinksock(sk);
 802             continue;
 803         }
 804     }
 805     free(pfds);
 806     for(sk = sockets; sk != NULL; sk = next)
 807     {
 808         next = sk->next;
 809         if(sk->refcount == 1 && (sockqueuesize(sk) == 0))
 810         {
 811             unlinksock(sk);
 812             continue;
 813         }
 814         if(sk->close && (sockqueuesize(sk) == 0))
 815             closesock(sk);
 816         if(sk->state == SOCK_STL)
 817         {
 818             unlinksock(sk);
 819             continue;
 820         }
 821     }
 822     return(1);
 823 }
 824
 825 int socksettos(struct socket *sk, int tos)
 826 {
 827     if(sk->family == AF_INET)
 828     {
 829         if(setsockopt(sk->fd, SOL_IP, IP_TOS, &tos, sizeof(tos)) < 0)
 830         {
 831             flog(LOG_WARNING, "could not set sock TOS to %i: %s", tos, strerror(errno));
 832             return(-1);
 833         }
 834         return(0);
 835     }
 836     /* XXX: How does the IPv6 traffic class work? */
 837     flog(LOG_WARNING, "could not set TOS on sock of family %i", sk->family);
 838     return(1);
 839 }
 840
 841 struct resolvedata
 842 {
 843     int fd;
 844     void (*callback)(struct sockaddr *addr, int addrlen, void *data);
 845     void *data;
 846     struct sockaddr_storage addr;
 847     int addrlen;
 848 };
 849
 850 static void resolvecb(pid_t pid, int status, struct resolvedata *data)
 851 {
 852     static char buf[80];
 853     int ret;
 854     struct sockaddr_in *ipv4;
 855
 856     if(!status)
 857     {
 858         if((ret = read(data->fd, buf, sizeof(buf))) != 4)
 859         {
 860             errno = ENONET;
 861             data->callback(NULL, 0, data->data);
 862         } else {
 863             ipv4 = (struct sockaddr_in *)&data->addr;
 864             memcpy(&ipv4->sin_addr, buf, 4);
 865             data->callback((struct sockaddr *)ipv4, sizeof(*ipv4), data->data);
 866         }
 867     } else {
 868         errno = ENONET;
 869         data->callback(NULL, 0, data->data);
 870     }
 871     close(data->fd);
 872     free(data);
 873 }
 874
 875 int netresolve(char *addr, void (*callback)(struct sockaddr *addr, int addrlen, void *data), void *data)
 876 {
 877     int i;
 878     char *p;
 879     int port;
 880     int pfd[2];
 881     pid_t child;
 882     struct resolvedata *rdata;
 883     struct sockaddr_in ipv4;
 884     struct hostent *he;
 885     sigset_t sigset;
 886
 887     /* IPv4 */
 888     port = -1;
 889     if((p = strchr(addr, ':')) != NULL)
 890     {
 891         *p = 0;
 892         port = atoi(p + 1);
 893     }
 894     ipv4.sin_family = AF_INET;
 895     ipv4.sin_port = htons(port);
 896     if(inet_aton(addr, &ipv4.sin_addr))
 897     {
 898         callback((struct sockaddr *)&ipv4, sizeof(ipv4), data);
 899     } else {
 900         sigemptyset(&sigset);
 901         sigaddset(&sigset, SIGCHLD);
 902         sigprocmask(SIG_BLOCK, &sigset, NULL);
 903         if((pipe(pfd) < 0) || ((child = fork()) < 0))
 904         {
 905             sigprocmask(SIG_UNBLOCK, &sigset, NULL);
 906             return(-1);
 907         }
 908         if(child == 0)
 909         {
 910             sigprocmask(SIG_UNBLOCK, &sigset, NULL);
 911             for(i = 3; i < FD_SETSIZE; i++)
 912             {
 913                 if(i != pfd[1])
 914                     close(i);
 915             }
 916             signal(SIGALRM, SIG_DFL);
 917             alarm(30);
 918             if((he = gethostbyname(addr)) == NULL)
 919                 exit(1);
 920             write(pfd[1], he->h_addr_list[0], 4);
 921             exit(0);
 922         } else {
 923             close(pfd[1]);
 924             fcntl(pfd[0], F_SETFL, fcntl(pfd[0], F_GETFL) | O_NONBLOCK);
 925             rdata = smalloc(sizeof(*rdata));
 926             rdata->fd = pfd[0];
 927             rdata->callback = callback;
 928             rdata->data = data;
 929             memcpy(&rdata->addr, &ipv4, rdata->addrlen = sizeof(ipv4));
 930             childcallback(child, (void (*)(pid_t, int, void *))resolvecb, rdata);
 931             sigprocmask(SIG_UNBLOCK, &sigset, NULL);
 932             return(1);
 933         }
 934     }
 935     return(0);
 936 }
 937
 938 int sockgetlocalname(struct socket *sk, struct sockaddr **namebuf, socklen_t *lenbuf)
 939 {
 940     socklen_t len;
 941     struct sockaddr_storage name;
 942
 943     *namebuf = NULL;
 944     if((sk->state == SOCK_STL) || (sk->fd < 0))
 945         return(-1);
 946     len = sizeof(name);
 947     if(getsockname(sk->fd, (struct sockaddr *)&name, &len) < 0)
 948     {
 949         flog(LOG_ERR, "BUG: alive socket with dead fd in sockgetlocalname");
 950         return(-1);
 951     }
 952     *namebuf = memcpy(smalloc(len), &name, len);
 953     *lenbuf = len;
 954     return(0);
 955 }
 956
 957 int sockgetremotename(struct socket *sk, struct sockaddr **namebuf, socklen_t *lenbuf)
 958 {
 959     socklen_t len;
 960     struct sockaddr_storage name;
 961     struct sockaddr_in *ipv4;
 962     struct sockaddr *pname;
 963     socklen_t pnamelen;
 964
 965     switch(confgetint("net", "mode"))
 966     {
 967     case 0:
 968         *namebuf = NULL;
 969         if((sk->state == SOCK_STL) || (sk->fd < 0))
 970             return(-1);
 971         len = sizeof(name);
 972         if(getsockname(sk->fd, (struct sockaddr *)&name, &len) < 0)
 973         {
 974             flog(LOG_ERR, "BUG: alive socket with dead fd in sockgetremotename");
 975             return(-1);
 976         }
 977         if(name.ss_family == AF_INET)
 978         {
 979             ipv4 = (struct sockaddr_in *)&name;
 980             if(getpublicaddr(AF_INET, &pname, &pnamelen) < 0)
 981             {
 982                 flog(LOG_WARNING, "could not determine public IP address - strange things may happen");
 983                 return(-1);
 984             }
 985             ipv4->sin_addr.s_addr = ((struct sockaddr_in *)pname)->sin_addr.s_addr;
 986             free(pname);
 987         }
 988         *namebuf = memcpy(smalloc(len), &name, len);
 989         *lenbuf = len;
 990         return(0);
 991     case 1:
 992         errno = EOPNOTSUPP;
 993         return(-1);
 994     default:
 995         flog(LOG_CRIT, "unknown net mode %i active", confgetint("net", "mode"));
 996         errno = EOPNOTSUPP;
 997         return(-1);
 998     }
 999 }
1000
1001 char *formataddress(struct sockaddr *arg, socklen_t arglen)
1002 {
1003     struct sockaddr_un *UNIX; /* Some wise guy has #defined unix with
1004                                * lowercase letters to 1, so I do this
1005                                * instead. */
1006     struct sockaddr_in *ipv4;
1007 #ifdef HAVE_IPV6
1008     struct sockaddr_in6 *ipv6;
1009 #endif
1010     static char *ret = NULL;
1011     char buf[1024];
1012
1013     if(ret != NULL)
1014         free(ret);
1015     ret = NULL;
1016     switch(arg->sa_family)
1017     {
1018     case AF_UNIX:
1019         UNIX = (struct sockaddr_un *)arg;
1020         ret = sprintf2("%s", UNIX->sun_path);
1021         break;
1022     case AF_INET:
1023         ipv4 = (struct sockaddr_in *)arg;
1024         if(inet_ntop(AF_INET, &ipv4->sin_addr, buf, sizeof(buf)) == NULL)
1025             return(NULL);
1026         ret = sprintf2("%s:%i", buf, (int)ntohs(ipv4->sin_port));
1027         break;
1028 #ifdef HAVE_IPV6
1029     case AF_INET6:
1030         ipv6 = (struct sockaddr_in6 *)arg;
1031         if(inet_ntop(AF_INET6, &ipv6->sin6_addr, buf, sizeof(buf)) == NULL)
1032             return(NULL);
1033         ret = sprintf2("%s:%i", buf, (int)ntohs(ipv6->sin6_port));
1034         break;
1035 #endif
1036     default:
1037         errno = EPFNOSUPPORT;
1038         break;
1039     }
1040     return(ret);
1041 }
1042
1043 #if 0
1044
1045 /*
1046  * It was very nice to use this, but it seems
1047  * to mess things up, so I guess it has to go... :-(
1048  */
1049
1050 static int formataddress(FILE *stream, const struct printf_info *info, const void *const *args)
1051 {
1052     struct sockaddr *arg;
1053     socklen_t arglen;
1054     struct sockaddr_un *UNIX; /* Some wise guy has #defined unix with
1055                                * lowercase letters to 1, so I do this
1056                                * instead. */
1057     struct sockaddr_in *ipv4;
1058     int ret;
1059
1060     arg = *(struct sockaddr **)(args[0]);
1061     arglen = *(socklen_t *)(args[1]);
1062     switch(arg->sa_family)
1063     {
1064     case AF_UNIX:
1065         UNIX = (struct sockaddr_un *)arg;
1066         ret = fprintf(stream, "%s", UNIX->sun_path);
1067         break;
1068     case AF_INET:
1069         ipv4 = (struct sockaddr_in *)arg;
1070         ret = fprintf(stream, "%s:%i", inet_ntoa(ipv4->sin_addr), (int)ntohs(ipv4->sin_port));
1071         break;
1072     default:
1073         ret = -1;
1074         errno = EPFNOSUPPORT;
1075         break;
1076     }
1077     return(ret);
1078 }
1079
1080 static int formataddress_arginfo(const struct printf_info *info, size_t n, int *argtypes)
1081 {
1082     if(n > 0)
1083         argtypes[0] = PA_POINTER;
1084     if(n > 1)
1085         argtypes[1] = PA_INT; /* Sources tell me that socklen_t _must_
1086                                * be an int, so I guess this should be
1087                                * safe. */
1088     return(2);
1089 }
1090 #endif
1091
1092 static int init(int hup)
1093 {
1094     if(!hup)
1095     {
1096         /*
1097         if(register_printf_function('N', formataddress, formataddress_arginfo))
1098         {
1099             flog(LOG_CRIT, "could not register printf handler %%N: %s", strerror(errno));
1100             return(1);
1101         }
1102         */
1103     }
1104     return(0);
1105 }
1106
1107 static void terminate(void)
1108 {
1109     while(sockets != NULL)
1110         unlinksock(sockets);
1111 }
1112
1113 static struct module me =
1114 {
1115     .name = "net",
1116     .conf =
1117     {
1118         .vars = myvars
1119     },
1120     .init = init,
1121     .terminate = terminate
1122 };
1123
1124 MODULE(me)