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   SKIPSPC;
 537   if (*p == '+') act = ALLOW;
 538   else if (*p == '-') act = DENY;
 539   else goto bad;
 540
 541   p++;
 542   SKIPSPC;
 543   if (KWMATCHP("any")) {
 544     minaddr = 0;
 545     maxaddr = 0xffffffff;
 546     goto justone;
 547   } else if (KWMATCHP("local")) {
 548     parse_ports(&p, &minport, &maxport);
 549     ACLNODE(*tail, act, 0, 0, minport, maxport);
 550     ACLNODE(*tail, act, 0xffffffff, 0xffffffff, minport, maxport);
 551     for (i = 0; i < n_local_ipaddrs; i++) {
 552       minaddr = ntohl(local_ipaddrs[i].s_addr);
 553       ACLNODE(*tail, act, minaddr, minaddr, minport, maxport);
 554     }
 555   } else {
 556     if (*p == ':') {
 557       minaddr = 0;
 558       maxaddr = 0xffffffff;
 559     } else {
 560       NEXTADDR(q, del);
 561       if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
 562       minaddr = ntohl(addr.s_addr);
 563       RESCAN(del);
 564       SKIPSPC;
 565       if (*p == '-') {
 566         p++;
 567         NEXTADDR(q, del);
 568         if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
 569         RESCAN(del);
 570         maxaddr = ntohl(addr.s_addr);
 571       } else if (*p == '/') {
 572         p++;
 573         NEXTADDR(q, del);
 574         if (strchr(q, '.')) {
 575           if (inet_pton(AF_INET, q, &addr) <= 0) goto bad;
 576           mask = ntohl(addr.s_addr);
 577         } else {
 578           n = atoi(q);
 579           mask = (~0ul << (32 - n)) & 0xffffffff;
 580         }
 581         RESCAN(del);
 582         minaddr &= mask;
 583         maxaddr = minaddr | (mask ^ 0xffffffff);
 584       } else
 585         maxaddr = minaddr;
 586     }
 587   justone:
 588     parse_ports(&p, &minport, &maxport);
 589     ACLNODE(*tail, act, minaddr, maxaddr, minport, maxport);
 590   }
 591   return;
 592
 593 bad:
 594   D( fprintf(stderr, "noip: bad acl spec (ignored)\n"); )
 595   return;
 596 }
 597
 598 static void readconfig(void)
 599 {
 600   FILE *fp;
 601   char buf[1024];
 602   size_t n;
 603   char *p, *cmd;
 604
 605   if ((p = getenv("NOIP_CONFIG")) == 0)
 606     snprintf(p = buf, sizeof(buf), "%s/.noip", home());
 607   D( fprintf(stderr, "noip: config file: %s\n", p); )
 608   if ((fp = fopen(p, "r")) == 0)
 609     goto done;
 610
 611   while (fgets(buf, sizeof(buf), fp)) {
 612     n = strlen(buf);
 613     p = buf;
 614
 615     SKIPSPC;
 616     if (!*p || *p == '#') continue;
 617     while (n && isspace(UC(buf[n - 1]))) n--;
 618     buf[n] = 0;
 619     NEXTWORD(cmd);
 620     SKIPSPC;
 621
 622     if (strcmp(cmd, "socketdir") == 0)
 623       sockdir = xstrdup(p);
 624     else if (strcmp(cmd, "realbind") == 0)
 625       parse_acl_line(&p, &bind_tail);
 626     else if (strcmp(cmd, "realconnect") == 0)
 627       parse_acl_line(&p, &connect_tail);
 628     else if (strcmp(cmd, "debug") == 0)
 629       debug = *p ? atoi(p) : 1;
 630     else
 631       D( fprintf(stderr, "noip: bad config command %s\n", cmd); )
 632   }
 633   fclose(fp);
 634
 635 done:
 636   *bind_tail = 0;
 637   *connect_tail = 0;
 638   if (!sockdir) {
 639     snprintf(buf, sizeof(buf), "%s/noip-%s", tmpdir(), user());
 640     sockdir = xstrdup(buf);
 641   }
 642   D( fprintf(stderr, "noip: sockdir: %s\n", sockdir);
 643      fprintf(stderr, "noip: realbind acl:\n");
 644      dump_acl(bind_real);
 645      fprintf(stderr, "noip: realconnect acl:\n");
 646      dump_acl(connect_real); )
 647 }
 648
 649 /* --- Hooks --- */
 650
 651 int socket(int pf, int ty, int proto)
 652 {
 653   if (pf == PF_INET) {
 654     pf = PF_UNIX;
 655     proto = 0;
 656   }
 657   return real_socket(pf, ty, proto);
 658 }
 659
 660 int socketpair(int pf, int ty, int proto, int *sk)
 661 {
 662   if (pf == PF_INET) {
 663     pf = PF_UNIX;
 664     proto = 0;
 665   }
 666   return (real_socketpair(pf, ty, proto, sk));
 667 }
 668
 669 int bind(int sk, const struct sockaddr *sa, socklen_t len)
 670 {
 671   struct sockaddr_un sun;
 672
 673   if (sa->sa_family == AF_INET) {
 674     PRESERVING_ERRNO({
 675       if (acl_allows_p(bind_real, SIN(sa))) {
 676         if (fixup_real_ip_socket(sk))
 677           return (-1);
 678       } else {
 679         encode_inet_addr(&sun, SIN(sa), WANT_FRESH);
 680         sa = SA(&sun);
 681         len = SUN_LEN(&sun);
 682       }
 683     });
 684   }
 685   return real_bind(sk, sa, len);
 686 }
 687
 688 int connect(int sk, const struct sockaddr *sa, socklen_t len)
 689 {
 690   struct sockaddr_un sun;
 691
 692   if (sa->sa_family == AF_INET) {
 693     PRESERVING_ERRNO({
 694       do_implicit_bind(sk, &sa, &len, &sun);
 695     });
 696   }
 697   return real_connect(sk, sa, len);
 698 }
 699
 700 ssize_t sendto(int sk, const void *buf, size_t len, int flags,
 701                const struct sockaddr *to, socklen_t tolen)
 702 {
 703   struct sockaddr_un sun;
 704
 705   if (to && to->sa_family == AF_INET) {
 706     PRESERVING_ERRNO({
 707       do_implicit_bind(sk, &to, &tolen, &sun);
 708     });
 709   }
 710   return real_sendto(sk, buf, len, flags, to, tolen);
 711 }
 712
 713 ssize_t recvfrom(int sk, void *buf, size_t len, int flags,
 714                  struct sockaddr *from, socklen_t *fromlen)
 715 {
 716   char sabuf[1024];
 717   socklen_t mylen = sizeof(sabuf);
 718   ssize_t n;
 719
 720   if (!from)
 721     return real_recvfrom(sk, buf, len, flags, 0, 0);
 722   PRESERVING_ERRNO({
 723     n = real_recvfrom(sk, buf, len, flags, SA(sabuf), &mylen);
 724     if (n < 0)
 725       return (-1);
 726     return_fake_name(SA(sabuf), mylen, from, fromlen);
 727   });
 728   return (n);
 729 }
 730
 731 ssize_t sendmsg(int sk, const struct msghdr *msg, int flags)
 732 {
 733   struct sockaddr_un sun;
 734   const struct sockaddr *sa;
 735   struct msghdr mymsg;
 736
 737   if (msg->msg_name && SA(msg->msg_name)->sa_family == AF_INET) {
 738     PRESERVING_ERRNO({
 739       sa = SA(msg->msg_name);
 740       mymsg = *msg;
 741       do_implicit_bind(sk, &sa, &mymsg.msg_namelen, &sun);
 742       mymsg.msg_name = SA(sa);
 743       msg = &mymsg;
 744     });
 745   }
 746   return real_sendmsg(sk, msg, flags);
 747 }
 748
 749 ssize_t recvmsg(int sk, struct msghdr *msg, int flags)
 750 {
 751   char sabuf[1024];
 752   struct sockaddr *sa;
 753   socklen_t len;
 754   ssize_t n;
 755
 756   if (!msg->msg_name)
 757     return real_recvmsg(sk, msg, flags);
 758   PRESERVING_ERRNO({
 759     sa = SA(msg->msg_name);
 760     len = msg->msg_namelen;
 761     msg->msg_name = sabuf;
 762     msg->msg_namelen = sizeof(sabuf);
 763     n = real_recvmsg(sk, msg, flags);
 764     if (n < 0)
 765       return (-1);
 766     return_fake_name(SA(sabuf), msg->msg_namelen, sa, &len);
 767     msg->msg_name = sa;
 768     msg->msg_namelen = len;
 769   });
 770   return (n);
 771 }
 772
 773 int accept(int sk, struct sockaddr *sa, socklen_t *len)
 774 {
 775   char sabuf[1024];
 776   socklen_t mylen = sizeof(sabuf);
 777   int nsk = real_accept(sk, SA(sabuf), &mylen);
 778
 779   if (nsk < 0)
 780     return (-1);
 781   return_fake_name(SA(sabuf), mylen, sa, len);
 782   return (nsk);
 783 }
 784
 785 int getsockname(int sk, struct sockaddr *sa, socklen_t *len)
 786 {
 787   PRESERVING_ERRNO({
 788     char sabuf[1024];
 789     socklen_t mylen = sizeof(sabuf);
 790     if (real_getsockname(sk, SA(sabuf), &mylen))
 791       return (-1);
 792     return_fake_name(SA(sabuf), mylen, sa, len);
 793   });
 794   return (0);
 795 }
 796
 797 int getpeername(int sk, struct sockaddr *sa, socklen_t *len)
 798 {
 799   PRESERVING_ERRNO({
 800     char sabuf[1024];
 801     socklen_t mylen = sizeof(sabuf);
 802     if (real_getpeername(sk, SA(sabuf), &mylen))
 803       return (-1);
 804     return_fake_name(SA(sabuf), mylen, sa, len);
 805   });
 806   return (0);
 807 }
 808
 809 int getsockopt(int sk, int lev, int opt, void *p, socklen_t *len)
 810 {
 811   switch (lev) {
 812     case SOL_IP:
 813     case SOL_TCP:
 814     case SOL_UDP:
 815       if (*len > 0)
 816         memset(p, 0, *len);
 817       return (0);
 818   }
 819   return real_getsockopt(sk, lev, opt, p, len);
 820 }
 821
 822 int setsockopt(int sk, int lev, int opt, const void *p, socklen_t len)
 823 {
 824   switch (lev) {
 825     case SOL_IP:
 826     case SOL_TCP:
 827     case SOL_UDP:
 828       return (0);
 829   }
 830   switch (opt) {
 831     case SO_BINDTODEVICE:
 832     case SO_ATTACH_FILTER:
 833     case SO_DETACH_FILTER:
 834       return (0);
 835   }
 836   return real_setsockopt(sk, lev, opt, p, len);
 837 }
 838
 839 /* --- Initialization --- */
 840
 841 static void cleanup_sockdir(void)
 842 {
 843   DIR *dir;
 844   struct dirent *d;
 845   struct sockaddr_un sun;
 846
 847   if ((dir = opendir(sockdir)) == 0)
 848     return;
 849   while ((d = readdir(dir)) != 0) {
 850     if (d->d_name[0] == '.') continue;
 851     snprintf(sun.sun_path, sizeof(sun.sun_path),
 852              "%s/%s", sockdir, d->d_name);
 853     if (unix_socket_status(&sun, 0) == STALE) {
 854       D( fprintf(stderr, "noip: clearing away stale socket %s\n",
 855                  d->d_name); )
 856       unlink(sun.sun_path);
 857     }
 858   }
 859   closedir(dir);
 860 }
 861
 862 static void get_local_ipaddrs(void)
 863 {
 864   struct if_nameindex *ifn;
 865   struct ifreq ifr;
 866   int sk;
 867   int i;
 868
 869   ifn = if_nameindex();
 870   if ((sk = real_socket(PF_INET, SOCK_STREAM, 00)) < 0)
 871     return;
 872   for (i = n_local_ipaddrs = 0;
 873        n_local_ipaddrs < MAX_LOCAL_IPADDRS &&
 874          ifn[i].if_name && *ifn[i].if_name;
 875        i++) {
 876     strcpy(ifr.ifr_name, ifn[i].if_name);
 877     if (ioctl(sk, SIOCGIFADDR, &ifr) || ifr.ifr_addr.sa_family != AF_INET)
 878       continue;
 879     local_ipaddrs[n_local_ipaddrs++] =
 880       SIN(&ifr.ifr_addr)->sin_addr;
 881     D( fprintf(stderr, "noip: local addr %s = %s\n", ifn[i].if_name,
 882                inet_ntoa(local_ipaddrs[n_local_ipaddrs - 1])); )
 883   }
 884   close(sk);
 885 }
 886
 887 static void setup(void)
 888 {
 889   PRESERVING_ERRNO({
 890     char *p;
 891
 892     import();
 893     uid = getuid();
 894     if ((p = getenv("NOIP_DEBUG")) && atoi(p))
 895       debug = 1;
 896     get_local_ipaddrs();
 897     readconfig();
 898     mkdir(sockdir, 0700);
 899     cleanup_sockdir();
 900   });
 901 }