Make file descriptors be nonblocking and close-on-exec.

[tripe] / admin.c

/* -*-c-*-
 *
 * $Id: admin.c,v 1.3 2001/02/04 01:17:12 mdw Exp $
 *
 * 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.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: admin.c,v $
 * Revision 1.3  2001/02/04 01:17:12  mdw
 * The `DAEMON' notification to stdout is replaced by a warning.  The
 * `DAEMON' and `QUIT' command send `OK' on successful completion.  Put
 * assignment of sequence number in a T(...) guard.
 *
 * Revision 1.2  2001/02/03 22:40:29  mdw
 * Put timer information into the entropy pool when packets are received
 * and on similar events.  Reseed the generator on the interval timer.
 *
 * Revision 1.1  2001/02/03 20:26:37  mdw
 * Initial checkin.
 *
 */

/*----- 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 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)

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

/* --- @a_write@ --- *
 *
 * Arguments:	@admin *a@ = admin connection to write to
 *		@const char *fmt@ = pointer to format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Sends a message to an admin connection.
 */

static void a_write(admin *a, const char *fmt, ...)
{
  va_list ap;
  dstr d = DSTR_INIT;
  va_start(ap, fmt);
  dstr_vputf(&d, fmt, ap);
  va_end(ap);
  write(a->fd, d.buf, d.len);
  dstr_destroy(&d);
}

/* --- @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;
  admin *a;
  dstr d = DSTR_INIT;

  if (flags & F_INIT)
    dstr_puts(&d, "WARN ");
  va_start(ap, fmt);
  dstr_vputf(&d, fmt, ap);
  va_end(ap);
  if (!(flags & F_INIT))
    moan("%s", d.buf);
  else {
    dstr_putc(&d, '\n');
    for (a = admins; a; a = a->next)
      write(a->fd, d.buf, d.len);
  }
  dstr_destroy(&d);
}

/* --- @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.
 */

#ifndef NTRACE
static void a_trace(const char *p, size_t sz, void *v)
{
  dstr d = DSTR_INIT;
  admin *a;

  dstr_puts(&d, "TRACE ");
  dstr_putm(&d, p, sz);
  dstr_putc(&d, '\n');
  for (a = admins; a; a = a->next)
    write(a->fd, d.buf, d.len);
  dstr_destroy(&d);  
}
#endif

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

void a_quit(void)
{
  close(sock.fd);
  unlink(sockname);
  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, "signal %i", sig);
      p = buf;
      break;
  }
  a_warn("shutting down on %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("received SIGHUP: ignoring");
}

/*----- Adding peers ------------------------------------------------------*/
 
/* --- @a_resolve@ --- *
 *
 * Arguments:	@struct hostent *h@ = pointer to resolved hostname
 *		@void *v@ = pointer to admin block
 *
 * Returns:	---
 *
 * Use:		Handles a completed name resolution.
 */

static void a_resolve(struct hostent *h, void *v)
{
  admin *a = v;
  T( trace(T_ADMIN, "admin: %u resolved", a->seq); )
  TIMER;
  sel_rmtimer(&a->t);
  if (!h)
    a_write(a, "ERR couldn't resolve hostname `%s'\n", a->paddr);
  else if (p_find(a->pname))
    a_write(a, "ERR peer `%s' already registered\n", a->pname);
  else {
    memcpy(&a->peer.sin.sin_addr, h->h_addr, sizeof(struct in_addr));
    if (!p_create(a->pname, &a->peer.sa, a->sasz))
      a_write(a, "ERR couldn't create peer\n");
    else
      a_write(a, "OK\n");
  }
  xfree(a->pname);
  xfree(a->paddr);
  a->pname = 0;
  selbuf_enable(&a->b);
}

/* --- @a_timer@ --- *
 *
 * Arguments:	@struct timeval *tv@ = timer
 *		@void *v@ = pointer to admin block
 *
 * Returns:	---
 *
 * Use:		Times out a resolver.
 */

