Backgrounded commands and RELOAD.

[tripe] / admin.c

/* -*-c-*-
 *
 * $Id$
 *
 * Admin interface for configuration
 *
 * (c) 2001 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Trivial IP Encryption (TrIPE).
 *
 * TrIPE is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * TrIPE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with TrIPE; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "tripe.h"

/*----- Global variables --------------------------------------------------*/

#ifndef NTRACE

const trace_opt tr_opts[] = {
  { 't',	T_TUNNEL,	"tunnel events" },
  { 'r',	T_PEER,		"peer events" },
  { 'a',	T_ADMIN,	"admin interface" },
  { 'p',	T_PACKET,	"packet contents" },
  { 'c',	T_CRYPTO,	"crypto details" },
  { 's',	T_KEYSET,	"symmetric keyset management" },
  { 'x',	T_KEYEXCH,	"key exchange" },
  { 'm',	T_KEYMGMT,	"key management" },
  { 'A',	T_ALL,		"all of the above" },
  { 0,		0,		0 }
};

unsigned tr_flags = 0;
#endif

static const trace_opt w_opts[] = {
  { 't',	AF_TRACE,	"trace messages" },
  { 'n',	AF_NOTE,	"asynchronous notifications" },
  { 'w',	AF_WARN,	"warnings" },
  { 'A',	AF_ALLMSGS,	"all of the above" },
  { 0,		0,		0 }
};

/*----- Static variables --------------------------------------------------*/

static admin *admins;
static sel_file sock;
static const char *sockname;
static unsigned flags = 0;
static admin *a_stdin = 0;
static sig s_term, s_int, s_hup;

#define F_DAEMON 1u
#define F_INIT 2u

#define T_RESOLVE SEC(30)
#define T_PING SEC(5)

static void a_destroy(admin */*a*/);
static void a_lock(admin */*a*/);
static void a_unlock(admin */*a*/);

/*----- Output functions --------------------------------------------------*/

/* --- @trywrite@ --- *
 *
 * Arguments:	@admin *a@ = pointer to an admin block
 *		@const char *p@ = pointer to buffer to write
 *		@size_t sz@ = size of data to write
 *
 * Returns:	The number of bytes written, or less than zero on error.
 *
 * Use:		Attempts to write data to a client.
 */

static ssize_t trywrite(admin *a, const char *p, size_t sz)
{
  ssize_t n, done = 0;

again:
  if (!sz)
    return (done);
  n = write(a->w.fd, p, sz);
  if (n > 0) {
    done += n;
    p += n;
    sz -= n;
    goto again;
  }
  if (n < 0) {
    if (errno == EINTR)
      goto again;
    if (errno != EAGAIN && errno != EWOULDBLOCK) {
      a_destroy(a);
      a_warn("ADMIN client-read-error -- %s", strerror(errno));
      return (-1);
    }
  }
  return (done);
}

/* --- @doqueue@ -- *
 *
 * Arguments:	@oqueue *q@ = pointer to output queue
 *		@const char *p@ = pointer to buffer to write
 *		@size_t sz@ = size of buffer
 *
 * Returns:	Nonzero if the queue was previously empty.
 *
 * Use:		Queues data to be written later.
 */

static int doqueue(oqueue *q, const char *p, size_t sz)
{
  obuf *o;
  int rc = 0;
  size_t n;

  o = q->tl;
  if (!o)
    rc = 1;
  else if (o->p_in < o->buf + OBUFSZ)
    goto noalloc;

  do {
    o = xmalloc(sizeof(obuf));
    o->next = 0;
    o->p_in = o->p_out = o->buf;
    if (q->tl)
      q->tl->next = o;
    else
      q->hd = o;
    q->tl = o;

  noalloc:
    n = o->buf + OBUFSZ - o->p_in;
    if (n > sz)
      n = sz;
    memcpy(o->p_in, p, n);
    o->p_in += n;
    p += n;
    sz -= n;
  } while (sz);

  return (rc);
}

/* --- @dosend@ --- *
 *
 * Arguemnts:	@admin *a@ = pointer to an admin block
 *		@const char *p@ = pointer to buffer to write
 *		@size_t sz@ = size of data to write
 *
 * Returns:	---
 *
 * Use:		Sends data to an admin client.
 */

static void dosend(admin *a, const char *p, size_t sz)
{
  ssize_t n;

  if (a->f & AF_DEAD)
    return;
  if (!a->out.hd) {
    if ((n = trywrite(a, p, sz)) < 0)
      return;
    p += n;
    sz -= n;
    if (!sz)
      return;
  }
  if (doqueue(&a->out, p, sz))
    sel_addfile(&a->w);
}

/* --- @a_flush@ --- *
 *
 * Arguments:	@int fd@ = file descriptor
 *		@unsigned mode@ = what's happening
 *		@void *v@ = pointer to my admin block
 *
 * Returns:	---
 *
 * Use:		Flushes buffers when a client is ready to read again.
 */

static void a_flush(int fd, unsigned mode, void *v)
{
  admin *a = v;
  obuf *o, *oo;
  ssize_t n;

  o = a->out.hd;
  while (o) {
    if ((n = trywrite(a, o->p_out, o->p_in - o->p_out)) < 0)
      return;
    o->p_out += n;
    if (o->p_in < o->p_out)
      break;
    oo = o;
    o = o->next;
    xfree(oo);
  }
  a->out.hd = o;
  if (!o) {
    a->out.tl = 0;
    sel_rmfile(&a->w);
  }
}

