chiark - git - mdw - preload-hacks/blob - noip.c

   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
  28 enum { UNUSED, STALE, USED };
  29 enum { WANT_FRESH, WANT_EXISTING };
  30 enum { DENY, ALLOW };
  31 typedef 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
  39 static struct in_addr local_ipaddrs[MAX_LOCAL_IPADDRS];
  40 static int n_local_ipaddrs;
  41
  42 static uid_t uid;
  43 static char *sockdir = 0;
  44 static int debug = 0;
  45
  46 static aclnode *bind_real, **bind_tail = &bind_real;
  47 static 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;
  70 IMPORTS(DECL)
  71 #undef DECL
  72
  73 static void setup(void) __attribute__((constructor));
  74 static 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
 103 static 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
 111 static 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
 119 static 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;
 147 done:
 148   if (fp) fclose(fp);
 149   return (rc);
 150 }
 151
 152 #ifdef DEBUG
 153
 154 static 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
 182 static 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
 207 static 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
 221 static 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
 268 static 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
 320 static 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
 380 static 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
 410 static 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
 430 static 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
 440 static 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
 449 static 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
 490 static 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
 525 static 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
 536   for (;;) {
 537     SKIPSPC;
 538     if (*p == '+') act = ALLOW;
 539     else if (*p == '-') act = DENY;
 540     else goto bad;
 541
 542     p++;
 543     SKIPSPC;
 544     if (KWMATCHP("any")) {
 545       minaddr = 0;
 546       maxaddr = 0xffffffff;
 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       }
 556     } else {
 557       if (*p == ':') {
 558         minaddr = 0;
 559         maxaddr = 0xffffffff;
 560       } else {
 561         NEXTADDR(q, del);
 562         if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
 563         minaddr = ntohl(addr.s_addr);
 564         RESCAN(del);
 565         SKIPSPC;
 566         if (*p == '-') {
 567           p++;
 568           NEXTADDR(q, del);
 569           if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
 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);
 591     }
 592     SKIPSPC;
 593     if (*p != ',') break;
 594     p++;
 595   }
 596   return;
 597
 598 bad:
 599   D( fprintf(stderr, "noip: bad acl spec (ignored)\n"); )
 600   return;
 601 }
 602
 603 static 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
 614 static 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
 627   parse_acl_env("NOIP_REALBIND_BEFORE", &bind_tail);
 628   parse_acl_env("NOIP_REALCONNECT_BEFORE", &connect_tail);
 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
 653 done:
 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);
 658   *bind_tail = 0;
 659   *connect_tail = 0;
 660   if (!sockdir) sockdir = getenv("NOIP_SOCKETDIR");
 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
 674 int 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
 683 int 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
 692 int 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
 711 int 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
 723 ssize_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
 736 ssize_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
 754 ssize_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
 772 ssize_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
 796 int 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
 808 int 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
 820 int 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
 832 int 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
 845 int 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
 864 static 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
 885 static 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
 910 static 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 }