static void a_timer(struct timeval *tv, void *v)
{
  admin *a = v;
  T( trace(T_ADMIN, "admin: %u resolver timeout", a->seq); )
  bres_abort(&a->r);
  a_write(a, "ERR timeout resolving `%s'\n", a->paddr);
  xfree(a->pname);
  xfree(a->paddr);
  a->pname = 0;
  selbuf_enable(&a->b);
}

/* --- @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;
  char *p;

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

  if (p_find(av[0])) {
    a_write(a, "ERR peer `%s' already registered\n", av[0]);
    return;
  }

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

  BURN(a->peer);
  a->peer.sin.sin_family = AF_INET;
  a->sasz = sizeof(a->peer.sin);
  pt = strtoul(av[2], &p, 0);
  if (*p) {
    struct servent *s = getservbyname(av[2], "udp");
    if (!s) {
      a_write(a, "ERR service `%s' not known\n", av[2]);
      return;
    }
    pt = ntohs(s->s_port);
  }
  if (pt == 0 || pt >= 65536) {
    a_write(a, "ERR bad port number %lu\n", pt);
    return;
  }
  a->peer.sin.sin_port = htons(pt);

  /* --- If the name is numeric, do it the easy way --- */
  
  if (inet_aton(av[1], &a->peer.sin.sin_addr)) {
    if (!p_create(av[0], &a->peer.sa, a->sasz))
      a_write(a, "ERR couldn't create peer\n");
    else
      a_write(a, "OK\n");
    return;
  }

  /* --- Store everything for later and crank up the resolver --- *
   *
   * We disable the line buffer until the resolver completes (or times out).
   * This prevents other commands on the same connection (though the rest of
   * the system continues regardless), but makes life simpler for the client.
   */

  a->pname = xstrdup(av[0]);
  a->paddr = xstrdup(av[1]);
  selbuf_disable(&a->b);
  gettimeofday(&tv, 0);
  tv.tv_sec += T_RESOLVE;
  sel_addtimer(&sel, &a->t, &tv, a_timer, a);
  bres_byname(&a->r, a->paddr, a_resolve, a);
  T( trace(T_ADMIN, "admin: %u resolving hostname `%s'",
	   a->seq, a->paddr); )
}

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

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

#ifndef NTRACE

static void acmd_trace(admin *a, unsigned ac, char *av[])
{
  if (!ac || strcmp(av[0], "?") == 0) {
    const trace_opt *t;
    a_write(a, "INFO Trace options:\n");
    for (t = tr_opts; t->ch; t++) {
      a_write(a, "INFO %c %c  %s\n",
	      t->ch, (tr_flags & t->f) == t->f ? '*' : ' ', t->help);
    }
  } else {
    unsigned sense = 1;
    unsigned f = tr_flags;
    const trace_opt *tt;
    char *p = av[0];

    while (*p) {
      switch (*p) {
	case '+': sense = 1; break;
	case '-': sense = 0; break;
	default:
	  for (tt = tr_opts; tt->ch; tt++) {
	    if (tt->ch == *p) {
	      if (sense) f |= tt->f;
	      else f &= ~tt->f;
	      goto tropt_ok;
	    }
	  }
	  a_write(a, "ERR unknown trace option `%c'\n", *p);
	  return;
        tropt_ok:;
	  break;
      }
      p++;
    }
    tr_flags = f;
    trace_level(tr_flags);
  }
  a_write(a, "OK\n");
}

#endif

static void acmd_port(admin *a, unsigned ac, char *av[])
{
  a_write(a, "INFO %u\nOK\n", p_port());
}

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

static void acmd_daemon(admin *a, unsigned ac, char *av[])
{
  if (flags & F_DAEMON)
    a_write(a, "ERR already running as a daemon\n");
  else {
    a_warn("becoming a daemon");
    if (a_stdin)
      a_destroy(a_stdin);
    if (u_daemon())
      a_write(a, "ERR error becoming a daemon: %s", strerror(errno));
    else {
      flags |= F_DAEMON;
      a_write(a, "OK\n");
    }
  }
}

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

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

  if ((p = p_find(av[0])) == 0)
    a_write(a, "ERR peer `%s' not found\n", av[0]);
  else
    a_write(a, "INFO %s\nOK\n", p_ifname(p));
}

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

  if ((p = p_find(av[0])) == 0)
    a_write(a, "ERR peer `%s' not found\n", av[0]);
  else {
    ad = p_addr(p);
    assert(ad->sa.sa_family == AF_INET);
    a_write(a, "INFO %s %u\nOK\n",
	    inet_ntoa(ad->sin.sin_addr),
	    (unsigned)ntohs(ad->sin.sin_port));
  }
}

