Upgrade licence to GPLv3+.

[tripe] / uslip / uslip.c

/* -*-c-*-
 *
 * A simple SLIP implementation drivable from the command-line
 *
 * (c) 2008 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 3 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, see <https://www.gnu.org/licenses/>.
 */

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

#include "config.h"

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include <mLib/alloc.h>
#include <mLib/bits.h>
#include <mLib/conn.h>
#include <mLib/dstr.h>
#include <mLib/fdflags.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sel.h>
#include <mLib/sig.h>
#include <mLib/sub.h>
#include <mLib/tv.h>

#include "slip.h"

#undef sun

/*----- Data structures ---------------------------------------------------*/

typedef struct pkq_node {
  struct pkq_node *next;
  unsigned char *buf;
  size_t n, sz;
} pkq_node;

typedef struct pkq {
  pkq_node *head, **tail;
} pkq;

enum { START, OK, ESC, BAD, SYNC1, SYNC2 };

typedef struct client {
  sel_file f;
  dstr d;
  int mode;
} client;

typedef struct gobbler {
  sel_file f;
  void (*done)(struct gobbler *, int, void *);
  void *p;
} gobbler;

typedef struct dribbler {
  sel_file f;
  pkq q;
  void (*done)(struct dribbler *, int, void *);
  void *p;
} dribbler;

typedef struct waiter {
  struct waiter *next;
  int fd;
  gobbler *g;
} waiter;

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

static pkq q_in;
static dribbler *dribble_out;
static dstr slipbuf = DSTR_INIT;
static int slipstate = SYNC1;
static sel_file slip_in, listener;
static sel_state sel;
static unsigned reasons;
static waiter *wait_head, **wait_tail = &wait_head;
static unsigned char buf[16384];
static const char *name;

/*----- Utilities ---------------------------------------------------------*/

static void socketaddr(struct sockaddr_un *sun, size_t *sz)
{
  size_t n = strlen(name) + 1;
  if (n + offsetof(struct sockaddr_un, sun_path) > sizeof(*sun))
    die(EXIT_FAILURE, "name too long: `%s'", name);
  sun->sun_family = AF_UNIX;
  memcpy(sun->sun_path, name, n);
  if (sz)
    *sz = n + offsetof(struct sockaddr_un, sun_path);
}

/*------ Packet queue -----------------------------------------------------*
 *
 * A packet queue contains a sequence of octet strings.  Packets can be added
 * to the end and read off the front.
 */

static void initqueue(pkq *q) { q->head = 0; q->tail = &q->head; }

static pkq_node *make_pkqnode(const void *p, size_t n)
{
  pkq_node *pn;

  if (!n) return (0);
  pn = CREATE(pkq_node);
  pn->next = 0;
  pn->buf = xmalloc(n);
  if (p) memcpy(pn->buf, p, n);
  pn->sz = n;
  pn->n = 0;
  return (pn);
}

static int enqueue(pkq *q, pkq_node *pn)
{
  int rc = 0;

  if (!pn) return (0);
  rc = !q->head;
  pn->next = 0;
  *q->tail = pn;
  q->tail = &pn->next;
  return (rc);
}

static void destroy_pkqnode(pkq_node *pn) { xfree(pn->buf); DESTROY(pn); }

static int dequeue(pkq *q, int freep)
{
  pkq_node *pn = q->head;
  assert(pn);
  q->head = pn->next;
  if (freep)
    destroy_pkqnode(pn);
  if (!q->head) {
    q->tail = &q->head;
    return (1);
  }
  return (0);
}

static void destroy_pkq(pkq *q)
{
  pkq_node *pn, *pnn;

  for (pn = q->head; pn; pn = pnn) {
    pnn = pn->next;
    destroy_pkqnode(pn);
  }
  q->head = 0; q->tail = &q->head;
}

