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

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