/*----- Utility functions -------------------------------------------------*/

/* --- @a_write@, @a_vwrite@ --- *
 *
 * Arguments:	@admin *a@ = admin connection to write to
 *		@const char *status@ = status code to report
 *		@const char *tag@ = tag string, or null
 *		@const char *fmt@ = pointer to format string
 *		@va_list ap@ = arguments in list
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Sends a message to an admin connection.
 */

static void a_vwrite(admin *a, const char *status, const char *tag,
		     const char *fmt, va_list ap)
{
  dstr d = DSTR_INIT;

  if (tag) dstr_puts(&d, "BG");
  dstr_puts(&d, status);
  if (tag) {
    dstr_putc(&d, ' ');
    dstr_puts(&d, tag);
  }
  if (fmt) {
    dstr_putc(&d, ' ');
    dstr_vputf(&d, fmt, &ap);
  }
  dstr_putc(&d, '\n');
  dosend(a, d.buf, d.len);
  dstr_destroy(&d);
}

static void a_write(admin *a, const char *status, const char *tag,
		    const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  a_vwrite(a, status, tag, fmt, ap);
  va_end(ap);
}

/* --- @a_ok@, @a_info@, @a_fail@ --- *
 *
 * Arguments:	@admin *a@ = connection
 *		@const char *fmt@ = format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Convenience functions for @a_write@.
 */

static void a_ok(admin *a) { a_write(a, "OK", 0, 0); }

static void a_info(admin *a, const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  a_vwrite(a, "INFO", 0, fmt, ap);
  va_end(ap);
}

static void a_fail(admin *a, const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  a_vwrite(a, "FAIL", 0, fmt, ap);
  va_end(ap);
}

/* --- @a_alert@, @a_valert@, @a_rawalert@ --- *
 *
 * Arguments:	@unsigned f_and, f_eq@ = filter for connections
 *		@const char *status@ = status string
 *		@const char *fmt@ = pointer to format string
 *		@const char *p@ = pointer to raw string
 *		@size_t sz@ = size of raw string
 *		@va_list ap@ = arguments in list
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Write a message to all admin connections matched by the given
 *		filter.
 */

static void a_rawalert(unsigned f_and, unsigned f_eq, const char *status,
		       const char *p, size_t sz)
{
  admin *a, *aa;
  dstr d = DSTR_INIT;
  
  if (!(flags & F_INIT))
    return;
  dstr_puts(&d, status);
  if (p) {
    dstr_putc(&d, ' ');
    dstr_putm(&d, p, sz);
  }
  dstr_putc(&d, '\n');
  p = d.buf;
  sz = d.len;
  for (a = admins; a; a = aa) {
    aa = a->next;
    if ((a->f & f_and) == f_eq)
      dosend(a, d.buf, d.len);
  }
  dstr_destroy(&d);
}

static void a_valert(unsigned f_and, unsigned f_eq, const char *tag,
		     const char *fmt, va_list ap)
{
  dstr d = DSTR_INIT;

  if (!(flags & F_INIT))
    return;
  if (fmt)
    dstr_vputf(&d, fmt, &ap);
  a_rawalert(f_and, f_eq, tag, fmt ? d.buf : 0, fmt ? d.len : 0);
  dstr_destroy(&d);
}

#if 0 /*unused*/
static void a_alert(unsigned f_and, unsigned f_eq, const char *tag,
		    const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  a_valert(f_and, f_eq, tag, fmt, ap);
  va_end(ap);
}
#endif

/* --- @a_warn@ --- *
 *
 * Arguments:	@const char *fmt@ = pointer to format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Informs all admin connections of a warning.
 */

void a_warn(const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt);
  if (flags & F_INIT)
    a_valert(0, 0, "WARN", fmt, ap);
  else {
    fprintf(stderr, "%s: ", QUIS);
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
  }
  va_end(ap);
}

/* --- @a_trace@ --- *
 *
 * Arguments:	@const char *p@ = pointer to a buffer
 *		@size_t sz@ = size of the buffer
 *		@void *v@ = uninteresting pointer
 *
 * Returns:	---
 *
 * Use:		Custom trace output handler.  Sends trace messages to
 *		interested admin connections.
 */

#ifndef NTRACE
static void a_trace(const char *p, size_t sz, void *v)
  { a_rawalert(AF_TRACE, AF_TRACE, "TRACE", p, sz); }
#endif

/* --- @a_notify@ --- *
 *
 * Arguments:	@const char *fmt@ = pointer to format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Sends a notification to interested admin connections.
 */

void a_notify(const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt);
  a_valert(AF_NOTE, AF_NOTE, "NOTE", fmt, ap);
  va_end(ap);
}

/* --- @a_quit@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Shuts things down nicely.
 */

void a_quit(void)
{
  peer *p;

  close(sock.fd);
  unlink(sockname);
  while ((p = p_first()) != 0)
    p_destroy(p);
  exit(0);
}

/* --- @a_sigdie@ --- *
 *
 * Arguments:	@int sig@ = signal number
 *		@void *v@ = an uninteresting argument
 *
 * Returns:	---
 *
 * Use		Shuts down on receipt of a fatal signal.
 */

static void a_sigdie(int sig, void *v)
{
  char *p;
  char buf[20];

  switch (sig) {
    case SIGTERM:	p = "SIGTERM"; break;
    case SIGINT:	p = "SIGINT"; break;
    default:
      sprintf(buf, "%i", sig);
      p = buf;
      break;
  }
  a_warn("SERVER quit signal %s", p);
  a_quit();
}