/*----- Gobblers ----------------------------------------------------------*
 *
 * A gobbler just eats everything it sees on its input descriptor.
 * Eventually, when it sees end-of-file, it closes the input descriptor,
 * calls a user-supplied calback function, and quits.
 */

static void close_gobbler(gobbler *g)
  { if (g->f.fd != -1) { sel_rmfile(&g->f); close(g->f.fd); g->f.fd = -1; } }

static void destroy_gobbler(gobbler *g) { close_gobbler(g); DESTROY(g); }

static void do_gobble_in(int fd, unsigned mode, void *p)
{
  gobbler *g = p;
  ssize_t n;

  for (;;) {
    n = read(fd, buf, sizeof(buf));
    if (n < 0) {
      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
	break;
      else {
	moan("read (gobble): %s", strerror(errno));
	if (g->done) g->done(g, errno, g->p);
	close_gobbler(g);
	break;
      }
    } else if (n == 0) {
      if (g->done) g->done(g, 0, g->p);
      close_gobbler(g);
      break;
    }
  }
}

static gobbler *make_gobbler(int fd,
			     void (*done)(gobbler *, int, void *),
			     void *p)
{
  gobbler *g;

  g = CREATE(gobbler);
  g->done = done;
  g->p = p;
  sel_initfile(&sel, &g->f, fd, SEL_READ, do_gobble_in, g);
  sel_addfile(&g->f);
  do_gobble_in(fd, SEL_READ, g);
  return (g);
}

/*----- Dribbler ----------------------------------------------------------*
 *
 * A dribbler hands out data from a packet queue to a file descriptor.  It
 * makes no attempt to preserve the record boundaries inherent in the packet
 * queue structure.  If the dribbler reaches the end of its queue, it invokes
 * a user-supplied `done' function and stops selecting its output descriptor
 * for writing.
 */

static void cripple_dribbler(dribbler *d) { close(d->f.fd); d->f.fd = -1; }

static void destroy_dribbler(dribbler *d)
  { cripple_dribbler(d); DESTROY(d); }

static void dribble_done(dribbler *d, int err)
{
  if (d->q.head) {
    sel_rmfile(&d->f);
    destroy_pkq(&d->q);
  }
  d->done(d, err, d->p);
}

static void do_dribble_out(int fd, unsigned mode, void *p)
{
  dribbler *d = p;
  ssize_t n;
  pkq_node *pn;

  for (;;) {
    pn = d->q.head;
    n = write(fd, pn->buf + pn->n, pn->sz - pn->n);
    if (n < 0) {
      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
	break;
      else {
	dribble_done(d, errno);
	break;
      }
    }
    pn->n += n;
    if (pn->n == pn->sz && dequeue(&d->q, 1)) {
      sel_rmfile(&d->f);
      dribble_done(d, 0);
      break;
    }
  }
}

static int enqueue_dribble(dribbler *d, pkq_node *pn)
{
  if (d->f.fd == -1) {
    destroy_pkqnode(pn);
    return (0);
  }
  if (enqueue(&d->q, pn)) {
    sel_addfile(&d->f);
    do_dribble_out(d->f.fd, SEL_WRITE, d);
    return (1);
  }
  return (0);
}

static dribbler *make_dribbler(int fd,
			       void (*done)(dribbler *, int, void *),
			       void *p)
{
  dribbler *d = CREATE(dribbler);
  sel_initfile(&sel, &d->f, fd, SEL_WRITE, do_dribble_out, d);
  initqueue(&d->q);
  d->done = done;
  d->p = p;
  return (d);
}

/*----- Clients -----------------------------------------------------------*/

static void done_client_dribble(dribbler *d, int err, void *p)
{
  if (err)
    moan("write (client): %s", strerror(err));
  destroy_gobbler(p);
  destroy_dribbler(d);
  reasons--;
}

