chiark - git - mdw - tripe/blob - admin.c

   1 /* -*-c-*-
   2  *
   3  * $Id: admin.c,v 1.7 2002/01/13 14:57:33 mdw Exp $
   4  *
   5  * Admin interface for configuration
   6  *
   7  * (c) 2001 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of Trivial IP Encryption (TrIPE).
  13  *
  14  * TrIPE is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * TrIPE is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with TrIPE; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Revision history --------------------------------------------------*
  30  *
  31  * $Log: admin.c,v $
  32  * Revision 1.7  2002/01/13 14:57:33  mdw
  33  * Track @lbuf@ and @dstr_vputf@ changes in mLib.
  34  *
  35  * Revision 1.6  2001/02/19 19:11:09  mdw
  36  * Output buffering on admin connections.
  37  *
  38  * Revision 1.5  2001/02/16 21:22:51  mdw
  39  * Support for displaying statistics.  Make client connections blocking, so
  40  * that things don't get dropped.  (This might change again if I add
  41  * buffering.)
  42  *
  43  * Revision 1.4  2001/02/06 09:34:53  mdw
  44  * Change ERR response to FAIL for consistency with other programs.
  45  *
  46  * Revision 1.3  2001/02/04 01:17:12  mdw
  47  * The `DAEMON' notification to stdout is replaced by a warning.  The
  48  * `DAEMON' and `QUIT' command send `OK' on successful completion.  Put
  49  * assignment of sequence number in a T(...) guard.
  50  *
  51  * Revision 1.2  2001/02/03 22:40:29  mdw
  52  * Put timer information into the entropy pool when packets are received
  53  * and on similar events.  Reseed the generator on the interval timer.
  54  *
  55  * Revision 1.1  2001/02/03 20:26:37  mdw
  56  * Initial checkin.
  57  *
  58  */
  59
  60 /*----- Header files ------------------------------------------------------*/
  61
  62 #include "tripe.h"
  63
  64 /*----- Global variables --------------------------------------------------*/
  65
  66 #ifndef NTRACE
  67
  68 const trace_opt tr_opts[] = {
  69   { 't',        T_TUNNEL,       "tunnel events" },
  70   { 'r',        T_PEER,         "peer events" },
  71   { 'a',        T_ADMIN,        "admin interface" },
  72   { 'p',        T_PACKET,       "packet contents" },
  73   { 'c',        T_CRYPTO,       "crypto details" },
  74   { 's',        T_KEYSET,       "symmetric keyset management" },
  75   { 'x',        T_KEYEXCH,      "key exchange" },
  76   { 'm',        T_KEYMGMT,      "key management" },
  77   { 'A',        T_ALL,          "all of the above" },
  78   { 0,          0,              0 }
  79 };
  80
  81 unsigned tr_flags = 0;
  82 #endif
  83
  84 /*----- Static variables --------------------------------------------------*/
  85
  86 static admin *admins;
  87 static sel_file sock;
  88 static const char *sockname;
  89 static unsigned flags = 0;
  90 static admin *a_stdin = 0;
  91 static sig s_term, s_int, s_hup;
  92
  93 #define F_DAEMON 1u
  94 #define F_INIT 2u
  95
  96 #define T_RESOLVE SEC(30)
  97
  98 static void a_destroy(admin */*a*/);
  99 static void a_lock(admin */*a*/);
 100 static void a_unlock(admin */*a*/);
 101
 102 /*----- Output functions --------------------------------------------------*/
 103
 104 /* --- @trywrite@ --- *
 105  *
 106  * Arguments:   @admin *a@ = pointer to an admin block
 107  *              @const char *p@ = pointer to buffer to write
 108  *              @size_t sz@ = size of data to write
 109  *
 110  * Returns:     The number of bytes written, or less than zero on error.
 111  *
 112  * Use:         Attempts to write data to a client.
 113  */
 114
 115 static ssize_t trywrite(admin *a, const char *p, size_t sz)
 116 {
 117   ssize_t n, done = 0;
 118
 119 again:
 120   if (!sz)
 121     return (done);
 122   n = write(a->w.fd, p, sz);
 123   if (n > 0) {
 124     done += n;
 125     p += n;
 126     sz -= n;
 127     goto again;
 128   }
 129   if (n < 0) {
 130     if (errno == EINTR)
 131       goto again;
 132     if (errno != EAGAIN && errno != EWOULDBLOCK) {
 133       a_destroy(a);
 134       a_warn("disconnecting admin client due to write errors: %s",
 135              strerror(errno));
 136       return (-1);
 137     }
 138   }
 139   return (done);
 140 }
 141
 142 /* --- @dosend@ --- *
 143  *
 144  * Arguemnts:   @admin *a@ = pointer to an admin block
 145  *              @const char *p@ = pointer to buffer to write
 146  *              @size_t sz@ = size of data to write
 147  *
 148  * Returns:     ---
 149  *
 150  * Use:         Sends data to an admin client.
 151  */
 152
 153 static void dosend(admin *a, const char *p, size_t sz)
 154 {
 155   ssize_t n;
 156   obuf *o;
 157
 158   if (a->f & AF_DEAD)
 159     return;
 160
 161   /* --- Try to send the data immediately --- */
 162
 163   if (!a->o_head) {
 164     if ((n = trywrite(a, p, sz)) < 0)
 165       return;
 166     p += n;
 167     sz -= n;
 168     if (!sz)
 169       return;
 170   }
 171
 172   /* --- Fill buffers with the data until it's all gone --- */
 173
 174   o = a->o_tail;
 175   if (!o)
 176     sel_addfile(&a->w);
 177   else if (o->p_in < o->buf + OBUFSZ)
 178     goto noalloc;
 179
 180   do {
 181     o = xmalloc(sizeof(obuf));
 182     o->next = 0;
 183     o->p_in = o->p_out = o->buf;
 184     if (a->o_tail)
 185       a->o_tail->next = o;
 186     else
 187       a->o_head = o;
 188     a->o_tail = o;
 189
 190   noalloc:
 191     n = o->buf + OBUFSZ - o->p_in;
 192     if (n > sz)
 193       n = sz;
 194     memcpy(o->p_in, p, n);
 195     o->p_in += n;
 196     p += n;
 197     sz -= n;
 198   } while (sz);
 199 }
 200
 201 /* --- @a_flush@ --- *
 202  *
 203  * Arguments:   @int fd@ = file descriptor
 204  *              @unsigned mode@ = what's happening
 205  *              @void *v@ = pointer to my admin block
 206  *
 207  * Returns:     ---
 208  *
 209  * Use:         Flushes buffers when a client is ready to read again.
 210  */
 211
 212 static void a_flush(int fd, unsigned mode, void *v)
 213 {
 214   admin *a = v;
 215   obuf *o, *oo;
 216   ssize_t n;
 217
 218   o = a->o_head;
 219   while (o) {
 220     if ((n = trywrite(a, o->p_out, o->p_in - o->p_out)) < 0)
 221       return;
 222     o->p_out += n;
 223     if (o->p_in < o->p_out)
 224       break;
 225     oo = o;
 226     o = o->next;
 227     xfree(oo);
 228   }
 229   a->o_head = o;
 230   if (!o) {
 231     a->o_tail = 0;
 232     sel_rmfile(&a->w);
 233   }
 234 }
 235
 236 /*----- Utility functions -------------------------------------------------*/
 237
 238 /* --- @a_write@ --- *
 239  *
 240  * Arguments:   @admin *a@ = admin connection to write to
 241  *              @const char *fmt@ = pointer to format string
 242  *              @...@ = other arguments
 243  *
 244  * Returns:     ---
 245  *
 246  * Use:         Sends a message to an admin connection.
 247  */
 248
 249 static void a_write(admin *a, const char *fmt, ...)
 250 {
 251   va_list ap;
 252   dstr d = DSTR_INIT;
 253   va_start(ap, fmt);
 254   dstr_vputf(&d, fmt, &ap);
 255   va_end(ap);
 256   dosend(a, d.buf, d.len);
 257   dstr_destroy(&d);
 258 }
 259
 260 /* --- @a_warn@ --- *
 261  *
 262  * Arguments:   @const char *fmt@ = pointer to format string
 263  *              @...@ = other arguments
 264  *
 265  * Returns:     ---
 266  *
 267  * Use:         Informs all admin connections of a warning.
 268  */
 269
 270 void a_warn(const char *fmt, ...)
 271 {
 272   va_list ap;
 273   admin *a, *aa;
 274   dstr d = DSTR_INIT;
 275
 276   if (flags & F_INIT)
 277     dstr_puts(&d, "WARN ");
 278   va_start(ap, fmt);
 279   dstr_vputf(&d, fmt, ap);
 280   va_end(ap);
 281   if (!(flags & F_INIT))
 282     moan("%s", d.buf);
 283   else {
 284     dstr_putc(&d, '\n');
 285     for (a = admins; a; a = aa) {
 286       aa = a->next;
 287       dosend(a, d.buf, d.len);
 288     }
 289   }
 290   dstr_destroy(&d);
 291 }
 292
 293 /* --- @a_trace@ --- *
 294  *
 295  * Arguments:   @const char *p@ = pointer to a buffer
 296  *              @size_t sz@ = size of the buffer
 297  *              @void *v@ = uninteresting pointer
 298  *
 299  * Returns:     ---
 300  *
 301  * Use:         Custom trace output handler.
 302  */
 303
 304 #ifndef NTRACE
 305 static void a_trace(const char *p, size_t sz, void *v)
 306 {
 307   dstr d = DSTR_INIT;
 308   admin *a, *aa;
 309
 310   dstr_puts(&d, "TRACE ");
 311   dstr_putm(&d, p, sz);
 312   dstr_putc(&d, '\n');
 313   for (a = admins; a; a = aa) {
 314     aa = a->next;
 315     dosend(a, d.buf, d.len);
 316   }
 317   dstr_destroy(&d);
 318 }
 319 #endif
 320
 321 /* --- @a_quit@ --- *
 322  *
 323  * Arguments:   ---
 324  *
 325  * Returns:     ---
 326  *
 327  * Use:         Shuts things down nicely.
 328  */
 329
 330 void a_quit(void)
 331 {
 332   close(sock.fd);
 333   unlink(sockname);
 334   exit(0);
 335 }
 336
 337 /* --- @a_sigdie@ --- *
 338  *
 339  * Arguments:   @int sig@ = signal number
 340  *              @void *v@ = an uninteresting argument
 341  *
 342  * Returns:     ---
 343  *
 344  * Use          Shuts down on receipt of a fatal signal.
 345  */
 346
 347 static void a_sigdie(int sig, void *v)
 348 {
 349   char *p;
 350   char buf[20];
 351
 352   switch (sig) {
 353     case SIGTERM:       p = "SIGTERM"; break;
 354     case SIGINT:        p = "SIGINT"; break;
 355     default:
 356       sprintf(buf, "signal %i", sig);
 357       p = buf;
 358       break;
 359   }
 360   a_warn("shutting down on %s", p);
 361   a_quit();
 362 }
 363
 364 /* --- @a_sighup@ --- *
 365  *
 366  * Arguments:   @int sig@ = signal number
 367  *              @void *v@ = an uninteresting argument
 368  *
 369  * Returns:     ---
 370  *
 371  * Use          Logs a message about SIGHUP not being useful.
 372  */
 373
 374 static void a_sighup(int sig, void *v)
 375 {
 376   a_warn("received SIGHUP: ignoring");
 377 }
 378
 379 /*----- Adding peers ------------------------------------------------------*/
 380
 381 /* --- @a_resolve@ --- *
 382  *
 383  * Arguments:   @struct hostent *h@ = pointer to resolved hostname
 384  *              @void *v@ = pointer to admin block
 385  *
 386  * Returns:     ---
 387  *
 388  * Use:         Handles a completed name resolution.
 389  */
 390
 391 static void a_resolve(struct hostent *h, void *v)
 392 {
 393   admin *a = v;
 394
 395   a_lock(a);
 396   T( trace(T_ADMIN, "admin: %u resolved", a->seq); )
 397   TIMER;
 398   sel_rmtimer(&a->t);
 399   if (!h)
 400     a_write(a, "FAIL couldn't resolve hostname `%s'\n", a->paddr);
 401   else if (p_find(a->pname))
 402     a_write(a, "FAIL peer `%s' already registered\n", a->pname);
 403   else {
 404     memcpy(&a->peer.sin.sin_addr, h->h_addr, sizeof(struct in_addr));
 405     if (!p_create(a->pname, &a->peer.sa, a->sasz))
 406       a_write(a, "FAIL couldn't create peer\n");
 407     else
 408       a_write(a, "OK\n");
 409   }
 410   xfree(a->pname);
 411   xfree(a->paddr);
 412   a->pname = 0;
 413   selbuf_enable(&a->b);
 414   a_unlock(a);
 415 }
 416
 417 /* --- @a_timer@ --- *
 418  *
 419  * Arguments:   @struct timeval *tv@ = timer
 420  *              @void *v@ = pointer to admin block
 421  *
 422  * Returns:     ---
 423  *
 424  * Use:         Times out a resolver.
 425  */
 426
 427 static void a_timer(struct timeval *tv, void *v)
 428 {
 429   admin *a = v;
 430
 431   a_lock(a);
 432   T( trace(T_ADMIN, "admin: %u resolver timeout", a->seq); )
 433   bres_abort(&a->r);
 434   a_write(a, "FAIL timeout resolving `%s'\n", a->paddr);
 435   xfree(a->pname);
 436   xfree(a->paddr);
 437   a->pname = 0;
 438   selbuf_enable(&a->b);
 439   a_unlock(a);
 440 }
 441
 442 /* --- @acmd_add@ --- *
 443  *
 444  * Arguments:   @admin *a@ = connection which requested the addition
 445  *              @unsigned ac@ = argument count
 446  *              @char *av[]@ = pointer to the argument list
 447  *
 448  * Returns:     ---
 449  *
 450  * Use:         Adds a new peer.
 451  */
 452
 453 static void acmd_add(admin *a, unsigned ac, char *av[])
 454 {
 455   unsigned long pt;
 456   struct timeval tv;
 457   char *p;
 458
 459   /* --- Make sure someone's not got there already --- */
 460
 461   if (p_find(av[0])) {
 462     a_write(a, "FAIL peer `%s' already registered\n", av[0]);
 463     return;
 464   }
 465
 466   /* --- Fill in the easy bits of address --- */
 467
 468   BURN(a->peer);
 469   a->peer.sin.sin_family = AF_INET;
 470   a->sasz = sizeof(a->peer.sin);
 471   pt = strtoul(av[2], &p, 0);
 472   if (*p) {
 473     struct servent *s = getservbyname(av[2], "udp");
 474     if (!s) {
 475       a_write(a, "FAIL service `%s' not known\n", av[2]);
 476       return;
 477     }
 478     pt = ntohs(s->s_port);
 479   }
 480   if (pt == 0 || pt >= 65536) {
 481     a_write(a, "FAIL bad port number %lu\n", pt);
 482     return;
 483   }
 484   a->peer.sin.sin_port = htons(pt);
 485
 486   /* --- If the name is numeric, do it the easy way --- */
 487
 488   if (inet_aton(av[1], &a->peer.sin.sin_addr)) {
 489     if (!p_create(av[0], &a->peer.sa, a->sasz))
 490       a_write(a, "FAIL couldn't create peer\n");
 491     else
 492       a_write(a, "OK\n");
 493     return;
 494   }
 495
 496   /* --- Store everything for later and crank up the resolver --- *
 497    *
 498    * We disable the line buffer until the resolver completes (or times out).
 499    * This prevents other commands on the same connection (though the rest of
 500    * the system continues regardless), but makes life simpler for the client.
 501    */
 502
 503   a->pname = xstrdup(av[0]);
 504   a->paddr = xstrdup(av[1]);
 505   selbuf_disable(&a->b);
 506   gettimeofday(&tv, 0);
 507   tv.tv_sec += T_RESOLVE;
 508   sel_addtimer(&sel, &a->t, &tv, a_timer, a);
 509   bres_byname(&a->r, a->paddr, a_resolve, a);
 510   T( trace(T_ADMIN, "admin: %u resolving hostname `%s'",
 511            a->seq, a->paddr); )
 512 }
 513
 514 /*----- Administration commands -------------------------------------------*/
 515
 516 /* --- Miscellaneous commands --- */
 517
 518 #ifndef NTRACE
 519
 520 static void acmd_trace(admin *a, unsigned ac, char *av[])
 521 {
 522   if (!ac || strcmp(av[0], "?") == 0) {
 523     const trace_opt *t;
 524     a_write(a, "INFO Trace options:\n");
 525     for (t = tr_opts; t->ch; t++) {
 526       a_write(a, "INFO %c %c  %s\n",
 527               t->ch, (tr_flags & t->f) == t->f ? '*' : ' ', t->help);
 528     }
 529   } else {
 530     unsigned sense = 1;
 531     unsigned f = tr_flags;
 532     const trace_opt *tt;
 533     char *p = av[0];
 534
 535     while (*p) {
 536       switch (*p) {
 537         case '+': sense = 1; break;
 538         case '-': sense = 0; break;
 539         default:
 540           for (tt = tr_opts; tt->ch; tt++) {
 541             if (tt->ch == *p) {
 542               if (sense) f |= tt->f;
 543               else f &= ~tt->f;
 544               goto tropt_ok;
 545             }
 546           }
 547           a_write(a, "FAIL unknown trace option `%c'\n", *p);
 548           return;
 549         tropt_ok:;
 550           break;
 551       }
 552       p++;
 553     }
 554     tr_flags = f;
 555     trace_level(tr_flags);
 556   }
 557   a_write(a, "OK\n");
 558 }
 559
 560 #endif
 561
 562 static void acmd_port(admin *a, unsigned ac, char *av[])
 563 {
 564   a_write(a, "INFO %u\nOK\n", p_port());
 565 }
 566
 567 static void acmd_daemon(admin *a, unsigned ac, char *av[])
 568 {
 569   if (flags & F_DAEMON)
 570     a_write(a, "FAIL already running as a daemon\n");
 571   else {
 572     a_warn("becoming a daemon");
 573     if (a_stdin)
 574       a_destroy(a_stdin);
 575     if (u_daemon())
 576       a_write(a, "FAIL error becoming a daemon: %s", strerror(errno));
 577     else {
 578       flags |= F_DAEMON;
 579       a_write(a, "OK\n");
 580     }
 581   }
 582 }
 583
 584 static void acmd_list(admin *a, unsigned ac, char *av[])
 585 {
 586   peer *p;
 587   for (p = p_first(); p; p = p_next(p))
 588     a_write(a, "INFO %s\n", p_name(p));
 589   a_write(a, "OK\n");
 590 }
 591
 592 static void acmd_ifname(admin *a, unsigned ac, char *av[])
 593 {
 594   peer *p;
 595
 596   if ((p = p_find(av[0])) == 0)
 597     a_write(a, "FAIL peer `%s' not found\n", av[0]);
 598   else
 599     a_write(a, "INFO %s\nOK\n", p_ifname(p));
 600 }
 601
 602 static void acmd_addr(admin *a, unsigned ac, char *av[])
 603 {
 604   peer *p;
 605   const addr *ad;
 606
 607   if ((p = p_find(av[0])) == 0)
 608     a_write(a, "FAIL peer `%s' not found\n", av[0]);
 609   else {
 610     ad = p_addr(p);
 611     assert(ad->sa.sa_family == AF_INET);
 612     a_write(a, "INFO %s %u\nOK\n",
 613             inet_ntoa(ad->sin.sin_addr),
 614             (unsigned)ntohs(ad->sin.sin_port));
 615   }
 616 }
 617
 618 static void acmd_stats(admin *a, unsigned ac, char *av[])
 619 {
 620   peer *p;
 621   stats *st;
 622
 623   if ((p = p_find(av[0])) == 0)
 624     a_write(a, "FAIL peer `%s' not found\n", av[0]);
 625   else {
 626     st = p_stats(p);
 627     a_write(a, "INFO start-time=%s\n", timestr(st->t_start));
 628     a_write(a, "INFO last-packet-time=%s\n", timestr(st->t_last));
 629     a_write(a, "INFO packets-in=%lu bytes-in=%lu\n", st->n_in, st->sz_in);
 630     a_write(a, "INFO packets-out=%lu bytes-out=%lu\n",
 631             st->n_out, st->sz_out);
 632     a_write(a, "INFO keyexch-packets-in=%lu keyexch-bytes-in=%lu\n",
 633             st->n_kxin, st->sz_kxin);
 634     a_write(a, "INFO keyexch-packets-out=%lu keyexch-bytes-out=%lu\n",
 635             st->n_kxout, st->sz_kxout);
 636     a_write(a, "INFO ip-packets-in=%lu ip-bytes-in=%lu\n",
 637             st->n_ipin, st->sz_ipin);
 638     a_write(a, "INFO ip-packets-out=%lu ip-bytes-out=%lu\n",
 639             st->n_ipout, st->sz_ipout);
 640     a_write(a, "INFO rejected-packets=%lu\n", st->n_reject);
 641     a_write(a, "OK\n");
 642   }
 643 }
 644
 645 static void acmd_kill(admin *a, unsigned ac, char *av[])
 646 {
 647   peer *p;
 648   if ((p = p_find(av[0])) == 0)
 649     a_write(a, "FAIL peer `%s' not found\n", av[0]);
 650   else {
 651     p_destroy(p);
 652     a_write(a, "OK\n");
 653   }
 654 }
 655
 656 static void acmd_quit(admin *a, unsigned ac, char *av[])
 657 {
 658   a_warn("closing down on admin request");
 659   a_write(a, "OK\n");
 660   a_quit();
 661 }
 662
 663 /* --- The command table and help --- */
 664
 665 typedef struct acmd {
 666   const char *name;
 667   const char *help;
 668   unsigned argmin, argmax;
 669   void (*func)(admin */*a*/, unsigned /*ac*/, char */*av*/[]);
 670 } acmd;
 671
 672 static void acmd_help(admin */*a*/, unsigned /*ac*/, char */*av*/[]);
 673
 674 static const acmd acmdtab[] = {
 675   { "help",     "HELP",                 0,      0,      acmd_help },
 676 #ifndef NTRACE
 677   { "trace",    "TRACE [options]",      0,      1,      acmd_trace },
 678 #endif
 679   { "port",     "PORT",                 0,      0,      acmd_port },
 680   { "daemon",   "DAEMON",               0,      0,      acmd_daemon },
 681   { "list",     "LIST",                 0,      0,      acmd_list },
 682   { "ifname",   "IFNAME peer",          1,      1,      acmd_ifname },
 683   { "addr",     "ADDR peer",            1,      1,      acmd_addr },
 684   { "stats",    "STATS peer",           1,      1,      acmd_stats },
 685   { "kill",     "KILL peer",            1,      1,      acmd_kill },
 686   { "add",      "ADD peer addr port",   3,      3,      acmd_add },
 687   { "quit",     "QUIT",                 0,      0,      acmd_quit },
 688   { 0,          0,                      0,      0,      0 }
 689 };
 690
 691 static void acmd_help(admin *a, unsigned ac, char *av[])
 692 {
 693   const acmd *c;
 694   for (c = acmdtab; c->name; c++)
 695     a_write(a, "INFO %s\n", c->help);
 696   a_write(a, "OK\n");
 697 }
 698
 699 /*----- Connection handling -----------------------------------------------*/
 700
 701 /* --- @a_lock@ --- *
 702  *
 703  * Arguments:   @admin *a@ = pointer to an admin block
 704  *
 705  * Returns:     ---
 706  *
 707  * Use:         Locks an admin block so that it won't be destroyed
 708  *              immediately.
 709  */
 710
 711 static void a_lock(admin *a) { assert(!(a->f & AF_LOCK)); a->f |= AF_LOCK; }
 712
 713 /* --- @a_unlock@ --- *
 714  *
 715  * Arguments:   @admin *a@ = pointer to an admin block
 716  *
 717  * Returns:     ---
 718  *
 719  * Use:         Unlocks an admin block, allowing its destruction.  This is
 720  *              also the second half of @a_destroy@.
 721  */
 722
 723 static void a_unlock(admin *a)
 724 {
 725   assert(a->f & AF_LOCK);
 726   if (!(a->f & AF_DEAD)) {
 727     a->f &= ~AF_LOCK;
 728     return;
 729   }
 730
 731   T( trace(T_ADMIN, "admin: completing destruction of connection %u",
 732            a->seq); )
 733
 734   selbuf_destroy(&a->b);
 735   if (a->pname) {
 736     xfree(a->pname);
 737     xfree(a->paddr);
 738     bres_abort(&a->r);
 739     sel_rmtimer(&a->t);
 740   }
 741   if (a->b.reader.fd != a->w.fd)
 742     close(a->b.reader.fd);
 743   close(a->w.fd);
 744
 745   if (a_stdin == a)
 746     a_stdin = 0;
 747   if (a->next)
 748     a->next->prev = a->prev;
 749   if (a->prev)
 750     a->prev->next = a->next;
 751   else
 752     admins = a->next;
 753   DESTROY(a);
 754 }
 755
 756 /* --- @a_destroy@ --- *
 757  *
 758  * Arguments:   @admin *a@ = pointer to an admin block
 759  *
 760  * Returns:     ---
 761  *
 762  * Use:         Destroys an admin block.  This requires a certain amount of
 763  *              care.
 764  */
 765
 766 static void a_destroy(admin *a)
 767 {
 768   /* --- Don't multiply destroy admin blocks --- */
 769
 770   if (a->f & AF_DEAD)
 771     return;
 772
 773   /* --- Make sure nobody expects it to work --- */
 774
 775   a->f |= AF_DEAD;
 776   T( trace(T_ADMIN, "admin: destroying connection %u", a->seq); )
 777
 778   /* --- Free the output buffers --- */
 779
 780   if (a->o_head) {
 781     obuf *o, *oo;
 782     sel_rmfile(&a->w);
 783     for (o = a->o_head; o; o = oo) {
 784       oo = o->next;
 785       xfree(o);
 786     }
 787     a->o_head = 0;
 788   }
 789
 790   /* --- If the block is locked, that's all we can manage --- */
 791
 792   if (a->f & AF_LOCK) {
 793     T( trace(T_ADMIN, "admin: deferring destruction..."); )
 794     return;
 795   }
 796   a->f |= AF_LOCK;
 797   a_unlock(a);
 798 }
 799
 800 /* --- @a_line@ --- *
 801  *
 802  * Arguments:   @char *p@ = pointer to the line read
 803  *              @size_t len@ = length of the line
 804  *              @void *vp@ = pointer to my admin block
 805  *
 806  * Returns:     ---
 807  *
 808  * Use:         Handles a line of input.
 809  */
 810
 811 static void a_line(char *p, size_t len, void *vp)
 812 {
 813   admin *a = vp;
 814   const acmd *c;
 815   char *av[4];
 816   size_t ac;
 817
 818   TIMER;
 819   if (a->f & AF_DEAD)
 820     return;
 821   if (!p) {
 822     a_destroy(a);
 823     return;
 824   }
 825   ac = str_qsplit(p, av, 4, 0, STRF_QUOTE);
 826   if (!ac)
 827     return;
 828   for (p = av[0]; *p; p++) *p = tolower((unsigned char)*p);
 829   for (c = acmdtab; c->name; c++) {
 830     if (strcmp(av[0], c->name) == 0) {
 831       ac--;
 832       if (c->argmin > ac || ac > c->argmax)
 833         a_write(a, "FAIL syntax: %s\n", c->help);
 834       else {
 835         a_lock(a);
 836         c->func(a, ac, av + 1);
 837         a_unlock(a);
 838       }
 839       return;
 840     }
 841   }
 842   a_write(a, "FAIL unknown command `%s'\n", av[0]);
 843 }
 844
 845 /* --- @a_create@ --- *
 846  *
 847  * Arguments:   @int fd_in, fd_out@ = file descriptors to use
 848  *
 849  * Returns:     ---
 850  *
 851  * Use:         Creates a new admin connection.
 852  */
 853
 854 void a_create(int fd_in, int fd_out)
 855 {
 856   admin *a = CREATE(admin);
 857   T( static unsigned seq = 0;
 858      a->seq = seq++; )
 859   T( trace(T_ADMIN, "admin: accepted connection %u", a->seq); )
 860   a->pname = 0;
 861   a->f = 0;
 862   if (fd_in == STDIN_FILENO)
 863     a_stdin = a;
 864   fdflags(fd_in, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
 865   if (fd_out != fd_in)
 866     fdflags(fd_out, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
 867   selbuf_init(&a->b, &sel, fd_in, a_line, a);
 868   sel_initfile(&sel, &a->w, fd_out, SEL_WRITE, a_flush, a);
 869   a->o_head = 0;
 870   a->o_tail = 0;
 871   a->next = admins;
 872   a->prev = 0;
 873   if (admins)
 874     admins->prev = a;
 875   admins = a;
 876 }
 877
 878 /* --- @a_accept@ --- *
 879  *
 880  * Arguments:   @int fd@ = file descriptor to accept
 881  *              @unsigned mode@ = what to do
 882  *              @void *v@ = uninteresting pointer
 883  *
 884  * Returns:     ---
 885  *
 886  * Use:         Accepts a new admin connection.
 887  */
 888
 889 static void a_accept(int fd, unsigned mode, void *v)
 890 {
 891   int nfd;
 892   struct sockaddr_un sun;
 893   size_t sz = sizeof(sun);
 894
 895   if ((nfd = accept(fd, (struct sockaddr *)&sun, &sz)) < 0) {
 896     a_warn("accept admin connection failed: %s", strerror(errno));
 897     return;
 898   }
 899   a_create(nfd, nfd);
 900 }
 901
 902 /* --- @a_daemon@ --- *
 903  *
 904  * Arguments:   ---
 905  *
 906  * Returns:     ---
 907  *
 908  * Use:         Informs the admin module that it's a daemon.
 909  */
 910
 911 void a_daemon(void)
 912 {
 913   flags |= F_DAEMON;
 914 }
 915
 916 /* --- @a_init@ --- *
 917  *
 918  * Arguments:   @const char *name@ = socket name to create
 919  *
 920  * Returns:     ---
 921  *
 922  * Use:         Creates the admin listening socket.
 923  */
 924
 925 void a_init(const char *name)
 926 {
 927   int fd;
 928   int n = 5;
 929   struct sockaddr_un sun;
 930   struct sigaction sa;
 931   size_t sz;
 932
 933   /* --- Set up the socket address --- */
 934
 935   sz = strlen(name) + 1;
 936   if (sz > sizeof(sun.sun_path))
 937     die(EXIT_FAILURE, "socket name `%s' too long", name);
 938   BURN(sun);
 939   sun.sun_family = AF_UNIX;
 940   memcpy(sun.sun_path, name, sz);
 941   sz += offsetof(struct sockaddr_un, sun_path);
 942
 943   /* --- Attempt to bind to the socket --- */
 944
 945   umask(0077);
 946 again:
 947   if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
 948     die(EXIT_FAILURE, "couldn't create socket: %s", strerror(errno));
 949   if (bind(fd, (struct sockaddr *)&sun, sz) < 0) {
 950     struct stat st;
 951     int e = errno;
 952     if (errno != EADDRINUSE) {
 953       die(EXIT_FAILURE, "couldn't bind to address `%s': %s",
 954           sun.sun_path, strerror(e));
 955     }
 956     if (!n)
 957       die(EXIT_FAILURE, "too many retries; giving up");
 958     n--;
 959     if (!connect(fd, (struct sockaddr *)&sun, sz)) {
 960       die(EXIT_FAILURE, "server already listening on admin socket `%s'",
 961           sun.sun_path);
 962     }
 963     if (errno != ECONNREFUSED)
 964       die(EXIT_FAILURE, "couldn't bind to address: %s", strerror(e));
 965     if (stat(sun.sun_path, &st)) {
 966       die(EXIT_FAILURE, "couldn't stat `%s': %s",
 967           sun.sun_path, strerror(errno));
 968     }
 969     if (!S_ISSOCK(st.st_mode))
 970       die(EXIT_FAILURE, "object `%s' isn't a socket", sun.sun_path);
 971     T( trace(T_ADMIN, "admin: stale socket found; removing it"); )
 972     unlink(sun.sun_path);
 973     close(fd);
 974     goto again;
 975   }
 976   chmod(sun.sun_path, 0600);
 977   fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
 978   if (listen(fd, 5))
 979     die(EXIT_FAILURE, "couldn't listen on socket: %s", strerror(errno));
 980
 981   /* --- Listen to the socket --- */
 982
 983   sel_initfile(&sel, &sock, fd, SEL_READ, a_accept, 0);
 984   sel_addfile(&sock);
 985   sockname = name;
 986   bres_init(&sel);
 987   T( trace_custom(a_trace, 0);
 988      trace(T_ADMIN, "admin: enabled custom tracing"); )
 989   flags |= F_INIT;
 990
 991   /* --- Set up signal handlers --- */
 992
 993   sig_add(&s_term, SIGTERM, a_sigdie, 0);
 994   sig_add(&s_hup, SIGHUP, a_sighup, 0);
 995   sigaction(SIGINT, 0, &sa);
 996   if (sa.sa_handler != SIG_IGN)
 997     sig_add(&s_int, SIGINT, a_sigdie, 0);
 998 }
 999
1000 /*----- That's all, folks -------------------------------------------------*/