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/select.h>
  32 #include <arpa/inet.h>
  33 #include <netinet/in.h>
  34 #include <netdb.h>
  35 #include <sys/signal.h>
  36 #include <sys/stat.h>       /* For rebindunix() */
  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     /** The network mode to use. Currently supported values are 0 for
  53      * active mode and 1 for passive mode. In the future, SOCKS5 proxy
  54      * support may be added. */
  55     {CONF_VAR_INT, "mode", {.num = 0}},
  56     /** Set the SO_REUSEADDR socket option on listening sockets, so
  57      * that dead TCP connections waiting for timeout are ignored. */
  58     {CONF_VAR_BOOL, "reuseaddr", {.num = 0}},
  59     /** Overrides the IPv4 address reported to other clients in active
  60      * mode. Useful for servers behind NAT routers. If both this and
  61      * net.publicif are unspecified the address of the hub connection
  62      * is used. */
  63     {CONF_VAR_IPV4, "visibleipv4", {.ipv4 = {0}}},
  64     /** Specifies an interface name from which to fetch the IPv4
  65      * address reported to other clients in active mode. If both this
  66      * and net.visibleipv4 are unspecified the address of the hub
  67      * connection is used. */
  68     {CONF_VAR_STRING, "publicif", {.str = L""}},
  69     /* Diffserv should be supported on IPv4, too, but I don't know the
  70      * API to do that. */
  71     /** The Diffserv value to use on IPv6 connections when the
  72      * minimize cost TOS value is used (see the TOS VALUES
  73      * section). */
  74     {CONF_VAR_INT, "diffserv-mincost", {.num = 0}},
  75     /** The Diffserv value to use on IPv6 connections when the
  76      * maximize reliability TOS value is used (see the TOS VALUES
  77      * section). */
  78     {CONF_VAR_INT, "diffserv-maxrel", {.num = 0}},
  79     /** The Diffserv value to use on IPv6 connections when the
  80      * maximize throughput TOS value is used (see the TOS VALUES
  81      * section). */
  82     {CONF_VAR_INT, "diffserv-maxtp", {.num = 0}},
  83     /** The Diffserv value to use on IPv6 connections when the
  84      * minimize delay TOS value is used (see the TOS VALUES
  85      * section). */
  86     {CONF_VAR_INT, "diffserv-mindelay", {.num = 0}},
  87     {CONF_VAR_END}
  88 };
  89
  90 #define UFD_SOCK 0
  91 #define UFD_PIPE 1
  92 #define UFD_LISTEN 2
  93
  94 struct scons {
  95     struct scons *n, *p;
  96     struct socket *s;
  97 };
  98
  99 struct ufd {
 100     struct ufd *next, *prev;
 101     int fd;
 102     int type;
 103     int ignread;
 104     struct socket *sk;
 105     union {
 106         struct {
 107             int family;
 108             int type;
 109             struct sockaddr *remote;
 110             socklen_t remotelen;
 111             struct {
 112                 uid_t uid;
 113                 gid_t gid;
 114             } ucred;
 115         } s;
 116         struct {
 117             struct lport *lp;
 118             int family;
 119         } l;
 120     } d;
 121 };
 122
 123 static struct ufd *ufds = NULL;
 124 static struct scons *rbatch, *wbatch, *cbatch;
 125 int numsocks = 0;
 126
 127 /* XXX: Get autoconf for all this... */
 128 int getpublicaddr(int af, struct sockaddr **addr, socklen_t *lenbuf)
 129 {
 130     struct sockaddr_in *ipv4;
 131     struct configvar *var;
 132     void *bufend;
 133     int sock;
 134     struct ifconf conf;
 135     struct ifreq *ifr, req;
 136     char *pif;
 137
 138     if(af == AF_INET)
 139     {
 140         var = confgetvar("net", "visibleipv4");
 141         if(var->val.ipv4.s_addr != 0)
 142         {
 143             ipv4 = smalloc(sizeof(*ipv4));
 144             ipv4->sin_family = AF_INET;
 145             ipv4->sin_addr.s_addr = var->val.ipv4.s_addr;
 146             *addr = (struct sockaddr *)ipv4;
 147             *lenbuf = sizeof(*ipv4);
 148             return(0);
 149         }
 150         if((pif = icswcstombs(confgetstr("net", "publicif"), NULL, NULL)) == NULL)
 151         {
 152             flog(LOG_ERR, "could not convert net.publicif into local charset: %s", strerror(errno));
 153             return(-1);
 154         }
 155         if(!strcmp(pif, ""))
 156             return(1);
 157         if((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 158             return(-1);
 159         conf.ifc_buf = smalloc(conf.ifc_len = 65536);
 160         if(ioctl(sock, SIOCGIFCONF, &conf) < 0)
 161         {
 162             free(conf.ifc_buf);
 163             close(sock);
 164             return(-1);
 165         }
 166         bufend = ((char *)conf.ifc_buf) + conf.ifc_len;
 167         ipv4 = NULL;
 168         for(ifr = conf.ifc_ifcu.ifcu_req; (void *)ifr < bufend; ifr++)
 169         {
 170             if(strcmp(ifr->ifr_name, pif))
 171                 continue;
 172             memset(&req, 0, sizeof(req));
 173             memcpy(req.ifr_name, ifr->ifr_name, sizeof(ifr->ifr_name));
 174             if(ioctl(sock, SIOCGIFFLAGS, &req) < 0)
 175                 break;
 176             if(!(req.ifr_flags & IFF_UP))
 177             {
 178                 flog(LOG_WARNING, "public interface is down");
 179                 break;
 180             }
 181             if(ifr->ifr_addr.sa_family != AF_INET)
 182             {
 183                 flog(LOG_WARNING, "address of the public interface is not AF_INET");
 184                 break;
 185             }
 186             ipv4 = smalloc(sizeof(*ipv4));
 187             memcpy(ipv4, &ifr->ifr_addr, sizeof(ifr->ifr_addr));
 188             break;
 189         }
 190         free(conf.ifc_buf);
 191         close(sock);
 192         if(ipv4 != NULL)
 193         {
 194             *addr = (struct sockaddr *)ipv4;
 195             *lenbuf = sizeof(*ipv4);
 196             return(0);
 197         }
 198         errno = ENETDOWN;
 199         return(-1);
 200     }
 201     return(1);
 202 }
 203
 204 static struct socket *newsock1(int dgram)
 205 {
 206     struct socket *new;
 207
 208     new = memset(smalloc(sizeof(*new)), 0, sizeof(*new));
 209     new->refcount = 1;
 210     new->state = -1;
 211     new->dgram = dgram;
 212     numsocks++;
 213     return(new);
 214 }
 215
 216 static struct socket *sockpair(int dgram)
 217 {
 218     struct socket *s1, *s2;
 219
 220     s1 = newsock1(dgram);
 221     s2 = newsock1(dgram);
 222     s1->back = s2;
 223     s2->back = s1;
 224     putsock(s2);
 225     return(s1);
 226 }
 227
 228 static void sksetstate(struct socket *sk, int state)
 229 {
 230     sk->state = state;
 231     sk->back->state = state;
 232 }
 233
 234 static void closeufd(struct ufd *ufd)
 235 {
 236     if(ufd->fd != -1)
 237         close(ufd->fd);
 238     ufd->fd = -1;
 239 }
 240
 241 static void freeufd(struct ufd *ufd)
 242 {
 243     if(ufd->next != NULL)
 244         ufd->next->prev = ufd->prev;
 245     if(ufd->prev != NULL)
 246         ufd->prev->next = ufd->next;
 247     if(ufd == ufds)
 248         ufds = ufd->next;
 249     closeufd(ufd);
 250     if(ufd->sk != NULL)
 251         putsock(ufd->sk);
 252     if(ufd->type == UFD_SOCK) {
 253         if(ufd->d.s.remote != NULL)
 254             free(ufd->d.s.remote);
 255     }
 256     free(ufd);
 257 }
 258
 259 static struct ufd *mkufd(int fd, int type, struct socket *sk)
 260 {
 261     struct ufd *ufd;
 262
 263     ufd = memset(smalloc(sizeof(*ufd)), 0, sizeof(*ufd));
 264     ufd->fd = fd;
 265     ufd->type = type;
 266     if(sk != NULL) {
 267         getsock(ufd->sk = sk);
 268         sk->ufd = ufd;
 269     }
 270     if(type == UFD_SOCK) {
 271         ufd->d.s.ucred.uid = -1;
 272         ufd->d.s.ucred.gid = -1;
 273     }
 274     ufd->next = ufds;
 275     if(ufds)
 276         ufds->prev = ufd;
 277     ufds = ufd;
 278     return(ufd);
 279 }
 280
 281 static struct ufd *dupufd(struct ufd *ufd)
 282 {
 283     struct ufd *nufd;
 284     struct socket *nsk;
 285
 286     if(ufd->sk != NULL)
 287         nsk = sockpair(ufd->sk->dgram);
 288     else
 289         nsk = NULL;
 290     nufd = mkufd(ufd->fd, ufd->type, nsk);
 291     if(nsk != NULL)
 292         putsock(nsk);
 293     if((nufd->fd = dup(ufd->fd)) < 0)
 294     {
 295         flog(LOG_WARNING, "could not dup() fd: %s", strerror(errno));
 296         freeufd(nufd);
 297         return(NULL);
 298     }
 299     sksetstate(nsk, SOCK_EST);
 300     if(ufd->type == UFD_SOCK) {
 301         nufd->d.s.family = ufd->d.s.family;
 302         nufd->d.s.type = ufd->d.s.type;
 303         nufd->d.s.ucred.uid = ufd->d.s.ucred.uid;
 304         nufd->d.s.ucred.gid = ufd->d.s.ucred.gid;
 305         if(ufd->d.s.remote != NULL)
 306             nufd->d.s.remote = memcpy(smalloc(ufd->d.s.remotelen), ufd->d.s.remote, nufd->d.s.remotelen = ufd->d.s.remotelen);
 307     } else if(ufd->type == UFD_LISTEN) {
 308         nufd->d.l.family = ufd->d.l.family;
 309     }
 310     return(nufd);
 311 }
 312
 313 static struct socket *mksock(int domain, int type)
 314 {
 315     int fd;
 316     struct socket *sk;
 317     struct ufd *ufd;
 318
 319     if((fd = socket(domain, type, 0)) < 0)
 320     {
 321         flog(LOG_CRIT, "could not create socket: %s", strerror(errno));
 322         return(NULL);
 323     }
 324     sk = sockpair(type == SOCK_DGRAM);
 325     ufd = mkufd(fd, UFD_SOCK, sk);
 326     ufd->d.s.family = domain;
 327     ufd->d.s.type = type;
 328     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 329     return(sk);
 330 }
 331
 332 struct socket *wrapsock(int fd)
 333 {
 334     struct socket *sk;
 335     struct ufd *ufd;
 336
 337     sk = sockpair(0);
 338     ufd = mkufd(fd, UFD_PIPE, sk->back);
 339     sksetstate(sk, SOCK_EST);
 340     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 341     return(sk);
 342 }
 343
 344 void getsock(struct socket *sk)
 345 {
 346     sk->refcount++;
 347 }
 348
 349 static void freesock(struct socket *sk)
 350 {
 351     struct dgrambuf *buf;
 352
 353     if(sk->dgram) {
 354         while((buf = sk->buf.d.f) != NULL) {
 355             sk->buf.d.f = buf->next;
 356             freedgbuf(buf);
 357         }
 358     } else {
 359         if(sk->buf.s.buf != NULL)
 360             free(sk->buf.s.buf);
 361     }
 362     free(sk);
 363     numsocks--;
 364 }
 365
 366 void putsock(struct socket *sk)
 367 {
 368     struct socket *back;
 369
 370     if(--(sk->refcount) < 0) {
 371         flog(LOG_CRIT, "BUG: socket refcount < 0");
 372         abort();
 373     }
 374     if((sk->refcount == 0) && (sk->back->refcount == 0)) {
 375         back = sk->back;
 376         freesock(sk);
 377         freesock(back);
 378     }
 379 }
 380
 381 static void linksock(struct scons **list, struct socket *sk)
 382 {
 383     struct scons *sc;
 384
 385     for(sc = *list; sc != NULL; sc = sc->n) {
 386         if(sc->s == sk)
 387             return;
 388     }
 389     sc = smalloc(sizeof(*sc));
 390     getsock(sc->s = sk);
 391     sc->n = *list;
 392     sc->p = NULL;
 393     if(*list)
 394         (*list)->p = sc;
 395     *list = sc;
 396 }
 397
 398 void sockpushdata(struct socket *sk, void *buf, size_t size)
 399 {
 400     if(size == 0)
 401         return;
 402     if(sk->dgram) {
 403         /* XXX */
 404     } else {
 405         sizebuf(&sk->buf.s.buf, &sk->buf.s.bufsize, sk->buf.s.datasize + size, 1, 1);
 406         memmove(sk->buf.s.buf + size, sk->buf.s.buf, sk->buf.s.datasize);
 407         memcpy(sk->buf.s.buf, buf, size);
 408         sk->buf.s.datasize += size;
 409         linksock(&rbatch, sk);
 410     }
 411 }
 412
 413 /* Read as the preterite of `read' */
 414 void sockread(struct socket *sk)
 415 {
 416     if((sockgetdatalen(sk) == 0) && (sk->eos == 1))
 417         linksock(&rbatch, sk);
 418     linksock(&wbatch, sk->back);
 419 }
 420
 421 void freedgbuf(struct dgrambuf *dg)
 422 {
 423     if(dg->data != NULL)
 424         free(dg->data);
 425     if(dg->addr != NULL)
 426         free(dg->addr);
 427     free(dg);
 428 }
 429
 430 struct dgrambuf *sockgetdgbuf(struct socket *sk)
 431 {
 432     struct dgrambuf *dbuf;
 433
 434     if((dbuf = sk->buf.d.f) == NULL)
 435         return(NULL);
 436     sk->buf.d.f = dbuf->next;
 437     if(dbuf->next == NULL)
 438         sk->buf.d.l = NULL;
 439     dbuf->next = NULL;
 440     sockread(sk);
 441     return(dbuf);
 442 }
 443
 444 void *sockgetinbuf(struct socket *sk, size_t *size)
 445 {
 446     void *buf;
 447     struct dgrambuf *dbuf;
 448
 449     if(sk->dgram) {
 450         dbuf = sockgetdgbuf(sk);
 451         buf = dbuf->data;
 452         *size = dbuf->size;
 453         free(dbuf->addr);
 454         free(dbuf);
 455     } else {
 456         if((sk->buf.s.buf == NULL) || (sk->buf.s.datasize == 0))
 457         {
 458             *size = 0;
 459             return(NULL);
 460         }
 461         buf = sk->buf.s.buf;
 462         *size = sk->buf.s.datasize;
 463         sk->buf.s.buf = NULL;
 464         sk->buf.s.bufsize = sk->buf.s.datasize = 0;
 465         sockread(sk);
 466     }
 467     return(buf);
 468 }
 469
 470 void sockqueue(struct socket *sk, void *data, size_t size)
 471 {
 472     struct dgrambuf *new;
 473     struct sockaddr *remote;
 474     socklen_t remotelen;
 475
 476     if(size == 0)
 477         return;
 478     if(sk->state == SOCK_STL)
 479         return;
 480     if(sk->dgram) {
 481         if(sockpeeraddr(sk, &remote, &remotelen))
 482             return;
 483         new = smalloc(sizeof(*new));
 484         new->next = NULL;
 485         memcpy(new->data = smalloc(size), data, new->size = size);
 486         new->addr = remote;
 487         new->addrlen = remotelen;
 488         if(sk->back->buf.d.l == NULL)
 489         {
 490             sk->back->buf.d.l = sk->back->buf.d.f = new;
 491         } else {
 492             sk->back->buf.d.l->next = new;
 493             sk->back->buf.d.l = new;
 494         }
 495     } else {
 496         sizebuf(&(sk->back->buf.s.buf), &(sk->back->buf.s.bufsize), sk->back->buf.s.datasize + size, 1, 1);
 497         memcpy(sk->back->buf.s.buf + sk->back->buf.s.datasize, data, size);
 498         sk->back->buf.s.datasize += size;
 499     }
 500     linksock(&rbatch, sk->back);
 501 }
 502
 503 void sockqueuedg(struct socket *sk, struct dgrambuf *dg)
 504 {
 505     if(sk->state == SOCK_STL) {
 506         freedgbuf(dg);
 507         return;
 508     }
 509     if(!sk->dgram) {
 510         flog(LOG_ERR, "BUG: sockqueuedg called on non-dgram socket");
 511         freedgbuf(dg);
 512         return;
 513     }
 514     dg->next = NULL;
 515     if(sk->back->buf.d.l == NULL)
 516     {
 517         sk->back->buf.d.l = sk->back->buf.d.f = dg;
 518     } else {
 519         sk->back->buf.d.l->next = dg;
 520         sk->back->buf.d.l = dg;
 521     }
 522     linksock(&rbatch, sk->back);
 523 }
 524
 525 void sockeos(struct socket *sk)
 526 {
 527     sksetstate(sk, SOCK_STL);
 528     if(sk->back->eos == 0)
 529         sk->back->eos = 1;
 530     linksock(&rbatch, sk->back);
 531 }
 532
 533 static void sockerror(struct socket *sk, int en)
 534 {
 535     sksetstate(sk, SOCK_STL);
 536     if(sk->back->errcb != NULL)
 537         sk->back->errcb(sk->back, en, sk->back->data);
 538 }
 539
 540 static void recvcmsg(struct ufd *ufd, struct msghdr *msg)
 541 {
 542     struct cmsghdr *cmsg;
 543
 544     for(cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg))
 545     {
 546 #if UNIX_AUTH_STYLE == 1
 547         if((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SCM_CREDENTIALS))
 548         {
 549             struct ucred *cred;
 550             if(ufd->d.s.ucred.uid == -1)
 551             {
 552                 cred = (struct ucred *)CMSG_DATA(cmsg);
 553                 ufd->d.s.ucred.uid = cred->uid;
 554                 ufd->d.s.ucred.gid = cred->gid;
 555             }
 556         }
 557 #endif
 558     }
 559 }
 560
 561 static int ufddgram(struct ufd *ufd)
 562 {
 563     int dgram;
 564
 565     if(ufd->type == UFD_SOCK) {
 566         dgram = ufd->d.s.type == SOCK_DGRAM;
 567     } else if(ufd->type == UFD_PIPE) {
 568         dgram = 0;
 569     } else {
 570         flog(LOG_ERR, "BUG: calling ufddgram on ufd of bad type %i", ufd->type);
 571         return(-1);
 572     }
 573     if(ufd->sk == NULL) {
 574         flog(LOG_ERR, "BUG: calling ufddgram on socketless ufd (type %i)", ufd->type);
 575         return(-1);
 576     }
 577     if(dgram != ufd->sk->dgram) {
 578         flog(LOG_ERR, "BUG: ufd/socket dgram value mismatch");
 579         return(-1);
 580     }
 581     return(dgram);
 582 }
 583
 584 static void sockrecv(struct ufd *ufd)
 585 {
 586     int ret, inq;
 587     int dgram;
 588     struct dgrambuf *dbuf;
 589     struct msghdr msg;
 590     char cbuf[65536];
 591     struct iovec bufvec;
 592     void *buf;
 593
 594     memset(&msg, 0, sizeof(msg));
 595     msg.msg_iov = &bufvec;
 596     msg.msg_iovlen = 1;
 597     msg.msg_control = cbuf;
 598     msg.msg_controllen = sizeof(cbuf);
 599     if((dgram = ufddgram(ufd)) < 0)
 600         return;
 601     if(dgram) {
 602 #if defined(HAVE_LINUX_SOCKIOS_H) && defined(SIOCINQ)
 603         if(ioctl(ufd->fd, SIOCINQ, &inq))
 604         {
 605             /* I don't really know what could go wrong here, so let's
 606              * assume it's transient. */
 607             flog(LOG_WARNING, "SIOCINQ return %s on socket %i", strerror(errno), ufd->fd);
 608             return;
 609         }
 610 #else
 611         inq = 65536;
 612 #endif
 613         dbuf = smalloc(sizeof(*dbuf));
 614         dbuf->data = smalloc(inq);
 615         dbuf->addr = smalloc(dbuf->addrlen = sizeof(struct sockaddr_storage));
 616         msg.msg_name = dbuf->addr;
 617         msg.msg_namelen = dbuf->addrlen;
 618         bufvec.iov_base = dbuf->data;
 619         bufvec.iov_len = inq;
 620         ret = recvmsg(ufd->fd, &msg, 0);
 621         dbuf->addrlen = msg.msg_namelen;
 622         if(ret < 0)
 623         {
 624             freedgbuf(dbuf);
 625             if((errno == EINTR) || (errno == EAGAIN))
 626                 return;
 627             closeufd(ufd);
 628             sockerror(ufd->sk, errno);
 629             return;
 630         }
 631         if(msg.msg_flags & MSG_CTRUNC)
 632             flog(LOG_DEBUG, "ancillary data was truncated");
 633         else
 634             recvcmsg(ufd, &msg);
 635         /* On UDP/IPv[46], ret == 0 doesn't mean EOF (since UDP can't
 636          * have EOF), but rather an empty packet. I don't know if any
 637          * other potential DGRAM protocols might have an EOF
 638          * condition, so let's play safe. */
 639         if(ret == 0)
 640         {
 641             freedgbuf(dbuf);
 642             if((ufd->type != UFD_SOCK) || !((ufd->d.s.family == AF_INET) || (ufd->d.s.family == AF_INET6)))
 643             {
 644                 sockeos(ufd->sk);
 645                 closeufd(ufd);
 646             }
 647             return;
 648         }
 649         dbuf->addr = srealloc(dbuf->addr, dbuf->addrlen);
 650         dbuf->data = srealloc(dbuf->data, dbuf->size = ret);
 651         dbuf->next = NULL;
 652         sockqueuedg(ufd->sk, dbuf);
 653     } else {
 654 #if defined(HAVE_LINUX_SOCKIOS_H) && defined(SIOCINQ)
 655         /* SIOCINQ is Linux-specific AFAIK, but I really have no idea
 656          * how to read the inqueue size on other OSs */
 657         if(ufd->type == UFD_SOCK) {
 658             if(ioctl(ufd->fd, SIOCINQ, &inq))
 659             {
 660                 /* I don't really know what could go wrong here, so let's
 661                  * assume it's transient. */
 662                 flog(LOG_WARNING, "SIOCINQ return %s on socket %i, falling back to 2048 bytes", strerror(errno), ufd->fd);
 663                 inq = 2048;
 664             }
 665         } else {
 666             /* There are perils when trying to use SIOCINQ on files >2GiB... */
 667             inq = 65536;
 668         }
 669 #else
 670         inq = 2048;
 671 #endif
 672         if(inq > 65536)
 673             inq = 65536;
 674         /* This part could be optimized by telling the kernel to read
 675          * directly into ufd->sk->back->buf, but that would be uglier
 676          * by not using the socket function interface. */
 677         buf = smalloc(inq);
 678         if(ufd->type == UFD_SOCK)
 679         {
 680             bufvec.iov_base = buf;
 681             bufvec.iov_len = inq;
 682             ret = recvmsg(ufd->fd, &msg, 0);
 683         } else {
 684             ret = read(ufd->fd, buf, inq);
 685             msg.msg_controllen = 0;
 686             msg.msg_flags = 0;
 687         }
 688         if(ret < 0)
 689         {
 690             free(buf);
 691             if((errno == EINTR) || (errno == EAGAIN))
 692                 return;
 693             closeufd(ufd);
 694             sockerror(ufd->sk, errno);
 695             return;
 696         }
 697         if(msg.msg_flags & MSG_CTRUNC)
 698             flog(LOG_DEBUG, "ancillary data was truncated");
 699         else
 700             recvcmsg(ufd, &msg);
 701         if(ret == 0)
 702         {
 703             free(buf);
 704             closeufd(ufd);
 705             sockeos(ufd->sk);
 706             return;
 707         }
 708         sockqueue(ufd->sk, buf, ret);
 709         free(buf);
 710     }
 711 }
 712
 713 static void sockflush(struct ufd *ufd)
 714 {
 715     int ret;
 716     struct dgrambuf *dbuf;
 717     int dgram;
 718
 719     if((dgram = ufddgram(ufd)) < 0)
 720         return;
 721     if(dgram) {
 722         dbuf = sockgetdgbuf(ufd->sk);
 723         sendto(ufd->fd, dbuf->data, dbuf->size, MSG_DONTWAIT | MSG_NOSIGNAL, dbuf->addr, dbuf->addrlen);
 724         freedgbuf(dbuf);
 725     } else {
 726         if(ufd->type == UFD_SOCK)
 727             ret = send(ufd->fd, ufd->sk->buf.s.buf, ufd->sk->buf.s.datasize, MSG_DONTWAIT | MSG_NOSIGNAL);
 728         else
 729             ret = write(ufd->fd, ufd->sk->buf.s.buf, ufd->sk->buf.s.datasize);
 730         if(ret < 0) {
 731             /* For now, assume transient error, since
 732              * the socket is polled for errors */
 733             return;
 734         }
 735         if(ret > 0) {
 736             memmove(ufd->sk->buf.s.buf, ((char *)ufd->sk->buf.s.buf) + ret, ufd->sk->buf.s.datasize -= ret);
 737             sockread(ufd->sk);
 738         }
 739     }
 740 }
 741
 742 void closesock(struct socket *sk)
 743 {
 744 /*
 745     struct sockaddr_un *un;
 746
 747     if((sk->family == AF_UNIX) && !sockgetlocalname(sk, (struct sockaddr **)(void *)&un, NULL) && (un->sun_family == PF_UNIX))
 748     {
 749         if((sk->state == SOCK_LST) && strchr(un->sun_path, '/'))
 750         {
 751             if(unlink(un->sun_path))
 752                 flog(LOG_WARNING, "could not unlink Unix socket %s: %s", un->sun_path, strerror(errno));
 753         }
 754     }
 755 */
 756     sksetstate(sk, SOCK_STL);
 757     sockeos(sk);
 758 }
 759
 760 size_t sockgetdatalen(struct socket *sk)
 761 {
 762     struct dgrambuf *b;
 763     size_t ret;
 764
 765     if(sk->dgram) {
 766         ret = 0;
 767         for(b = sk->buf.d.f; b != NULL; b = b->next)
 768             ret += b->size;
 769     } else {
 770         ret = sk->buf.s.datasize;
 771     }
 772     return(ret);
 773 }
 774
 775 size_t sockqueuesize(struct socket *sk)
 776 {
 777     return(sockgetdatalen(sk->back));
 778 }
 779
 780 /*
 781  * Seriously, I don't know if it's naughty or not to remove
 782  * pre-existing Unix sockets.
 783  */
 784 static int rebindunix(struct ufd *ufd, struct sockaddr *name, socklen_t namelen)
 785 {
 786     struct sockaddr_un *un;
 787     struct stat sb;
 788
 789     if((ufd->d.l.family != AF_UNIX) || (name->sa_family != PF_UNIX))
 790         return(-1);
 791     un = (struct sockaddr_un *)name;
 792     if(stat(un->sun_path, &sb))
 793         return(-1);
 794     if(!S_ISSOCK(sb.st_mode))
 795         return(-1);
 796     if(unlink(un->sun_path))
 797         return(-1);
 798     if(bind(ufd->fd, name, namelen) < 0)
 799         return(-1);
 800     return(0);
 801 }
 802
 803 void closelport(struct lport *lp)
 804 {
 805     freeufd(lp->ufd);
 806 }
 807
 808 /*
 809  * The difference between netcslisten() and netcslistenlocal() is that
 810  * netcslistenlocal() always listens on the local host, instead of
 811  * following proxy/passive mode directions. It is suitable for eg. the
 812  * UI channel, while the file sharing networks should, naturally, use
 813  * netcslisten() instead.
 814 */
 815
 816 struct lport *netcslistenlocal(int type, struct sockaddr *name, socklen_t namelen, void (*func)(struct lport *, struct socket *, void *), void *data)
 817 {
 818     struct lport *lp;
 819     struct ufd *ufd;
 820     int fd;
 821     int intbuf;
 822
 823     /* I don't know if this is actually correct (it probably isn't),
 824      * but since, at on least Linux systems, PF_* are specifically
 825      * #define'd to their AF_* counterparts, it allows for a severely
 826      * smoother implementation. If it breaks something on your
 827      * platform, please tell me so.
 828      */
 829     if((fd = socket(name->sa_family, type, 0)) < 0)
 830         return(NULL);
 831     if(confgetint("net", "reuseaddr")) {
 832         intbuf = 1;
 833         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &intbuf, sizeof(intbuf));
 834     }
 835     ufd = mkufd(fd, UFD_LISTEN, NULL);
 836     ufd->d.l.family = name->sa_family;
 837     lp = memset(smalloc(sizeof(*lp)), 0, sizeof(*lp));
 838     lp->ufd = ufd;
 839     ufd->d.l.lp = lp;
 840     if((bind(fd, name, namelen) < 0) && ((errno != EADDRINUSE) || (rebindunix(ufd, name, namelen) < 0))) {
 841         freeufd(ufd);
 842         return(NULL);
 843     }
 844     if(listen(fd, 16) < 0)
 845     {
 846         freeufd(ufd);
 847         return(NULL);
 848     }
 849     lp->acceptcb = func;
 850     lp->data = data;
 851     return(lp);
 852 }
 853
 854 struct lport *netcslisten(int type, struct sockaddr *name, socklen_t namelen, void (*func)(struct lport *, struct socket *, void *), void *data)
 855 {
 856     if(confgetint("net", "mode") == 1)
 857     {
 858         errno = EOPNOTSUPP;
 859         return(NULL);
 860     }
 861     if(confgetint("net", "mode") == 0)
 862         return(netcslistenlocal(type, name, namelen, func, data));
 863     errno = EOPNOTSUPP;
 864     return(NULL);
 865 }
 866
 867 struct lport *netcstcplisten(int port, int local, void (*func)(struct lport *, struct socket *, void *), void *data)
 868 {
 869     struct sockaddr_in addr;
 870 #ifdef HAVE_IPV6
 871     struct sockaddr_in6 addr6;
 872 #endif
 873     struct lport *(*csfunc)(int, struct sockaddr *, socklen_t, void (*)(struct lport *, struct socket *, void *), void *);
 874     struct lport *ret;
 875
 876     if(local)
 877         csfunc = netcslistenlocal;
 878     else
 879         csfunc = netcslisten;
 880 #ifdef HAVE_IPV6
 881     memset(&addr6, 0, sizeof(addr6));
 882     addr6.sin6_family = AF_INET6;
 883     addr6.sin6_port = htons(port);
 884     addr6.sin6_addr = in6addr_any;
 885     if((ret = csfunc(SOCK_STREAM, (struct sockaddr *)&addr6, sizeof(addr6), func, data)) != NULL)
 886         return(ret);
 887     if((ret == NULL) && (errno != EAFNOSUPPORT))
 888         return(NULL);
 889 #endif
 890     memset(&addr, 0, sizeof(addr));
 891     addr.sin_family = AF_INET;
 892     addr.sin_port = htons(port);
 893     return(csfunc(SOCK_STREAM, (struct sockaddr *)&addr, sizeof(addr), func, data));
 894 }
 895
 896 struct socket *netcsdgram(struct sockaddr *name, socklen_t namelen)
 897 {
 898     struct socket *sk;
 899     int mode;
 900
 901     mode = confgetint("net", "mode");
 902     if((mode == 0) || (mode == 1))
 903     {
 904         if((sk = mksock(name->sa_family, SOCK_DGRAM)) == NULL)
 905             return(NULL);
 906         if(bind(sk->ufd->fd, name, namelen) < 0)
 907         {
 908             putsock(sk);
 909             return(NULL);
 910         }
 911         sksetstate(sk, SOCK_EST);
 912         return(sk->back);
 913     }
 914     errno = EOPNOTSUPP;
 915     return(NULL);
 916 }
 917
 918 struct socket *netdgramconn(struct socket *sk, struct sockaddr *addr, socklen_t addrlen)
 919 {
 920     struct ufd *nufd;
 921
 922     nufd = dupufd(sk->back->ufd);
 923     getsock(sk = nufd->sk->back);
 924     memcpy(nufd->d.s.remote = smalloc(addrlen), addr, nufd->d.s.remotelen = addrlen);
 925     nufd->ignread = 1;
 926     return(sk);
 927 }
 928
 929 struct socket *netcsconn(struct sockaddr *addr, socklen_t addrlen, void (*func)(struct socket *, int, void *), void *data)
 930 {
 931     struct socket *sk;
 932     int mode;
 933
 934     mode = confgetint("net", "mode");
 935     if((mode == 0) || (mode == 1))
 936     {
 937         if((sk = mksock(addr->sa_family, SOCK_STREAM)) == NULL)
 938             return(NULL);
 939         memcpy(sk->ufd->d.s.remote = smalloc(addrlen), addr, sk->ufd->d.s.remotelen = addrlen);
 940         sk->back->conncb = func;
 941         sk->back->data = data;
 942         if(!connect(sk->ufd->fd, addr, addrlen))
 943         {
 944             sksetstate(sk, SOCK_EST);
 945             linksock(&cbatch, sk->back);
 946             return(sk->back);
 947         }
 948         if(errno == EINPROGRESS)
 949         {
 950             sksetstate(sk, SOCK_SYN);
 951             return(sk->back);
 952         }
 953         putsock(sk);
 954         return(NULL);
 955     }
 956     errno = EOPNOTSUPP;
 957     return(NULL);
 958 }
 959
 960 static void acceptunix(struct ufd *ufd)
 961 {
 962     int buf;
 963
 964     buf = 1;
 965 #if UNIX_AUTH_STYLE == 1
 966     if(setsockopt(ufd->fd, SOL_SOCKET, SO_PASSCRED, &buf, sizeof(buf)) < 0)
 967         flog(LOG_WARNING, "could not enable SO_PASSCRED on Unix socket %i: %s", ufd->fd, strerror(errno));
 968 #elif UNIX_AUTH_STYLE == 2
 969     if(getpeereid(ufd->fd, &ufd->d.s.ucred.uid, &ufd->d.s.ucred.gid) < 0)
 970     {
 971         flog(LOG_WARNING, "could not get peer creds on Unix socket %i: %s", ufd->fd, strerror(errno));
 972         ufd->d.s.ucred.uid = -1;
 973         ufd->d.s.ucred.gid = -1;
 974     }
 975 #endif
 976 }
 977
 978 static void runbatches(void)
 979 {
 980     struct scons *sc, *nsc;
 981
 982     for(sc = cbatch, cbatch = NULL; sc; sc = nsc) {
 983         nsc = sc->n;
 984         if(sc->s->conncb != NULL)
 985             sc->s->conncb(sc->s, 0, sc->s->data);
 986         free(sc);
 987     }
 988     for(sc = rbatch, rbatch = NULL; sc; sc = nsc) {
 989         nsc = sc->n;
 990         if(sc->s->readcb != NULL)
 991             sc->s->readcb(sc->s, sc->s->data);
 992         if((sockgetdatalen(sc->s) == 0) && (sc->s->eos == 1)) {
 993             if(sc->s->errcb != NULL)
 994                 sc->s->errcb(sc->s, 0, sc->s->data);
 995             sc->s->eos = 2;
 996         }
 997         free(sc);
 998     }
 999     for(sc = wbatch, wbatch = NULL; sc; sc = nsc) {
1000         nsc = sc->n;
1001         if(sc->s->writecb != NULL)
1002             sc->s->writecb(sc->s, sc->s->data);
1003         free(sc);
1004     }
1005 }
1006
1007 static void cleansocks(void)
1008 {
1009     struct ufd *ufd, *next;
1010
1011     for(ufd = ufds; ufd != NULL; ufd = next) {
1012         next = ufd->next;
1013         if(ufd->sk && (sockgetdatalen(ufd->sk) == 0)) {
1014             if(ufd->sk->eos == 1) {
1015                 ufd->sk->eos = 2;
1016                 closeufd(ufd);
1017                 closesock(ufd->sk);
1018             }
1019             if((ufd->sk->refcount == 1) && (ufd->sk->back->refcount == 0)) {
1020                 freeufd(ufd);
1021                 continue;
1022             }
1023         }
1024     }
1025 }
1026
1027 int pollsocks(int timeout)
1028 {
1029     int ret;
1030     socklen_t retlen;
1031     int newfd, maxfd;
1032     fd_set rfds, wfds, efds;
1033     struct ufd *ufd, *nufd;
1034     struct socket *nsk;
1035     struct sockaddr_storage ss;
1036     socklen_t sslen;
1037     struct timeval tv;
1038
1039     cleansocks();
1040     FD_ZERO(&rfds);
1041     FD_ZERO(&wfds);
1042     FD_ZERO(&efds);
1043     for(maxfd = 0, ufd = ufds; ufd != NULL; ufd = ufd->next) {
1044         if(ufd->fd < 0)
1045             continue;
1046         if(!ufd->ignread)
1047             FD_SET(ufd->fd, &rfds);
1048         if(ufd->sk != NULL) {
1049             if(sockgetdatalen(ufd->sk) > 0)
1050                 FD_SET(ufd->fd, &wfds);
1051             else if(ufd->sk->state == SOCK_SYN)
1052                 FD_SET(ufd->fd, &wfds);
1053         }
1054         FD_SET(ufd->fd, &efds);
1055         if(ufd->fd > maxfd)
1056             maxfd = ufd->fd;
1057     }
1058     if(rbatch || wbatch || cbatch)
1059         timeout = 0;
1060     tv.tv_sec = timeout / 1000;
1061     tv.tv_usec = (timeout % 1000) * 1000;
1062     ret = select(maxfd + 1, &rfds, &wfds, &efds, (timeout < 0)?NULL:&tv);
1063     if(ret < 0) {
1064         if(errno != EINTR) {
1065             flog(LOG_CRIT, "pollsocks: select errored out: %s", strerror(errno));
1066             /* To avoid CPU hogging in case it's bad, which it
1067              * probably is. */
1068             sleep(1);
1069         }
1070         return(1);
1071     }
1072     for(ufd = ufds; ufd != NULL; ufd = ufd->next) {
1073         if(ufd->sk < 0)
1074             continue;
1075         if(ufd->type == UFD_LISTEN) {
1076             if(FD_ISSET(ufd->fd, &rfds)) {
1077                 sslen = sizeof(ss);
1078                 if((newfd = accept(ufd->fd, (struct sockaddr *)&ss, &sslen)) < 0) {
1079                     if(ufd->d.l.lp->errcb != NULL)
1080                         ufd->d.l.lp->errcb(ufd->d.l.lp, errno, ufd->d.l.lp->data);
1081                 }
1082                 nsk = sockpair(0);
1083                 nufd = mkufd(newfd, UFD_SOCK, nsk);
1084                 nufd->d.s.family = ufd->d.l.family;
1085                 sksetstate(nsk, SOCK_EST);
1086                 memcpy(nufd->d.s.remote = smalloc(sslen), &ss, sslen);
1087                 nufd->d.s.remotelen = sslen;
1088                 if(ss.ss_family == PF_UNIX)
1089                     acceptunix(nufd);
1090                 if(ufd->d.l.lp->acceptcb != NULL)
1091                     ufd->d.l.lp->acceptcb(ufd->d.l.lp, nsk->back, ufd->d.l.lp->data);
1092                 putsock(nsk);
1093             }
1094             if(FD_ISSET(ufd->fd, &efds)) {
1095                 retlen = sizeof(ret);
1096                 getsockopt(ufd->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
1097                 if(ufd->d.l.lp->errcb != NULL)
1098                     ufd->d.l.lp->errcb(ufd->d.l.lp, ret, ufd->d.l.lp->data);
1099                 continue;
1100             }
1101         } else {
1102             if(ufd->sk->state == SOCK_SYN) {
1103                 if(FD_ISSET(ufd->fd, &efds)) {
1104                     retlen = sizeof(ret);
1105                     getsockopt(ufd->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
1106                     if(ufd->sk->back->conncb != NULL)
1107                         ufd->sk->back->conncb(ufd->sk->back, ret, ufd->sk->back->data);
1108                     closeufd(ufd);
1109                     continue;
1110                 }
1111                 if(FD_ISSET(ufd->fd, &rfds) || FD_ISSET(ufd->fd, &wfds)) {
1112                     sksetstate(ufd->sk, SOCK_EST);
1113                     linksock(&cbatch, ufd->sk->back);
1114                 }
1115             } else if(ufd->sk->state == SOCK_EST) {
1116                 if(FD_ISSET(ufd->fd, &efds)) {
1117                     retlen = sizeof(ret);
1118                     getsockopt(ufd->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
1119                     sockerror(ufd->sk, ret);
1120                     closeufd(ufd);
1121                     continue;
1122                 }
1123                 if(FD_ISSET(ufd->fd, &rfds))
1124                     sockrecv(ufd);
1125                 if(ufd->fd == -1)
1126                     continue;
1127                 if(FD_ISSET(ufd->fd, &wfds))
1128                     sockflush(ufd);
1129             }
1130         }
1131     }
1132     runbatches();
1133     cleansocks();
1134     return(1);
1135 }
1136
1137 static struct ufd *getskufd(struct socket *sk)
1138 {
1139     while(1) {
1140         if(sk->back->ufd != NULL)
1141             return(sk->back->ufd);
1142         if((sk = sk->back->pnext) == NULL)
1143             break;
1144     }
1145     return(NULL);
1146 }
1147
1148 int socksettos(struct socket *sk, int tos)
1149 {
1150     int buf;
1151     struct ufd *ufd;
1152
1153     ufd = getskufd(sk);
1154     if(ufd->type != UFD_SOCK) {
1155         errno = EOPNOTSUPP;
1156         return(-1);
1157     }
1158     if(ufd->d.s.family == AF_UNIX)
1159         return(0); /* Unix sockets are always perfect. :) */
1160     if(ufd->d.s.family == AF_INET)
1161     {
1162         switch(tos)
1163         {
1164         case 0:
1165             buf = 0;
1166             break;
1167         case SOCK_TOS_MINCOST:
1168             buf = 0x02;
1169             break;
1170         case SOCK_TOS_MAXREL:
1171             buf = 0x04;
1172             break;
1173         case SOCK_TOS_MAXTP:
1174             buf = 0x08;
1175             break;
1176         case SOCK_TOS_MINDELAY:
1177             buf = 0x10;
1178             break;
1179         default:
1180             flog(LOG_WARNING, "attempted to set unknown TOS value %i to IPv4 sock", tos);
1181             return(-1);
1182         }
1183         if(setsockopt(ufd->fd, IPPROTO_IP, IP_TOS, &buf, sizeof(buf)) < 0)
1184         {
1185             flog(LOG_WARNING, "could not set sock TOS to %i: %s", tos, strerror(errno));
1186             return(-1);
1187         }
1188         return(0);
1189     }
1190     if(ufd->d.s.family == AF_INET6)
1191     {
1192         switch(tos)
1193         {
1194         case 0:
1195             buf = 0;
1196         case SOCK_TOS_MINCOST:
1197             buf = confgetint("net", "diffserv-mincost");
1198             break;
1199         case SOCK_TOS_MAXREL:
1200             buf = confgetint("net", "diffserv-maxrel");
1201             break;
1202         case SOCK_TOS_MAXTP:
1203             buf = confgetint("net", "diffserv-maxtp");
1204             break;
1205         case SOCK_TOS_MINDELAY:
1206             buf = confgetint("net", "diffserv-mindelay");
1207             break;
1208         default:
1209             flog(LOG_WARNING, "attempted to set unknown TOS value %i to IPv4 sock", tos);
1210             return(-1);
1211         }
1212         /*
1213           On Linux, the API IPv6 flow label management doesn't seem to
1214           be entirely complete, so I guess this will have to wait.
1215
1216         if(setsockopt(...) < 0)
1217         {
1218             flog(LOG_WARNING, "could not set sock traffic class to %i: %s", tos, strerror(errno));
1219             return(-1);
1220         }
1221         */
1222         return(0);
1223     }
1224     flog(LOG_WARNING, "could not set TOS on sock of family %i", ufd->d.s.family);
1225     return(1);
1226 }
1227
1228 struct resolvedata
1229 {
1230     int fd;
1231     void (*callback)(struct sockaddr *addr, int addrlen, void *data);
1232     void *data;
1233     struct sockaddr_storage addr;
1234     int addrlen;
1235 };
1236
1237 static void resolvecb(pid_t pid, int status, struct resolvedata *data)
1238 {
1239     static char buf[80];
1240     int ret;
1241     struct sockaddr_in *ipv4;
1242
1243     if(!status)
1244     {
1245         if((ret = read(data->fd, buf, sizeof(buf))) != 4)
1246         {
1247             errno = ENOENT;
1248             data->callback(NULL, 0, data->data);
1249         } else {
1250             ipv4 = (struct sockaddr_in *)&data->addr;
1251             memcpy(&ipv4->sin_addr, buf, 4);
1252             data->callback((struct sockaddr *)ipv4, sizeof(*ipv4), data->data);
1253         }
1254     } else {
1255         errno = ENOENT;
1256         data->callback(NULL, 0, data->data);
1257     }
1258     close(data->fd);
1259     free(data);
1260 }
1261
1262 int netresolve(char *addr, void (*callback)(struct sockaddr *addr, int addrlen, void *data), void *data)
1263 {
1264     int i;
1265     char *p;
1266     int port;
1267     int pfd[2];
1268     pid_t child;
1269     struct resolvedata *rdata;
1270     struct sockaddr_in ipv4;
1271     struct hostent *he;
1272     sigset_t sigset;
1273
1274     /* IPv4 */
1275     port = -1;
1276     if((p = strchr(addr, ':')) != NULL)
1277     {
1278         *p = 0;
1279         port = atoi(p + 1);
1280     }
1281     ipv4.sin_family = AF_INET;
1282     ipv4.sin_port = htons(port);
1283     if(inet_aton(addr, &ipv4.sin_addr))
1284     {
1285         callback((struct sockaddr *)&ipv4, sizeof(ipv4), data);
1286     } else {
1287         sigemptyset(&sigset);
1288         sigaddset(&sigset, SIGCHLD);
1289         sigprocmask(SIG_BLOCK, &sigset, NULL);
1290         if((pipe(pfd) < 0) || ((child = fork()) < 0))
1291         {
1292             sigprocmask(SIG_UNBLOCK, &sigset, NULL);
1293             return(-1);
1294         }
1295         if(child == 0)
1296         {
1297             sigprocmask(SIG_UNBLOCK, &sigset, NULL);
1298             for(i = 3; i < FD_SETSIZE; i++)
1299             {
1300                 if(i != pfd[1])
1301                     close(i);
1302             }
1303             signal(SIGALRM, SIG_DFL);
1304             alarm(30);
1305             if((he = gethostbyname(addr)) == NULL)
1306                 exit(1);
1307             write(pfd[1], he->h_addr_list[0], 4);
1308             exit(0);
1309         } else {
1310             close(pfd[1]);
1311             fcntl(pfd[0], F_SETFL, fcntl(pfd[0], F_GETFL) | O_NONBLOCK);
1312             rdata = smalloc(sizeof(*rdata));
1313             rdata->fd = pfd[0];
1314             rdata->callback = callback;
1315             rdata->data = data;
1316             memcpy(&rdata->addr, &ipv4, rdata->addrlen = sizeof(ipv4));
1317             childcallback(child, (void (*)(pid_t, int, void *))resolvecb, rdata);
1318             sigprocmask(SIG_UNBLOCK, &sigset, NULL);
1319             return(1);
1320         }
1321     }
1322     return(0);
1323 }
1324
1325 static int getlocalname(int fd, struct sockaddr **namebuf, socklen_t *lenbuf)
1326 {
1327     socklen_t len;
1328     struct sockaddr_storage name;
1329
1330     *namebuf = NULL;
1331     if(fd < 0)
1332         return(-1);
1333     len = sizeof(name);
1334     if(getsockname(fd, (struct sockaddr *)&name, &len) < 0)
1335     {
1336         flog(LOG_ERR, "BUG: alive socket with dead fd in sockgetlocalname (%s)", strerror(errno));
1337         return(-1);
1338     }
1339     *namebuf = memcpy(smalloc(len), &name, len);
1340     if(lenbuf != NULL)
1341         *lenbuf = len;
1342     return(0);
1343 }
1344
1345 int lstgetlocalname(struct lport *lp, struct sockaddr **namebuf, socklen_t *lenbuf)
1346 {
1347     struct ufd *ufd;
1348
1349     ufd = lp->ufd;
1350     return(getlocalname(ufd->fd, namebuf, lenbuf));
1351 }
1352
1353 int sockgetlocalname(struct socket *sk, struct sockaddr **namebuf, socklen_t *lenbuf)
1354 {
1355     struct ufd *ufd;
1356
1357     ufd = getskufd(sk);
1358     if(ufd->type != UFD_SOCK) {
1359         errno = EOPNOTSUPP;
1360         return(-1);
1361     }
1362     return(getlocalname(ufd->fd, namebuf, lenbuf));
1363 }
1364
1365 static void sethostaddr(struct sockaddr *dst, struct sockaddr *src)
1366 {
1367     if(dst->sa_family != src->sa_family)
1368     {
1369         flog(LOG_ERR, "BUG: non-matching socket families in sethostaddr (%i -> %i)", src->sa_family, dst->sa_family);
1370         return;
1371     }
1372     switch(src->sa_family)
1373     {
1374     case AF_INET:
1375         ((struct sockaddr_in *)dst)->sin_addr = ((struct sockaddr_in *)src)->sin_addr;
1376         break;
1377     case AF_INET6:
1378         ((struct sockaddr_in6 *)dst)->sin6_addr = ((struct sockaddr_in6 *)src)->sin6_addr;
1379         break;
1380     default:
1381         flog(LOG_WARNING, "sethostaddr unimplemented for family %i", src->sa_family);
1382         break;
1383     }
1384 }
1385
1386 static int makepublic(struct sockaddr *addr)
1387 {
1388     int ret;
1389     socklen_t plen;
1390     struct sockaddr *pname;
1391
1392     if((ret = getpublicaddr(addr->sa_family, &pname, &plen)) < 0)
1393     {
1394         flog(LOG_ERR, "could not get public address: %s", strerror(errno));
1395         return(-1);
1396     }
1397     if(ret)
1398         return(0);
1399     sethostaddr(addr, pname);
1400     free(pname);
1401     return(0);
1402 }
1403
1404 static int getremotename(int fd, struct sockaddr **namebuf, socklen_t *lenbuf)
1405 {
1406     socklen_t len;
1407     struct sockaddr *name;
1408
1409     switch(confgetint("net", "mode")) {
1410     case 0:
1411         *namebuf = NULL;
1412         if(!getlocalname(fd, &name, &len)) {
1413             *namebuf = name;
1414             *lenbuf = len;
1415             makepublic(name);
1416             return(0);
1417         }
1418         flog(LOG_ERR, "could not get remotely accessible name by any means");
1419         return(-1);
1420     case 1:
1421         errno = EOPNOTSUPP;
1422         return(-1);
1423     default:
1424         flog(LOG_CRIT, "unknown net mode %i active", confgetint("net", "mode"));
1425         errno = EOPNOTSUPP;
1426         return(-1);
1427     }
1428 }
1429
1430 int sockgetremotename(struct socket *sk, struct sockaddr **namebuf, socklen_t *lenbuf)
1431 {
1432     struct ufd *ufd;
1433
1434     ufd = getskufd(sk);
1435     if(ufd->type != UFD_SOCK) {
1436         errno = EOPNOTSUPP;
1437         return(-1);
1438     }
1439     if(ufd->fd < 0) {
1440         errno = EBADF;
1441         return(-1);
1442     }
1443     return(getremotename(ufd->fd, namebuf, lenbuf));
1444 }
1445
1446 int lstgetremotename(struct lport *lp, struct sockaddr **namebuf, socklen_t *lenbuf)
1447 {
1448     struct ufd *ufd;
1449
1450     ufd = lp->ufd;
1451     return(getremotename(ufd->fd, namebuf, lenbuf));
1452 }
1453
1454 int sockgetremotename2(struct socket *sk, struct socket *sk2, struct sockaddr **namebuf, socklen_t *lenbuf)
1455 {
1456     struct sockaddr *name1, *name2;
1457     socklen_t len1, len2;
1458     struct ufd *ufd1, *ufd2;
1459
1460     ufd1 = getskufd(sk);
1461     ufd2 = getskufd(sk2);
1462     if((ufd1->type != UFD_SOCK) || (ufd2->type != UFD_SOCK)) {
1463         errno = EOPNOTSUPP;
1464         return(-1);
1465     }
1466     if(ufd1->d.s.family != ufd2->d.s.family)
1467     {
1468         flog(LOG_ERR, "using sockgetremotename2 with sockets of differing family: %i %i", ufd1->d.s.family, ufd2->d.s.family);
1469         return(-1);
1470     }
1471     if(getremotename(ufd1->fd, &name1, &len1))
1472         return(-1);
1473     if(getremotename(ufd2->fd, &name2, &len2)) {
1474         free(name1);
1475         return(-1);
1476     }
1477     sethostaddr(name1, name2);
1478     free(name2);
1479     *namebuf = name1;
1480     *lenbuf = len1;
1481     return(0);
1482 }
1483
1484 int lstgetremotename2(struct lport *lp, struct socket *sk2, struct sockaddr **namebuf, socklen_t *lenbuf)
1485 {
1486     struct sockaddr *name1, *name2;
1487     socklen_t len1, len2;
1488     struct ufd *ufd1, *ufd2;
1489
1490     ufd1 = lp->ufd;
1491     ufd2 = getskufd(sk2);
1492     if(ufd2->type != UFD_SOCK) {
1493         errno = EOPNOTSUPP;
1494         return(-1);
1495     }
1496     if(ufd1->d.s.family != ufd2->d.s.family)
1497     {
1498         flog(LOG_ERR, "using lstgetremotename2 with sockets of differing family: %i %i", ufd1->d.s.family, ufd2->d.s.family);
1499         return(-1);
1500     }
1501     if(getremotename(ufd1->fd, &name1, &len1))
1502         return(-1);
1503     if(getremotename(ufd2->fd, &name2, &len2)) {
1504         free(name1);
1505         return(-1);
1506     }
1507     sethostaddr(name1, name2);
1508     free(name2);
1509     *namebuf = name1;
1510     *lenbuf = len1;
1511     return(0);
1512 }
1513
1514 int getucred(struct socket *sk, uid_t *uid, gid_t *gid)
1515 {
1516     struct ufd *ufd;
1517
1518     ufd = getskufd(sk);
1519     if(ufd->type != UFD_SOCK) {
1520         errno = EOPNOTSUPP;
1521         return(-1);
1522     }
1523     if(ufd->d.s.family != AF_UNIX) {
1524         errno = EOPNOTSUPP;
1525         return(-1);
1526     }
1527     *uid = ufd->d.s.ucred.uid;
1528     *gid = ufd->d.s.ucred.gid;
1529     return(0);
1530 }
1531
1532 void sockblock(struct socket *sk, int block)
1533 {
1534     struct ufd *ufd;
1535
1536     ufd = getskufd(sk);
1537     ufd->ignread = block;
1538 }
1539
1540 int sockfamily(struct socket *sk)
1541 {
1542     struct ufd *ufd;
1543
1544     ufd = getskufd(sk);
1545     if(ufd->type != UFD_SOCK) {
1546         errno = EOPNOTSUPP;
1547         return(-1);
1548     }
1549     return(ufd->d.s.family);
1550 }
1551
1552 int sockpeeraddr(struct socket *sk, struct sockaddr **namebuf, socklen_t *lenbuf)
1553 {
1554     struct ufd *ufd;
1555
1556     ufd = getskufd(sk);
1557     if(ufd->type != UFD_SOCK) {
1558         errno = EOPNOTSUPP;
1559         return(-1);
1560     }
1561     if(ufd->d.s.remote == NULL)
1562         return(-1);
1563     *namebuf = memcpy(smalloc(ufd->d.s.remotelen), ufd->d.s.remote, ufd->d.s.remotelen);
1564     if(lenbuf != NULL)
1565         *lenbuf = ufd->d.s.remotelen;
1566     return(0);
1567 }
1568
1569 char *formatsockpeer(struct socket *sk)
1570 {
1571     struct sockaddr *name;
1572     socklen_t nlen;
1573     char *ret;
1574
1575     if(sockpeeraddr(sk, &name, &nlen))
1576         return(NULL);
1577     ret = formataddress(name, nlen);
1578     free(name);
1579     return(ret);
1580 }
1581
1582 int addreq(struct sockaddr *x, struct sockaddr *y)
1583 {
1584     struct sockaddr_un *u1, *u2;
1585     struct sockaddr_in *n1, *n2;
1586 #ifdef HAVE_IPV6
1587     struct sockaddr_in6 *s1, *s2;
1588 #endif
1589
1590     if(x->sa_family != y->sa_family)
1591         return(0);
1592     switch(x->sa_family) {
1593     case AF_UNIX:
1594         u1 = (struct sockaddr_un *)x; u2 = (struct sockaddr_un *)y;
1595         if(strncmp(u1->sun_path, u2->sun_path, sizeof(u1->sun_path)))
1596             return(0);
1597         break;
1598     case AF_INET:
1599         n1 = (struct sockaddr_in *)x; n2 = (struct sockaddr_in *)y;
1600         if(n1->sin_port != n2->sin_port)
1601             return(0);
1602         if(n1->sin_addr.s_addr != n2->sin_addr.s_addr)
1603             return(0);
1604         break;
1605 #ifdef HAVE_IPV6
1606     case AF_INET6:
1607         s1 = (struct sockaddr_in6 *)x; s2 = (struct sockaddr_in6 *)y;
1608         if(s1->sin6_port != s2->sin6_port)
1609             return(0);
1610         if(memcmp(s1->sin6_addr.s6_addr, s2->sin6_addr.s6_addr, sizeof(s1->sin6_addr.s6_addr)))
1611             return(0);
1612         break;
1613 #endif
1614     }
1615     return(1);
1616 }
1617
1618 char *formataddress(struct sockaddr *arg, socklen_t arglen)
1619 {
1620     struct sockaddr_in *ipv4;
1621 #ifdef HAVE_IPV6
1622     struct sockaddr_in6 *ipv6;
1623 #endif
1624     static char *ret = NULL;
1625     char buf[1024];
1626
1627     if(ret != NULL)
1628         free(ret);
1629     ret = NULL;
1630     switch(arg->sa_family)
1631     {
1632     case AF_UNIX:
1633         ret = sstrdup("Unix socket");
1634         break;
1635     case AF_INET:
1636         ipv4 = (struct sockaddr_in *)arg;
1637         if(inet_ntop(AF_INET, &ipv4->sin_addr, buf, sizeof(buf)) == NULL)
1638             return(NULL);
1639         ret = sprintf2("%s:%i", buf, (int)ntohs(ipv4->sin_port));
1640         break;
1641 #ifdef HAVE_IPV6
1642     case AF_INET6:
1643         ipv6 = (struct sockaddr_in6 *)arg;
1644         if(inet_ntop(AF_INET6, &ipv6->sin6_addr, buf, sizeof(buf)) == NULL)
1645             return(NULL);
1646         ret = sprintf2("[%s]:%i", buf, (int)ntohs(ipv6->sin6_port));
1647         break;
1648 #endif
1649     default:
1650         errno = EPFNOSUPPORT;
1651         break;
1652     }
1653     return(ret);
1654 }
1655
1656 #if 0
1657
1658 /*
1659  * It was very nice to use this, but it seems
1660  * to mess things up, so I guess it has to go... :-(
1661  */
1662
1663 static int formataddress(FILE *stream, const struct printf_info *info, const void *const *args)
1664 {
1665     struct sockaddr *arg;
1666     socklen_t arglen;
1667     struct sockaddr_un *UNIX; /* Some wise guy has #defined unix with
1668                                * lowercase letters to 1, so I do this
1669                                * instead. */
1670     struct sockaddr_in *ipv4;
1671     int ret;
1672
1673     arg = *(struct sockaddr **)(args[0]);
1674     arglen = *(socklen_t *)(args[1]);
1675     switch(arg->sa_family)
1676     {
1677     case AF_UNIX:
1678         UNIX = (struct sockaddr_un *)arg;
1679         ret = fprintf(stream, "%s", UNIX->sun_path);
1680         break;
1681     case AF_INET:
1682         ipv4 = (struct sockaddr_in *)arg;
1683         ret = fprintf(stream, "%s:%i", inet_ntoa(ipv4->sin_addr), (int)ntohs(ipv4->sin_port));
1684         break;
1685     default:
1686         ret = -1;
1687         errno = EPFNOSUPPORT;
1688         break;
1689     }
1690     return(ret);
1691 }
1692
1693 static int formataddress_arginfo(const struct printf_info *info, size_t n, int *argtypes)
1694 {
1695     if(n > 0)
1696         argtypes[0] = PA_POINTER;
1697     if(n > 1)
1698         argtypes[1] = PA_INT; /* Sources tell me that socklen_t _must_
1699                                * be an int, so I guess this should be
1700                                * safe. */
1701     return(2);
1702 }
1703 #endif
1704
1705 static int init(int hup)
1706 {
1707     if(!hup)
1708     {
1709         /*
1710         if(register_printf_function('N', formataddress, formataddress_arginfo))
1711         {
1712             flog(LOG_CRIT, "could not register printf handler %%N: %s", strerror(errno));
1713             return(1);
1714         }
1715         */
1716     }
1717     return(0);
1718 }
1719
1720 static void terminate(void)
1721 {
1722     /*
1723     while(ufds != NULL)
1724         freeufd(ufds);
1725     */
1726 }
1727
1728 static struct module me =
1729 {
1730     .name = "net",
1731     .conf =
1732     {
1733         .vars = myvars
1734     },
1735     .init = init,
1736     .terminate = terminate
1737 };
1738
1739 MODULE(me)