/* --- @a_sighup@ --- *
 *
 * Arguments:	@int sig@ = signal number
 *		@void *v@ = an uninteresting argument
 *
 * Returns:	---
 *
 * Use		Logs a message about SIGHUP not being useful.
 */

static void a_sighup(int sig, void *v)
{
  a_warn("SERVER ignore signal SIGHUP");
}

/* --- @a_parsetime@ --- *
 *
 * Arguments;	@const char *p@ = time string to parse
 *
 * Returns:	Time in seconds, or @< 0@ on error.
 */

static long a_parsetime(const char *p)
{
  char *q;
  long t = strtol(p, &q, 0);

  switch (*q) {
    case 'd': t *= 24;
    case 'h': t *= 60;
    case 'm': t *= 60;
    case 's': if (q[1] != 0)
    default:    t = -1;
    case 0:   break;
  }
  return (t);    
}

/*----- Backgrounded operations -------------------------------------------*/

/* --- @a_bgrelease@ --- *
 *
 * Arguments:	@admin_bgop *bg@ = backgrounded operation
 *
 * Returns:	---
 *
 * Use:		Removes a backgrounded operation from the queue, since
 *		(presumably) it's done.
 */

static void a_bgrelease(admin_bgop *bg)
{
  admin *a = bg->a;

  if (bg->tag)
    xfree(bg->tag);
  else
    selbuf_enable(&a->b);
  if (bg->next)
    bg->next->prev = bg->prev;
  if (bg->prev)
    bg->prev->next = bg->next;
  else
    a->bg = bg->next;
  xfree(bg);
  if (a->f & AF_CLOSE)
    a_destroy(a);
}

/* --- @a_bgok@, @a_bginfo@, @a_bgfail@ --- *
 *
 * Arguments:	@admin_bgop *bg@ = backgrounded operation
 *		@const char *fmt@ = format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Convenience functions for @a_write@.
 */

static void a_bgok(admin_bgop *bg)
  { a_write(bg->a, "OK", bg->tag, 0); }

static void a_bginfo(admin_bgop *bg, const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  a_vwrite(bg->a, "INFO", bg->tag, fmt, ap);
  va_end(ap);
}

static void a_bgfail(admin_bgop *bg, const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  a_vwrite(bg->a, "FAIL", bg->tag, fmt, ap);
  va_end(ap);
}

/* --- @a_bgadd@ --- *
 *
 * Arguments:	@admin *a@ = administration connection
 *		@admin_bgop *bg@ = pointer to background operation
 *		@const char *tag@ = background tag, or null for foreground
 *		@void (*cancel)(admin_bgop *)@ = cancel function
 *
 * Returns:	---
 *
 * Use:		Links a background job into the list.
 */

static void a_bgadd(admin *a, admin_bgop *bg, const char *tag,
		    void (*cancel)(admin_bgop *))
{
  if (tag)
    bg->tag = xstrdup(tag);
  else {
    bg->tag = 0;
    selbuf_disable(&a->b);
  }
  bg->a = a;
  bg->cancel = cancel;
  bg->next = a->bg;
  bg->prev = 0;
  a->bg = bg;
  if (tag) a_write(a, "DETACH", tag, 0);
}

/*----- Adding peers ------------------------------------------------------*/

/* --- @a_addfree@ --- *
 *
 * Arguments:	@admin_addop *add@ = operation block
 *
 * Returns:	---
 *
 * Use:		Frees an add operation.
 */

static void a_addfree(admin_addop *add)
{
  if (add->peer.name) xfree(add->peer.name);
  if (add->paddr) xfree(add->paddr);
}

/* --- @a_addcancel@ --- *
 *
 * Arguments:	@admin_bgop *bg@ = background operation
 *
 * Returns:	---
 *
 * Use:		Cancels an add operation.
 */

static void a_addcancel(admin_bgop *bg)
{
  admin_addop *add = (admin_addop *)bg;

  sel_rmtimer(&add->t);
  bres_abort(&add->r);
  a_addfree(add);
}

/* --- @a_doadd@ --- *
 *
 * Arguments:	@admin_addop *add@ = operation block
 *
 * Returns:	---
 *
 * Use:		Does the peer add thing.
 */

static void a_doadd(admin_addop *add)
{
  if (p_find(add->peer.name))
    a_bgfail(&add->bg, "peer-exists %s", add->peer.name);
  else if (!p_create(&add->peer))
    a_bgfail(&add->bg, "peer-create-fail %s", add->peer.name);
  else
    a_bgok(&add->bg);
}
 
/* --- @a_addresolve@ --- *
 *
 * Arguments:	@struct hostent *h@ = pointer to resolved hostname
 *		@void *v@ = pointer to add operation
 *
 * Returns:	---
 *
 * Use:		Handles a completed name resolution.
 */

static void a_addresolve(struct hostent *h, void *v)
{
  admin_addop *add = v;

  a_lock(add->bg.a);
  T( trace(T_ADMIN, "admin: %u resolved", add->bg.a->seq); )
  TIMER;
  if (!h)
    a_bgfail(&add->bg, "resolve-error %s", add->paddr);
  else {
    memcpy(&add->peer.sa.sin.sin_addr, h->h_addr, sizeof(struct in_addr));
    a_doadd(add);
  }
  sel_rmtimer(&add->t);
  a_addfree(add);
  a_bgrelease(&add->bg);
  a_unlock(add->bg.a);
}

