chiark / gitweb /
~mdw / preload-hacks / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
noip: set ACLs from environment variables.
[preload-hacks] / noip.c
CommitLineData
e4976bb0 1#define _GNU_SOURCE
2#undef sun
3#undef SUN
4#define DEBUG
5
6#include <ctype.h>
7#include <errno.h>
8#include <stdio.h>
9#include <stdlib.h>
10
11#include <unistd.h>
12#include <dirent.h>
13#include <dlfcn.h>
14#include <fcntl.h>
15#include <pwd.h>
16
17#include <sys/ioctl.h>
18#include <sys/socket.h>
19#include <sys/stat.h>
20#include <sys/un.h>
21
22#include <netinet/in.h>
23#include <arpa/inet.h>
24#include <netinet/tcp.h>
25#include <netinet/udp.h>
26#include <net/if.h>
27
28enum { UNUSED, STALE, USED };
29enum { WANT_FRESH, WANT_EXISTING };
30enum { DENY, ALLOW };
31typedef struct aclnode {
32 struct aclnode *next;
33 int act;
34 unsigned long minaddr, maxaddr;
35 unsigned short minport, maxport;
36} aclnode;
37
38#define MAX_LOCAL_IPADDRS 16
39static struct in_addr local_ipaddrs[MAX_LOCAL_IPADDRS];
40static int n_local_ipaddrs;
41
42static uid_t uid;
43static char *sockdir = 0;
44static int debug = 0;
45
46static aclnode *bind_real, **bind_tail = &bind_real;
47static aclnode *connect_real, **connect_tail = &connect_real;
48
49/* --- Import magic --- */
50
51#define IMPORTS(_) \
52 _(socket, int, (int, int, int)) \
53 _(socketpair, int, (int, int, int, int *)) \
54 _(connect, int, (int, const struct sockaddr *, socklen_t)) \
55 _(bind, int, (int, const struct sockaddr *, socklen_t)) \
56 _(accept, int, (int, struct sockaddr *, socklen_t *)) \
57 _(getsockname, int, (int, struct sockaddr *, socklen_t *)) \
58 _(getpeername, int, (int, struct sockaddr *, socklen_t *)) \
59 _(getsockopt, int, (int, int, int, void *, socklen_t *)) \
60 _(setsockopt, int, (int, int, int, const void *, socklen_t)) \
61 _(sendto, ssize_t, (int, const void *buf, size_t, int, \
62 const struct sockaddr *to, socklen_t tolen)) \
63 _(recvfrom, ssize_t, (int, void *buf, size_t, int, \
64 struct sockaddr *from, socklen_t *fromlen)) \
65 _(sendmsg, ssize_t, (int, const struct msghdr *, int)) \
66 _(recvmsg, ssize_t, (int, struct msghdr *, int)) \
67 _(close, int, (int))
68
69#define DECL(imp, ret, args) static ret (*real_##imp) args;
70IMPORTS(DECL)
71#undef DECL
72
73static void setup(void) __attribute__((constructor));
74static void import(void)
75{
76#define IMPORT(imp, ret, args) \
77 real_##imp = (ret (*)args)dlsym(RTLD_NEXT, #imp);
78 IMPORTS(IMPORT)
79#undef IMPORT
80}
81
82/* --- Support --- */
83
84#define SA(sa) ((struct sockaddr *)(sa))
85#define SIN(sa) ((struct sockaddr_in *)(sa))
86#define SUN(sa) ((struct sockaddr_un *)(sa))
87
88#define UC(ch) ((unsigned char)(ch))
89
90#define NEW(x) ((x) = xmalloc(sizeof(*x)))
91#define NEWV(x, n) ((x) = xmalloc(sizeof(*x) * (n)))
92
93#ifdef DEBUG
94# define D(body) { if (debug) { body } }
95#else
96# define D(body) ;
97#endif
98
99#define PRESERVING_ERRNO(body) do { \
100 int _err = errno; { body } errno = _err; \
101} while (0)
102
103static void *xmalloc(size_t n)
104{
105 void *p;
106 if (!n) return (0);
107 if ((p = malloc(n)) == 0) { perror("malloc"); exit(1); }
108 return (p);
109}
110
111static char *xstrdup(const char *p)
112{
113 size_t n = strlen(p) + 1;
114 char *q = xmalloc(n);
115 memcpy(q, p, n);
116 return (q);
117}
118
119static int unix_socket_status(struct sockaddr_un *sun, int quick_p)
120{
121 struct stat st;
122 FILE *fp = 0;
123 size_t len, n;
124 int rc;
125 char buf[256];
126
127 rc = UNUSED;
128 if (stat(sun->sun_path, &st) && errno == ENOENT)
129 goto done;
130 rc = USED;
131 if (quick_p)
132 goto done;
133
134 if ((fp = fopen("/proc/net/unix", "r")) == 0)
135 goto done;
136 fgets(buf, sizeof(buf), fp); /* skip header */
137 len = strlen(sun->sun_path);
138 while (fgets(buf, sizeof(buf), fp)) {
139 n = strlen(buf);
140 if (n >= len + 2 && buf[n - len - 2] == ' ' && buf[n - 1] == '\n' &&
141 memcmp(buf + n - len - 1, sun->sun_path, len) == 0)
142 goto done;
143 }
144 if (ferror(fp))
145 goto done;
146 rc = STALE;
147done:
148 if (fp) fclose(fp);
149 return (rc);
150}
151
152#ifdef DEBUG
153
154static void dump_aclnode(aclnode *a)
155{
156 char minbuf[16], maxbuf[16];
157 struct in_addr amin, amax;
158
159 amin.s_addr = htonl(a->minaddr);
160 amax.s_addr = htonl(a->maxaddr);
161 fprintf(stderr, "noip: %c ", a->act ? '+' : '-');
162 if (a->minaddr == 0 && a->maxaddr == 0xffffffff)
163 fprintf(stderr, "any");
164 else {
165 fprintf(stderr, "%s",
166 inet_ntop(AF_INET, &amin, minbuf, sizeof(minbuf)));
167 if (a->maxaddr != a->minaddr) {
168 fprintf(stderr, "-%s",
169 inet_ntop(AF_INET, &amax, maxbuf, sizeof(maxbuf)));
170 }
171 }
172 if (a->minport != 0 || a->maxport != 0xffff) {
173 fprintf(stderr, ":%u", (unsigned)a->minport);
174 if (a->minport != a->maxport)
175 fprintf(stderr, "-%u", (unsigned)a->maxport);
176 }
177 fputc('\n', stderr);
178}
179
180#endif
181
182static int acl_allows_p(aclnode *a, const struct sockaddr_in *sin)
183{
184 unsigned long addr = ntohl(sin->sin_addr.s_addr);
185 unsigned short port = ntohs(sin->sin_port);
186 int act = ALLOW;
187
188 D( char buf[16];
189 fprintf(stderr, "noip: check %s:%u\n",
190 inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)),
191 ntohs((unsigned)sin->sin_port)); )
192 for (; a; a = a->next) {
193 D( dump_aclnode(a); )
194 if (a->minaddr <= addr && addr <= a->maxaddr &&
195 a->minport <= port && port <= a->maxport) {
196 D( fprintf(stderr, "noip: aha! %s\n", a->act ? "ALLOW" : "DENY"); )
197 return (a->act);
198 }
199 act = a->act;
200 }
201 D( fprintf(stderr, "noip: nothing found: %s\n", act ? "DENY" : "ALLOW"); )
202 return (!act);
203}
204
205#ifdef DEBUG
206
207static void dump_acl(aclnode *a)
208{
209 int act = ALLOW;
210
211 for (; a; a = a->next) {
212 dump_aclnode(a);
213 act = a->act;
214 }
215 fprintf(stderr, "noip: [default policy: %s]\n",
216 act == ALLOW ? "DENY" : "ALLOW");
217}
218
219#endif
220
221static int encode_inet_addr(struct sockaddr_un *sun,
222 const struct sockaddr_in *sin,
223 int want)
224{
225 int i;
226 int desperate_p = 0;
227 char buf[INET_ADDRSTRLEN];
228 int rc;
229
230 D( fprintf(stderr, "noip: encode %s:%u (%s)",
231 inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)),
232 (unsigned)ntohs(sin->sin_port),
233 want == WANT_EXISTING ? "EXISTING" : "FRESH"); )
234 sun->sun_family = AF_UNIX;
235 if (sin->sin_port || want == WANT_EXISTING) {
236 snprintf(sun->sun_path, sizeof(sun->sun_path), "%s/%s:%u", sockdir,
237 inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)),
238 (unsigned)ntohs(sin->sin_port));
239 rc = unix_socket_status(sun, 0);
240 if (rc == STALE) unlink(sun->sun_path);
241 if (rc != USED && want == WANT_EXISTING) {
242 snprintf(sun->sun_path, sizeof(sun->sun_path), "%s/0.0.0.0:%u",
243 sockdir, (unsigned)ntohs(sin->sin_port));
244 if (unix_socket_status(sun, 0) == STALE) unlink(sun->sun_path);
245 }
246 } else {
247 for (desperate_p = 0; desperate_p < 2; desperate_p++) {
248 for (i = 16384; i < 65536; i++) {
249 snprintf(sun->sun_path, sizeof(sun->sun_path), "%s/%s:%u", sockdir,
250 inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)),
251 (unsigned)i);
252 rc = unix_socket_status(sun, !desperate_p);
253 switch (rc) {
254 case STALE: unlink(sun->sun_path);
255 case UNUSED: goto found;
256 }
257 }
258 }
259 errno = EADDRINUSE;
260 D( fprintf(stderr, " -- can't resolve\n"); )
261 return (-1);
262 found:;
263 }
264 D( fprintf(stderr, " -> `%s'\n", sun->sun_path); )
265 return (0);
266}
267
268static int decode_inet_addr(struct sockaddr_in *sin,
269 const struct sockaddr_un *sun,
270 socklen_t len)
271{
272 char buf[INET_ADDRSTRLEN + 16];
273 char *p;
274 size_t n = strlen(sockdir), nn = strlen(sun->sun_path);
275 struct sockaddr_in sin_mine;
276 unsigned long port;
277
278 if (!sin)
279 sin = &sin_mine;
280 if (sun->sun_family != AF_UNIX)
281 return (-1);
282 if (len < sizeof(sun)) ((char *)sun)[len] = 0;
283 D( fprintf(stderr, "noip: decode (%d) `%s'",
284 *sun->sun_path, sun->sun_path); )
285 if (!sun->sun_path[0]) {
286 sin->sin_family = AF_INET;
287 sin->sin_addr.s_addr = INADDR_ANY;
288 sin->sin_port = 0;
289 D( fprintf(stderr, " -- unbound socket\n"); )
290 return (0);
291 }
292 if (nn < n + 1 || nn - n >= sizeof(buf) || sun->sun_path[n] != '/' ||
293 memcmp(sun->sun_path, sockdir, n) != 0) {
294 D( fprintf(stderr, " -- not one of ours\n"); )
295 return (-1);
296 }
297 memcpy(buf, sun->sun_path + n + 1, nn - n);
298 if ((p = strchr(buf, ':')) == 0) {
299 D( fprintf(stderr, " -- malformed (no port)\n"); )
300 return (-1);
301 }
302 *p++ = 0;
303 sin->sin_family = AF_INET;
304 if (inet_pton(AF_INET, buf, &sin->sin_addr) <= 0) {
305 D( fprintf(stderr, " -- malformed (bad address `%s')\n", buf); )
306 return (-1);
307 }
308 port = strtoul(p, &p, 10);
309 if (*p || port >= 65536) {
310 D( fprintf(stderr, " -- malformed (port out of range)"); )
311 return (-1);
312 }
313 sin->sin_port = htons(port);
314 D( fprintf(stderr, " -> %s:%u\n",
315 inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)),
316 (unsigned)port); )
317 return (0);
318}
319
320static int fixup_real_ip_socket(int sk)
321{
322 int nsk;
323 int type;
324 int f, fd;
325 struct sockaddr_un sun;
326 struct sockaddr_in sin;
327 socklen_t len;
328
329#define OPTS(_) \
330 _(DEBUG, int) \
331 _(REUSEADDR, int) \
332 _(DONTROUTE, int) \
333 _(BROADCAST, int) \
334 _(SNDBUF, int) \
335 _(RCVBUF, int) \
336 _(OOBINLINE, int) \
337 _(NO_CHECK, int) \
338 _(LINGER, struct linger) \
339 _(BSDCOMPAT, int) \
340 _(RCVLOWAT, int) \
341 _(RCVTIMEO, struct timeval) \
342 _(SNDTIMEO, struct timeval)
343
344 len = sizeof(sun);
345 if (real_getsockname(sk, SA(&sun), &len))
346 return (-1);
347 if (decode_inet_addr(&sin, &sun, len))
348 return (0); /* Not one of ours */
349 len = sizeof(type);
350 if (real_getsockopt(sk, SOL_SOCKET, SO_TYPE, &type, &len) < 0 ||
351 (nsk = real_socket(PF_INET, type, 0)) < 0)
352 return (-1);
353#define FIX(opt, ty) do { \
354 ty ov_; \
355 len = sizeof(ov_); \
356 if (real_getsockopt(sk, SOL_SOCKET, SO_##opt, &ov_, &len) < 0 || \
357 real_setsockopt(nsk, SOL_SOCKET, SO_##opt, &ov_, len)) { \
358 real_close(nsk); \
359 return (-1); \
360 } \
361} while (0);
362 OPTS(FIX)
363#undef FIX
364 if ((f = fcntl(sk, F_GETFL)) < 0 ||
365 (fd = fcntl(sk, F_GETFD)) < 0 ||
366 fcntl(nsk, F_SETFL, f) < 0 ||
367 dup2(nsk, sk) < 0) {
368 real_close(nsk);
369 return (-1);
370 }
371 unlink(sun.sun_path);
372 real_close(nsk);
373 if (fcntl(sk, F_SETFD, fd) < 0) {
374 perror("noip: fixup_real_ip_socket F_SETFD");
375 abort();
376 }
377 return (0);
378}
379
380static int do_implicit_bind(int sk, const struct sockaddr **sa,
381 socklen_t *len, struct sockaddr_un *sun)
382{
383 struct sockaddr_in sin;
384 socklen_t mylen = sizeof(*sun);
385
386 if (acl_allows_p(connect_real, SIN(*sa))) {
387 if (fixup_real_ip_socket(sk))
388 return (-1);
389 } else {
390 if (real_getsockname(sk, SA(sun), &mylen) < 0)
391 return (-1);
392 if (sun->sun_family == AF_UNIX) {
393 if (mylen < sizeof(*sun)) ((char *)sun)[mylen] = 0;
394 if (!sun->sun_path[0]) {
395 sin.sin_family = AF_INET;
396 sin.sin_addr.s_addr = INADDR_LOOPBACK;
397 sin.sin_port = 0;
398 encode_inet_addr(sun, &sin, WANT_FRESH);
399 if (real_bind(sk, SA(sun), SUN_LEN(sun)))
400 return (-1);
401 }
402 encode_inet_addr(sun, SIN(*sa), WANT_EXISTING);
403 *sa = SA(sun);
404 *len = SUN_LEN(sun);
405 }
406 }
407 return (0);
408}
409
410static void return_fake_name(struct sockaddr *sa, socklen_t len,
411 struct sockaddr *fake, socklen_t *fakelen)
412{
413 struct sockaddr_in sin;
414 socklen_t alen;
415
416 if (sa->sa_family == AF_UNIX && !decode_inet_addr(&sin, SUN(sa), len)) {
417 sa = SA(&sin);
418 len = sizeof(sin);
419 }
420 alen = len;
421 if (len > *fakelen)
422 len = *fakelen;
423 if (len > 0)
424 memcpy(fake, sa, len);
425 *fakelen = alen;
426}
427
428/* --- Configuration --- */
429
430static char *home(void)
431{
432 char *p;
433 struct passwd *pw;
434
435 if ((p = getenv("HOME")) != 0) return (p);
436 else if ((pw = getpwuid(uid)) != 0) return (pw->pw_dir);
437 else return "/notexist";
438}
439
440static char *tmpdir(void)
441{
442 char *p;
443
444 if ((p = getenv("TMPDIR")) != 0) return (p);
445 else if ((p = getenv("TMP")) != 0) return (p);
446 else return ("/tmp");
447}
448
449static char *user(void)
450{
451 static char buf[16];
452 char *p;
453 struct passwd *pw;
454
455 if ((p = getenv("USER")) != 0) return (p);
456 else if ((p = getenv("LOGNAME")) != 0) return (p);
457 else if ((pw = getpwuid(uid)) != 0) return (pw->pw_name);
458 else {
459 snprintf(buf, sizeof(buf), "uid-%lu", (unsigned long)uid);
460 return (buf);
461 }
462}
463
464#define SKIPSPC do { while (*p && isspace(UC(*p))) p++; } while (0)
465#define NEXTWORD(q) do { \
466 SKIPSPC; \
467 q = p; \
468 while (*p && !isspace(UC(*p))) p++; \
469 if (*p) *p++ = 0; \
470} while (0)
471#define NEXTADDR(q, del) do { \
472 SKIPSPC; \
473 q = p; \
474 while (*p && (*p == '.' || isdigit(UC(*p)))) p++; \
475 del = *p; \
476 if (*p) *p++ = 0; \
477} while (0)
478#define NEXTNUMBER(q, del) do { \
479 SKIPSPC; \
480 q = p; \
481 while (*p && isdigit(UC(*p))) p++; \
482 del = *p; \
483 if (*p) *p++ = 0; \
484} while (0)
485#define RESCAN(del) do { if (del) *--p = del; } while (0)
486#define KWMATCHP(kw) (strncmp(p, kw, sizeof(kw) - 1) == 0 && \
487 !isalnum(UC(p[sizeof(kw) - 1])) && \
488 (p += sizeof(kw) - 1))
489
490static void parse_ports(char **pp, unsigned short *min, unsigned short *max)
491{
492 char *p = *pp, *q;
493 int del;
494
495 SKIPSPC;
496 if (*p != ':') {
497 *min = 0;
498 *max = 0xffff;
499 } else {
500 p++;
501 NEXTNUMBER(q, del);
502 *min = atoi(q);
503 RESCAN(del);
504 SKIPSPC;
505 if (*p == '-') {
506 NEXTNUMBER(q, del);
507 *max = atoi(q);
508 RESCAN(del);
509 } else
510 *max = *min;
511 }
512 *pp = p;
513}
514
515#define ACLNODE(tail_, act_, \
516 minaddr_, maxaddr_, minport_, maxport_) do { \
517 aclnode *a_; \
518 NEW(a_); \
519 a_->act = act_; \
520 a_->minaddr = minaddr_; a_->maxaddr = maxaddr_; \
521 a_->minport = minport_; a_->maxport = maxport_; \
522 *tail_ = a_; tail_ = &a_->next; \
523} while (0)
524
525static void parse_acl_line(char **pp, aclnode ***tail)
526{
527 struct in_addr addr;
528 unsigned long minaddr, maxaddr, mask;
529 unsigned short minport, maxport;
530 int i, n;
531 int act;
532 int del;
533 char *p = *pp;
534 char *q;
535
a6d9626b 536 for (;;) {
537 SKIPSPC;
538 if (*p == '+') act = ALLOW;
539 else if (*p == '-') act = DENY;
540 else goto bad;
e4976bb0 541
a6d9626b 542 p++;
543 SKIPSPC;
544 if (KWMATCHP("any")) {
e4976bb0 545 minaddr = 0;
546 maxaddr = 0xffffffff;
a6d9626b 547 goto justone;
548 } else if (KWMATCHP("local")) {
549 parse_ports(&p, &minport, &maxport);
550 ACLNODE(*tail, act, 0, 0, minport, maxport);
551 ACLNODE(*tail, act, 0xffffffff, 0xffffffff, minport, maxport);
552 for (i = 0; i < n_local_ipaddrs; i++) {
553 minaddr = ntohl(local_ipaddrs[i].s_addr);
554 ACLNODE(*tail, act, minaddr, minaddr, minport, maxport);
555 }
e4976bb0 556 } else {
a6d9626b 557 if (*p == ':') {
558 minaddr = 0;
559 maxaddr = 0xffffffff;
560 } else {
e4976bb0 561 NEXTADDR(q, del);
562 if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
a6d9626b 563 minaddr = ntohl(addr.s_addr);
e4976bb0 564 RESCAN(del);
a6d9626b 565 SKIPSPC;
566 if (*p == '-') {
567 p++;
568 NEXTADDR(q, del);
e4976bb0 569 if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
a6d9626b 570 RESCAN(del);
571 maxaddr = ntohl(addr.s_addr);
572 } else if (*p == '/') {
573 p++;
574 NEXTADDR(q, del);
575 if (strchr(q, '.')) {
576 if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
577 mask = ntohl(addr.s_addr);
578 } else {
579 n = atoi(q);
580 mask = (~0ul << (32 - n)) & 0xffffffff;
581 }
582 RESCAN(del);
583 minaddr &= mask;
584 maxaddr = minaddr | (mask ^ 0xffffffff);
585 } else
586 maxaddr = minaddr;
587 }
588 justone:
589 parse_ports(&p, &minport, &maxport);
590 ACLNODE(*tail, act, minaddr, maxaddr, minport, maxport);
e4976bb0 591 }
a6d9626b 592 SKIPSPC;
593 if (*p != ',') break;
594 p++;
e4976bb0 595 }
596 return;
597
598bad:
599 D( fprintf(stderr, "noip: bad acl spec (ignored)\n"); )
600 return;
601}
602
a6d9626b 603static void parse_acl_env(const char *var, aclnode ***tail)
604{
605 char *p;
606
607 if ((p = getenv(var)) != 0) {
608 p = xstrdup(p);
609 parse_acl_line(&p, tail);
610 free(p);
611 }
612}
613
e4976bb0 614static void readconfig(void)
615{
616 FILE *fp;
617 char buf[1024];
618 size_t n;
619 char *p, *cmd;
620
621 if ((p = getenv("NOIP_CONFIG")) == 0)
622 snprintf(p = buf, sizeof(buf), "%s/.noip", home());
623 D( fprintf(stderr, "noip: config file: %s\n", p); )
624 if ((fp = fopen(p, "r")) == 0)
625 goto done;
626
a6d9626b 627 parse_acl_env("NOIP_REALBIND_BEFORE", &bind_tail);
628 parse_acl_env("NOIP_REALCONNECT_BEFORE", &connect_tail);
e4976bb0 629 while (fgets(buf, sizeof(buf), fp)) {
630 n = strlen(buf);
631 p = buf;
632
633 SKIPSPC;
634 if (!*p || *p == '#') continue;
635 while (n && isspace(UC(buf[n - 1]))) n--;
636 buf[n] = 0;
637 NEXTWORD(cmd);
638 SKIPSPC;
639
640 if (strcmp(cmd, "socketdir") == 0)
641 sockdir = xstrdup(p);
642 else if (strcmp(cmd, "realbind") == 0)
643 parse_acl_line(&p, &bind_tail);
644 else if (strcmp(cmd, "realconnect") == 0)
645 parse_acl_line(&p, &connect_tail);
646 else if (strcmp(cmd, "debug") == 0)
647 debug = *p ? atoi(p) : 1;
648 else
649 D( fprintf(stderr, "noip: bad config command %s\n", cmd); )
650 }
651 fclose(fp);
652
653done:
a6d9626b 654 parse_acl_env("NOIP_REALBIND", &bind_tail);
655 parse_acl_env("NOIP_REALCONNECT", &connect_tail);
656 parse_acl_env("NOIP_REALBIND_AFTER", &bind_tail);
657 parse_acl_env("NOIP_REALCONNECT_AFTER", &connect_tail);
e4976bb0 658 *bind_tail = 0;
659 *connect_tail = 0;
a6d9626b 660 if (!sockdir) sockdir = getenv("NOIP_SOCKETDIR");
e4976bb0 661 if (!sockdir) {
662 snprintf(buf, sizeof(buf), "%s/noip-%s", tmpdir(), user());
663 sockdir = xstrdup(buf);
664 }
665 D( fprintf(stderr, "noip: sockdir: %s\n", sockdir);
666 fprintf(stderr, "noip: realbind acl:\n");
667 dump_acl(bind_real);
668 fprintf(stderr, "noip: realconnect acl:\n");
669 dump_acl(connect_real); )
670}
671
672/* --- Hooks --- */
673
674int socket(int pf, int ty, int proto)
675{
676 if (pf == PF_INET) {
677 pf = PF_UNIX;
678 proto = 0;
679 }
680 return real_socket(pf, ty, proto);
681}
682
683int socketpair(int pf, int ty, int proto, int *sk)
684{
685 if (pf == PF_INET) {
686 pf = PF_UNIX;
687 proto = 0;
688 }
689 return (real_socketpair(pf, ty, proto, sk));
690}
691
692int bind(int sk, const struct sockaddr *sa, socklen_t len)
693{
694 struct sockaddr_un sun;
695
696 if (sa->sa_family == AF_INET) {
697 PRESERVING_ERRNO({
698 if (acl_allows_p(bind_real, SIN(sa))) {
699 if (fixup_real_ip_socket(sk))
700 return (-1);
701 } else {
702 encode_inet_addr(&sun, SIN(sa), WANT_FRESH);
703 sa = SA(&sun);
704 len = SUN_LEN(&sun);
705 }
706 });
707 }
708 return real_bind(sk, sa, len);
709}
710
711int connect(int sk, const struct sockaddr *sa, socklen_t len)
712{
713 struct sockaddr_un sun;
714
715 if (sa->sa_family == AF_INET) {
716 PRESERVING_ERRNO({
717 do_implicit_bind(sk, &sa, &len, &sun);
718 });
719 }
720 return real_connect(sk, sa, len);
721}
722
723ssize_t sendto(int sk, const void *buf, size_t len, int flags,
724 const struct sockaddr *to, socklen_t tolen)
725{
726 struct sockaddr_un sun;
727
728 if (to && to->sa_family == AF_INET) {
729 PRESERVING_ERRNO({
730 do_implicit_bind(sk, &to, &tolen, &sun);
731 });
732 }
733 return real_sendto(sk, buf, len, flags, to, tolen);
734}
735
736ssize_t recvfrom(int sk, void *buf, size_t len, int flags,
737 struct sockaddr *from, socklen_t *fromlen)
738{
739 char sabuf[1024];
740 socklen_t mylen = sizeof(sabuf);
741 ssize_t n;
742
743 if (!from)
744 return real_recvfrom(sk, buf, len, flags, 0, 0);
745 PRESERVING_ERRNO({
746 n = real_recvfrom(sk, buf, len, flags, SA(sabuf), &mylen);
747 if (n < 0)
748 return (-1);
749 return_fake_name(SA(sabuf), mylen, from, fromlen);
750 });
751 return (n);
752}
753
754ssize_t sendmsg(int sk, const struct msghdr *msg, int flags)
755{
756 struct sockaddr_un sun;
757 const struct sockaddr *sa;
758 struct msghdr mymsg;
759
760 if (msg->msg_name && SA(msg->msg_name)->sa_family == AF_INET) {
761 PRESERVING_ERRNO({
762 sa = SA(msg->msg_name);
763 mymsg = *msg;
764 do_implicit_bind(sk, &sa, &mymsg.msg_namelen, &sun);
765 mymsg.msg_name = SA(sa);
766 msg = &mymsg;
767 });
768 }
769 return real_sendmsg(sk, msg, flags);
770}
771
772ssize_t recvmsg(int sk, struct msghdr *msg, int flags)
773{
774 char sabuf[1024];
775 struct sockaddr *sa;
776 socklen_t len;
777 ssize_t n;
778
779 if (!msg->msg_name)
780 return real_recvmsg(sk, msg, flags);
781 PRESERVING_ERRNO({
782 sa = SA(msg->msg_name);
783 len = msg->msg_namelen;
784 msg->msg_name = sabuf;
785 msg->msg_namelen = sizeof(sabuf);
786 n = real_recvmsg(sk, msg, flags);
787 if (n < 0)
788 return (-1);
789 return_fake_name(SA(sabuf), msg->msg_namelen, sa, &len);
790 msg->msg_name = sa;
791 msg->msg_namelen = len;
792 });
793 return (n);
794}
795
796int accept(int sk, struct sockaddr *sa, socklen_t *len)
797{
798 char sabuf[1024];
799 socklen_t mylen = sizeof(sabuf);
800 int nsk = real_accept(sk, SA(sabuf), &mylen);
801
802 if (nsk < 0)
803 return (-1);
804 return_fake_name(SA(sabuf), mylen, sa, len);
805 return (nsk);
806}
807
808int getsockname(int sk, struct sockaddr *sa, socklen_t *len)
809{
810 PRESERVING_ERRNO({
811 char sabuf[1024];
812 socklen_t mylen = sizeof(sabuf);
813 if (real_getsockname(sk, SA(sabuf), &mylen))
814 return (-1);
815 return_fake_name(SA(sabuf), mylen, sa, len);
816 });
817 return (0);
818}
819
820int getpeername(int sk, struct sockaddr *sa, socklen_t *len)
821{
822 PRESERVING_ERRNO({
823 char sabuf[1024];
824 socklen_t mylen = sizeof(sabuf);
825 if (real_getpeername(sk, SA(sabuf), &mylen))
826 return (-1);
827 return_fake_name(SA(sabuf), mylen, sa, len);
828 });
829 return (0);
830}
831
832int getsockopt(int sk, int lev, int opt, void *p, socklen_t *len)
833{
834 switch (lev) {
835 case SOL_IP:
836 case SOL_TCP:
837 case SOL_UDP:
838 if (*len > 0)
839 memset(p, 0, *len);
840 return (0);
841 }
842 return real_getsockopt(sk, lev, opt, p, len);
843}
844
845int setsockopt(int sk, int lev, int opt, const void *p, socklen_t len)
846{
847 switch (lev) {
848 case SOL_IP:
849 case SOL_TCP:
850 case SOL_UDP:
851 return (0);
852 }
853 switch (opt) {
854 case SO_BINDTODEVICE:
855 case SO_ATTACH_FILTER:
856 case SO_DETACH_FILTER:
857 return (0);
858 }
859 return real_setsockopt(sk, lev, opt, p, len);
860}
861
862/* --- Initialization --- */
863
864static void cleanup_sockdir(void)
865{
866 DIR *dir;
867 struct dirent *d;
868 struct sockaddr_un sun;
869
870 if ((dir = opendir(sockdir)) == 0)
871 return;
872 while ((d = readdir(dir)) != 0) {
873 if (d->d_name[0] == '.') continue;
874 snprintf(sun.sun_path, sizeof(sun.sun_path),
875 "%s/%s", sockdir, d->d_name);
876 if (unix_socket_status(&sun, 0) == STALE) {
877 D( fprintf(stderr, "noip: clearing away stale socket %s\n",
878 d->d_name); )
879 unlink(sun.sun_path);
880 }
881 }
882 closedir(dir);
883}
884
885static void get_local_ipaddrs(void)
886{
887 struct if_nameindex *ifn;
888 struct ifreq ifr;
889 int sk;
890 int i;
891
892 ifn = if_nameindex();
893 if ((sk = real_socket(PF_INET, SOCK_STREAM, 00)) < 0)
894 return;
895 for (i = n_local_ipaddrs = 0;
896 n_local_ipaddrs < MAX_LOCAL_IPADDRS &&
897 ifn[i].if_name && *ifn[i].if_name;
898 i++) {
899 strcpy(ifr.ifr_name, ifn[i].if_name);
900 if (ioctl(sk, SIOCGIFADDR, &ifr) || ifr.ifr_addr.sa_family != AF_INET)
901 continue;
902 local_ipaddrs[n_local_ipaddrs++] =
903 SIN(&ifr.ifr_addr)->sin_addr;
904 D( fprintf(stderr, "noip: local addr %s = %s\n", ifn[i].if_name,
905 inet_ntoa(local_ipaddrs[n_local_ipaddrs - 1])); )
906 }
907 close(sk);
908}
909
910static void setup(void)
911{
912 PRESERVING_ERRNO({
913 char *p;
914
915 import();
916 uid = getuid();
917 if ((p = getenv("NOIP_DEBUG")) && atoi(p))
918 debug = 1;
919 get_local_ipaddrs();
920 readconfig();
921 mkdir(sockdir, 0700);
922 cleanup_sockdir();
923 });
924}
LD_PRELOAD hacks