Dolda2000 GitWeb / doldaconnect.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Return errors directly from sockflush.
[doldaconnect.git] / daemon / net.c
CommitLineData
d3372da9 1/*
2 * Dolda Connect - Modular multiuser Direct Connect-style client
302a2600 3 * Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
d3372da9 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>
72a7835e 31#include <sys/select.h>
d3372da9 32#include <arpa/inet.h>
33#include <netinet/in.h>
34#include <netdb.h>
35#include <sys/signal.h>
7ab36fbd 36#include <sys/stat.h> /* For rebindunix() */
d3372da9 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
50static struct configvar myvars[] =
51{
d9f89ef5 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. */
d3372da9 55 {CONF_VAR_INT, "mode", {.num = 0}},
d9f89ef5 56 /** Set the SO_REUSEADDR socket option on listening sockets, so
57 * that dead TCP connections waiting for timeout are ignored. */
347d6d76 58 {CONF_VAR_BOOL, "reuseaddr", {.num = 0}},
d9f89ef5 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. */
d3372da9 63 {CONF_VAR_IPV4, "visibleipv4", {.ipv4 = {0}}},
d9f89ef5 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. */
d3372da9 68 {CONF_VAR_STRING, "publicif", {.str = L""}},
b020fb3d 69 /* Diffserv should be supported on IPv4, too, but I don't know the
70 * API to do that. */
d9f89ef5 71 /** The Diffserv value to use on IPv6 connections when the
72 * minimize cost TOS value is used (see the TOS VALUES
73 * section). */
b020fb3d 74 {CONF_VAR_INT, "diffserv-mincost", {.num = 0}},
d9f89ef5 75 /** The Diffserv value to use on IPv6 connections when the
76 * maximize reliability TOS value is used (see the TOS VALUES
77 * section). */
b020fb3d 78 {CONF_VAR_INT, "diffserv-maxrel", {.num = 0}},
d9f89ef5 79 /** The Diffserv value to use on IPv6 connections when the
80 * maximize throughput TOS value is used (see the TOS VALUES
81 * section). */
b020fb3d 82 {CONF_VAR_INT, "diffserv-maxtp", {.num = 0}},
d9f89ef5 83 /** The Diffserv value to use on IPv6 connections when the
84 * minimize delay TOS value is used (see the TOS VALUES
85 * section). */
b020fb3d 86 {CONF_VAR_INT, "diffserv-mindelay", {.num = 0}},
d3372da9 87 {CONF_VAR_END}
88};
89
02a705ad
FT		 90#define UFD_SOCK 0
91#define UFD_PIPE 1
92#define UFD_LISTEN 2
93
94struct scons {
95 struct scons *n, *p;
96 struct socket *s;
97};
98
99struct 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
40c21c4f
FT		 123static int getlocalname(int fd, struct sockaddr **namebuf, socklen_t *lenbuf);
124
02a705ad
FT		 125static struct ufd *ufds = NULL;
126static struct scons *rbatch, *wbatch, *cbatch;
d3372da9 127int numsocks = 0;
128
129/* XXX: Get autoconf for all this... */
130int getpublicaddr(int af, struct sockaddr **addr, socklen_t *lenbuf)
131{
132 struct sockaddr_in *ipv4;
133 struct configvar *var;
134 void *bufend;
135 int sock;
136 struct ifconf conf;
137 struct ifreq *ifr, req;
138 char *pif;
139
140 if(af == AF_INET)
141 {
142 var = confgetvar("net", "visibleipv4");
143 if(var->val.ipv4.s_addr != 0)
144 {
145 ipv4 = smalloc(sizeof(*ipv4));
146 ipv4->sin_family = AF_INET;
147 ipv4->sin_addr.s_addr = var->val.ipv4.s_addr;
148 *addr = (struct sockaddr *)ipv4;
149 *lenbuf = sizeof(*ipv4);
150 return(0);
151 }
bcb73bb3 152 if((pif = icswcstombs(confgetstr("net", "publicif"), NULL, NULL)) == NULL)
d3372da9 153 {
154 flog(LOG_ERR, "could not convert net.publicif into local charset: %s", strerror(errno));
155 return(-1);
156 }
6fb0c6ac 157 if(!strcmp(pif, ""))
158 return(1);
d3372da9 159 if((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
160 return(-1);
161 conf.ifc_buf = smalloc(conf.ifc_len = 65536);
162 if(ioctl(sock, SIOCGIFCONF, &conf) < 0)
163 {
164 free(conf.ifc_buf);
165 close(sock);
166 return(-1);
167 }
168 bufend = ((char *)conf.ifc_buf) + conf.ifc_len;
169 ipv4 = NULL;
170 for(ifr = conf.ifc_ifcu.ifcu_req; (void *)ifr < bufend; ifr++)
171 {
1315d02a 172 if(strcmp(ifr->ifr_name, pif))
6fb0c6ac 173 continue;
d3372da9 174 memset(&req, 0, sizeof(req));
175 memcpy(req.ifr_name, ifr->ifr_name, sizeof(ifr->ifr_name));
176 if(ioctl(sock, SIOCGIFFLAGS, &req) < 0)
6fb0c6ac 177 break;
178 if(!(req.ifr_flags & IFF_UP))
d3372da9 179 {
6fb0c6ac 180 flog(LOG_WARNING, "public interface is down");
181 break;
d3372da9 182 }
6fb0c6ac 183 if(ifr->ifr_addr.sa_family != AF_INET)
d3372da9 184 {
6fb0c6ac 185 flog(LOG_WARNING, "address of the public interface is not AF_INET");
186 break;
d3372da9 187 }
6fb0c6ac 188 ipv4 = smalloc(sizeof(*ipv4));
189 memcpy(ipv4, &ifr->ifr_addr, sizeof(ifr->ifr_addr));
190 break;
d3372da9 191 }
bcb73bb3 192 free(conf.ifc_buf);
d3372da9 193 close(sock);
194 if(ipv4 != NULL)
195 {
196 *addr = (struct sockaddr *)ipv4;
197 *lenbuf = sizeof(*ipv4);
198 return(0);
199 }
200 errno = ENETDOWN;
201 return(-1);
202 }
6fb0c6ac 203 return(1);
d3372da9 204}
205
02a705ad 206static struct socket *newsock1(int dgram)
d3372da9 207{
208 struct socket *new;
209
02a705ad
FT		 210 new = memset(smalloc(sizeof(*new)), 0, sizeof(*new));
211 new->refcount = 1;
d3372da9 212 new->state = -1;
02a705ad 213 new->dgram = dgram;
d3372da9 214 numsocks++;
215 return(new);
216}
217
02a705ad
FT		 218static struct socket *sockpair(int dgram)
219{
220 struct socket *s1, *s2;
221
222 s1 = newsock1(dgram);
223 s2 = newsock1(dgram);
224 s1->back = s2;
225 s2->back = s1;
226 putsock(s2);
227 return(s1);
228}
229
230static void sksetstate(struct socket *sk, int state)
231{
232 sk->state = state;
233 sk->back->state = state;
234}
235
236static void closeufd(struct ufd *ufd)
237{
238 if(ufd->fd != -1)
239 close(ufd->fd);
240 ufd->fd = -1;
241}
242
243static void freeufd(struct ufd *ufd)
244{
245 if(ufd->next != NULL)
246 ufd->next->prev = ufd->prev;
247 if(ufd->prev != NULL)
248 ufd->prev->next = ufd->next;
249 if(ufd == ufds)
250 ufds = ufd->next;
251 closeufd(ufd);
5afb0d14
FT		 252 if(ufd->sk != NULL)
253 putsock(ufd->sk);
02a705ad
FT		 254 if(ufd->type == UFD_SOCK) {
255 if(ufd->d.s.remote != NULL)
256 free(ufd->d.s.remote);
257 }
258 free(ufd);
259}
260
261static struct ufd *mkufd(int fd, int type, struct socket *sk)
262{
263 struct ufd *ufd;
264
265 ufd = memset(smalloc(sizeof(*ufd)), 0, sizeof(*ufd));
266 ufd->fd = fd;
5afb0d14 267 ufd->type = type;
02a705ad
FT		 268 if(sk != NULL) {
269 getsock(ufd->sk = sk);
270 sk->ufd = ufd;
271 }
272 if(type == UFD_SOCK) {
273 ufd->d.s.ucred.uid = -1;
274 ufd->d.s.ucred.gid = -1;
275 }
276 ufd->next = ufds;
277 if(ufds)
278 ufds->prev = ufd;
279 ufds = ufd;
280 return(ufd);
281}
282
283static struct ufd *dupufd(struct ufd *ufd)
284{
285 struct ufd *nufd;
286 struct socket *nsk;
287
288 if(ufd->sk != NULL)
289 nsk = sockpair(ufd->sk->dgram);
290 else
291 nsk = NULL;
292 nufd = mkufd(ufd->fd, ufd->type, nsk);
293 if(nsk != NULL)
294 putsock(nsk);
295 if((nufd->fd = dup(ufd->fd)) < 0)
296 {
297 flog(LOG_WARNING, "could not dup() fd: %s", strerror(errno));
298 freeufd(nufd);
299 return(NULL);
300 }
5afb0d14 301 sksetstate(nsk, SOCK_EST);
02a705ad
FT		 302 if(ufd->type == UFD_SOCK) {
303 nufd->d.s.family = ufd->d.s.family;
304 nufd->d.s.type = ufd->d.s.type;
305 nufd->d.s.ucred.uid = ufd->d.s.ucred.uid;
306 nufd->d.s.ucred.gid = ufd->d.s.ucred.gid;
307 if(ufd->d.s.remote != NULL)
308 nufd->d.s.remote = memcpy(smalloc(ufd->d.s.remotelen), ufd->d.s.remote, nufd->d.s.remotelen = ufd->d.s.remotelen);
309 } else if(ufd->type == UFD_LISTEN) {
310 nufd->d.l.family = ufd->d.l.family;
311 }
312 return(nufd);
313}
314
d3372da9 315static struct socket *mksock(int domain, int type)
316{
317 int fd;
02a705ad
FT		 318 struct socket *sk;
319 struct ufd *ufd;
d3372da9 320
321 if((fd = socket(domain, type, 0)) < 0)
322 {
323 flog(LOG_CRIT, "could not create socket: %s", strerror(errno));
324 return(NULL);
325 }
02a705ad
FT		 326 sk = sockpair(type == SOCK_DGRAM);
327 ufd = mkufd(fd, UFD_SOCK, sk);
328 ufd->d.s.family = domain;
329 ufd->d.s.type = type;
d3372da9 330 fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
02a705ad 331 return(sk);
d3372da9 332}
333
334struct socket *wrapsock(int fd)
335{
02a705ad
FT		 336 struct socket *sk;
337 struct ufd *ufd;
d3372da9 338
02a705ad
FT		 339 sk = sockpair(0);
340 ufd = mkufd(fd, UFD_PIPE, sk->back);
341 sksetstate(sk, SOCK_EST);
d3372da9 342 fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
02a705ad 343 return(sk);
d3372da9 344}
345
346void getsock(struct socket *sk)
347{
348 sk->refcount++;
349}
350
02a705ad 351static void freesock(struct socket *sk)
d3372da9 352{
353 struct dgrambuf *buf;
354
02a705ad
FT		 355 if(sk->dgram) {
356 while((buf = sk->buf.d.f) != NULL) {
357 sk->buf.d.f = buf->next;
358 freedgbuf(buf);
d3372da9 359 }
02a705ad
FT		 360 } else {
361 if(sk->buf.s.buf != NULL)
362 free(sk->buf.s.buf);
363 }
364 free(sk);
365 numsocks--;
366}
367
368void putsock(struct socket *sk)
369{
7dddb551
FT		 370 struct socket *back;
371
02a705ad
FT		 372 if(--(sk->refcount) < 0) {
373 flog(LOG_CRIT, "BUG: socket refcount < 0");
374 abort();
375 }
376 if((sk->refcount == 0) && (sk->back->refcount == 0)) {
7dddb551 377 back = sk->back;
02a705ad 378 freesock(sk);
7dddb551 379 freesock(back);
02a705ad
FT		 380 }
381}
382
383static void linksock(struct scons **list, struct socket *sk)
384{
385 struct scons *sc;
386
387 for(sc = *list; sc != NULL; sc = sc->n) {
388 if(sc->s == sk)
389 return;
d3372da9 390 }
02a705ad
FT		 391 sc = smalloc(sizeof(*sc));
392 getsock(sc->s = sk);
393 sc->n = *list;
394 sc->p = NULL;
395 if(*list)
396 (*list)->p = sc;
397 *list = sc;
d3372da9 398}
399
336539c2 400void sockpushdata(struct socket *sk, void *buf, size_t size)
401{
02a705ad
FT		 402 if(size == 0)
403 return;
404 if(sk->dgram) {
336539c2 405 /* XXX */
02a705ad
FT		 406 } else {
407 sizebuf(&sk->buf.s.buf, &sk->buf.s.bufsize, sk->buf.s.datasize + size, 1, 1);
408 memmove(sk->buf.s.buf + size, sk->buf.s.buf, sk->buf.s.datasize);
409 memcpy(sk->buf.s.buf, buf, size);
410 sk->buf.s.datasize += size;
411 linksock(&rbatch, sk);
336539c2 412 }
02a705ad
FT		 413}
414
415/* Read as the preterite of `read' */
416void sockread(struct socket *sk)
417{
5afb0d14
FT		 418 if((sockgetdatalen(sk) == 0) && (sk->eos == 1))
419 linksock(&rbatch, sk);
02a705ad
FT		 420 linksock(&wbatch, sk->back);
421}
422
423void freedgbuf(struct dgrambuf *dg)
424{
425 if(dg->data != NULL)
426 free(dg->data);
427 if(dg->addr != NULL)
428 free(dg->addr);
429 free(dg);
430}
431
432struct dgrambuf *sockgetdgbuf(struct socket *sk)
433{
434 struct dgrambuf *dbuf;
435
436 if((dbuf = sk->buf.d.f) == NULL)
437 return(NULL);
438 sk->buf.d.f = dbuf->next;
439 if(dbuf->next == NULL)
440 sk->buf.d.l = NULL;
441 dbuf->next = NULL;
442 sockread(sk);
443 return(dbuf);
336539c2 444}
445
d3372da9 446void *sockgetinbuf(struct socket *sk, size_t *size)
447{
448 void *buf;
449 struct dgrambuf *dbuf;
450
02a705ad
FT		 451 if(sk->dgram) {
452 dbuf = sockgetdgbuf(sk);
d3372da9 453 buf = dbuf->data;
454 *size = dbuf->size;
455 free(dbuf->addr);
456 free(dbuf);
02a705ad
FT		 457 } else {
458 if((sk->buf.s.buf == NULL) || (sk->buf.s.datasize == 0))
459 {
460 *size = 0;
461 return(NULL);
462 }
463 buf = sk->buf.s.buf;
464 *size = sk->buf.s.datasize;
465 sk->buf.s.buf = NULL;
466 sk->buf.s.bufsize = sk->buf.s.datasize = 0;
467 sockread(sk);
d3372da9 468 }
02a705ad
FT		 469 return(buf);
470}
471
472void sockqueue(struct socket *sk, void *data, size_t size)
473{
474 struct dgrambuf *new;
475 struct sockaddr *remote;
476 socklen_t remotelen;
477
478 if(size == 0)
479 return;
480 if(sk->state == SOCK_STL)
481 return;
482 if(sk->dgram) {
483 if(sockpeeraddr(sk, &remote, &remotelen))
484 return;
485 new = smalloc(sizeof(*new));
486 new->next = NULL;
487 memcpy(new->data = smalloc(size), data, new->size = size);
488 new->addr = remote;
489 new->addrlen = remotelen;
490 if(sk->back->buf.d.l == NULL)
491 {
492 sk->back->buf.d.l = sk->back->buf.d.f = new;
493 } else {
494 sk->back->buf.d.l->next = new;
495 sk->back->buf.d.l = new;
496 }
497 } else {
498 sizebuf(&(sk->back->buf.s.buf), &(sk->back->buf.s.bufsize), sk->back->buf.s.datasize + size, 1, 1);
499 memcpy(sk->back->buf.s.buf + sk->back->buf.s.datasize, data, size);
500 sk->back->buf.s.datasize += size;
501 }
502 linksock(&rbatch, sk->back);
503}
504
505void sockqueuedg(struct socket *sk, struct dgrambuf *dg)
506{
507 if(sk->state == SOCK_STL) {
508 freedgbuf(dg);
509 return;
510 }
511 if(!sk->dgram) {
512 flog(LOG_ERR, "BUG: sockqueuedg called on non-dgram socket");
513 freedgbuf(dg);
514 return;
515 }
516 dg->next = NULL;
517 if(sk->back->buf.d.l == NULL)
518 {
519 sk->back->buf.d.l = sk->back->buf.d.f = dg;
520 } else {
521 sk->back->buf.d.l->next = dg;
522 sk->back->buf.d.l = dg;
523 }
524 linksock(&rbatch, sk->back);
525}
526
40c21c4f 527void sockerror(struct socket *sk, int en)
02a705ad
FT		 528{
529 sksetstate(sk, SOCK_STL);
530 if(sk->back->errcb != NULL)
531 sk->back->errcb(sk->back, en, sk->back->data);
d3372da9 532}
533
02a705ad 534static void recvcmsg(struct ufd *ufd, struct msghdr *msg)
9e5f2b29 535{
536 struct cmsghdr *cmsg;
9e5f2b29 537
538 for(cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg))
539 {
a8c5ada6 540#if UNIX_AUTH_STYLE == 1
9e5f2b29 541 if((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SCM_CREDENTIALS))
542 {
a8c5ada6 543 struct ucred *cred;
02a705ad 544 if(ufd->d.s.ucred.uid == -1)
9e5f2b29 545 {
546 cred = (struct ucred *)CMSG_DATA(cmsg);
02a705ad
FT		 547 ufd->d.s.ucred.uid = cred->uid;
548 ufd->d.s.ucred.gid = cred->gid;
9e5f2b29 549 }
550 }
a8c5ada6 551#endif
9e5f2b29 552 }
553}
554
02a705ad
FT		 555static int ufddgram(struct ufd *ufd)
556{
557 int dgram;
558
559 if(ufd->type == UFD_SOCK) {
560 dgram = ufd->d.s.type == SOCK_DGRAM;
561 } else if(ufd->type == UFD_PIPE) {
562 dgram = 0;
563 } else {
564 flog(LOG_ERR, "BUG: calling ufddgram on ufd of bad type %i", ufd->type);
565 return(-1);
566 }
567 if(ufd->sk == NULL) {
568 flog(LOG_ERR, "BUG: calling ufddgram on socketless ufd (type %i)", ufd->type);
569 return(-1);
570 }
571 if(dgram != ufd->sk->dgram) {
572 flog(LOG_ERR, "BUG: ufd/socket dgram value mismatch");
573 return(-1);
574 }
575 return(dgram);
576}
577
578static void sockrecv(struct ufd *ufd)
d3372da9 579{
580 int ret, inq;
02a705ad 581 int dgram;
d3372da9 582 struct dgrambuf *dbuf;
9e5f2b29 583 struct msghdr msg;
584 char cbuf[65536];
585 struct iovec bufvec;
02a705ad 586 void *buf;
d3372da9 587
9e5f2b29 588 memset(&msg, 0, sizeof(msg));
589 msg.msg_iov = &bufvec;
590 msg.msg_iovlen = 1;
591 msg.msg_control = cbuf;
592 msg.msg_controllen = sizeof(cbuf);
02a705ad
FT		 593 if((dgram = ufddgram(ufd)) < 0)
594 return;
595 if(dgram) {
9e5f2b29 596#if defined(HAVE_LINUX_SOCKIOS_H) && defined(SIOCINQ)
02a705ad 597 if(ioctl(ufd->fd, SIOCINQ, &inq))
d3372da9 598 {
599 /* I don't really know what could go wrong here, so let's
600 * assume it's transient. */
02a705ad 601 flog(LOG_WARNING, "SIOCINQ return %s on socket %i", strerror(errno), ufd->fd);
d3372da9 602 return;
603 }
9e5f2b29 604#else
605 inq = 65536;
606#endif
d3372da9 607 dbuf = smalloc(sizeof(*dbuf));
608 dbuf->data = smalloc(inq);
609 dbuf->addr = smalloc(dbuf->addrlen = sizeof(struct sockaddr_storage));
9e5f2b29 610 msg.msg_name = dbuf->addr;
611 msg.msg_namelen = dbuf->addrlen;
612 bufvec.iov_base = dbuf->data;
613 bufvec.iov_len = inq;
02a705ad 614 ret = recvmsg(ufd->fd, &msg, 0);
9e5f2b29 615 dbuf->addrlen = msg.msg_namelen;
d3372da9 616 if(ret < 0)
617 {
02a705ad 618 freedgbuf(dbuf);
d3372da9 619 if((errno == EINTR) || (errno == EAGAIN))
620 return;
02a705ad
FT		 621 closeufd(ufd);
622 sockerror(ufd->sk, errno);
d3372da9 623 return;
624 }
9e5f2b29 625 if(msg.msg_flags & MSG_CTRUNC)
626 flog(LOG_DEBUG, "ancillary data was truncated");
627 else
02a705ad 628 recvcmsg(ufd, &msg);
d3372da9 629 /* On UDP/IPv[46], ret == 0 doesn't mean EOF (since UDP can't
630 * have EOF), but rather an empty packet. I don't know if any
631 * other potential DGRAM protocols might have an EOF
632 * condition, so let's play safe. */
633 if(ret == 0)
634 {
02a705ad
FT		 635 freedgbuf(dbuf);
636 if((ufd->type != UFD_SOCK) || !((ufd->d.s.family == AF_INET) || (ufd->d.s.family == AF_INET6)))
d3372da9 637 {
40c21c4f 638 closesock(ufd->sk);
02a705ad 639 closeufd(ufd);
d3372da9 640 }
641 return;
642 }
643 dbuf->addr = srealloc(dbuf->addr, dbuf->addrlen);
644 dbuf->data = srealloc(dbuf->data, dbuf->size = ret);
645 dbuf->next = NULL;
02a705ad
FT		 646 sockqueuedg(ufd->sk, dbuf);
647 } else {
648#if defined(HAVE_LINUX_SOCKIOS_H) && defined(SIOCINQ)
649 /* SIOCINQ is Linux-specific AFAIK, but I really have no idea
650 * how to read the inqueue size on other OSs */
651 if(ufd->type == UFD_SOCK) {
652 if(ioctl(ufd->fd, SIOCINQ, &inq))
653 {
654 /* I don't really know what could go wrong here, so let's
655 * assume it's transient. */
656 flog(LOG_WARNING, "SIOCINQ return %s on socket %i, falling back to 2048 bytes", strerror(errno), ufd->fd);
657 inq = 2048;
658 }
659 } else {
660 /* There are perils when trying to use SIOCINQ on files >2GiB... */
661 inq = 65536;
662 }
663#else
664 inq = 2048;
665#endif
666 if(inq > 65536)
667 inq = 65536;
668 /* This part could be optimized by telling the kernel to read
669 * directly into ufd->sk->back->buf, but that would be uglier
670 * by not using the socket function interface. */
671 buf = smalloc(inq);
672 if(ufd->type == UFD_SOCK)
673 {
674 bufvec.iov_base = buf;
675 bufvec.iov_len = inq;
676 ret = recvmsg(ufd->fd, &msg, 0);
677 } else {
678 ret = read(ufd->fd, buf, inq);
679 msg.msg_controllen = 0;
680 msg.msg_flags = 0;
681 }
682 if(ret < 0)
683 {
684 free(buf);
685 if((errno == EINTR) || (errno == EAGAIN))
686 return;
687 closeufd(ufd);
688 sockerror(ufd->sk, errno);
689 return;
690 }
691 if(msg.msg_flags & MSG_CTRUNC)
692 flog(LOG_DEBUG, "ancillary data was truncated");
d3372da9 693 else
02a705ad
FT		 694 recvcmsg(ufd, &msg);
695 if(ret == 0)
696 {
697 free(buf);
698 closeufd(ufd);
40c21c4f 699 closesock(ufd->sk);
02a705ad
FT		 700 return;
701 }
702 sockqueue(ufd->sk, buf, ret);
703 free(buf);
d3372da9 704 }
705}
706
89d650f1 707static int sockflush(struct ufd *ufd)
d3372da9 708{
709 int ret;
710 struct dgrambuf *dbuf;
02a705ad 711 int dgram;
d3372da9 712
89d650f1
FT		 713 if((dgram = ufddgram(ufd)) < 0) {
714 errno = EBADFD;
715 return(-1);
716 }
02a705ad
FT		 717 if(dgram) {
718 dbuf = sockgetdgbuf(ufd->sk);
719 sendto(ufd->fd, dbuf->data, dbuf->size, MSG_DONTWAIT | MSG_NOSIGNAL, dbuf->addr, dbuf->addrlen);
720 freedgbuf(dbuf);
721 } else {
722 if(ufd->type == UFD_SOCK)
723 ret = send(ufd->fd, ufd->sk->buf.s.buf, ufd->sk->buf.s.datasize, MSG_DONTWAIT | MSG_NOSIGNAL);
d3372da9 724 else
02a705ad 725 ret = write(ufd->fd, ufd->sk->buf.s.buf, ufd->sk->buf.s.datasize);
89d650f1
FT		 726 if(ret < 0)
727 return(-1);
02a705ad
FT		 728 if(ret > 0) {
729 memmove(ufd->sk->buf.s.buf, ((char *)ufd->sk->buf.s.buf) + ret, ufd->sk->buf.s.datasize -= ret);
730 sockread(ufd->sk);
d3372da9 731 }
d3372da9 732 }
89d650f1 733 return(0);
d3372da9 734}
735
736void closesock(struct socket *sk)
737{
02a705ad 738 sksetstate(sk, SOCK_STL);
40c21c4f
FT		 739 if(sk->back->eos == 0)
740 sk->back->eos = 1;
741 linksock(&rbatch, sk->back);
d3372da9 742}
743
744size_t sockgetdatalen(struct socket *sk)
745{
746 struct dgrambuf *b;
747 size_t ret;
748
02a705ad 749 if(sk->dgram) {
d3372da9 750 ret = 0;
02a705ad 751 for(b = sk->buf.d.f; b != NULL; b = b->next)
d3372da9 752 ret += b->size;
02a705ad
FT		 753 } else {
754 ret = sk->buf.s.datasize;
d3372da9 755 }
756 return(ret);
757}
758
759size_t sockqueuesize(struct socket *sk)
760{
02a705ad 761 return(sockgetdatalen(sk->back));
d3372da9 762}
763
d3372da9 764/*
7ab36fbd 765 * Seriously, I don't know if it's naughty or not to remove
766 * pre-existing Unix sockets.
767 */
02a705ad 768static int rebindunix(struct ufd *ufd, struct sockaddr *name, socklen_t namelen)
7ab36fbd 769{
770 struct sockaddr_un *un;
771 struct stat sb;
772
02a705ad 773 if((ufd->d.l.family != AF_UNIX) || (name->sa_family != PF_UNIX))
7ab36fbd 774 return(-1);
775 un = (struct sockaddr_un *)name;
776 if(stat(un->sun_path, &sb))
777 return(-1);
778 if(!S_ISSOCK(sb.st_mode))
779 return(-1);
780 if(unlink(un->sun_path))
781 return(-1);
02a705ad 782 if(bind(ufd->fd, name, namelen) < 0)
7ab36fbd 783 return(-1);
784 return(0);
785}
786
f96d0914
FT		 787void closelport(struct lport *lp)
788{
40c21c4f
FT		 789 struct ufd *ufd;
790 struct sockaddr_un *un;
791
792 ufd = lp->ufd;
793 if((ufd->d.l.family == AF_UNIX) && !getlocalname(ufd->fd, (struct sockaddr **)(void *)&un, NULL) && (un->sun_family == PF_UNIX) && strchr(un->sun_path, '/')) {
794 if(unlink(un->sun_path))
795 flog(LOG_WARNING, "could not unlink Unix socket %s: %s", un->sun_path, strerror(errno));
796 }
f96d0914
FT		 797 freeufd(lp->ufd);
798}
799
7ab36fbd 800/*
d3372da9 801 * The difference between netcslisten() and netcslistenlocal() is that
802 * netcslistenlocal() always listens on the local host, instead of
803 * following proxy/passive mode directions. It is suitable for eg. the
804 * UI channel, while the file sharing networks should, naturally, use
805 * netcslisten() instead.
806*/
807
02a705ad 808struct lport *netcslistenlocal(int type, struct sockaddr *name, socklen_t namelen, void (*func)(struct lport *, struct socket *, void *), void *data)
d3372da9 809{
02a705ad
FT		 810 struct lport *lp;
811 struct ufd *ufd;
812 int fd;
66c517d2 813 int intbuf;
d3372da9 814
815 /* I don't know if this is actually correct (it probably isn't),
816 * but since, at on least Linux systems, PF_* are specifically
817 * #define'd to their AF_* counterparts, it allows for a severely
818 * smoother implementation. If it breaks something on your
819 * platform, please tell me so.
820 */
02a705ad 821 if((fd = socket(name->sa_family, type, 0)) < 0)
d3372da9 822 return(NULL);
02a705ad 823 if(confgetint("net", "reuseaddr")) {
687b2ee2 824 intbuf = 1;
02a705ad 825 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &intbuf, sizeof(intbuf));
687b2ee2 826 }
02a705ad 827 ufd = mkufd(fd, UFD_LISTEN, NULL);
02a705ad 828 ufd->d.l.family = name->sa_family;
f96d0914
FT		 829 lp = memset(smalloc(sizeof(*lp)), 0, sizeof(*lp));
830 lp->ufd = ufd;
831 ufd->d.l.lp = lp;
02a705ad
FT		 832 if((bind(fd, name, namelen) < 0) && ((errno != EADDRINUSE) || (rebindunix(ufd, name, namelen) < 0))) {
833 freeufd(ufd);
d3372da9 834 return(NULL);
835 }
02a705ad 836 if(listen(fd, 16) < 0)
d3372da9 837 {
02a705ad 838 freeufd(ufd);
d3372da9 839 return(NULL);
840 }
02a705ad
FT		 841 lp->acceptcb = func;
842 lp->data = data;
843 return(lp);
d3372da9 844}
845
02a705ad 846struct lport *netcslisten(int type, struct sockaddr *name, socklen_t namelen, void (*func)(struct lport *, struct socket *, void *), void *data)
c23acc61 847{
848 if(confgetint("net", "mode") == 1)
849 {
850 errno = EOPNOTSUPP;
851 return(NULL);
852 }
c23acc61 853 if(confgetint("net", "mode") == 0)
854 return(netcslistenlocal(type, name, namelen, func, data));
855 errno = EOPNOTSUPP;
856 return(NULL);
857}
858
02a705ad 859struct lport *netcstcplisten(int port, int local, void (*func)(struct lport *, struct socket *, void *), void *data)
0a1bc5b1 860{
861 struct sockaddr_in addr;
862#ifdef HAVE_IPV6
863 struct sockaddr_in6 addr6;
864#endif
02a705ad
FT		 865 struct lport *(*csfunc)(int, struct sockaddr *, socklen_t, void (*)(struct lport *, struct socket *, void *), void *);
866 struct lport *ret;
0a1bc5b1 867
868 if(local)
869 csfunc = netcslistenlocal;
870 else
871 csfunc = netcslisten;
872#ifdef HAVE_IPV6
873 memset(&addr6, 0, sizeof(addr6));
874 addr6.sin6_family = AF_INET6;
875 addr6.sin6_port = htons(port);
876 addr6.sin6_addr = in6addr_any;
877 if((ret = csfunc(SOCK_STREAM, (struct sockaddr *)&addr6, sizeof(addr6), func, data)) != NULL)
878 return(ret);
879 if((ret == NULL) && (errno != EAFNOSUPPORT))
880 return(NULL);
881#endif
882 memset(&addr, 0, sizeof(addr));
883 addr.sin_family = AF_INET;
884 addr.sin_port = htons(port);
885 return(csfunc(SOCK_STREAM, (struct sockaddr *)&addr, sizeof(addr), func, data));
886}
887
d3372da9 888struct socket *netcsdgram(struct sockaddr *name, socklen_t namelen)
889{
890 struct socket *sk;
891 int mode;
892
893 mode = confgetint("net", "mode");
894 if((mode == 0) || (mode == 1))
895 {
896 if((sk = mksock(name->sa_family, SOCK_DGRAM)) == NULL)
897 return(NULL);
02a705ad 898 if(bind(sk->ufd->fd, name, namelen) < 0)
d3372da9 899 {
900 putsock(sk);
901 return(NULL);
902 }
02a705ad
FT		 903 sksetstate(sk, SOCK_EST);
904 return(sk->back);
d3372da9 905 }
906 errno = EOPNOTSUPP;
907 return(NULL);
908}
909
02a705ad 910struct socket *netdgramconn(struct socket *sk, struct sockaddr *addr, socklen_t addrlen)
d3372da9 911{
02a705ad 912 struct ufd *nufd;
d3372da9 913
02a705ad 914 nufd = dupufd(sk->back->ufd);
5afb0d14 915 getsock(sk = nufd->sk->back);
02a705ad
FT		 916 memcpy(nufd->d.s.remote = smalloc(addrlen), addr, nufd->d.s.remotelen = addrlen);
917 nufd->ignread = 1;
918 return(sk);
d3372da9 919}
920
cab0b442 921struct socket *netcsconn(struct sockaddr *addr, socklen_t addrlen, void (*func)(struct socket *, int, void *), void *data)
d3372da9 922{
923 struct socket *sk;
924 int mode;
925
926 mode = confgetint("net", "mode");
927 if((mode == 0) || (mode == 1))
928 {
929 if((sk = mksock(addr->sa_family, SOCK_STREAM)) == NULL)
930 return(NULL);
02a705ad
FT		 931 memcpy(sk->ufd->d.s.remote = smalloc(addrlen), addr, sk->ufd->d.s.remotelen = addrlen);
932 sk->back->conncb = func;
933 sk->back->data = data;
934 if(!connect(sk->ufd->fd, addr, addrlen))
d3372da9 935 {
02a705ad
FT		 936 sksetstate(sk, SOCK_EST);
937 linksock(&cbatch, sk->back);
938 return(sk->back);
d3372da9 939 }
940 if(errno == EINPROGRESS)
941 {
02a705ad
FT		 942 sksetstate(sk, SOCK_SYN);
943 return(sk->back);
d3372da9 944 }
945 putsock(sk);
946 return(NULL);
947 }
948 errno = EOPNOTSUPP;
949 return(NULL);
950}
951
02a705ad 952static void acceptunix(struct ufd *ufd)
9e5f2b29 953{
954 int buf;
955
956 buf = 1;
a8c5ada6 957#if UNIX_AUTH_STYLE == 1
02a705ad
FT		 958 if(setsockopt(ufd->fd, SOL_SOCKET, SO_PASSCRED, &buf, sizeof(buf)) < 0)
959 flog(LOG_WARNING, "could not enable SO_PASSCRED on Unix socket %i: %s", ufd->fd, strerror(errno));
a8c5ada6 960#elif UNIX_AUTH_STYLE == 2
02a705ad 961 if(getpeereid(ufd->fd, &ufd->d.s.ucred.uid, &ufd->d.s.ucred.gid) < 0)
a8c5ada6 962 {
02a705ad
FT		 963 flog(LOG_WARNING, "could not get peer creds on Unix socket %i: %s", ufd->fd, strerror(errno));
964 ufd->d.s.ucred.uid = -1;
965 ufd->d.s.ucred.gid = -1;
a8c5ada6 966 }
967#endif
9e5f2b29 968}
969
f96d0914
FT		 970static void runbatches(void)
971{
972 struct scons *sc, *nsc;
973
974 for(sc = cbatch, cbatch = NULL; sc; sc = nsc) {
975 nsc = sc->n;
5afb0d14
FT		 976 if(sc->s->conncb != NULL)
977 sc->s->conncb(sc->s, 0, sc->s->data);
834b0aa6 978 putsock(sc->s);
f96d0914
FT		 979 free(sc);
980 }
981 for(sc = rbatch, rbatch = NULL; sc; sc = nsc) {
982 nsc = sc->n;
5afb0d14
FT		 983 if(sc->s->readcb != NULL)
984 sc->s->readcb(sc->s, sc->s->data);
985 if((sockgetdatalen(sc->s) == 0) && (sc->s->eos == 1)) {
986 if(sc->s->errcb != NULL)
987 sc->s->errcb(sc->s, 0, sc->s->data);
988 sc->s->eos = 2;
989 }
834b0aa6 990 putsock(sc->s);
f96d0914
FT		 991 free(sc);
992 }
993 for(sc = wbatch, wbatch = NULL; sc; sc = nsc) {
994 nsc = sc->n;
5afb0d14
FT		 995 if(sc->s->writecb != NULL)
996 sc->s->writecb(sc->s, sc->s->data);
834b0aa6 997 putsock(sc->s);
f96d0914
FT		 998 free(sc);
999 }
1000}
1001
5afb0d14
FT		 1002static void cleansocks(void)
1003{
1004 struct ufd *ufd, *next;
1005
1006 for(ufd = ufds; ufd != NULL; ufd = next) {
1007 next = ufd->next;
834b0aa6 1008 if(ufd->sk && ((ufd->fd < 0) || (sockgetdatalen(ufd->sk) == 0))) {
5afb0d14
FT		 1009 if(ufd->sk->eos == 1) {
1010 ufd->sk->eos = 2;
1011 closeufd(ufd);
1012 closesock(ufd->sk);
1013 }
1014 if((ufd->sk->refcount == 1) && (ufd->sk->back->refcount == 0)) {
1015 freeufd(ufd);
1016 continue;
1017 }
1018 }
1019 }
1020}
1021
d3372da9 1022int pollsocks(int timeout)
1023{
02a705ad 1024 int ret;
eaa35963 1025 socklen_t retlen;
72a7835e
FT		 1026 int newfd, maxfd;
1027 fd_set rfds, wfds, efds;
5afb0d14 1028 struct ufd *ufd, *nufd;
02a705ad 1029 struct socket *nsk;
d3372da9 1030 struct sockaddr_storage ss;
1031 socklen_t sslen;
72a7835e 1032 struct timeval tv;
d3372da9 1033
5afb0d14 1034 cleansocks();
72a7835e
FT		 1035 FD_ZERO(&rfds);
1036 FD_ZERO(&wfds);
1037 FD_ZERO(&efds);
02a705ad
FT		 1038 for(maxfd = 0, ufd = ufds; ufd != NULL; ufd = ufd->next) {
1039 if(ufd->fd < 0)
d3372da9 1040 continue;
02a705ad
FT		 1041 if(!ufd->ignread)
1042 FD_SET(ufd->fd, &rfds);
1043 if(ufd->sk != NULL) {
1044 if(sockgetdatalen(ufd->sk) > 0)
1045 FD_SET(ufd->fd, &wfds);
1046 else if(ufd->sk->state == SOCK_SYN)
1047 FD_SET(ufd->fd, &wfds);
1048 }
1049 FD_SET(ufd->fd, &efds);
1050 if(ufd->fd > maxfd)
1051 maxfd = ufd->fd;
d3372da9 1052 }
5afb0d14
FT		 1053 if(rbatch || wbatch || cbatch)
1054 timeout = 0;
72a7835e
FT		 1055 tv.tv_sec = timeout / 1000;
1056 tv.tv_usec = (timeout % 1000) * 1000;
1057 ret = select(maxfd + 1, &rfds, &wfds, &efds, (timeout < 0)?NULL:&tv);
02a705ad
FT		 1058 if(ret < 0) {
1059 if(errno != EINTR) {
72a7835e 1060 flog(LOG_CRIT, "pollsocks: select errored out: %s", strerror(errno));
d3372da9 1061 /* To avoid CPU hogging in case it's bad, which it
1062 * probably is. */
1063 sleep(1);
1064 }
d3372da9 1065 return(1);
1066 }
5afb0d14 1067 for(ufd = ufds; ufd != NULL; ufd = ufd->next) {
02a705ad
FT		 1068 if(ufd->sk < 0)
1069 continue;
1070 if(ufd->type == UFD_LISTEN) {
1071 if(FD_ISSET(ufd->fd, &rfds)) {
d3372da9 1072 sslen = sizeof(ss);
02a705ad
FT		 1073 if((newfd = accept(ufd->fd, (struct sockaddr *)&ss, &sslen)) < 0) {
1074 if(ufd->d.l.lp->errcb != NULL)
1075 ufd->d.l.lp->errcb(ufd->d.l.lp, errno, ufd->d.l.lp->data);
cab0b442 1076 }
02a705ad
FT		 1077 nsk = sockpair(0);
1078 nufd = mkufd(newfd, UFD_SOCK, nsk);
1079 nufd->d.s.family = ufd->d.l.family;
1080 sksetstate(nsk, SOCK_EST);
1081 memcpy(nufd->d.s.remote = smalloc(sslen), &ss, sslen);
1082 nufd->d.s.remotelen = sslen;
9e5f2b29 1083 if(ss.ss_family == PF_UNIX)
02a705ad
FT		 1084 acceptunix(nufd);
1085 if(ufd->d.l.lp->acceptcb != NULL)
5afb0d14 1086 ufd->d.l.lp->acceptcb(ufd->d.l.lp, nsk->back, ufd->d.l.lp->data);
02a705ad 1087 putsock(nsk);
d3372da9 1088 }
02a705ad 1089 if(FD_ISSET(ufd->fd, &efds)) {
d3372da9 1090 retlen = sizeof(ret);
02a705ad
FT		 1091 getsockopt(ufd->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
1092 if(ufd->d.l.lp->errcb != NULL)
1093 ufd->d.l.lp->errcb(ufd->d.l.lp, ret, ufd->d.l.lp->data);
d3372da9 1094 continue;
1095 }
02a705ad
FT		 1096 } else {
1097 if(ufd->sk->state == SOCK_SYN) {
1098 if(FD_ISSET(ufd->fd, &efds)) {
1099 retlen = sizeof(ret);
1100 getsockopt(ufd->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
1101 if(ufd->sk->back->conncb != NULL)
1102 ufd->sk->back->conncb(ufd->sk->back, ret, ufd->sk->back->data);
1103 closeufd(ufd);
1104 continue;
1105 }
1106 if(FD_ISSET(ufd->fd, &rfds) || FD_ISSET(ufd->fd, &wfds)) {
1107 sksetstate(ufd->sk, SOCK_EST);
1108 linksock(&cbatch, ufd->sk->back);
1109 }
1110 } else if(ufd->sk->state == SOCK_EST) {
1111 if(FD_ISSET(ufd->fd, &efds)) {
1112 retlen = sizeof(ret);
1113 getsockopt(ufd->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen);
1114 sockerror(ufd->sk, ret);
1115 closeufd(ufd);
1116 continue;
1117 }
1118 if(FD_ISSET(ufd->fd, &rfds))
1119 sockrecv(ufd);
5afb0d14
FT		 1120 if(ufd->fd == -1)
1121 continue;
89d650f1
FT		 1122 if(FD_ISSET(ufd->fd, &wfds)) {
1123 if(sockflush(ufd)) {
1124 sockerror(ufd->sk, errno);
1125 closeufd(ufd);
1126 continue;
1127 }
1128 }
d3372da9 1129 }
d3372da9 1130 }
d3372da9 1131 }
f96d0914 1132 runbatches();
5afb0d14 1133 cleansocks();
d3372da9 1134 return(1);
1135}
1136
f96d0914
FT		 1137static 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
d3372da9 1148int socksettos(struct socket *sk, int tos)
1149{
b020fb3d 1150 int buf;
f96d0914 1151 struct ufd *ufd;
b020fb3d 1152
f96d0914
FT		 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)
7ab36fbd 1159 return(0); /* Unix sockets are always perfect. :) */
f96d0914 1160 if(ufd->d.s.family == AF_INET)
d3372da9 1161 {
b020fb3d 1162 switch(tos)
1163 {
b198bed6 1164 case 0:
1165 buf = 0;
1166 break;
b020fb3d 1167 case SOCK_TOS_MINCOST:
18c1ae1d 1168 buf = 0x02;
b020fb3d 1169 break;
1170 case SOCK_TOS_MAXREL:
18c1ae1d 1171 buf = 0x04;
b020fb3d 1172 break;
1173 case SOCK_TOS_MAXTP:
18c1ae1d 1174 buf = 0x08;
b020fb3d 1175 break;
1176 case SOCK_TOS_MINDELAY:
18c1ae1d 1177 buf = 0x10;
b020fb3d 1178 break;
1179 default:
1180 flog(LOG_WARNING, "attempted to set unknown TOS value %i to IPv4 sock", tos);
1181 return(-1);
1182 }
f96d0914 1183 if(setsockopt(ufd->fd, IPPROTO_IP, IP_TOS, &buf, sizeof(buf)) < 0)
d3372da9 1184 {
1185 flog(LOG_WARNING, "could not set sock TOS to %i: %s", tos, strerror(errno));
1186 return(-1);
1187 }
1188 return(0);
1189 }
f96d0914 1190 if(ufd->d.s.family == AF_INET6)
b020fb3d 1191 {
1192 switch(tos)
1193 {
b198bed6 1194 case 0:
1195 buf = 0;
b020fb3d 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 }
f96d0914 1224 flog(LOG_WARNING, "could not set TOS on sock of family %i", ufd->d.s.family);
d3372da9 1225 return(1);
1226}
1227
1228struct 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
1237static 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 {
b4d16e90 1247 errno = ENOENT;
d3372da9 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 {
b4d16e90 1255 errno = ENOENT;
d3372da9 1256 data->callback(NULL, 0, data->data);
1257 }
1258 close(data->fd);
1259 free(data);
1260}
1261
1262int 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
f96d0914 1325static int getlocalname(int fd, struct sockaddr **namebuf, socklen_t *lenbuf)
d3372da9 1326{
1327 socklen_t len;
1328 struct sockaddr_storage name;
1329
1330 *namebuf = NULL;
f96d0914 1331 if(fd < 0)
d3372da9 1332 return(-1);
1333 len = sizeof(name);
f96d0914 1334 if(getsockname(fd, (struct sockaddr *)&name, &len) < 0)
d3372da9 1335 {
6fb0c6ac 1336 flog(LOG_ERR, "BUG: alive socket with dead fd in sockgetlocalname (%s)", strerror(errno));
d3372da9 1337 return(-1);
1338 }
1339 *namebuf = memcpy(smalloc(len), &name, len);
b870805e 1340 if(lenbuf != NULL)
1341 *lenbuf = len;
d3372da9 1342 return(0);
1343}
1344
f96d0914
FT		 1345int 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
1353int 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
eaa35963 1365static 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
1386static int makepublic(struct sockaddr *addr)
d3372da9 1387{
6fb0c6ac 1388 int ret;
eaa35963 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
f96d0914 1404static int getremotename(int fd, struct sockaddr **namebuf, socklen_t *lenbuf)
eaa35963 1405{
d3372da9 1406 socklen_t len;
6fb0c6ac 1407 struct sockaddr *name;
f96d0914
FT		 1408
1409 switch(confgetint("net", "mode")) {
d3372da9 1410 case 0:
1411 *namebuf = NULL;
f96d0914 1412 if(!getlocalname(fd, &name, &len)) {
6fb0c6ac 1413 *namebuf = name;
1414 *lenbuf = len;
eaa35963 1415 makepublic(name);
6fb0c6ac 1416 return(0);
1417 }
1418 flog(LOG_ERR, "could not get remotely accessible name by any means");
1419 return(-1);
d3372da9 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
f96d0914
FT		 1430int 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
1446int 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
d29853b1 1454int sockgetremotename2(struct socket *sk, struct socket *sk2, struct sockaddr **namebuf, socklen_t *lenbuf)
1455{
1456 struct sockaddr *name1, *name2;
1457 socklen_t len1, len2;
f96d0914
FT		 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
1484int 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;
d29853b1 1489
f96d0914
FT		 1490 ufd1 = lp->ufd;
1491 ufd2 = getskufd(sk2);
1492 if(ufd2->type != UFD_SOCK) {
1493 errno = EOPNOTSUPP;
1494 return(-1);
1495 }
d334fbb5 1496 if(ufd1->d.l.family != ufd2->d.s.family)
d29853b1 1497 {
d334fbb5 1498 flog(LOG_ERR, "using lstgetremotename2 with sockets of differing family: %i %i", ufd1->d.l.family, ufd2->d.s.family);
d29853b1 1499 return(-1);
1500 }
f96d0914 1501 if(getremotename(ufd1->fd, &name1, &len1))
d29853b1 1502 return(-1);
f96d0914 1503 if(getremotename(ufd2->fd, &name2, &len2)) {
d29853b1 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
f96d0914
FT		 1514int 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
02a705ad
FT		 1532void sockblock(struct socket *sk, int block)
1533{
f96d0914
FT		 1534 struct ufd *ufd;
1535
1536 ufd = getskufd(sk);
1537 ufd->ignread = block;
1538}
1539
1540int 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);
02a705ad
FT		 1550}
1551
1552int sockpeeraddr(struct socket *sk, struct sockaddr **namebuf, socklen_t *lenbuf)
1553{
f96d0914
FT		 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);
02a705ad
FT		 1567}
1568
1569char *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
99a28d47 1582int 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;
c8a729d7 1605#ifdef HAVE_IPV6
99a28d47 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;
c8a729d7 1613#endif
99a28d47 1614 }
1615 return(1);
1616}
1617
d3372da9 1618char *formataddress(struct sockaddr *arg, socklen_t arglen)
1619{
d3372da9 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:
6a97462e 1633 ret = sstrdup("Unix socket");
d3372da9 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);
fc7f7735 1646 ret = sprintf2("[%s]:%i", buf, (int)ntohs(ipv6->sin6_port));
d3372da9 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
1663static 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
1693static 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
1705static 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
1720static void terminate(void)
1721{
f96d0914
FT		 1722 /*
1723 while(ufds != NULL)
1724 freeufd(ufds);
1725 */
d3372da9 1726}
1727
1728static struct module me =
1729{
1730 .name = "net",
1731 .conf =
1732 {
1733 .vars = myvars
1734 },
1735 .init = init,
1736 .terminate = terminate
1737};
1738
1739MODULE(me)
Dolda Connect