static void dequeue_to_waiter(void)
{
  waiter *w;
  dribbler *d;
  pkq_node *pn;

  while (q_in.head && wait_head) {
    w = wait_head;
    wait_head = w->next;
    if (!wait_head)
      wait_tail = &wait_head;
    d = make_dribbler(w->fd, done_client_dribble, w->g);
    DESTROY(w);
    pn = q_in.head;
    if (dequeue(&q_in, 0))
      reasons--;
    enqueue_dribble(d, pn);
  }
}

static void destroy_client(client *c)
{
  sel_rmfile(&c->f);
  close(c->f.fd);
  dstr_destroy(&c->d);
  reasons--;
  DESTROY(c);
}

static void do_client_in(int fd, unsigned mode, void *p)
{
  client *c = p;
  ssize_t n, i, i0;
  waiter *w;

  /* --- Attention --- *
   *
   * The queue for outbound packets is SLIP-encoded; we need to encode it
   * here. The queue for inbound packets is raw.
   */

  for (;;) {
    n = read(fd, buf, sizeof(buf));
    i0 = 0;
    if (n < 0) {
      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
	break;
      else {
	moan("read (client): %s", strerror(errno));
	destroy_client(c);
	return;
      }
    } else if (n == 0) {
      if (c->mode == '>') {
	DPUTC(&c->d, SL_END);
	if (enqueue_dribble(dribble_out, make_pkqnode(c->d.buf, c->d.len)))
	  reasons++;
      }
      destroy_client(c);
      return;
    }
    if (c->mode == '?') {
      switch (buf[0]) {
	case '>':
	  i0 = 1;
	  c->mode = '>';
	  break;
	case '<':
	  w = CREATE(waiter);
	  w->g = make_gobbler(fd, 0, 0);
	  w->next = 0;
	  w->fd = fd;
	  *wait_tail = w;
	  wait_tail = &w->next;
	  sel_rmfile(&c->f);
	  DESTROY(c);
	  dequeue_to_waiter();
	  return;
	default:
	  moan("bad client mode `%c'", buf[0]);
	  destroy_client(c);
	  return;
      }
    }
    for (i = i0; i < n; i++) {
      switch (buf[i]) {
	case SL_ESC:
	  DPUTC(&c->d, SL_ESC);
	  DPUTC(&c->d, SL_ESCESC);
	  break;
	case SL_END:
	  DPUTC(&c->d, SL_ESC);
	  DPUTC(&c->d, SL_ESCEND);
	  break;
	default:
	  DPUTC(&c->d, buf[i]);
	  break;
      }
    }
  }
}

static void do_accept(int fd, unsigned mode, void *hunoz)
{
  client *c;
  struct sockaddr_un sun;
  socklen_t n = sizeof(sun);
  int nfd;

  if ((nfd = accept(fd, (struct sockaddr *)&sun, &n)) < 0) {
    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
      return;
    else
      die(EXIT_FAILURE, "accept: %s", strerror(errno));
  }
  c = CREATE(client);
  c->mode = '?';
  dstr_create(&c->d);
  fdflags(nfd, O_NONBLOCK, O_NONBLOCK, 0, 0);
  sel_initfile(&sel, &c->f, nfd, SEL_READ, do_client_in, c);
  sel_addfile(&c->f);
  reasons++;
}

/*----- Main daemon -------------------------------------------------------*/

static void done_slip_dribble(dribbler *d, int err, void *hunoz)
{
  if (!err)
    reasons--;
  else if (err != EPIPE)
    die(EXIT_FAILURE, "write (slip): %s", strerror(errno));
  else
    cripple_dribbler(d);
}

static void close_slip(int fd)
{
  switch (slipstate) {
    case SYNC1: case SYNC2: case START: case BAD: break;
    default: moan("eof found while processing packet (discarding)"); break;
  }
  close(fd); sel_rmfile(&slip_in);
  reasons--;
}

