3 * Make programs use Unix-domain sockets instead of IP
5 * (c) 2008 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the preload-hacks package.
12 * Preload-hacks are free software; you can redistribute it and/or modify
13 * them under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or (at
15 * your option) any later version.
17 * Preload-hacks are distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 * You should have received a copy of the GNU General Public License along
23 * with preload-hacks; if not, write to the Free Software Foundation, Inc.,
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
32 /*----- Header files ------------------------------------------------------*/
48 #include <sys/ioctl.h>
49 #include <sys/socket.h>
53 #include <netinet/in.h>
54 #include <arpa/inet.h>
55 #include <netinet/tcp.h>
56 #include <netinet/udp.h>
60 /*----- Data structures ---------------------------------------------------*/
62 enum { UNUSED, STALE, USED }; /* Unix socket status values */
63 enum { DENY, ALLOW }; /* ACL verdicts */
65 static int address_families[] = { AF_INET, AF_INET6, -1 };
69 /* Address representations. */
70 typedef union ipaddr {
75 /* Convenient socket address hacking. */
76 typedef union address {
78 struct sockaddr_in sin;
79 struct sockaddr_in6 sin6;
82 /* Access control list nodes */
83 typedef struct aclnode {
87 ipaddr minaddr, maxaddr;
88 unsigned short minport, maxport;
91 /* Implicit bind records */
92 typedef struct impbind {
95 ipaddr minaddr, maxaddr, bindaddr;
97 enum { EXPLICIT, SAME };
99 /* A type for an address range */
100 typedef struct addrrange {
103 struct { int af; ipaddr min, max; } range;
106 enum { EMPTY, ANY, LOCAL, RANGE };
108 /* Local address records */
109 typedef struct full_ipaddr {
113 #define MAX_LOCAL_IPADDRS 64
114 static full_ipaddr local_ipaddrs[MAX_LOCAL_IPADDRS];
115 static int n_local_ipaddrs;
117 /* General configuration */
119 static char *sockdir = 0;
120 static int debug = 0;
121 static unsigned minautoport = 16384, maxautoport = 65536;
123 /* Access control lists */
124 static aclnode *bind_real, **bind_tail = &bind_real;
125 static aclnode *connect_real, **connect_tail = &connect_real;
126 static impbind *impbinds, **impbind_tail = &impbinds;
128 /*----- Import the real versions of functions -----------------------------*/
130 /* The list of functions to immport. */
132 _(socket, int, (int, int, int)) \
133 _(socketpair, int, (int, int, int, int *)) \
134 _(connect, int, (int, const struct sockaddr *, socklen_t)) \
135 _(bind, int, (int, const struct sockaddr *, socklen_t)) \
136 _(accept, int, (int, struct sockaddr *, socklen_t *)) \
137 _(getsockname, int, (int, struct sockaddr *, socklen_t *)) \
138 _(getpeername, int, (int, struct sockaddr *, socklen_t *)) \
139 _(getsockopt, int, (int, int, int, void *, socklen_t *)) \
140 _(setsockopt, int, (int, int, int, const void *, socklen_t)) \
141 _(sendto, ssize_t, (int, const void *buf, size_t, int, \
142 const struct sockaddr *to, socklen_t tolen)) \
143 _(recvfrom, ssize_t, (int, void *buf, size_t, int, \
144 struct sockaddr *from, socklen_t *fromlen)) \
145 _(sendmsg, ssize_t, (int, const struct msghdr *, int)) \
146 _(recvmsg, ssize_t, (int, struct msghdr *, int)) \
147 _(ioctl, int, (int, unsigned long, ...))
149 /* Function pointers to set up. */
150 #define DECL(imp, ret, args) static ret (*real_##imp) args;
154 /* Import the system calls. */
155 static void import(void)
157 #define IMPORT(imp, ret, args) \
158 real_##imp = (ret (*)args)dlsym(RTLD_NEXT, #imp);
163 /*----- Utilities ---------------------------------------------------------*/
165 /* Socket address casts */
166 #define SA(sa) ((struct sockaddr *)(sa))
167 #define SIN(sa) ((struct sockaddr_in *)(sa))
168 #define SIN6(sa) ((struct sockaddr_in6 *)(sa))
169 #define SUN(sa) ((struct sockaddr_un *)(sa))
172 #define UC(ch) ((unsigned char)(ch))
174 /* Memory allocation */
175 #define NEW(x) ((x) = xmalloc(sizeof(*x)))
176 #define NEWV(x, n) ((x) = xmalloc(sizeof(*x) * (n)))
180 # define D(body) { if (debug) { body } }
181 # define Dpid pid_t pid = debug ? getpid() : -1
187 /* Preservation of error status */
188 #define PRESERVING_ERRNO(body) do { \
189 int _err = errno; { body } errno = _err; \
192 /* Allocate N bytes of memory; abort on failure. */
193 static void *xmalloc(size_t n)
197 if ((p = malloc(n)) == 0) { perror("malloc"); exit(127); }
201 /* Allocate a copy of the null-terminated string P; abort on failure. */
202 static char *xstrdup(const char *p)
204 size_t n = strlen(p) + 1;
205 char *q = xmalloc(n);
210 /*----- Address-type hacking ----------------------------------------------*/
212 /* If M is a simple mask, i.e., consists of a sequence of zero bits followed
213 * by a sequence of one bits, then return the length of the latter sequence
214 * (which may be zero); otherwise return -1.
216 static int simple_mask_length(unsigned long m)
220 while (m & 1) { n++; m >>= 1; }
224 /* Answer whether AF is an interesting address family. */
225 static int family_known_p(int af)
236 /* Return the socket address length for address family AF. */
237 static socklen_t family_socklen(int af)
240 case AF_INET: return (sizeof(struct sockaddr_in));
241 case AF_INET6: return (sizeof(struct sockaddr_in6));
246 /* Return the width of addresses of kind AF. */
247 static int address_width(int af)
250 case AF_INET: return 32;
251 case AF_INET6: return 128;
256 /* If addresses A and B share a common prefix then return its length;
257 * otherwise return -1.
259 static int common_prefix_length(int af, const ipaddr *a, const ipaddr *b)
263 unsigned long aa = ntohl(a->v4.s_addr), bb = ntohl(b->v4.s_addr);
264 unsigned long m = aa^bb;
265 if ((aa&m) == 0 && (bb&m) == m) return (32 - simple_mask_length(m));
269 const uint8_t *aa = a->v6.s6_addr, *bb = b->v6.s6_addr;
274 for (i = 0; i < 16 && aa[i] == bb[i]; i++);
278 if ((aa[i]&m) != 0 || (bb[i]&m) != m) return (-1);
279 n += 8 - simple_mask_length(m);
280 for (i++; i < 16; i++)
281 if (aa[i] || bb[i] != 0xff) return (-1);
290 /* Extract the port number (in host byte-order) from SA. */
291 static int port_from_sockaddr(const struct sockaddr *sa)
293 switch (sa->sa_family) {
294 case AF_INET: return (ntohs(SIN(sa)->sin_port));
295 case AF_INET6: return (ntohs(SIN6(sa)->sin6_port));
300 /* Store the port number PORT (in host byte-order) in SA. */
301 static void port_to_sockaddr(struct sockaddr *sa, int port)
303 switch (sa->sa_family) {
304 case AF_INET: SIN(sa)->sin_port = htons(port); break;
305 case AF_INET6: SIN6(sa)->sin6_port = htons(port); break;
310 /* Extract the address part from SA and store it in A. */
311 static void ipaddr_from_sockaddr(ipaddr *a, const struct sockaddr *sa)
313 switch (sa->sa_family) {
314 case AF_INET: a->v4 = SIN(sa)->sin_addr; break;
315 case AF_INET6: a->v6 = SIN6(sa)->sin6_addr; break;
320 /* Store the address A in SA. */
321 static void ipaddr_to_sockaddr(struct sockaddr *sa, const ipaddr *a)
323 switch (sa->sa_family) {
325 SIN(sa)->sin_addr = a->v4;
328 SIN6(sa)->sin6_addr = a->v6;
329 SIN6(sa)->sin6_scope_id = 0;
330 SIN6(sa)->sin6_flowinfo = 0;
337 /* Copy a whole socket address about. */
338 static void copy_sockaddr(struct sockaddr *sa_dst,
339 const struct sockaddr *sa_src)
340 { memcpy(sa_dst, sa_src, family_socklen(sa_src->sa_family)); }
342 /* Convert an AF_INET socket address into the equivalent IPv4-mapped AF_INET6
345 static void map_ipv4_sockaddr(struct sockaddr_in6 *a6,
346 const struct sockaddr_in *a4)
349 in_addr_t a = ntohl(a4->sin_addr.s_addr);
351 a6->sin6_family = AF_INET6;
352 a6->sin6_port = a4->sin_port;
353 a6->sin6_scope_id = 0;
354 a6->sin6_flowinfo = 0;
355 for (i = 0; i < 10; i++) a6->sin6_addr.s6_addr[i] = 0;
356 for (i = 10; i < 12; i++) a6->sin6_addr.s6_addr[i] = 0xff;
357 for (i = 0; i < 4; i++) a6->sin6_addr.s6_addr[15 - i] = (a >> 8*i)&0xff;
360 /* Convert an AF_INET6 socket address containing an IPv4-mapped IPv6 address
361 * into the equivalent AF_INET4 address. Return zero on success, or -1 if
362 * the address has the wrong form.
364 static int unmap_ipv4_sockaddr(struct sockaddr_in *a4,
365 const struct sockaddr_in6 *a6)
370 for (i = 0; i < 10; i++) if (a6->sin6_addr.s6_addr[i] != 0) return (-1);
371 for (i = 10; i < 12; i++) if (a6->sin6_addr.s6_addr[i] != 0xff) return (-1);
372 for (i = 0, a = 0; i < 4; i++) a |= a6->sin6_addr.s6_addr[15 - i] << 8*i;
373 a4->sin_family = AF_INET;
374 a4->sin_port = a6->sin6_port;
375 a4->sin_addr.s_addr = htonl(a);
379 /* Answer whether two addresses are equal. */
380 static int ipaddr_equal_p(int af, const ipaddr *a, const ipaddr *b)
383 case AF_INET: return (a->v4.s_addr == b->v4.s_addr);
384 case AF_INET6: return (memcmp(a->v6.s6_addr, b->v6.s6_addr, 16) == 0);
389 /* Answer whether the address part of SA is between A and B (inclusive). We
390 * assume that SA has the correct address family.
392 static int sockaddr_in_range_p(const struct sockaddr *sa,
393 const ipaddr *a, const ipaddr *b)
395 switch (sa->sa_family) {
397 unsigned long addr = ntohl(SIN(sa)->sin_addr.s_addr);
398 return (ntohl(a->v4.s_addr) <= addr &&
399 addr <= ntohl(b->v4.s_addr));
402 const uint8_t *ss = SIN6(sa)->sin6_addr.s6_addr;
403 const uint8_t *aa = a->v6.s6_addr, *bb = b->v6.s6_addr;
407 for (i = 0; h && l && i < 16; i++, ss++, aa++, bb++) {
408 if (*ss < *aa || *bb < *ss) return (0);
409 if (*aa < *ss) l = 0;
410 if (*ss < *bb) h = 0;
419 /* Fill in SA with the appropriate wildcard address. */
420 static void wildcard_address(int af, struct sockaddr *sa)
424 struct sockaddr_in *sin = SIN(sa);
425 memset(sin, 0, sizeof(*sin));
426 sin->sin_family = AF_INET;
428 sin->sin_addr.s_addr = INADDR_ANY;
431 struct sockaddr_in6 *sin6 = SIN6(sa);
432 memset(sin6, 0, sizeof(*sin6));
433 sin6->sin6_family = AF_INET6;
435 sin6->sin6_addr = in6addr_any;
436 sin6->sin6_scope_id = 0;
437 sin6->sin6_flowinfo = 0;
444 /* Mask the address A, forcing all but the top PLEN bits to zero or one
445 * according to HIGHP.
447 static void mask_address(int af, ipaddr *a, int plen, int highp)
451 unsigned long addr = ntohl(a->v4.s_addr);
452 unsigned long mask = plen ? ~0ul << (32 - plen) : 0;
454 if (highp) addr |= ~mask;
455 a->v4.s_addr = htonl(addr & 0xffffffff);
459 unsigned m = (0xff << (8 - plen%8)) & 0xff;
460 unsigned s = highp ? 0xff : 0;
462 a->v6.s6_addr[i] = (a->v6.s6_addr[i] & m) | (s & ~m);
465 for (; i < 16; i++) a->v6.s6_addr[i] = s;
472 /* Write a presentation form of SA to BUF, a buffer of length SZ. LEN is the
473 * address length; if it's zero, look it up based on the address family.
474 * Return a pointer to the string (which might, in an emergency, be a static
475 * string rather than your buffer).
477 static char *present_sockaddr(const struct sockaddr *sa, socklen_t len,
478 char *buf, size_t sz)
480 #define WANT(n_) do { if (sz < (n_)) goto nospace; } while (0)
481 #define PUTC(c_) do { *buf++ = (c_); sz--; } while (0)
483 if (!sa) return "<null-address>";
484 if (!sz) return "<no-space-in-buffer>";
485 if (!len) len = family_socklen(sa->sa_family);
487 switch (sa->sa_family) {
489 struct sockaddr_un *sun = SUN(sa);
490 char *p = sun->sun_path;
491 size_t n = len - offsetof(struct sockaddr_un, sun_path);
499 case 0: WANT(2); PUTC('\\'); PUTC('0'); break;
500 case '\a': WANT(2); PUTC('\\'); PUTC('a'); break;
501 case '\n': WANT(2); PUTC('\\'); PUTC('n'); break;
502 case '\r': WANT(2); PUTC('\\'); PUTC('r'); break;
503 case '\t': WANT(2); PUTC('\\'); PUTC('t'); break;
504 case '\v': WANT(2); PUTC('\\'); PUTC('v'); break;
505 case '\\': WANT(2); PUTC('\\'); PUTC('\\'); break;
507 if (*p > ' ' && *p <= '~')
508 { WANT(1); PUTC(*p); }
510 WANT(4); PUTC('\\'); PUTC('x');
511 PUTC((*p >> 4)&0xf); PUTC((*p >> 0)&0xf);
518 if (*p != '/') { WANT(2); PUTC('.'); PUTC('/'); }
519 while (n && *p) { WANT(1); PUTC(*p); p++; n--; }
523 case AF_INET: case AF_INET6: {
524 char addrbuf[NI_MAXHOST], portbuf[NI_MAXSERV];
525 int err = getnameinfo(sa, len,
526 addrbuf, sizeof(addrbuf),
527 portbuf, sizeof(portbuf),
528 NI_NUMERICHOST | NI_NUMERICSERV);
530 snprintf(buf, sz, strchr(addrbuf, ':') ? "[%s]:%s" : "%s:%s",
534 snprintf(buf, sz, "<unknown-address-family %d>", sa->sa_family);
544 /* Guess the family of a textual socket address. */
545 static int guess_address_family(const char *p)
546 { return (strchr(p, ':') ? AF_INET6 : AF_INET); }
548 /* Parse a socket address P and write the result to SA. */
549 static int parse_sockaddr(struct sockaddr *sa, const char *p)
553 struct addrinfo *ai, ai_hint = { 0 };
555 if (strlen(p) >= sizeof(buf) - 1) return (-1);
556 strcpy(buf, p); p = buf;
558 if ((q = strchr(p, ':')) == 0) return (-1);
562 if ((q = strchr(p, ']')) == 0) return (-1);
564 if (*q != ':') return (-1);
568 ai_hint.ai_family = AF_UNSPEC;
569 ai_hint.ai_socktype = SOCK_DGRAM;
570 ai_hint.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
571 if (getaddrinfo(p, q, &ai_hint, &ai)) return (-1);
572 memcpy(sa, ai->ai_addr, ai->ai_addrlen);
577 /*----- Access control lists ----------------------------------------------*/
581 static void dump_addrrange(int af, const ipaddr *min, const ipaddr *max)
587 plen = common_prefix_length(af, min, max);
588 p = inet_ntop(af, min, buf, sizeof(buf));
589 fprintf(stderr, strchr(p, ':') ? "[%s]" : "%s", p);
591 p = inet_ntop(af, &max, buf, sizeof(buf));
592 fprintf(stderr, strchr(p, ':') ? "-[%s]" : "-%s", p);
593 } else if (plen < address_width(af))
594 fprintf(stderr, "/%d", plen);
597 /* Write to standard error a description of the ACL node A. */
598 static void dump_aclnode(const aclnode *a)
600 fprintf(stderr, "noip(%d): %c ", getpid(), a->act ? '+' : '-');
601 dump_addrrange(a->af, &a->minaddr, &a->maxaddr);
602 if (a->minport != 0 || a->maxport != 0xffff) {
603 fprintf(stderr, ":%u", (unsigned)a->minport);
604 if (a->minport != a->maxport)
605 fprintf(stderr, "-%u", (unsigned)a->maxport);
610 static void dump_acl(const aclnode *a)
614 for (; a; a = a->next) {
618 fprintf(stderr, "noip(%d): [default policy: %s]\n", getpid(),
619 act == ALLOW ? "DENY" : "ALLOW");
624 /* Returns nonzero if the ACL A allows the socket address SA. */
625 static int acl_allows_p(const aclnode *a, const struct sockaddr *sa)
627 unsigned short port = port_from_sockaddr(sa);
631 D({ char buf[ADDRBUFSZ];
632 fprintf(stderr, "noip(%d): check %s\n", pid,
633 present_sockaddr(sa, 0, buf, sizeof(buf))); })
634 for (; a; a = a->next) {
635 D( dump_aclnode(a); )
636 if (a->af == sa->sa_family &&
637 sockaddr_in_range_p(sa, &a->minaddr, &a->maxaddr) &&
638 a->minport <= port && port <= a->maxport) {
639 D( fprintf(stderr, "noip(%d): aha! %s\n", pid,
640 a->act ? "ALLOW" : "DENY"); )
645 D( fprintf(stderr, "noip(%d): nothing found: %s\n", pid,
646 act ? "DENY" : "ALLOW"); )
650 /*----- Socket address conversion -----------------------------------------*/
652 /* Return a uniformly distributed integer between MIN and MAX inclusive. */
653 static unsigned randrange(unsigned min, unsigned max)
657 /* It's so nice not to have to care about the quality of the generator
661 for (mask = 1; mask < max; mask = (mask << 1) | 1)
663 do i = rand() & mask; while (i > max);
667 /* Return the status of Unix-domain socket address SUN. Returns: UNUSED if
668 * the socket doesn't exist; USED if the path refers to an active socket, or
669 * isn't really a socket at all, or we can't tell without a careful search
670 * and QUICKP is set; or STALE if the file refers to a socket which isn't
671 * being used any more.
673 static int unix_socket_status(struct sockaddr_un *sun, int quickp)
681 /* If we can't find the socket node, then it's definitely not in use. If
682 * we get some other error, then this socket is weird.
684 if (stat(sun->sun_path, &st))
685 return (errno == ENOENT ? UNUSED : USED);
687 /* If it's not a socket, then something weird is going on. If we're just
688 * probing quickly to find a spare port, then existence is sufficient to
691 if (!S_ISSOCK(st.st_mode) || quickp)
694 /* The socket's definitely there, but is anyone actually still holding it
695 * open? The only way I know to discover this is to trundle through
696 * `/proc/net/unix'. If there's no entry, then the socket must be stale.
699 if ((fp = fopen("/proc/net/unix", "r")) == 0)
701 if (!fgets(buf, sizeof(buf), fp)) goto done; /* skip header */
702 len = strlen(sun->sun_path);
703 while (fgets(buf, sizeof(buf), fp)) {
705 if (n >= len + 2 && buf[n - len - 2] == ' ' && buf[n - 1] == '\n' &&
706 memcmp(buf + n - len - 1, sun->sun_path, len) == 0)
719 /* Encode SA as a Unix-domain address SUN, and return whether it's currently
722 static int encode_single_inet_addr(const struct sockaddr *sa,
723 struct sockaddr_un *sun,
729 snprintf(sun->sun_path, sizeof(sun->sun_path), "%s/%s", sockdir,
730 present_sockaddr(sa, 0, buf, sizeof(buf)));
731 if ((rc = unix_socket_status(sun, quickp)) == USED) return (USED);
732 else if (rc == STALE) unlink(sun->sun_path);
736 /* Convert the IP address SA to a Unix-domain address SUN. Fail if the
737 * address seems already taken. If DESPARATEP then try cleaning up stale old
740 static int encode_unused_inet_addr(struct sockaddr *sa,
741 struct sockaddr_un *sun,
744 address waddr, maddr;
745 struct sockaddr_un wsun;
746 int port = port_from_sockaddr(sa);
748 /* First, look for an exact match. Only look quickly unless we're
749 * desperate. If the socket is in use, we fail here. (This could get
750 * racy. Let's not worry about that for now.)
752 if (encode_single_inet_addr(sa, sun, !desperatep) == USED)
755 /* Next, check the corresponding wildcard address, so as to avoid
756 * inadvertant collisions with listeners. Do this in the same way.
758 wildcard_address(sa->sa_family, &waddr.sa);
759 port_to_sockaddr(&waddr.sa, port);
760 if (encode_single_inet_addr(&waddr.sa, &wsun, !desperatep) == USED)
763 /* We're not done yet. If this is an IPv4 address, then /also/ check (a)
764 * the v6-mapped version, (b) the v6-mapped v4 wildcard, /and/ (c) the v6
767 if (sa->sa_family == AF_INET) {
768 map_ipv4_sockaddr(&maddr.sin6, SIN(&sa));
769 if (encode_single_inet_addr(&maddr.sa, &wsun, !desperatep) == USED)
772 map_ipv4_sockaddr(&maddr.sin6, &waddr.sin);
773 if (encode_single_inet_addr(&maddr.sa, &wsun, !desperatep) == USED)
776 wildcard_address(AF_INET6, &waddr.sa);
777 port_to_sockaddr(&waddr.sa, port);
778 if (encode_single_inet_addr(&waddr.sa, &wsun, !desperatep) == USED)
786 /* Encode the Internet address SA as a Unix-domain address SUN. If the flag
787 * `ENCF_FRESH' is set, and SA's port number is zero, then we pick an
788 * arbitrary local port. Otherwise we pick the port given. There's an
789 * unpleasant hack to find servers bound to local wildcard addresses.
790 * Returns zero on success; -1 on failure.
792 #define ENCF_FRESH 1u
793 static int encode_inet_addr(struct sockaddr_un *sun,
794 const struct sockaddr *sa,
800 struct sockaddr_in6 sin6;
801 int port = port_from_sockaddr(sa);
804 D( fprintf(stderr, "noip(%d): encode %s (%s)", getpid(),
805 present_sockaddr(sa, 0, buf, sizeof(buf)),
806 (f&ENCF_FRESH) ? "FRESH" : "EXISTING"); )
808 /* Start making the Unix-domain address. */
809 sun->sun_family = AF_UNIX;
811 if (port || !(f&ENCF_FRESH)) {
813 /* Try the address as given. If it's in use, or we don't necessarily
814 * want an existing socket, then we're done.
816 if (encode_single_inet_addr(sa, sun, 0) == USED || (f&ENCF_FRESH))
819 /* We're looking for a socket which already exists. This is
820 * unfortunately difficult, because we must deal both with wildcards and
821 * v6-mapped IPv4 addresses.
823 * * We've just tried searching for a socket whose name is an exact
824 * match for our remote address. If the remote address is IPv4, then
825 * we should try again with the v6-mapped equivalent.
827 * * Failing that, we try again with the wildcard address for the
828 * appropriate address family.
830 * * Failing /that/, if the remote address is IPv4, then we try
831 * /again/, increasingly desperately, first with the v6-mapped IPv4
832 * wildcard address, and then with the IPv6 wildcard address. This
833 * will cause magic v6-mapping to occur when the connection is
834 * accepted, which we hope won't cause too much trouble.
837 if (sa->sa_family == AF_INET) {
838 map_ipv4_sockaddr(&addr.sin6, SIN(sa));
839 if (encode_single_inet_addr(&addr.sa, sun, 0) == USED) goto found;
842 wildcard_address(sa->sa_family, &addr.sa);
843 port_to_sockaddr(&addr.sa, port);
844 if (encode_single_inet_addr(&addr.sa, sun, 0) == USED) goto found;
846 if (sa->sa_family == AF_INET) {
847 map_ipv4_sockaddr(&sin6, &addr.sin);
848 if (encode_single_inet_addr(SA(&sin6), sun, 0) == USED) goto found;
849 wildcard_address(AF_INET6, &addr.sa);
850 port_to_sockaddr(&addr.sa, port);
851 if (encode_single_inet_addr(&addr.sa, sun, 0) == USED) goto found;
854 /* Well, this isn't going to work (unless a miraculous race is lost), but
855 * we might as well try.
857 encode_single_inet_addr(sa, sun, 1);
860 /* We want a fresh new socket. */
862 /* Make a copy of the given address, because we're going to mangle it. */
863 copy_sockaddr(&addr.sa, sa);
865 /* Try a few random-ish port numbers to see if any of them is spare. */
866 for (i = 0; i < 10; i++) {
867 port_to_sockaddr(&addr.sa, randrange(minautoport, maxautoport));
868 if (!encode_unused_inet_addr(&addr.sa, sun, 0)) goto found;
871 /* Things must be getting tight. Work through all of the autoport range
872 * to see if we can find a spare one. The first time, just do it the
873 * quick way; if that doesn't work, then check harder for stale sockets.
875 for (desperatep = 0; desperatep < 2; desperatep++) {
876 for (i = minautoport; i <= maxautoport; i++) {
877 port_to_sockaddr(&addr.sa, i);
878 if (!encode_unused_inet_addr(&addr.sa, sun, 0)) goto found;
882 /* We failed to find any free ports. */
884 D( fprintf(stderr, " -- can't resolve\n"); )
890 D( fprintf(stderr, " -> `%s'\n", sun->sun_path); )
894 /* Decode the Unix address SUN to an Internet address SIN. If AF_HINT is
895 * nonzero, an empty address (indicative of an unbound Unix-domain socket) is
896 * translated to a wildcard Internet address of the appropriate family.
897 * Returns zero on success; -1 on failure (e.g., it wasn't one of our
900 static int decode_inet_addr(struct sockaddr *sa, int af_hint,
901 const struct sockaddr_un *sun,
905 size_t n = strlen(sockdir), nn;
908 if (!sa) sa = &addr.sa;
909 if (sun->sun_family != AF_UNIX) return (-1);
910 if (len > sizeof(*sun)) return (-1);
911 ((char *)sun)[len] = 0;
912 nn = strlen(sun->sun_path);
913 D( fprintf(stderr, "noip(%d): decode `%s'", getpid(), sun->sun_path); )
914 if (af_hint && !sun->sun_path[0]) {
915 wildcard_address(af_hint, sa);
916 D( fprintf(stderr, " -- unbound socket\n"); )
919 if (nn < n + 1 || nn - n >= sizeof(buf) || sun->sun_path[n] != '/' ||
920 memcmp(sun->sun_path, sockdir, n) != 0) {
921 D( fprintf(stderr, " -- not one of ours\n"); )
924 if (parse_sockaddr(sa, sun->sun_path + n + 1)) return (-1);
925 D( fprintf(stderr, " -> %s\n",
926 present_sockaddr(sa, 0, buf, sizeof(buf))); )
930 /* SK is (or at least might be) a Unix-domain socket we created when an
931 * Internet socket was asked for. We've decided it should be an Internet
932 * socket after all, with family AF_HINT, so convert it. If TMP is not null,
933 * then don't replace the existing descriptor: store the new socket in *TMP
936 static int fixup_real_ip_socket(int sk, int af_hint, int *tmp)
941 struct sockaddr_un sun;
954 _(LINGER, struct linger) \
957 _(RCVTIMEO, struct timeval) \
958 _(SNDTIMEO, struct timeval)
961 if (real_getsockname(sk, SA(&sun), &len))
963 if (decode_inet_addr(&addr.sa, af_hint, &sun, len))
964 return (0); /* Not one of ours */
966 if (real_getsockopt(sk, SOL_SOCKET, SO_TYPE, &type, &len) < 0 ||
967 (nsk = real_socket(addr.sa.sa_family, type, 0)) < 0)
969 #define FIX(opt, ty) do { \
972 if (real_getsockopt(sk, SOL_SOCKET, SO_##opt, &ov_, &len) < 0 || \
973 real_setsockopt(nsk, SOL_SOCKET, SO_##opt, &ov_, len)) { \
983 if ((f = fcntl(sk, F_GETFL)) < 0 ||
984 (fd = fcntl(sk, F_GETFD)) < 0 ||
985 fcntl(nsk, F_SETFL, f) < 0 ||
990 unlink(sun.sun_path);
992 if (fcntl(sk, F_SETFD, fd) < 0) {
993 perror("noip: fixup_real_ip_socket F_SETFD");
1000 /* We found the real address SA, with length LEN; if it's a Unix-domain
1001 * address corresponding to a fake socket, convert it to cover up the
1002 * deception. Whatever happens, put the result at FAKE and store its length
1005 #define FNF_V6MAPPED 1u
1006 static void return_fake_name(struct sockaddr *sa, socklen_t len,
1007 struct sockaddr *fake, socklen_t *fakelen,
1011 struct sockaddr_in6 sin6;
1014 if (sa->sa_family == AF_UNIX &&
1015 !decode_inet_addr(&addr.sa, 0, SUN(sa), len)) {
1016 if (addr.sa.sa_family != AF_INET || !(f&FNF_V6MAPPED)) {
1018 len = family_socklen(addr.sa.sa_family);
1020 map_ipv4_sockaddr(&sin6, &addr.sin);
1022 len = family_socklen(AF_INET6);
1026 if (len > *fakelen) len = *fakelen;
1027 if (len > 0) memcpy(fake, sa, len);
1031 /* Variant of `return_fake_name' above, specifically handling the weirdness
1032 * of remote v6-mapped IPv4 addresses. If SK's fake local address is IPv6,
1033 * and the remote address is IPv4, then return a v6-mapped version of the
1036 static void return_fake_peer(int sk, struct sockaddr *sa, socklen_t len,
1037 struct sockaddr *fake, socklen_t *fakelen)
1040 socklen_t mylen = sizeof(sabuf);
1046 rc = real_getsockname(sk, SA(sabuf), &mylen);
1047 if (!rc && sa->sa_family == AF_UNIX &&
1048 !decode_inet_addr(&addr.sa, 0, SUN(sabuf), mylen) &&
1049 addr.sa.sa_family == AF_INET6)
1050 fnf |= FNF_V6MAPPED;
1052 return_fake_name(sa, len, fake, fakelen, fnf);
1055 /*----- Implicit binding --------------------------------------------------*/
1059 static void dump_impbind(const impbind *i)
1061 char buf[ADDRBUFSZ];
1063 fprintf(stderr, "noip(%d): ", getpid());
1064 dump_addrrange(i->af, &i->minaddr, &i->maxaddr);
1066 case SAME: fprintf(stderr, " <self>"); break;
1068 fprintf(stderr, " %s", inet_ntop(i->af, &i->bindaddr,
1073 fputc('\n', stderr);
1076 static void dump_impbind_list(void)
1080 for (i = impbinds; i; i = i->next) dump_impbind(i);
1085 /* The socket SK is about to be used to communicate with the remote address
1086 * SA. Assign it a local address so that getpeername(2) does something
1089 * If the flag `IBF_V6MAPPED' is set then, then SA must be an `AF_INET'
1090 * address; after deciding on the appropriate local address, convert it to be
1091 * an IPv4-mapped IPv6 address before final conversion to a Unix-domain
1092 * socket address and actually binding. Note that this could well mean that
1093 * the socket ends up bound to the v6-mapped v4 wildcard address
1094 * ::ffff:0.0.0.0, which looks very strange but is meaningful.
1096 #define IBF_V6MAPPED 1u
1097 static int do_implicit_bind(int sk, const struct sockaddr *sa, unsigned f)
1100 struct sockaddr_in6 sin6;
1101 struct sockaddr_un sun;
1105 D( fprintf(stderr, "noip(%d): checking impbind list...\n", pid); )
1106 for (i = impbinds; i; i = i->next) {
1107 D( dump_impbind(i); )
1108 if (sa->sa_family == i->af &&
1109 sockaddr_in_range_p(sa, &i->minaddr, &i->maxaddr)) {
1110 D( fprintf(stderr, "noip(%d): match!\n", pid); )
1111 addr.sa.sa_family = sa->sa_family;
1112 ipaddr_to_sockaddr(&addr.sa, &i->bindaddr);
1116 D( fprintf(stderr, "noip(%d): no match; using wildcard\n", pid); )
1117 wildcard_address(sa->sa_family, &addr.sa);
1119 if (addr.sa.sa_family != AF_INET || !(f&IBF_V6MAPPED)) sa = &addr.sa;
1120 else { map_ipv4_sockaddr(&sin6, &addr.sin); sa = SA(&sin6); }
1121 encode_inet_addr(&sun, sa, ENCF_FRESH);
1122 D( fprintf(stderr, "noip(%d): implicitly binding to %s\n",
1123 pid, sun.sun_path); )
1124 if (real_bind(sk, SA(&sun), SUN_LEN(&sun))) return (-1);
1128 /* The socket SK is about to communicate with the remote address *SA. Ensure
1129 * that the socket has a local address, and adjust *SA to refer to the real
1132 * If we need to translate the remote address, then the Unix-domain endpoint
1133 * address will end in *SUN, and *SA will be adjusted to point to it.
1135 static int fixup_client_socket(int sk, const struct sockaddr **sa_r,
1136 socklen_t *len_r, struct sockaddr_un *sun)
1138 struct sockaddr_in sin;
1139 socklen_t mylen = sizeof(*sun);
1140 const struct sockaddr *sa = *sa_r;
1143 /* If this isn't a Unix-domain socket then there's nothing to do. */
1144 if (real_getsockname(sk, SA(sun), &mylen) < 0) return (-1);
1145 if (sun->sun_family != AF_UNIX) return (0);
1146 if (mylen < sizeof(*sun)) ((char *)sun)[mylen] = 0;
1148 /* If the remote address is v6-mapped IPv4, then unmap it so as to search
1149 * for IPv4 servers. Also remember to v6-map the local address when we
1152 if (sa->sa_family == AF_INET6 && !(unmap_ipv4_sockaddr(&sin, SIN6(sa)))) {
1154 ibf |= IBF_V6MAPPED;
1157 /* If we're allowed to talk to a real remote endpoint, then fix things up
1158 * as necessary and proceed.
1160 if (acl_allows_p(connect_real, sa)) {
1161 if (fixup_real_ip_socket(sk, (*sa_r)->sa_family, 0)) return (-1);
1165 /* Speaking of which, if we don't have a local address, then we should
1168 if (!sun->sun_path[0] && do_implicit_bind(sk, sa, ibf)) return (-1);
1170 /* And then come up with a remote address. */
1171 encode_inet_addr(sun, sa, 0);
1173 *len_r = SUN_LEN(sun);
1177 /*----- Configuration -----------------------------------------------------*/
1179 /* Return the process owner's home directory. */
1180 static char *home(void)
1185 if (getuid() == uid &&
1186 (p = getenv("HOME")) != 0)
1188 else if ((pw = getpwuid(uid)) != 0)
1189 return (pw->pw_dir);
1194 /* Return a good temporary directory to use. */
1195 static char *tmpdir(void)
1199 if ((p = getenv("TMPDIR")) != 0) return (p);
1200 else if ((p = getenv("TMP")) != 0) return (p);
1201 else return ("/tmp");
1204 /* Return the user's name, or at least something distinctive. */
1205 static char *user(void)
1207 static char buf[16];
1211 if ((p = getenv("USER")) != 0) return (p);
1212 else if ((p = getenv("LOGNAME")) != 0) return (p);
1213 else if ((pw = getpwuid(uid)) != 0) return (pw->pw_name);
1215 snprintf(buf, sizeof(buf), "uid-%lu", (unsigned long)uid);
1220 /* Skip P over space characters. */
1221 #define SKIPSPC do { while (*p && isspace(UC(*p))) p++; } while (0)
1223 /* Set Q to point to the next word following P, null-terminate it, and step P
1225 #define NEXTWORD(q) do { \
1228 while (*p && !isspace(UC(*p))) p++; \
1232 /* Set Q to point to the next dotted-quad address, store the ending delimiter
1233 * in DEL, null-terminate it, and step P past it. */
1234 static void parse_nextaddr(char **pp, char **qq, int *del)
1242 p += strcspn(p, "]");
1247 while (*p && (*p == '.' || isdigit(UC(*p)))) p++;
1254 /* Set Q to point to the next decimal number, store the ending delimiter in
1255 * DEL, null-terminate it, and step P past it. */
1256 #define NEXTNUMBER(q, del) do { \
1259 while (*p && isdigit(UC(*p))) p++; \
1264 /* Push the character DEL back so we scan it again, unless it's zero
1266 #define RESCAN(del) do { if (del) *--p = del; } while (0)
1268 /* Evaluate true if P is pointing to the word KW (and not some longer string
1269 * of which KW is a prefix). */
1271 #define KWMATCHP(kw) (strncmp(p, kw, sizeof(kw) - 1) == 0 && \
1272 !isalnum(UC(p[sizeof(kw) - 1])) && \
1273 (p += sizeof(kw) - 1))
1275 /* Parse a port list, starting at *PP. Port lists have the form
1276 * [:LOW[-HIGH]]: if omitted, all ports are included; if HIGH is omitted,
1277 * it's as if HIGH = LOW. Store LOW in *MIN, HIGH in *MAX and set *PP to the
1278 * rest of the string.
1280 static void parse_ports(char **pp, unsigned short *min, unsigned short *max)
1287 { *min = 0; *max = 0xffff; }
1290 NEXTNUMBER(q, del); *min = strtoul(q, 0, 0); RESCAN(del);
1293 { p++; NEXTNUMBER(q, del); *max = strtoul(q, 0, 0); RESCAN(del); }
1300 /* Parse an address range designator starting at PP and store a
1301 * representation of it in R. An address range designator has the form:
1303 * any | local | ADDR | ADDR - ADDR | ADDR/ADDR | ADDR/INT
1305 static int parse_addrrange(char **pp, addrrange *r)
1313 if (KWMATCHP("any")) r->type = ANY;
1314 else if (KWMATCHP("local")) r->type = LOCAL;
1316 parse_nextaddr(&p, &q, &del);
1317 af = guess_address_family(q);
1318 if (inet_pton(af, q, &r->u.range.min) <= 0) goto bad;
1323 parse_nextaddr(&p, &q, &del);
1324 if (inet_pton(af, q, &r->u.range.max) <= 0) goto bad;
1326 } else if (*p == '/') {
1329 n = strtoul(q, 0, 0);
1330 r->u.range.max = r->u.range.min;
1331 mask_address(af, &r->u.range.min, n, 0);
1332 mask_address(af, &r->u.range.max, n, 1);
1335 r->u.range.max = r->u.range.min;
1346 /* Call FUNC on each individual address range in R. */
1347 static void foreach_addrrange(const addrrange *r,
1348 void (*func)(int af,
1354 ipaddr minaddr, maxaddr;
1361 for (i = 0; address_families[i] >= 0; i++) {
1362 af = address_families[i];
1363 memset(&minaddr, 0, sizeof(minaddr));
1364 maxaddr = minaddr; mask_address(af, &maxaddr, 0, 1);
1365 func(af, &minaddr, &maxaddr, p);
1369 for (i = 0; address_families[i] >= 0; i++) {
1370 af = address_families[i];
1371 memset(&minaddr, 0, sizeof(minaddr));
1372 maxaddr = minaddr; mask_address(af, &maxaddr, 0, 1);
1373 func(af, &minaddr, &minaddr, p);
1374 func(af, &maxaddr, &maxaddr, p);
1376 for (i = 0; i < n_local_ipaddrs; i++) {
1377 func(local_ipaddrs[i].af,
1378 &local_ipaddrs[i].addr, &local_ipaddrs[i].addr,
1383 func(r->u.range.af, &r->u.range.min, &r->u.range.max, p);
1390 struct add_aclnode_ctx {
1392 unsigned short minport, maxport;
1396 static void add_aclnode(int af, const ipaddr *min, const ipaddr *max,
1399 struct add_aclnode_ctx *ctx = p;
1405 a->minaddr = *min; a->maxaddr = *max;
1406 a->minport = ctx->minport; a->maxport = ctx->maxport;
1407 **ctx->tail = a; *ctx->tail = &a->next;
1410 /* Parse an ACL line. *PP points to the end of the line; *TAIL points to
1411 * the list tail (i.e., the final link in the list). An ACL entry has the
1412 * form +|- ADDR-RANGE PORTS
1413 * where PORTS is parsed by parse_ports above; an ACL line consists of a
1414 * comma-separated sequence of entries..
1416 static void parse_acl_line(char **pp, aclnode ***tail)
1418 struct add_aclnode_ctx ctx;
1425 if (*p == '+') ctx.act = ALLOW;
1426 else if (*p == '-') ctx.act = DENY;
1430 if (parse_addrrange(&p, &r)) goto bad;
1431 parse_ports(&p, &ctx.minport, &ctx.maxport);
1432 foreach_addrrange(&r, add_aclnode, &ctx);
1434 if (*p != ',') break;
1442 D( fprintf(stderr, "noip(%d): bad acl spec (ignored)\n", getpid()); )
1446 /* Parse an ACL from an environment variable VAR, attaching it to the list
1449 static void parse_acl_env(const char *var, aclnode ***tail)
1453 if ((p = getenv(var)) != 0) {
1455 parse_acl_line(&q, tail);
1460 struct add_impbind_ctx {
1465 static void add_impbind(int af, const ipaddr *min, const ipaddr *max,
1468 struct add_impbind_ctx *ctx = p;
1471 if (ctx->af && af != ctx->af) return;
1475 i->minaddr = *min; i->maxaddr = *max;
1477 case EXPLICIT: i->bindaddr = ctx->addr;
1481 *impbind_tail = i; impbind_tail = &i->next;
1484 /* Parse an implicit-bind line. An implicit-bind entry has the form
1485 * ADDR-RANGE {ADDR | same}
1487 static void parse_impbind_line(char **pp)
1489 struct add_impbind_ctx ctx;
1495 if (parse_addrrange(&p, &r)) goto bad;
1497 if (KWMATCHP("same")) {
1502 parse_nextaddr(&p, &q, &del);
1503 ctx.af = guess_address_family(q);
1504 if (inet_pton(ctx.af, q, &ctx.addr) < 0) goto bad;
1507 foreach_addrrange(&r, add_impbind, &ctx);
1509 if (*p != ',') break;
1517 D( fprintf(stderr, "noip(%d): bad implicit-bind spec (ignored)\n",
1522 /* Parse implicit-bind instructions from an environment variable VAR,
1523 * attaching it to the list.
1525 static void parse_impbind_env(const char *var)
1529 if ((p = getenv(var)) != 0) {
1531 parse_impbind_line(&q);
1536 /* Parse the autoports configuration directive. Syntax is MIN - MAX. */
1537 static void parse_autoports(char **pp)
1544 NEXTNUMBER(q, del); x = strtoul(q, 0, 0); RESCAN(del);
1546 if (*p != '-') goto bad;
1548 NEXTNUMBER(q, del); y = strtoul(q, 0, 0); RESCAN(del);
1549 minautoport = x; maxautoport = y;
1550 SKIPSPC; if (*p) goto bad;
1555 D( fprintf(stderr, "noip(%d): bad port range (ignored)\n", getpid()); )
1559 /* Read the configuration from the config file and environment. */
1560 static void readconfig(void)
1568 parse_acl_env("NOIP_REALBIND_BEFORE", &bind_tail);
1569 parse_acl_env("NOIP_REALCONNECT_BEFORE", &connect_tail);
1570 parse_impbind_env("NOIP_IMPBIND_BEFORE");
1571 if ((p = getenv("NOIP_AUTOPORTS")) != 0) {
1573 parse_autoports(&q);
1576 if ((p = getenv("NOIP_CONFIG")) == 0)
1577 snprintf(p = buf, sizeof(buf), "%s/.noip", home());
1578 D( fprintf(stderr, "noip(%d): config file: %s\n", pid, p); )
1580 if ((fp = fopen(p, "r")) == 0) {
1581 D( fprintf(stderr, "noip(%d): couldn't read config: %s\n",
1582 pid, strerror(errno)); )
1585 while (fgets(buf, sizeof(buf), fp)) {
1590 if (!*p || *p == '#') continue;
1591 while (n && isspace(UC(buf[n - 1]))) n--;
1596 if (strcmp(cmd, "socketdir") == 0)
1597 sockdir = xstrdup(p);
1598 else if (strcmp(cmd, "realbind") == 0)
1599 parse_acl_line(&p, &bind_tail);
1600 else if (strcmp(cmd, "realconnect") == 0)
1601 parse_acl_line(&p, &connect_tail);
1602 else if (strcmp(cmd, "impbind") == 0)
1603 parse_impbind_line(&p);
1604 else if (strcmp(cmd, "autoports") == 0)
1605 parse_autoports(&p);
1606 else if (strcmp(cmd, "debug") == 0)
1607 debug = *p ? atoi(p) : 1;
1609 D( fprintf(stderr, "noip(%d): bad config command %s\n", pid, cmd); )
1614 parse_acl_env("NOIP_REALBIND", &bind_tail);
1615 parse_acl_env("NOIP_REALCONNECT", &connect_tail);
1616 parse_impbind_env("NOIP_IMPBIND");
1617 parse_acl_env("NOIP_REALBIND_AFTER", &bind_tail);
1618 parse_acl_env("NOIP_REALCONNECT_AFTER", &connect_tail);
1619 parse_impbind_env("NOIP_IMPBIND_AFTER");
1623 if (!sockdir) sockdir = getenv("NOIP_SOCKETDIR");
1625 snprintf(buf, sizeof(buf), "%s/noip-%s", tmpdir(), user());
1626 sockdir = xstrdup(buf);
1628 D( fprintf(stderr, "noip(%d): socketdir: %s\n", pid, sockdir);
1629 fprintf(stderr, "noip(%d): autoports: %u-%u\n",
1630 pid, minautoport, maxautoport);
1631 fprintf(stderr, "noip(%d): realbind acl:\n", pid);
1632 dump_acl(bind_real);
1633 fprintf(stderr, "noip(%d): realconnect acl:\n", pid);
1634 dump_acl(connect_real);
1635 fprintf(stderr, "noip(%d): impbind list:\n", pid);
1636 dump_impbind_list(); )
1639 /*----- Overridden system calls -------------------------------------------*/
1641 static void dump_syserr(long rc)
1642 { fprintf(stderr, " => %ld (E%d)\n", rc, errno); }
1644 static void dump_sysresult(long rc)
1646 if (rc < 0) dump_syserr(rc);
1647 else fprintf(stderr, " => %ld\n", rc);
1650 static void dump_addrresult(long rc, const struct sockaddr *sa,
1653 char addrbuf[ADDRBUFSZ];
1655 if (rc < 0) dump_syserr(rc);
1657 fprintf(stderr, " => %ld [%s]\n", rc,
1658 present_sockaddr(sa, len, addrbuf, sizeof(addrbuf)));
1662 int socket(int pf, int ty, int proto)
1666 D( fprintf(stderr, "noip(%d): SOCKET pf=%d, type=%d, proto=%d",
1667 getpid(), pf, ty, proto); )
1671 if (!family_known_p(pf)) {
1672 D( fprintf(stderr, " -> unknown; refuse\n"); )
1673 errno = EAFNOSUPPORT;
1676 D( fprintf(stderr, " -> inet; substitute"); )
1684 D( fprintf(stderr, " -> safe; permit"); )
1687 sk = real_socket(pf, ty, proto);
1688 D( dump_sysresult(sk); )
1692 int socketpair(int pf, int ty, int proto, int *sk)
1696 D( fprintf(stderr, "noip(%d): SOCKETPAIR pf=%d, type=%d, proto=%d",
1697 getpid(), pf, ty, proto); )
1698 if (!family_known_p(pf))
1699 D( fprintf(stderr, " -> unknown; permit"); )
1701 D( fprintf(stderr, " -> inet; substitute"); )
1705 rc = real_socketpair(pf, ty, proto, sk);
1706 D( if (rc < 0) dump_syserr(rc);
1707 else fprintf(stderr, " => %d (%d, %d)\n", rc, sk[0], sk[1]); )
1711 int bind(int sk, const struct sockaddr *sa, socklen_t len)
1713 struct sockaddr_un sun;
1717 D({ char buf[ADDRBUFSZ];
1718 fprintf(stderr, "noip(%d): BIND sk=%d, sa[%d]=%s", pid,
1719 sk, len, present_sockaddr(sa, len, buf, sizeof(buf))); })
1721 if (!family_known_p(sa->sa_family))
1722 D( fprintf(stderr, " -> unknown af; pass through"); )
1724 D( fprintf(stderr, " -> checking...\n"); )
1726 if (acl_allows_p(bind_real, sa)) {
1727 if (fixup_real_ip_socket(sk, sa->sa_family, 0))
1730 encode_inet_addr(&sun, sa, ENCF_FRESH);
1732 len = SUN_LEN(&sun);
1735 D( fprintf(stderr, "noip(%d): BIND ...", pid); )
1737 rc = real_bind(sk, sa, len);
1738 D( dump_sysresult(rc); )
1742 int connect(int sk, const struct sockaddr *sa, socklen_t len)
1744 struct sockaddr_un sun;
1748 D({ char buf[ADDRBUFSZ];
1749 fprintf(stderr, "noip(%d): CONNECT sk=%d, sa[%d]=%s", pid,
1750 sk, len, present_sockaddr(sa, len, buf, sizeof(buf))); })
1752 if (!family_known_p(sa->sa_family)) {
1753 D( fprintf(stderr, " -> unknown af; pass through"); )
1754 rc = real_connect(sk, sa, len);
1756 D( fprintf(stderr, " -> checking...\n"); )
1758 fixup_client_socket(sk, &sa, &len, &sun);
1760 D( fprintf(stderr, "noip(%d): CONNECT ...", pid); )
1761 rc = real_connect(sk, sa, len);
1764 case ENOENT: errno = ECONNREFUSED; break;
1768 D( dump_sysresult(rc); )
1772 ssize_t sendto(int sk, const void *buf, size_t len, int flags,
1773 const struct sockaddr *to, socklen_t tolen)
1775 struct sockaddr_un sun;
1779 D({ char addrbuf[ADDRBUFSZ];
1780 fprintf(stderr, "noip(%d): SENDTO sk=%d, len=%lu, flags=%d, to[%d]=%s",
1781 pid, sk, (unsigned long)len, flags, tolen,
1782 present_sockaddr(to, tolen, addrbuf, sizeof(addrbuf))); })
1785 D( fprintf(stderr, " -> null address; leaving"); )
1786 else if (!family_known_p(to->sa_family))
1787 D( fprintf(stderr, " -> unknown af; pass through"); )
1789 D( fprintf(stderr, " -> checking...\n"); )
1791 fixup_client_socket(sk, &to, &tolen, &sun);
1793 D( fprintf(stderr, "noip(%d): SENDTO ...", pid); )
1795 n = real_sendto(sk, buf, len, flags, to, tolen);
1796 D( dump_sysresult(n); )
1800 ssize_t recvfrom(int sk, void *buf, size_t len, int flags,
1801 struct sockaddr *from, socklen_t *fromlen)
1804 socklen_t mylen = sizeof(sabuf);
1808 D( fprintf(stderr, "noip(%d): RECVFROM sk=%d, len=%lu, flags=%d",
1809 pid, sk, (unsigned long)len, flags); )
1812 D( fprintf(stderr, " -> null addr; pass through"); )
1813 n = real_recvfrom(sk, buf, len, flags, 0, 0);
1816 n = real_recvfrom(sk, buf, len, flags, SA(sabuf), &mylen);
1818 D( fprintf(stderr, " -> converting...\n"); )
1819 return_fake_peer(sk, SA(sabuf), mylen, from, fromlen);
1820 D( fprintf(stderr, "noip(%d): ... RECVFROM", pid); )
1824 D( dump_addrresult(n, from, fromlen ? *fromlen : 0); )
1828 ssize_t sendmsg(int sk, const struct msghdr *msg, int flags)
1830 struct sockaddr_un sun;
1831 const struct sockaddr *sa = SA(msg->msg_name);
1832 struct msghdr mymsg;
1836 D({ char addrbuf[ADDRBUFSZ];
1837 fprintf(stderr, "noip(%d): SENDMSG sk=%d, "
1838 "msg_flags=%d, msg_name[%d]=%s, ...",
1839 pid, sk, msg->msg_flags, msg->msg_namelen,
1840 present_sockaddr(sa, msg->msg_namelen,
1841 addrbuf, sizeof(addrbuf))); })
1844 D( fprintf(stderr, " -> null address; leaving"); )
1845 else if (!family_known_p(sa->sa_family))
1846 D( fprintf(stderr, " -> unknown af; pass through"); )
1848 D( fprintf(stderr, " -> checking...\n"); )
1851 fixup_client_socket(sk, &sa, &mymsg.msg_namelen, &sun);
1852 mymsg.msg_name = SA(sa);
1855 D( fprintf(stderr, "noip(%d): SENDMSG ...", pid); )
1857 n = real_sendmsg(sk, msg, flags);
1858 D( dump_sysresult(n); )
1862 ssize_t recvmsg(int sk, struct msghdr *msg, int flags)
1865 struct sockaddr *sa = SA(msg->msg_name);
1866 socklen_t len = msg->msg_namelen;
1870 D( fprintf(stderr, "noip(%d): RECVMSG sk=%d msg_flags=%d, ...",
1871 pid, sk, msg->msg_flags); )
1873 if (!msg->msg_name) {
1874 D( fprintf(stderr, " -> null addr; pass through"); )
1875 return (real_recvmsg(sk, msg, flags));
1878 msg->msg_name = sabuf;
1879 msg->msg_namelen = sizeof(sabuf);
1880 n = real_recvmsg(sk, msg, flags);
1882 D( fprintf(stderr, " -> converting...\n"); )
1883 return_fake_peer(sk, SA(sabuf), msg->msg_namelen, sa, &len);
1884 D( fprintf(stderr, "noip(%d): ... RECVMSG", pid); )
1887 msg->msg_namelen = len;
1890 D( dump_addrresult(n, sa, len); )
1894 int accept(int sk, struct sockaddr *sa, socklen_t *len)
1897 socklen_t mylen = sizeof(sabuf);
1901 D( fprintf(stderr, "noip(%d): ACCEPT sk=%d", pid, sk); )
1903 nsk = real_accept(sk, SA(sabuf), &mylen);
1904 if (nsk < 0) /* failed */;
1905 else if (!sa) D( fprintf(stderr, " -> address not wanted"); )
1907 D( fprintf(stderr, " -> converting...\n"); )
1908 return_fake_peer(sk, SA(sabuf), mylen, sa, len);
1909 D( fprintf(stderr, "noip(%d): ... ACCEPT", pid); )
1911 D( dump_addrresult(nsk, sa, len ? *len : 0); )
1915 int getsockname(int sk, struct sockaddr *sa, socklen_t *len)
1918 socklen_t mylen = sizeof(sabuf);
1922 D( fprintf(stderr, "noip(%d): GETSOCKNAME sk=%d", pid, sk); )
1923 rc = real_getsockname(sk, SA(sabuf), &mylen);
1925 D( fprintf(stderr, " -> converting...\n"); )
1926 return_fake_name(SA(sabuf), mylen, sa, len, 0);
1927 D( fprintf(stderr, "noip(%d): ... GETSOCKNAME", pid); )
1929 D( dump_addrresult(rc, sa, *len); )
1933 int getpeername(int sk, struct sockaddr *sa, socklen_t *len)
1936 socklen_t mylen = sizeof(sabuf);
1940 D( fprintf(stderr, "noip(%d): GETPEERNAME sk=%d", pid, sk); )
1941 rc = real_getpeername(sk, SA(sabuf), &mylen);
1943 D( fprintf(stderr, " -> converting...\n"); )
1944 return_fake_peer(sk, SA(sabuf), mylen, sa, len);
1945 D( fprintf(stderr, "noip(%d): ... GETPEERNAME", pid); )
1947 D( dump_addrresult(rc, sa, *len); )
1951 int getsockopt(int sk, int lev, int opt, void *p, socklen_t *len)
1962 return (real_getsockopt(sk, lev, opt, p, len));
1965 int setsockopt(int sk, int lev, int opt, const void *p, socklen_t len)
1975 case SO_BINDTODEVICE:
1976 case SO_ATTACH_FILTER:
1977 case SO_DETACH_FILTER:
1980 return (real_setsockopt(sk, lev, opt, p, len));
1983 int ioctl(int fd, unsigned long op, ...)
1991 arg = va_arg(ap, void *);
1995 case SIOCGIFBRDADDR:
1996 case SIOCGIFDSTADDR:
1997 case SIOCGIFNETMASK:
1999 if (fixup_real_ip_socket(fd, AF_INET, &sk)) goto real;
2001 rc = real_ioctl(sk, op, arg);
2002 PRESERVING_ERRNO({ close(sk); });
2006 rc = real_ioctl(fd, op, arg);
2013 /*----- Initialization ----------------------------------------------------*/
2015 /* Clean up the socket directory, deleting stale sockets. */
2016 static void cleanup_sockdir(void)
2021 struct sockaddr_un sun;
2025 if ((dir = opendir(sockdir)) == 0) return;
2026 sun.sun_family = AF_UNIX;
2027 while ((d = readdir(dir)) != 0) {
2028 if (d->d_name[0] == '.') continue;
2029 snprintf(sun.sun_path, sizeof(sun.sun_path),
2030 "%s/%s", sockdir, d->d_name);
2031 if (decode_inet_addr(&addr.sa, 0, &sun, SUN_LEN(&sun)) ||
2032 stat(sun.sun_path, &st) ||
2033 !S_ISSOCK(st.st_mode)) {
2034 D( fprintf(stderr, "noip(%d): ignoring unknown socketdir entry `%s'\n",
2035 pid, sun.sun_path); )
2038 if (unix_socket_status(&sun, 0) == STALE) {
2039 D( fprintf(stderr, "noip(%d): clearing away stale socket %s\n",
2041 unlink(sun.sun_path);
2047 /* Find the addresses attached to local network interfaces, and remember them
2050 static void get_local_ipaddrs(void)
2052 struct ifaddrs *ifa_head, *ifa;
2057 D( fprintf(stderr, "noip(%d): fetching local addresses...\n", pid); )
2058 if (getifaddrs(&ifa_head)) { perror("getifaddrs"); return; }
2059 for (n_local_ipaddrs = 0, ifa = ifa_head;
2060 n_local_ipaddrs < MAX_LOCAL_IPADDRS && ifa;
2061 ifa = ifa->ifa_next) {
2062 if (!ifa->ifa_addr || !family_known_p(ifa->ifa_addr->sa_family))
2064 ipaddr_from_sockaddr(&a, ifa->ifa_addr);
2065 D({ char buf[ADDRBUFSZ];
2066 fprintf(stderr, "noip(%d): local addr %s = %s", pid,
2068 inet_ntop(ifa->ifa_addr->sa_family, &a,
2069 buf, sizeof(buf))); })
2070 for (i = 0; i < n_local_ipaddrs; i++) {
2071 if (ifa->ifa_addr->sa_family == local_ipaddrs[i].af &&
2072 ipaddr_equal_p(local_ipaddrs[i].af, &a, &local_ipaddrs[i].addr)) {
2073 D( fprintf(stderr, " (duplicate)\n"); )
2077 D( fprintf(stderr, "\n"); )
2078 local_ipaddrs[n_local_ipaddrs].af = ifa->ifa_addr->sa_family;
2079 local_ipaddrs[n_local_ipaddrs].addr = a;
2083 freeifaddrs(ifa_head);
2086 /* Print the given message to standard error. Avoids stdio. */
2087 static void printerr(const char *p)
2088 { if (write(STDERR_FILENO, p, strlen(p))) ; }
2090 /* Create the socket directory, being careful about permissions. */
2091 static void create_sockdir(void)
2095 if (lstat(sockdir, &st)) {
2096 if (errno == ENOENT) {
2097 if (mkdir(sockdir, 0700)) {
2098 perror("noip: creating socketdir");
2101 if (!lstat(sockdir, &st))
2104 perror("noip: checking socketdir");
2108 if (!S_ISDIR(st.st_mode)) {
2109 printerr("noip: bad socketdir: not a directory\n");
2112 if (st.st_uid != uid) {
2113 printerr("noip: bad socketdir: not owner\n");
2116 if (st.st_mode & 077) {
2117 printerr("noip: bad socketdir: not private\n");
2122 /* Initialization function. */
2123 static void setup(void) __attribute__((constructor));
2124 static void setup(void)
2131 if ((p = getenv("NOIP_DEBUG")) && atoi(p))
2133 get_local_ipaddrs();
2140 /*----- That's all, folks -------------------------------------------------*/