/* --- @a_addtimer@ --- *
 *
 * Arguments:	@struct timeval *tv@ = timer
 *		@void *v@ = pointer to add operation
 *
 * Returns:	---
 *
 * Use:		Times out a resolver.
 */

static void a_addtimer(struct timeval *tv, void *v)
{
  admin_addop *add = v;

  a_lock(add->bg.a);
  T( trace(T_ADMIN, "admin: %u resolver timeout", add->bg.a->seq); )
  a_bgfail(&add->bg, "resolver-timeout %s\n", add->paddr);
  bres_abort(&add->r);
  a_addfree(add);
  a_bgrelease(&add->bg);
  a_unlock(add->bg.a);
}

/* --- @acmd_add@ --- *
 *
 * Arguments:	@admin *a@ = connection which requested the addition
 *		@unsigned ac@ = argument count
 *		@char *av[]@ = pointer to the argument list
 *
 * Returns:	---
 *
 * Use:		Adds a new peer.
 */

static void acmd_add(admin *a, unsigned ac, char *av[])
{
  unsigned long pt;
  struct timeval tv;
  unsigned i, j;
  char *p;
  const char *tag = 0;
  admin_addop *add = 0;

  /* --- Make sure someone's not got there already --- */

  if (p_find(av[0])) {
    a_fail(a, "peer-exists %s", av[0]);
    goto fail;
  }

  /* --- Set stuff up --- */

  add = xmalloc(sizeof(*add));
  add->peer.name = xstrdup(av[0]);
  add->peer.t_ka = 0;
  add->peer.tops = tun_default;
  add->paddr = 0;

  /* --- Parse options --- */

  i = 1;
  for (;;) {
    if (!av[i])
      goto bad_syntax;
    if (mystrieq(av[i], "-background")) {
      if (!av[++i]) goto bad_syntax;
      tag = av[i];
    } else if (mystrieq(av[i], "-tunnel")) {
      if (!av[++i]) goto bad_syntax;
      for (j = 0;; j++) {
	if (!tunnels[j]) {
	  a_fail(a, "unknown-tunnel %s", av[i]);
	  return;
	}
	if (mystrieq(av[i], tunnels[j]->name)) {
	  add->peer.tops = tunnels[j];
	  break;
	}
      }
    } else if (mystrieq(av[i], "-keepalive")) {
      long t;
      if (!av[++i]) goto bad_syntax;
      if ((t = a_parsetime(av[i])) < 0) {
	a_fail(a, "bad-time-spec %s", av[i]);
	return;
      }
      add->peer.t_ka = t;
    } else if (mystrieq(av[i], "--")) {
      i++;
      break;
    } else
      break;
    i++;
  }

  /* --- Fill in the easy bits of address --- */

  if (mystrieq(av[i], "inet")) i++;
  if (ac - i != 2) {
    a_fail(a, "bad-syntax -- add PEER [OPTIONS] [inet] ADDRESS PORT");
    goto fail;
  }
  add->peer.sa.sin.sin_family = AF_INET;
  add->peer.sasz = sizeof(add->peer.sa.sin);
  add->paddr = xstrdup(av[i]);
  pt = strtoul(av[i + 1], &p, 0);
  if (*p) {
    struct servent *s = getservbyname(av[i + 1], "udp");
    if (!s) {
      a_fail(a, "unknown-service %s", av[i + 1]);
      goto fail;
    }
    pt = ntohs(s->s_port);
  }
  if (pt == 0 || pt >= 65536) {
    a_fail(a, "invalid-port %lu", pt);
    goto fail;
  }
  add->peer.sa.sin.sin_port = htons(pt);

  /* --- Report backgrounding --- *
   *
   * Do this for consistency of interface, even if we're going to get the
   * answer straight away.
   */

  a_bgadd(a, &add->bg, tag, a_addcancel);

  /* --- If the name is numeric, do it the easy way --- */
  
  if (inet_aton(av[i], &add->peer.sa.sin.sin_addr)) {
    a_doadd(add);
    a_addfree(add);
    a_bgrelease(&add->bg);
    return;
  }

  /* --- Store everything for later and crank up the resolver --- */

  gettimeofday(&tv, 0);
  tv.tv_sec += T_RESOLVE;
  sel_addtimer(&sel, &add->t, &tv, a_addtimer, add);
  bres_byname(&add->r, add->paddr, a_addresolve, add);
  T( trace(T_ADMIN, "admin: %u resolving hostname `%s'",
	   a->seq, add->paddr); )
  return;

bad_syntax:
  a_fail(a, "bad-syntax -- add PEER [OPTIONS] ADDR ...");
fail:
  if (add) {
    a_addfree(add);
    xfree(add);
  }
  return;
}

/*----- Ping --------------------------------------------------------------*/

/* --- @a_pingcancel@ --- *
 *
 * Arguments:	@admin_bgop *bg@ = background operation block
 *
 * Returns:	---
 *
 * Use:		Cancels a running ping.
 */

static void a_pingcancel(admin_bgop *bg)
{
  admin_pingop *pg = (admin_pingop *)bg;
  p_pingdone(&pg->ping, PING_NONOTIFY);
}

/* --- @a_pong@ --- *
 *
 * Arguments:	@int rc@ = return code
 *		@void *v@ = ping operation block
 *
 * Returns:	---
 *
 * Use:		Collects what happened to a ping message.
 */