static void do_slip_in(int fd, unsigned mode, void *hunoz)
{
  ssize_t i, n;

  /* --- Attention --- *
   *
   * The queue for inbound packets contains raw data; we need to decode it
   * here.  The queue for outbound packets is SLIP-encoded.
   *
   * TrIPE sends two empty packets on start-up, in order to resynchronize the
   * target.  We don't need this and it messes us up.
   */

  for (;;) {
    n = read(fd, buf, sizeof(buf));
    if (n == 0) {
      close_slip(fd);
      return;
    } else if (n < 0) {
      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
	break;
      die(EXIT_FAILURE, "read (slip in): %s", strerror(errno));
    }
    for (i = 0; i < n; i++) {
      switch (slipstate) {
	case SYNC1:
	  switch (buf[i]) {
	    case SL_END:
	      slipstate = SYNC2;
	      break;
	    default:
	      goto start;
	  }
	  break;
	case SYNC2:
	  switch (buf[i]) {
	    case SL_END:
	      slipstate = START;
	      break;
	    default:
	      goto start;
	  }
	  break;
	case BAD:
	  switch (buf[i]) {
	    case SL_END:
	      DRESET(&slipbuf);
	      slipstate = OK;
	      break;
	    default:
	      break;
	  }
	  break;
	case ESC:
	  switch (buf[i]) {
	    case SL_ESCEND:
	      DPUTC(&slipbuf, SL_END);
	      slipstate = OK;
	      break;
	    case SL_ESCESC:
	      DPUTC(&slipbuf, SL_ESC);
	      slipstate = OK;
	      break;
	    case SL_END:
	      moan("found escaped end byte (discard packet and resync");
	      DRESET(&slipbuf);
	      slipstate = OK;
	      break;
	    default:
	      moan("unexpected escape char 0x%02x", buf[i]);
	      slipstate = BAD;
	      break;
	  }
	  break;
	case START:
	case OK:
	start:
	  switch (buf[i]) {
	    case SL_ESC:
	      slipstate = ESC;
	      break;
	    case SL_END:
	      if (enqueue(&q_in, make_pkqnode(slipbuf.buf, slipbuf.len)))
		reasons++;
	      DRESET(&slipbuf);
	      dequeue_to_waiter();
	      slipstate = START;
	      break;
	    default:
	      DPUTC(&slipbuf, buf[i]);
	      slipstate = OK;
	      break;
	  }
	  break;
      }
    }
  }
}

static void slip_term(int n, void *fdp)
  { close_slip(*(int *)fdp); }

static void slipif(void)
{
  int fd;
  dstr d = DSTR_INIT;
  struct sockaddr_un sun;
  sig term;
  size_t sz;

  /* --- Make the socket --- */

  if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
    die(EXIT_FAILURE, "socket: %s", strerror(errno));
  socketaddr(&sun, &sz);
  if (bind(fd, (struct sockaddr *)&sun, sz))
    die(EXIT_FAILURE, "bind: %s", strerror(errno));
  if (listen(fd, 5))
    die(EXIT_FAILURE, "listen: %s", strerror(errno));

  /* --- Set up listeners for things --- */

  fdflags(fd, O_NONBLOCK, O_NONBLOCK, 0, 0);
  sel_initfile(&sel, &listener, fd, SEL_READ, do_accept, 0);
  sel_addfile(&listener);

  fdflags(STDIN_FILENO, O_NONBLOCK, O_NONBLOCK, 0, 0);
  fdflags(STDOUT_FILENO, O_NONBLOCK, O_NONBLOCK, 0, 0);
  sel_initfile(&sel, &slip_in, STDIN_FILENO, SEL_READ, do_slip_in, 0);
  dribble_out = make_dribbler(STDOUT_FILENO, done_slip_dribble, 0);
  sel_addfile(&slip_in);

  sig_init(&sel);
  sig_add(&term, SIGTERM, slip_term, &fd);
  sig_add(&term, SIGINT, slip_term, &fd);

  initqueue(&q_in);
  reasons++;

  /* --- Write the interface name --- */

  dstr_putf(&d, "%s-%s\n", QUIS, name);
  if (enqueue_dribble(dribble_out, make_pkqnode(d.buf, d.len)))
    reasons++;
  dstr_destroy(&d);

  /* --- Main loop --- */

  while (reasons) {
    if (sel_select(&sel))
      die(EXIT_FAILURE, "select: %s", strerror(errno));
  }

  /* --- Done --- */

  unlink(name);
}