static void acmd_kill(admin *a, unsigned ac, char *av[])
{
  peer *p;
  if ((p = p_find(av[0])) == 0)
    a_write(a, "ERR peer `%s' not found\n", av[0]);
  else {
    p_destroy(p);
    a_write(a, "OK\n");
  }
}

static void acmd_quit(admin *a, unsigned ac, char *av[])
{
  a_warn("closing down on admin request");
  a_write(a, "OK\n");
  a_quit();
}

/* --- 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[] = {
  { "help",	"HELP",			0,	0,	acmd_help },
#ifndef NTRACE
  { "trace",	"TRACE [options]",	0,	1,	acmd_trace },
#endif
  { "port",	"PORT",			0,	0,	acmd_port },
  { "daemon",	"DAEMON",		0,	0,	acmd_daemon },
  { "list",	"LIST",			0,	0,	acmd_list },
  { "ifname",	"IFNAME peer",		1,	1,	acmd_ifname },
  { "addr",	"ADDR peer",		1,	1,	acmd_addr },
  { "kill",	"KILL peer",		1,	1,	acmd_kill },
  { "add",	"ADD peer addr port",	3,	3,	acmd_add },
  { "quit",	"QUIT",			0,	0,	acmd_quit },
  { 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_write(a, "INFO %s\n", c->help);
  a_write(a, "OK\n");
}

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

/* --- @a_destroy@ --- *
 *
 * Arguments:	@admin *a@ = pointer to an admin block
 *
 * Returns:	---
 *
 * Use:		Destroys an admin block.
 */

static void a_destroy(admin *a)
{
  T( trace(T_ADMIN, "admin: destroying connection %u", a->seq); )
  selbuf_destroy(&a->b);
  if (a->b.reader.fd != a->fd)
    close(a->b.reader.fd);
  close(a->fd);
  if (a->pname) {
    xfree(a->pname);
    xfree(a->paddr);
    bres_abort(&a->r);
    sel_rmtimer(&a->t);
  }
  if (a->next)
    a->next->prev = a->prev;
  if (a->prev)
    a->prev->next = a->next;
  else
    admins = a->next;
  if (a_stdin == a)
    a_stdin = 0;
  DESTROY(a);
}

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

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

  TIMER;
  if (!p) {
    a_destroy(a);
    return;
  }
  ac = str_qsplit(p, av, 4, 0, STRF_QUOTE);
  if (!ac)
    return;
  for (p = av[0]; *p; p++) *p = tolower((unsigned char)*p);
  for (c = acmdtab; c->name; c++) {
    if (strcmp(av[0], c->name) == 0) {
      ac--;
      if (c->argmin > ac || ac > c->argmax)
	a_write(a, "ERR syntax: %s\n", c->help);
      else
	c->func(a, ac, av + 1);
      return;
    }
  }
  a_write(a, "ERR unknown command `%s'\n", av[0]);
}

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

void a_create(int fd_in, int fd_out)
{
  admin *a = CREATE(admin);
  T( static unsigned seq = 0;
     a->seq = seq++; )
  T( trace(T_ADMIN, "admin: accepted connection %u", a->seq); )
  a->pname = 0;
  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);
  a->fd = fd_out;
  selbuf_init(&a->b, &sel, fd_in, a_line, a);
  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) {
    a_warn("accept admin connection failed: %s", strerror(errno));
    return;
  }
  a_create(nfd, nfd);
}

/* --- @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, "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);
  sigaction(SIGINT, 0, &sa);
  if (sa.sa_handler != SIG_IGN)
    sig_add(&s_int, SIGINT, a_sigdie, 0);
}

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