static void a_pong(int rc, void *v)
{
  admin_pingop *pg = v;
  struct timeval tv;
  double millis;

  a_lock(pg->bg.a);
  switch (rc) {
    case PING_OK:
      gettimeofday(&tv, 0);
      tv_sub(&tv, &tv, &pg->pingtime);
      millis = (double)tv.tv_sec * 1000 + (double)tv.tv_usec/1000;
      a_bginfo(&pg->bg, "ping-ok %.1f", millis);
      a_bgok(&pg->bg);
      break;
    case PING_TIMEOUT:
      a_bginfo(&pg->bg, "ping-timeout");
      a_bgok(&pg->bg);
      break;
    case PING_PEERDIED:
      a_bginfo(&pg->bg, "ping-peer-died");
      a_bgok(&pg->bg);
      break;
    default:
      abort();
  }
  a_bgrelease(&pg->bg);
  a_unlock(pg->bg.a);
}

/* --- @acmd_ping@, @acmd_eping@ --- *
 *
 * Arguments:	@admin *a@ = connection which requested the ping
 *		@unsigned ac@ = argument count
 *		@char *av[]@ = pointer to the argument list
 *
 * Returns:	---
 *
 * Use:		Pings a peer.
 */

static void a_ping(admin *a, unsigned ac, char *av[],
		   const char *cmd, unsigned msg)
{
  long t = T_PING;
  int i;
  peer *p;
  admin_pingop *pg = 0;
  const char *tag = 0;

  i = 0;
  for (;;) {
    if (!av[i])
      goto bad_syntax;
    if (mystrieq(av[i], "-background")) {
      if (!av[++i]) goto bad_syntax;
      tag = av[i];
    } else if (mystrieq(av[i], "-timeout")) {
      if (!av[++i]) goto bad_syntax;
      if ((t = a_parsetime(av[i])) < 0) {
	a_fail(a, "bad-time-spec %s", av[i]);
	return;
      }
    } else if (mystrieq(av[i], "--")) {
      i++;
      break;
    } else
      break;
    i++;
  }

  if (!av[i]) goto bad_syntax;
  if ((p = p_find(av[i])) == 0) {
    a_fail(a, "unknown-peer %s", av[i]);
    return;
  }
  pg = xmalloc(sizeof(*pg));
  gettimeofday(&pg->pingtime, 0);
  a_bgadd(a, &pg->bg, tag, a_pingcancel);
  if (p_pingsend(p, &pg->ping, msg, t, a_pong, pg)) {
    a_bgfail(&pg->bg, "ping-send-failed");
    a_bgrelease(&pg->bg);
  }
  return;
    
bad_syntax:
  a_fail(a, "bad-syntax -- %s [OPTIONS] PEER", cmd);
  return;
}

static void acmd_ping(admin *a, unsigned ac, char *av[])
  { a_ping(a, ac, av, "ping", MISC_PING); }
static void acmd_eping(admin *a, unsigned ac, char *av[])
  { a_ping(a, ac, av, "eping", MISC_EPING); }

/*----- Administration commands -------------------------------------------*/

/* --- Miscellaneous commands --- */

/* --- @traceish@ --- *
 *
 * Arguments:	@admin *a@ = connection to complain on
 *		@unsigned ac@ = number of arguments
 *		@char *av[]@ = vector of arguments
 *		@const char *what@ = what we're messing with
 *		@const trace_opt *tt@ = options table
 *		@unsigned *ff@ = where the flags are
 *
 * Returns:	Nonzero if anything changed.
 *
 * Use:		Guts of trace-ish commands like `trace' and `watch'.
 */

static int traceish(admin *a, unsigned ac, char *av[],
		    const char *what, const trace_opt *tt, unsigned *ff)
{
  int ch = 0;

  if (!ac || strcmp(av[0], "?") == 0) {
    const trace_opt *t;
    a_info(a, "Current %s status:", what);
    for (t = tt; t->ch; t++) {
      a_info(a, "%c %c  %s",
	     t->ch, (*ff & t->f) == t->f ? '*' : ' ', t->help);
    }
  } else {
    unsigned sense = 1;
    unsigned f = *ff;
    const trace_opt *t;
    char *p = av[0];

    while (*p) {
      switch (*p) {
	case '+': sense = 1; break;
	case '-': sense = 0; break;
	default:
	  for (t = tt; t->ch; t++) {
	    if (t->ch == *p) {
	      if (sense) f |= t->f;
	      else f &= ~t->f;
	      goto tropt_ok;
	    }
	  }
	  a_fail(a, "bad-%s-option %c", what, *p);
	  return (0);
        tropt_ok:;
	  break;
      }
      p++;
    }
    *ff = f;
    ch = 1;
  }
  a_ok(a);
  return (ch);
}

#ifndef NTRACE

static void acmd_trace(admin *a, unsigned ac, char *av[])
{
  if (traceish(a, ac, av, "trace", tr_opts, &tr_flags))
    trace_level(tr_flags);
}

#endif

static void acmd_watch(admin *a, unsigned ac, char *av[])
{
  traceish(a, ac, av, "watch", w_opts, &a->f);
}

static void quotify(dstr *d, const char *p)
{
  if (d->len)
    dstr_putc(d, ' ');
  if (*p && !p[strcspn(p, "\"' \t\n\v")])
    dstr_puts(d, p);
  else {
    dstr_putc(d, '\"');
    while (*p) {
      if (*p == '\\' || *p == '\"')
	dstr_putc(d, '\\');
      dstr_putc(d, *p++);
    }
    dstr_putc(d, '\"');
  }
}