/*----- Putting and getting -----------------------------------------------*/

static int make_sock(int mode)
{
  struct sockaddr_un sun;
  size_t sz;
  int fd;
  char ch;

  if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
    die(EXIT_FAILURE, "socket: %s", strerror(errno));
  socketaddr(&sun, &sz);
  if (connect(fd, (struct sockaddr *)&sun, sz))
    die(EXIT_FAILURE, "connect: %s", strerror(errno));
  ch = mode;
  if (write(fd, &ch, 1) < 0)
    die(EXIT_FAILURE, "write (mode): %s", strerror(errno));
  return (fd);
}

static void shovel(int from, int to)
{
  ssize_t n;
  size_t sz;
  unsigned char *p;

  for (;;) {
    n = read(from, buf, sizeof(buf));
    if (n < 0) {
      if (errno == EINTR)
	continue;
      else
	die(EXIT_FAILURE, "read (shovel): %s", strerror(errno));
    } else if (n == 0)
      break;

    sz = n;
    p = buf;
    while (sz) {
      n = write(to, p, sz);
      if (n < 0) {
	if (errno == EINTR)
	  continue;
	else
	  die(EXIT_FAILURE, "write (shovel): %s", strerror(errno));
      }
      p += n;
      sz -= n;
    }
  }
  close(from);
  close(to);
}

static void put(void) { shovel(STDIN_FILENO, make_sock('>')); }
static void get(void) { shovel(make_sock('<'), STDOUT_FILENO); }

/*----- Flooding and sinking ----------------------------------------------*/

/* --- Connection jobs --- */

typedef struct conninfo {
  struct conninfo *next;
  conn c;
} conninfo;

#define MAXCONN 32
static conninfo conns[MAXCONN], *freeconns;

static void (*connhook)(int, conninfo *);

static void connrecycle(conninfo *c) { c->next = freeconns; freeconns = c; }

static void connerr(conninfo *c)
{
  if (errno == EAGAIN) connrecycle(c);
  else die(EXIT_FAILURE, "connect: %s", strerror(errno));
}

static void connected(int fd, void *p)
  { if (fd == -1) connerr(p); else connhook(fd, p); }

static void conndoconnect(conninfo *c)
{
  int fd;
  struct sockaddr_un sun;
  size_t sz;

  if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
    die(EXIT_FAILURE, "socket: %s", strerror(errno));
  socketaddr(&sun, &sz);
  if (conn_init(&c->c, &sel, fd, (struct sockaddr *)&sun, sz, connected, c))
    connerr(c);
}

static int timerflag;

static void conndrip(struct timeval *tv, void *hunoz)
{
  conninfo *c, *cc;

  timerflag = 0;
  while (freeconns) {
    c = freeconns; freeconns = 0;
    while (c) { cc = c->next; conndoconnect(c); c = cc; }
  }
}

static void connloop(void (*connected)(int, conninfo *))
{
  int i;
  conninfo **cc;
  sel_timer t;
  struct timeval tv;

  connhook = connected;
  for (i = 0, cc = &freeconns; i < MAXCONN; i++) {
    *cc = &conns[i];
    cc = &conns[i].next;
  }
  *cc = 0;

  for (;;) {
    if (freeconns && !timerflag) {
      gettimeofday(&tv, 0);
      TV_ADDL(&tv, &tv, 0, 10000);
      sel_addtimer(&sel, &t, &tv, conndrip, 0);
      timerflag = 1;
    }
    if (sel_select(&sel))
      die(EXIT_FAILURE, "select: %s", strerror(errno));
  }
}

