chiark - git - mdw - yaid/blob - linux.c

   1 /* -*-c-*-
   2  *
   3  * Discover the owner of a connection (Linux version)
   4  *
   5  * (c) 2012 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Yet Another Ident Daemon (YAID).
  11  *
  12  * YAID is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * YAID is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with YAID; if not, write to the Free Software Foundation,
  24  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27 /*----- Header files ------------------------------------------------------*/
  28
  29 #include "yaid.h"
  30
  31 #include <linux/netlink.h>
  32 #include <linux/rtnetlink.h>
  33
  34 /*----- Static variables --------------------------------------------------*/
  35
  36 static FILE *natfp;                     /* File handle for NAT table */
  37 static int randfd;                      /* File descriptor for random data */
  38
  39 /*----- Miscellaneous system services -------------------------------------*/
  40
  41 /* Fill the buffer at P with SZ random bytes.  The buffer will be moderately
  42  * large: this is intended to be a low-level interface, not a general-purpose
  43  * utility.
  44  */
  45 void fill_random(void *p, size_t sz)
  46 {
  47   ssize_t n;
  48
  49   n = read(randfd, p, sz);
  50   if (n < 0) fatal("error reading `/dev/urandom': %s", strerror(errno));
  51   else if (n < sz) fatal("unexpected short read from `/dev/urandom'");
  52 }
  53
  54 /*----- Address-type operations -------------------------------------------*/
  55
  56 struct addrops_sys {
  57   const char *procfile;
  58   const char *nfl3name;
  59   int (*parseaddr)(char **, union addr *);
  60 };
  61
  62 #define PROCFILE_IPV4 "/proc/net/tcp"
  63 #define NFL3NAME_IPV4 "ipv4"
  64
  65 static int parseaddr_ipv4(char **pp, union addr *a)
  66   { a->ipv4.s_addr = strtoul(*pp, pp, 16); return (0); }
  67
  68 #define PROCFILE_IPV6 "/proc/net/tcp6"
  69 #define NFL3NAME_IPV6 "ipv6"
  70
  71 static int parseaddr_ipv6(char **pp, union addr *a)
  72 {
  73   int i, j;
  74   unsigned long y;
  75   char *p = *pp;
  76   unsigned x;
  77
  78   /* The format is byteswapped in a really annoying way. */
  79   for (i = 0; i < 4; i++) {
  80     y = 0;
  81     for (j = 0; j < 8; j++) {
  82       if ('0' <= *p && *p <= '9') x = *p - '0';
  83       else if ('a' <= *p && *p <= 'f') x = *p - 'a' + 10;
  84       else if ('A' <= *p && *p <= 'F') x = *p - 'A' + 10;
  85       else return (-1);
  86       y = (y << 4) | x;
  87       p++;
  88     }
  89     a->ipv6.s6_addr32[i] = y;
  90   }
  91   *pp = p;
  92   return (0);
  93 }
  94
  95 #define DEFOPSYS(ty, TY)                                                \
  96   const struct addrops_sys addrops_sys_##ty = {                         \
  97     PROCFILE_##TY, NFL3NAME_##TY, parseaddr_##ty                        \
  98   };
  99 ADDRTYPES(DEFOPSYS)
 100 #undef DEFOPSYS
 101
 102 /*----- Main code ---------------------------------------------------------*/
 103
 104 /* Store in A the default gateway address for the given address family.
 105  * Return zero on success, or nonzero on error.
 106  */
 107 static int get_default_gw(int af, union addr *a)
 108 {
 109   int fd;
 110   char buf[32768];
 111   struct nlmsghdr *nlmsg;
 112   struct rtgenmsg *rtgen;
 113   const struct rtattr *rta;
 114   const struct rtmsg *rtm;
 115   ssize_t n, nn;
 116   int rc = -1;
 117   static unsigned long seq = 0x48b4aec4;
 118
 119   /* Open a netlink socket for interrogating the kernel. */
 120   if ((fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0)
 121     fatal("failed to create netlink socket: %s", strerror(errno));
 122
 123   /* We want to read the routing table.  There doesn't seem to be a good way
 124    * to do this without just crawling through the whole thing.
 125    */
 126   nlmsg = (struct nlmsghdr *)buf;
 127   assert(NLMSG_SPACE(sizeof(*rtgen)) < sizeof(buf));
 128   nlmsg->nlmsg_len = NLMSG_LENGTH(sizeof(*rtgen));
 129   nlmsg->nlmsg_type = RTM_GETROUTE;
 130   nlmsg->nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
 131   nlmsg->nlmsg_seq = ++seq;
 132   nlmsg->nlmsg_pid = 0;
 133
 134   rtgen = (struct rtgenmsg *)NLMSG_DATA(nlmsg);
 135   rtgen->rtgen_family = af;
 136
 137   if (write(fd, nlmsg, nlmsg->nlmsg_len) < 0)
 138     fatal("failed to send RTM_GETROUTE request: %s", strerror(errno));
 139
 140   /* Now we try to parse the answer. */
 141   for (;;) {
 142
 143     /* Not finished yet, so read another chunk of answer. */
 144     if ((n = read(fd, buf, sizeof(buf))) < 0)
 145       fatal("failed to read RTM_GETROUTE response: %s", strerror(errno));
 146
 147     /* Start at the beginning of the response. */
 148     nlmsg = (struct nlmsghdr *)buf;
 149
 150     /* Make sure this looks plausible.  The precise rules don't appear to be
 151      * documented, so it seems advisable to fail messily if my understanding
 152      * is wrong.
 153      */
 154     if (nlmsg->nlmsg_seq != seq) continue;
 155     assert(nlmsg->nlmsg_flags & NLM_F_MULTI);
 156
 157     /* Work through all of the individual routes. */
 158     for (; NLMSG_OK(nlmsg, n); nlmsg = NLMSG_NEXT(nlmsg, n)) {
 159       if (nlmsg->nlmsg_type == NLMSG_DONE) goto done;
 160       if (nlmsg->nlmsg_type != RTM_NEWROUTE) continue;
 161       rtm = (const struct rtmsg *)NLMSG_DATA(nlmsg);
 162
 163       /* If this record doesn't look interesting then skip it. */
 164       if (rtm->rtm_family != af ||      /* wrong address family */
 165           rtm->rtm_dst_len > 0 ||       /* specific destination */
 166           rtm->rtm_src_len > 0 ||       /* specific source  */
 167           rtm->rtm_type != RTN_UNICAST || /* not for unicast */
 168           rtm->rtm_scope != RT_SCOPE_UNIVERSE || /* wrong scope */
 169           rtm->rtm_tos != 0)            /* specific type of service */
 170         continue;
 171
 172       /* Trundle through the attributes and find the gateway address. */
 173       for (rta = RTM_RTA(rtm), nn = RTM_PAYLOAD(nlmsg);
 174            RTA_OK(rta, nn); rta = RTA_NEXT(rta, nn)) {
 175
 176         /* Got one.  We're all done.  Except that we should carry on reading
 177          * to the end, or something bad will happen.
 178          */
 179         if (rta->rta_type == RTA_GATEWAY) {
 180           assert(RTA_PAYLOAD(rta) <= sizeof(*a));
 181           memcpy(a, RTA_DATA(rta), RTA_PAYLOAD(rta));
 182           rc = 0;
 183         }
 184       }
 185     }
 186   }
 187
 188 done:
 189   close(fd);
 190   return (rc);
 191 }
 192
 193 /* Initially, PP points into a string containing whitespace-separated fields.
 194  * Point P to the next field, null-terminate it, and advance PP so that we
 195  * can read the next field in the next call.
 196  */
 197 #define NEXTFIELD do {                                                  \
 198   for (p = pp; isspace((unsigned char)*p); p++);                        \
 199   for (pp = p; *pp && !isspace((unsigned char)*pp); pp++);              \
 200   if (*pp) *pp++ = 0;                                                   \
 201 } while (0)
 202
 203 /* Search the `tcp' connection table for the address family AO, looking for a
 204  * connection between the addresses in QS.  GWP is nonzero if the query's
 205  * remote address is our gateway and we shouldn't expect the remote address
 206  * in the system table to actually match it because of NAT.  Return nonzero
 207  * if we have filled in Q conclusively; return zero if the caller should try
 208  * a different approach.
 209  */
 210 static int search_tcp_file(struct query *q, int gwp,
 211                            const struct addrops *ao,
 212                            struct socket qs[NDIR])
 213 {
 214   FILE *fp = 0;
 215   dstr d = DSTR_INIT;
 216   char *p, *pp;
 217   struct socket s[NDIR];
 218   int i;
 219   uid_t uid;
 220   enum { LOC, REM, ST, UID, NFIELD };
 221   int f, ff[NFIELD];
 222   int rc = 1;
 223
 224   /* Open the relevant TCP connection table. */
 225   if ((fp = fopen(ao->sys->procfile, "r")) == 0) {
 226     logmsg(q, LOG_ERR, "failed to open `%s' for reading: %s",
 227            ao->sys->procfile, strerror(errno));
 228     goto err_unk;
 229   }
 230
 231   /* Read the header line from the file. */
 232   if (dstr_putline(&d, fp) == EOF) {
 233     logmsg(q, LOG_ERR, "failed to read header line from `%s': %s",
 234            ao->sys->procfile,
 235            ferror(fp) ? strerror(errno) : "unexpected EOF");
 236     goto err_unk;
 237   }
 238
 239   /* Now scan the header line to identify which columns the various
 240    * interesting fields are in.  Store these in the map `ff'.  Problems:
 241    * `tx_queue rx_queue' and `tr tm->when' are both really single columns in
 242    * disguise; and the remote address column has a different heading
 243    * depending on which address family we're using.  Rather than dispatch,
 244    * just recognize both of them.
 245    */
 246   for (i = 0; i < NFIELD; i++) ff[i] = -1;
 247   pp = d.buf;
 248   for (f = 0;; f++) {
 249     NEXTFIELD; if (!*p) break;
 250     if (strcmp(p, "local_address") == 0)
 251       ff[LOC] = f;
 252     else if (strcmp(p, "rem_address") == 0 ||
 253              strcmp(p, "remote_address") == 0)
 254       ff[REM] = f;
 255     else if (strcmp(p, "uid") == 0)
 256       ff[UID] = f;
 257     else if (strcmp(p, "st") == 0)
 258       ff[ST] = f;
 259     else if (strcmp(p, "rx_queue") == 0 ||
 260              strcmp(p, "tm->when") == 0)
 261       f--;
 262   }
 263
 264   /* Make sure that we found all of the fields we actually want. */
 265   for (i = 0; i < NFIELD; i++) {
 266     if (ff[i] < 0) {
 267       logmsg(q, LOG_ERR, "failed to find required fields in `%s'",
 268              ao->sys->procfile);
 269       goto err_unk;
 270     }
 271   }
 272
 273   /* Work through the lines in the file. */
 274   for (;;) {
 275
 276     /* Read a line, and prepare to scan the fields. */
 277     DRESET(&d);
 278     if (dstr_putline(&d, fp) == EOF) break;
 279     pp = d.buf;
 280     uid = -1;
 281
 282     /* Work through the fields.  If an address field fails to match then we
 283      * skip this record.  If the state field isn't 1 (`ESTABLISHED') then
 284      * skip the record.  If it's the UID, then remember it: if we get all the
 285      * way to the end then we've won.
 286      */
 287     for (f = 0;; f++) {
 288       NEXTFIELD; if (!*p) break;
 289       if (f == ff[LOC]) { i = L; goto compare; }
 290       else if (f == ff[REM]) { i = R; goto compare; }
 291       else if (f == ff[UID]) uid = atoi(p);
 292       else if (f == ff[ST]) {
 293         if (strtol(p, 0, 16) != 1) goto next_row;
 294       }
 295       continue;
 296
 297     compare:
 298       /* Compare an address (in the current field) with the local or remote
 299        * address in the query, as indicated by `i'.  The address field looks
 300        * like `ADDR:PORT', where the ADDR is in some mad format which
 301        * `sys->parseaddr' knows how to unpick.  If the remote address in the
 302        * query is our gateway then don't check the remote address in the
 303        * field (but do check the port number).
 304        */
 305       if (ao->sys->parseaddr(&p, &s[i].addr)) goto next_row;
 306       if (*p != ':') break;
 307       p++;
 308       s[i].port = strtoul(p, 0, 16);
 309       if ((i == R && gwp) ?
 310             qs[R].port != s[i].port :
 311             !sockeq(ao, &qs[i], &s[i]))
 312         goto next_row;
 313     }
 314
 315     /* We got to the end, and everything matched.  If we found a UID then
 316      * we're done.  If the apparent remote address is our gateway then copy
 317      * the true one into the query structure.
 318      */
 319     if (uid != -1) {
 320       q->resp = R_UID;
 321       q->u.uid = uid;
 322       if (gwp) qs[R].addr = s[i].addr;
 323       goto done;
 324     }
 325   next_row:;
 326   }
 327
 328   /* We got to the end of the file and didn't find anything. */
 329   if (ferror(fp)) {
 330     logmsg(q, LOG_ERR, "failed to read connection table `%s': %s",
 331            ao->sys->procfile, strerror(errno));
 332     goto err_unk;
 333   }
 334   rc = 0;
 335
 336 err_unk:
 337   /* Something went wrong and the protocol can't express what.  We should
 338    * have logged what the problem actually was.
 339    */
 340   q->resp = R_ERROR;
 341   q->u.error = E_UNKNOWN;
 342
 343 done:
 344   /* All done. */
 345   dstr_destroy(&d);
 346   if (fp) fclose(fp);
 347   return (rc);
 348 }
 349
 350 /* Find out who is responsible for the connection described in the query Q.
 351  * Write the answer to Q.  Errors are logged and reported via the query
 352  * structure.
 353  */
 354 void identify(struct query *q)
 355 {
 356   FILE *fp = 0;
 357   dstr d = DSTR_INIT;
 358   char *p, *pp;
 359   struct socket s[4];
 360   int i;
 361   int gwp = 0;
 362   unsigned fl;
 363 #define F_SADDR 1u
 364 #define F_SPORT 2u
 365 #define F_DADDR 4u
 366 #define F_DPORT 8u
 367 #define F_ALL (F_SADDR | F_SPORT | F_DADDR | F_DPORT)
 368 #define F_ESTAB 16u
 369
 370   /* If we have a default gateway, and it matches the remote address then
 371    * this may be a proxy connection from our NAT, so remember this, and don't
 372    * inspect the remote addresses in the TCP tables.
 373    */
 374   if (!get_default_gw(q->ao->af, &s[0].addr) &&
 375       q->ao->addreq(&s[0].addr, &q->s[R].addr))
 376     gwp = 1;
 377
 378   /* Search the main `tcp' table. */
 379   if (search_tcp_file(q, gwp, q->ao, q->s)) goto done;
 380
 381   /* If we opened the NAT table file, and we're using IPv4, then check to see
 382    * whether we should proxy the connection.  At least the addresses in this
 383    * file aren't crazy.
 384    */
 385   if (natfp) {
 386
 387     /* Start again from the beginning. */
 388     rewind(natfp);
 389
 390     /* Read a line at a time. */
 391     for (;;) {
 392
 393       /* Read the line. */
 394       DRESET(&d);
 395       if (dstr_putline(&d, natfp) == EOF) break;
 396       pp = d.buf;
 397
 398       /* Check that this is for the right protocol. */
 399       NEXTFIELD; if (!*p) break;
 400       if (strcmp(p, q->ao->sys->nfl3name)) continue;
 401       NEXTFIELD; if (!*p) break;
 402       NEXTFIELD; if (!*p) break;
 403       if (strcmp(p, "tcp") != 0) continue;
 404
 405       /* Parse the other fields.  Each line has two src/dst pairs, for the
 406        * outgoing and incoming directions.  Depending on exactly what kind of
 407        * NAT is in use, either the outgoing source or the incoming
 408        * destination might be the client we're after.  Collect all of the
 409        * addresses and sort out the mess later.
 410        */
 411       i = 0;
 412       fl = 0;
 413       for (;;) {
 414         NEXTFIELD; if (!*p) break;
 415         if (strcmp(p, "ESTABLISHED") == 0)
 416           fl |= F_ESTAB;
 417         else if (strncmp(p, "src=", 4) == 0) {
 418           inet_pton(q->ao->af, p + 4, &s[i].addr);
 419           fl |= F_SADDR;
 420         } else if (strncmp(p, "dst=", 4) == 0) {
 421           inet_pton(q->ao->af, p + 4, &s[i + 1].addr);
 422           fl |= F_DADDR;
 423         } else if (strncmp(p, "sport=", 6) == 0) {
 424           s[i].port = atoi(p + 6);
 425           fl |= F_SPORT;
 426         } else if (strncmp(p, "dport=", 6) == 0) {
 427           s[i + 1].port = atoi(p + 6);
 428           fl |= F_DPORT;
 429         }
 430         if ((fl & F_ALL) == F_ALL) {
 431           fl &= ~F_ALL;
 432           if (i < 4) i += 2;
 433           else break;
 434         }
 435       }
 436
 437 #ifdef DEBUG
 438       {
 439         /* Print the record we found. */
 440         dstr dd = DSTR_INIT;
 441         dstr_putf(&dd, "%sestab ", (fl & F_ESTAB) ? " " : "!");
 442         dputsock(&dd, q->ao, &s[0]);
 443         dstr_puts(&dd, "<->");
 444         dputsock(&dd, q->ao, &s[1]);
 445         dstr_puts(&dd, " | ");
 446         dputsock(&dd, q->ao, &s[2]);
 447         dstr_puts(&dd, "<->");
 448         dputsock(&dd, q->ao, &s[3]);
 449         printf("parsed: %s\n", dd.buf);
 450         dstr_destroy(&dd);
 451       }
 452 #endif
 453
 454       /* If the connection isn't ESTABLISHED then skip it. */
 455       if (!(fl & F_ESTAB)) continue;
 456
 457       /* Now we try to piece together what's going on.  One of these
 458        * addresses will be us.  So let's just try to find it.
 459        */
 460       for (i = 0; i < 4; i++)
 461         if (sockeq(q->ao, &s[i], &q->s[L])) goto found_local;
 462       continue;
 463
 464     found_local:
 465       /* So address `i' is us.  In that case, we expect the other address in
 466        * the same direction, and the same address in the opposite direction,
 467        * to match each other and be the remote address in the query.
 468        */
 469       if (!sockeq(q->ao, &s[i^1], &s[i^2]) ||
 470           !sockeq(q->ao, &s[i^1], &q->s[R]))
 471         continue;
 472
 473       /* As a trap for the unwary, this file contains unhelpful entries which
 474        * just mirror the source/destination addresses.  If this is one of
 475        * those, we'll be stuck in a cycle talking to ourselves.
 476        */
 477       if (sockeq(q->ao, &s[i], &s[i^3]))
 478         continue;
 479
 480       /* We win.  The remaining address must be the client host.  We should
 481        * proxy this query.
 482        */
 483       q->resp = R_NAT;
 484       q->u.nat = s[i^3];
 485       goto done;
 486     }
 487
 488     /* Reached the end of the NAT file. */
 489     if (ferror(natfp)) {
 490       logmsg(q, LOG_ERR, "failed to read `/proc/net/nf_conntrack': %s",
 491              strerror(errno));
 492       goto err_unk;
 493     }
 494   }
 495
 496   /* We didn't find a match anywhere.  How unfortunate. */
 497   logmsg(q, LOG_NOTICE, "connection not found");
 498   q->resp = R_ERROR;
 499   q->u.error = E_NOUSER;
 500   goto done;
 501
 502 err_unk:
 503   /* Something went wrong and the protocol can't express what.  We should
 504    * have logged what the problem actually was.
 505    */
 506   q->resp = R_ERROR;
 507   q->u.error = E_UNKNOWN;
 508
 509 done:
 510   /* All done. */
 511   dstr_destroy(&d);
 512   if (fp) fclose(fp);
 513 }
 514
 515 #undef NEXTFIELD
 516
 517 /* Initialize the system-specific code. */
 518 void init_sys(void)
 519 {
 520   /* Open the NAT connection map. */
 521   if ((natfp = fopen("/proc/net/nf_conntrack", "r")) == 0 &&
 522       errno != ENOENT) {
 523     die(1, "failed to open `/proc/net/nf_conntrack' for reading: %s",
 524         strerror(errno));
 525   }
 526
 527   /* Open the random data source. */
 528   if ((randfd = open("/dev/urandom", O_RDONLY)) < 0) {
 529     die(1, "failed to open `/dev/urandom' for reading: %s",
 530         strerror(errno));
 531   }
 532 }
 533
 534 /*----- That's all, folks -------------------------------------------------*/