static void alertcmd(admin *a, unsigned f_and, unsigned f_eq,
		     const char *tag, unsigned ac, char *av[])
{
  dstr d = DSTR_INIT;
  unsigned i;

  dstr_puts(&d, "USER");
  for (i = 0; i < ac; i++)
    quotify(&d, av[i]);
  dstr_putz(&d);
  a_rawalert(f_and, f_eq, tag, d.buf, d.len);
  dstr_destroy(&d);
  a_ok(a);
}

static void acmd_notify(admin *a, unsigned ac, char *av[])
  { alertcmd(a, AF_NOTE, AF_NOTE, "NOTE", ac, av); }
static void acmd_warn(admin *a, unsigned ac, char *av[])
  { alertcmd(a, AF_WARN, AF_WARN, "WARN", ac, av); }

static void acmd_port(admin *a, unsigned ac, char *av[])
{
  a_info(a, "%u", p_port());
  a_ok(a);
}

static void acmd_daemon(admin *a, unsigned ac, char *av[])
{
  if (flags & F_DAEMON)
    a_fail(a, "already-daemon");
  else {
    a_notify("DAEMON");
    if (a_stdin)
      a_destroy(a_stdin);
    if (u_daemon())
      a_fail(a, "daemon-error -- %s", strerror(errno));
    else {
      flags |= F_DAEMON;
      a_ok(a);
    }
  }
}

static void acmd_list(admin *a, unsigned ac, char *av[])
{
  peer *p;
  for (p = p_first(); p; p = p_next(p))
    a_info(a, "%s", p_name(p));
  a_ok(a);
}

static void acmd_ifname(admin *a, unsigned ac, char *av[])
{
  peer *p;

  if ((p = p_find(av[0])) == 0)
    a_fail(a, "unknown-peer %s", av[0]);
  else {
    a_info(a, "%s", p_ifname(p));
    a_ok(a);
  }
}

static void acmd_addr(admin *a, unsigned ac, char *av[])
{
  peer *p;
  const addr *ad;

  if ((p = p_find(av[0])) == 0)
    a_fail(a, "unknown-peer %s", av[0]);
  else {
    ad = p_addr(p);
    assert(ad->sa.sa_family == AF_INET);
    a_info(a, "INET %s %u",
	    inet_ntoa(ad->sin.sin_addr),
	    (unsigned)ntohs(ad->sin.sin_port));
    a_ok(a);
  }
}

static void acmd_stats(admin *a, unsigned ac, char *av[])
{
  peer *p;
  stats *st;

  if ((p = p_find(av[0])) == 0)
    a_fail(a, "unknown-peer %s", av[0]);
  else {
    st = p_stats(p);
    a_info(a, "start-time=%s", timestr(st->t_start));
    a_info(a, "last-packet-time=%s", timestr(st->t_last));
    a_info(a, "last-keyexch-time=%s", timestr(st->t_kx));
    a_info(a, "packets-in=%lu bytes-in=%lu", st->n_in, st->sz_in);
    a_info(a, "packets-out=%lu bytes-out=%lu",
	    st->n_out, st->sz_out);
    a_info(a, "keyexch-packets-in=%lu keyexch-bytes-in=%lu",
	    st->n_kxin, st->sz_kxin);
    a_info(a, "keyexch-packets-out=%lu keyexch-bytes-out=%lu",
	    st->n_kxout, st->sz_kxout);
    a_info(a, "ip-packets-in=%lu ip-bytes-in=%lu",
	    st->n_ipin, st->sz_ipin);
    a_info(a, "ip-packets-out=%lu ip-bytes-out=%lu",
	    st->n_ipout, st->sz_ipout);
    a_info(a, "rejected-packets=%lu", st->n_reject);
    a_ok(a);
  }
}

static void acmd_kill(admin *a, unsigned ac, char *av[])
{
  peer *p;
  if ((p = p_find(av[0])) == 0)
    a_fail(a, "unknown-peer %s", av[0]);
  else {
    p_destroy(p);
    a_ok(a);
  }
}

static void acmd_forcekx(admin *a, unsigned ac, char *av[])
{
  peer *p;
  if ((p = p_find(av[0])) == 0)
    a_fail(a, "unknown-peer %s", av[0]);
  else {
    kx_start(&p->kx, 1);
    a_ok(a);
  }
}

static void acmd_reload(admin *a, unsigned ac, char *av[])
  { p_keyreload(); a_ok(a); }

static void acmd_quit(admin *a, unsigned ac, char *av[])
{
  a_warn("SERVER quit admin-request");
  a_ok(a);
  a_unlock(a);
  a_quit();
}

static void acmd_version(admin *a, unsigned ac, char *av[])
{
  a_info(a, "%s %s", PACKAGE, VERSION);
  a_ok(a);
}

static void acmd_tunnels(admin *a, unsigned ac, char *av[])
{
  int i;
  for (i = 0; tunnels[i]; i++)
    a_info(a, "%s", tunnels[i]->name);
  a_ok(a);
}

/* --- The command table and help --- */

typedef struct acmd {
  const char *name;
  const char *help;
  unsigned argmin, argmax;
  void (*func)(admin */*a*/, unsigned /*ac*/, char */*av*/[]);
} acmd;

static void acmd_help(admin */*a*/, unsigned /*ac*/, char */*av*/[]);