/* --- Sinking (glug glug) --- */

static void close_sink(gobbler *g, int err, void *p)
{
  static char baton[4] = "/-\\|";
  static int pos = 0;
  static int count = 0;
  static int state = '?';

  conninfo *c = p;

  if (!err) {
    if (state == '?')
      state = isatty(STDOUT_FILENO) ? 'y' : 'n';
    if (state == 'y') {
      if (count) count--;
      else {
	putchar(baton[pos]);
	putchar('\b');
	fflush(stdout);
	pos++;
	if (pos >= sizeof(baton)) pos = 0;
	count = 128;
      }
    }
  }
  connrecycle(c);
}

static void sink_connected(int fd, conninfo *c)
{
  char dir = '<';

  if (write(fd, &dir, 1) != 1) {
    moan("write: %s (continuing)", strerror(errno));
    close(fd);
    connrecycle(c);
    return;
  }
  make_gobbler(fd, close_sink, c);
}

static void sink(void) { connloop(sink_connected); }

/* --- Flooding --- */

static void close_flood(dribbler *d, int err, void *p)
{
  conninfo *c = p;

  if (err) moan("write: %s (continuing)\n", strerror(errno));
  destroy_dribbler(d);
  connrecycle(c);
}

static void flood_connected(int fd, conninfo *c)
{
  static uint32 seq;

  dribbler *d;
  pkq_node *pn;
  int i;

#define FLOOD_PKSZ 1024

  pn = make_pkqnode(0, 1 + FLOOD_PKSZ);
  pn->buf[0] = '>';
  STORE32(pn->buf + 1, seq);
  for (i = 4; i < FLOOD_PKSZ; i++)
    pn->buf[i + 1] = i & 0xff;
  seq++;
  d = make_dribbler(fd, close_flood, c);
  enqueue_dribble(d, pn);
}

static void flood(void) { connloop(flood_connected); }

/*----- Main code ---------------------------------------------------------*/

static void usage(FILE *fp) { pquis(fp, "Usage: $ [-fgps] SOCKET\n"); }

static void version(void)
  { pquis(stdout, "$ (" PACKAGE " version " VERSION")\n"); }

static void help(void)
{
  version();
  fputc('\n', stdout);
  usage(stdout);
  puts("\n\
With no options, provides a SLIP interface for TrIPE.\n\
\n\
Options:\n\
  -f, --flood	Send packets to TrIPE as fast as possible.\n\
  -g, --get	Receive packet from TrIPE and write to stdout.\n\
  -p, --put	Send packet on stdin to TrIPE.\n\
  -s, --sink	Slurp packets out of TrIPE and display progress.");
}

int main(int argc, char *argv[])
{
  int mode = 'd';
  int i;

  ego(argv[0]);
  for (;;) {
    const struct option opt[] = {
      { "help",			0,		0,		'h' },
      { "version",		0,		0,		'v' },
      { "put",			0,		0,		'p' },
      { "get",			0,		0,		'g' },
      { "flood",		0,		0,		'f' },
      { "sink",			0,		0,		's' },
      { 0,			0,		0,		0 }
    };
    i = mdwopt(argc, argv, "hvpgfs", opt, 0, 0, 0);
    if (i < 0)
      break;
    switch (i) {
      case 'h': help(); return (0);
      case 'v': version(); return (0);
      case 'p': case 'g': case 's': case 'f': mode = i; break;
      default: usage(stderr); exit(EXIT_FAILURE); break;
    }
  }
  if (argc - optind != 1) { usage(stderr); exit(EXIT_FAILURE); }
  name = argv[optind];
  signal(SIGPIPE, SIG_IGN);
  switch (mode) {
    case 'd': slipif(); break;
    case 'p': put(); break;
    case 'g': get(); break;
    case 'f': flood(); break;
    case 's': sink(); break;
  }
  return (0);
}

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