static const acmd acmdtab[] = {
  { "add",	"add PEER [OPTIONS] ADDR ...",
					2,	0xffff,	acmd_add },
  { "addr",	"addr PEER",		1,	1,	acmd_addr },
  { "daemon",	"daemon",		0,	0,	acmd_daemon },
  { "eping",	"eping [OPTIONS] PEER",	1,	0xffff,	acmd_eping },
  { "forcekx",	"forcekx PEER",		1,	1,	acmd_forcekx },
  { "help",	"help",			0,	0,	acmd_help },
  { "ifname",	"ifname PEER",		1,	1,	acmd_ifname },
  { "kill",	"kill PEER",		1,	1,	acmd_kill },
  { "list",	"list",			0,	0,	acmd_list },
  { "notify",	"notify MESSAGE ...",	1,	0xffff,	acmd_notify },
  { "ping",	"ping [OPTIONS] PEER",	1,	0xffff,	acmd_ping },
  { "port",	"port",			0,	0,	acmd_port },
  { "quit",	"quit",			0,	0,	acmd_quit },
  { "reload",	"reload",		0,	0,	acmd_reload },
  { "stats",	"stats PEER",		1,	1,	acmd_stats },
#ifndef NTRACE
  { "trace",	"trace [OPTIONS]",	0,	1,	acmd_trace },
#endif
  { "tunnels",	"tunnels",		0,	0,	acmd_tunnels },
  { "version",	"version",		0,	0,	acmd_version },
  { "warn",	"warn MESSAGE ...",	1,	0xffff,	acmd_warn },
  { "watch",	"watch [OPTIONS]", 	0,	1,	acmd_watch },
  { 0,		0,			0,	0,	0 }
};

static void acmd_help(admin *a, unsigned ac, char *av[])
{
  const acmd *c;
  for (c = acmdtab; c->name; c++)
    a_info(a, "%s", c->help);
  a_ok(a);
}

/*----- Connection handling -----------------------------------------------*/

/* --- @a_lock@ --- *
 *
 * Arguments:	@admin *a@ = pointer to an admin block
 *
 * Returns:	---
 *
 * Use:		Locks an admin block so that it won't be destroyed
 *		immediately.
 */

static void a_lock(admin *a) { assert(!(a->f & AF_LOCK)); a->f |= AF_LOCK; }

/* --- @a_unlock@ --- *
 *
 * Arguments:	@admin *a@ = pointer to an admin block
 *
 * Returns:	---
 *
 * Use:		Unlocks an admin block, allowing its destruction.  This is
 *		also the second half of @a_destroy@.
 */

static void a_unlock(admin *a)
{
  admin_bgop *bg, *bbg;
  
  assert(a->f & AF_LOCK);

  /* --- If we're not dead, that's fine --- */

  if (!(a->f & AF_DEAD)) {
    a->f &= ~AF_LOCK;
    return;
  }

  /* --- If we are, then destroy the rest of the block --- */

  T( trace(T_ADMIN, "admin: completing destruction of connection %u",
	   a->seq); )

  selbuf_destroy(&a->b);
  for (bg = a->bg; bg; bg = bbg) {
    bbg = bg->next;
    bg->cancel(bg);
    if (bg->tag) xfree(bg->tag);
    xfree(bg);
  }
  if (a->b.reader.fd != a->w.fd) close(a->b.reader.fd);
  close(a->w.fd);

  if (a_stdin == a)
    a_stdin = 0;
  if (a->next)
    a->next->prev = a->prev;
  if (a->prev)
    a->prev->next = a->next;
  else
    admins = a->next;
  DESTROY(a);
}

/* --- @a_destroy@ --- *
 *
 * Arguments:	@admin *a@ = pointer to an admin block
 *
 * Returns:	---
 *
 * Use:		Destroys an admin block.  This requires a certain amount of
 *		care.
 */

static void freequeue(oqueue *q)
{
  obuf *o, *oo;

  for (o = q->hd; o; o = oo) {
    oo = o->next;
    xfree(o);
  }
  q->hd = q->tl = 0;
}

static void a_destroy(admin *a)
{
  /* --- Don't multiply destroy admin blocks --- */

  if (a->f & AF_DEAD)
    return;

  /* --- Make sure nobody expects it to work --- */

  a->f |= AF_DEAD;
  T( trace(T_ADMIN, "admin: destroying connection %u", a->seq); )

  /* --- Free the output buffers --- */

  if (a->out.hd)
    sel_rmfile(&a->w);
  freequeue(&a->out);

  /* --- If the block is locked, that's all we can manage --- */

  if (a->f & AF_LOCK) {
    T( trace(T_ADMIN, "admin: deferring destruction..."); )
    return;
  }
  a->f |= AF_LOCK;
  a_unlock(a);
}

/* --- @a_line@ --- *
 *
 * Arguments:	@char *p@ = pointer to the line read
 *		@size_t len@ = length of the line
 *		@void *vp@ = pointer to my admin block
 *
 * Returns:	---
 *
 * Use:		Handles a line of input.
 */

static void a_line(char *p, size_t len, void *vp)
{
  admin *a = vp;
  const acmd *c;
  char *av[16];
  size_t ac;

  TIMER;
  if (a->f & AF_DEAD)
    return;
  if (!p) {
    if (!a->bg)
      a_destroy(a);
    else {
      a->f |= AF_CLOSE;
      selbuf_disable(&a->b);
    }
    return;
  }
  ac = str_qsplit(p, av, 16, 0, STRF_QUOTE);
  if (!ac)
    return;
  for (c = acmdtab; c->name; c++) {
    if (mystrieq(av[0], c->name)) {
      ac--;
      if (c->argmin > ac || ac > c->argmax)
	a_fail(a, "bad-syntax -- %s", c->help);
      else {
	a_lock(a);
	c->func(a, ac, av + 1);
	a_unlock(a);
      }
      return;
    }
  }
  a_fail(a, "unknown-command %s", av[0]);
}

/* --- @a_create@ --- *
 *
 * Arguments:	@int fd_in, fd_out@ = file descriptors to use
 *		@unsigned f@ = initial flags to set
 *
 * Returns:	---
 *
 * Use:		Creates a new admin connection.
 */

void a_create(int fd_in, int fd_out, unsigned f)
{
  admin *a = CREATE(admin);

  T( static unsigned seq = 0;
     a->seq = seq++; )
  T( trace(T_ADMIN, "admin: accepted connection %u", a->seq); )
  a->bg = 0;
  a->f = f;
  if (fd_in == STDIN_FILENO) a_stdin = a;
  fdflags(fd_in, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
  if (fd_out != fd_in)
    fdflags(fd_out, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
  selbuf_init(&a->b, &sel, fd_in, a_line, a);
  sel_initfile(&sel, &a->w, fd_out, SEL_WRITE, a_flush, a);
  a->out.hd = a->out.tl = 0;
  a->next = admins;
  a->prev = 0;
  if (admins) admins->prev = a;
  admins = a;
}

/* --- @a_accept@ --- *
 *
 * Arguments:	@int fd@ = file descriptor to accept
 *		@unsigned mode@ = what to do
 *		@void *v@ = uninteresting pointer
 *
 * Returns:	---
 *
 * Use:		Accepts a new admin connection.
 */

static void a_accept(int fd, unsigned mode, void *v)
{
  int nfd;
  struct sockaddr_un sun;
  size_t sz = sizeof(sun);

  if ((nfd = accept(fd, (struct sockaddr *)&sun, &sz)) < 0) {
    if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK &&
	errno != ECONNABORTED && errno != EPROTO)
      a_warn("ADMIN accept-error -- %s", strerror(errno));
    return;
  }
  a_create(nfd, nfd, 0);
}

/* --- @a_daemon@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Informs the admin module that it's a daemon.
 */

void a_daemon(void)
{
  flags |= F_DAEMON;
}

/* --- @a_init@ --- *
 *
 * Arguments:	@const char *name@ = socket name to create
 *
 * Returns:	---
 *
 * Use:		Creates the admin listening socket.
 */

void a_init(const char *name)
{
  int fd;
  int n = 5;
  struct sockaddr_un sun;
  struct sigaction sa;
  size_t sz;

  /* --- Set up the socket address --- */

  sz = strlen(name) + 1;
  if (sz > sizeof(sun.sun_path))
    die(EXIT_FAILURE, "socket name `%s' too long", name);
  BURN(sun);
  sun.sun_family = AF_UNIX;
  memcpy(sun.sun_path, name, sz);
  sz += offsetof(struct sockaddr_un, sun_path);

  /* --- Attempt to bind to the socket --- */

  umask(0077);
again:
  if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
    die(EXIT_FAILURE, "couldn't create socket: %s", strerror(errno));
  if (bind(fd, (struct sockaddr *)&sun, sz) < 0) {
    struct stat st;
    int e = errno;
    if (errno != EADDRINUSE) {
      die(EXIT_FAILURE, "couldn't bind to address `%s': %s",
	  sun.sun_path, strerror(e));
    }
    if (!n)
      die(EXIT_FAILURE, "too many retries; giving up");
    n--;
    if (!connect(fd, (struct sockaddr *)&sun, sz)) {
      die(EXIT_FAILURE, "server already listening on admin socket `%s'",
	  sun.sun_path);
    }
    if (errno != ECONNREFUSED)
      die(EXIT_FAILURE, "couldn't bind to address: %s", strerror(e));
    if (stat(sun.sun_path, &st)) {
      die(EXIT_FAILURE, "couldn't stat `%s': %s",
	  sun.sun_path, strerror(errno));
    }
    if (!S_ISSOCK(st.st_mode))
      die(EXIT_FAILURE, "object `%s' isn't a socket", sun.sun_path);
    T( trace(T_ADMIN, "admin: stale socket found; removing it"); )
    unlink(sun.sun_path);
    close(fd);
    goto again;
  }
  chmod(sun.sun_path, 0600);
  fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
  if (listen(fd, 5))
    die(EXIT_FAILURE, "couldn't listen on socket: %s", strerror(errno));

  /* --- Listen to the socket --- */

  sel_initfile(&sel, &sock, fd, SEL_READ, a_accept, 0);
  sel_addfile(&sock);
  sockname = name;
  bres_init(&sel);
  T( trace_custom(a_trace, 0);
     trace(T_ADMIN, "admin: enabled custom tracing"); )
  flags |= F_INIT;

  /* --- Set up signal handlers --- */

  sig_add(&s_term, SIGTERM, a_sigdie, 0);
  sig_add(&s_hup, SIGHUP, a_sighup, 0);
  signal(SIGPIPE, SIG_IGN);
  sigaction(SIGINT, 0, &sa);
  if (sa.sa_handler != SIG_IGN)
    sig_add(&s_int, SIGINT, a_sigdie, 0);
}

/*----- That's all, folks -------------------------------------------------*/