[tripe] / mallory.c

/* -*-c-*-
 *
 * $Id$
 *
 * An evil proxy for TrIPE
 *
 * (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 "config.h"

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

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

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

#include <mLib/alloc.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/sub.h>
#include <mLib/tv.h>

#include <catacomb/buf.h>

#include <catacomb/key.h>

#include <catacomb/mp.h>
#include <catacomb/mprand.h>
#include <catacomb/dh.h>

#include <catacomb/noise.h>
#include <catacomb/rand.h>
#include <catacomb/rc4.h>


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

typedef struct peer {
  sel_file sf;
  dh_pub kpub;
  const char *name;
  struct filter *f;
} peer;

typedef struct filter {
  struct filter *next;
  peer *p_from, *p_to;
  void (*func)(struct filter */*f*/, const octet */*buf*/, size_t /*sz*/);
  void *state;
} filter;

typedef struct qnode {
  octet *buf;
  size_t sz;
} qnode;

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

#define PKBUFSZ 65536

static sel_state sel;
static peer peers[2];
static unsigned npeer = 0;
static key_file keys;
static grand *rng;

#define PASS(f, buf, sz) ((f) ? (f)->func((f), (buf), (sz)) : (void)0)
#define RND(i) (rng->ops->range(rng, (i)))

/*----- Peer management ---------------------------------------------------*/

static void dopacket(int fd, unsigned mode, void *vv)
{
  octet buf[PKBUFSZ];
  peer *p = vv;
  int r = read(fd, buf, sizeof(buf));
  if (r >= 0) {
    printf("recv from `%s'\n", p->name);
    PASS(p->f, buf, r);
  }
}

static void addpeer(unsigned ac, char **av)
{
  key_packstruct kps[DH_PUBFETCHSZ];
  key_packdef *kp;
  struct hostent *h;
  struct sockaddr_in sin;
  int len = PKBUFSZ;
  peer *p;
  int fd;
  int e;

  if (ac != 4)
    die(1, "syntax: peer:NAME:PORT:ADDR:PORT");
  if (npeer >= 2)
    die(1, "enough peers already");
  p = &peers[npeer++];
  p->name = xstrdup(av[0]);
  kp = key_fetchinit(dh_pubfetch, kps, &p->kpub);
  e = key_fetchbyname(kp, &keys, av[0]);
  key_fetchdone(kp);
  if (e)
    die(1, "key_fetch `%s': %s", av[0], key_strerror(e));
  if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
    die(1, "socket: %s", strerror(errno));
  fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
  memset(&sin, 0, sizeof(sin));
  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = INADDR_ANY;
  sin.sin_port = htons(atoi(av[1]));
  if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)))
    die(1, "bind: %s", strerror(errno));
  memset(&sin, 0, sizeof(sin));
  sin.sin_family = AF_INET;
  if ((h = gethostbyname(av[2])) == 0)
    die(1, "gethostbyname `%s'", av[2]);
  if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)) ||
      setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len)))
    die(1, "setsockopt: %s", strerror(errno));
  memcpy(&sin.sin_addr, h->h_addr, sizeof(sin.sin_addr));
  sin.sin_port = htons(atoi(av[3]));
  if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)))
    die(1, "connect: %s", strerror(errno));
  sel_initfile(&sel, &p->sf, fd, SEL_READ, dopacket, p);
  sel_addfile(&p->sf);
}

/*----- Fork filter -------------------------------------------------------*/

typedef struct forknode {
  struct forknode *next;
  filter *f;
} forknode;

typedef struct forkfilt {
  const char *name;
  forknode *fn;
} forkfilt;

static void dofork(filter *f, const octet *buf, size_t sz)
{
  forkfilt *ff = f->state;
  forknode *fn;
  unsigned i = 0;

  ff = f->state;
  for (fn = ff->fn; fn; fn = fn->next) {
    printf("fork branch %u of fork `%s'\n", i++, ff->name);
    PASS(fn->f, buf, sz);
  }
  printf("fork branch %u of fork `%s'\n", i++, ff->name);
  PASS(f->next, buf, sz);
}

static void addfork(filter *f, unsigned ac, char **av)
{
  forkfilt *ff;
  if (ac != 1)
    die(1, "syntax: filt:fork:NAME");
  ff = CREATE(forkfilt);
  ff->name = xstrdup(av[0]);
  ff->fn = 0;
  f->func = dofork;
  f->state = ff;
}

static void nextfork(unsigned ac, char **av)
{
  unsigned i, j;
  filter *f;
  forkfilt *ff;
  forknode *fn, **ffn;
  peer *p;

  if (ac < 1)
    die(1, "syntax: next:NAME:...");
  for (i = 0; i < 2; i++) {
    p = &peers[i];
    for (f = p->f; f; f = f->next) {
      if (f->func != dofork)
	continue;
      ff = f->state;
      for (j = 0; j < ac; j++) {
	if (strcmp(av[j], ff->name) == 0)
	  goto match;
      }
      continue;
    match:
      fn = CREATE(forknode);
      for (ffn = &ff->fn; *ffn; ffn = &(*ffn)->next)
	;
      fn->f = f->next;
      f->next = 0;
      fn->next = 0;
      *ffn = fn;
    }
  }
}

/*----- Corrupt filter ----------------------------------------------------*/

typedef struct corrupt {
  unsigned p_corrupt;
} corrupt;

static void docorrupt(filter *f, const octet *buf, size_t sz)
{
  corrupt *c = f->state;
  octet b[PKBUFSZ];
  memcpy(b, buf, sz);

  while (!RND(c->p_corrupt)) {
    puts("corrupt packet");
    b[RND(sz)] ^= RND(256);
  }
  PASS(f->next, b, sz);
}

static void addcorrupt(filter *f, unsigned ac, char **av)
{
  corrupt *c;
  if (ac > 1)
    die(1, "syntax: filt:corrupt[:PCORRUPT]");
  c = CREATE(corrupt);
  if (ac > 0)
    c->p_corrupt = atoi(av[0]);
  else
    c->p_corrupt = 5;
  f->state = c;
  f->func = docorrupt;
}

/*----- Delay filter ------------------------------------------------------*/

typedef struct delaynode {
  unsigned flag;
  sel_timer tm;
  unsigned i;
  struct delay *d;
  octet *buf;
  size_t sz;
  unsigned seq;
} delaynode;

typedef struct delay {
  unsigned max, n;
  unsigned long t;
  unsigned p_replay;
  filter *f;
  delaynode *q;
} delay;

static void dtimer(struct timeval *tv, void *vv);

static void dinsert(delaynode *dn)
{
  struct timeval tv;
  sel_timer *ta, *tb;
  unsigned long tdelta = RND(dn->d->t);
  gettimeofday(&tv, 0);
  TV_ADDL(&tv, &tv, 0, tdelta);
  assert(!dn->flag);
  sel_addtimer(&sel, &dn->tm, &tv, dtimer, dn);
  dn->flag = 1;
  for (ta = tb = sel.timers; ta; ta = ta->next) {
    ta = ta->next; if (!ta) break; assert(ta != tb);
    ta = ta->next; if (!ta) break; assert(ta != tb);
    tb = tb->next;
  }
  printf(" delay %lu usecs", tdelta);
}

static void dsend(delaynode *dn, unsigned force)
{
  delay *d = dn->d;
  delaynode *ddn;
  fputs(" send...\n", stdout);
  assert(dn->buf);
  PASS(d->f->next, dn->buf, dn->sz);
  fputs("delay ...", stdout);
  if (!force)
    dinsert(dn);
  else {
    xfree(dn->buf);
    dn->buf = 0;
    d->n--;
    if (dn->i < d->n) {
      ddn = &d->q[d->n];
      sel_rmtimer(&ddn->tm);
      sel_addtimer(&sel, &dn->tm, &ddn->tm.tv, dtimer, dn);
      dn->flag = 1;
      dn->buf = ddn->buf;
      dn->sz = ddn->sz;
      dn->seq = ddn->seq;
      ddn->buf = 0;
      ddn->flag = 0;
      printf(" move id %u from slot %u to slot %u", ddn->seq, ddn->i, dn->i);
    }
    { unsigned i; for (i = 0; i < d->n; i++) assert(d->q[i].buf); }
    fputs(" remove", stdout);
  }
}

static void dtimer(struct timeval *tv, void *vv)
{
  delaynode *dn = vv;
  printf("delay timer peer `%s' id %u slot %u",
	 dn->d->f->p_from->name, dn->seq, dn->i);
  dn->flag = 0;
  dsend(dn, RND(dn->d->p_replay));
  fputc('\n', stdout);
}

static void dodelay(filter *f, const octet *buf, size_t sz)
{
  delay *d = f->state;
  delaynode *dn;
  static unsigned seq = 0;

  fputs("delay", stdout);
  if (d->n == d->max) {
    dn = &d->q[RND(d->n)];
    printf(" force uid %u", dn->seq);
    sel_rmtimer(&dn->tm);
    dn->flag = 0;
    dsend(dn, 1);
    fputc(';', stdout);
  }
  dn = &d->q[d->n++];
  dn->seq = seq++;
  printf(" new id %u in slot %u", dn->seq, dn->i);
  dn->buf = xmalloc(sz);
  dn->sz = sz;
  memcpy(dn->buf, buf, sz);
  dinsert(dn);
  fputc('\n', stdout);
}

static void adddelay(filter *f, unsigned ac, char **av)
{
  delay *d;
  unsigned i;

  if (ac < 1 || ac > 3)
    die(1, "syntax: filt:delay:QLEN[:MILLIS:PREPLAY]");
  d = CREATE(delay);
  d->max = atoi(av[0]);
  if (ac > 1)
    d->t = strtoul(av[1], 0, 10);
  else
    d->t = 100;
  d->t *= 1000;
  if (ac > 2)
    d->p_replay = atoi(av[2]);
  else
    d->p_replay = 20;
  d->n = 0;
  d->q = xmalloc(d->max * sizeof(delaynode));
  d->f = f;
  f->state = d;
  f->func = dodelay;
  for (i = 0; i < d->max; i++) {
    d->q[i].d = d;
    d->q[i].i = i;
    d->q[i].buf = 0;
    d->q[i].flag = 0;
  }
}

/*----- Filters -----------------------------------------------------------*/

static void dosend(filter *f, const octet *buf, size_t sz)
{
  printf("send to `%s'\n", f->p_to->name);
  write(f->p_to->sf.fd, buf, sz);
}

static void addsend(filter *f, unsigned ac, char **av)
{
  if (ac)
    die(1, "syntax: filt:send");
  f->func = dosend;
}

const struct filtab {
  const char *name;
  void (*func)(filter */*f*/, unsigned /*ac*/, char **/*av*/);
} filtab[] = {
  { "send",	addsend },
  { "fork",	addfork },
  { "delay",	adddelay },
  { "corrupt",	addcorrupt },
  { 0,		0 }
};

static void dofilter(peer *from, peer *to, unsigned ac, char **av)
{
  filter **ff, *f = CREATE(filter);
  const struct filtab *ft;
  if (ac < 1)
    die(1, "syntax: {l,r,}filt:NAME:...");
  f->next = 0;
  f->p_from = from;
  f->p_to = to;
  f->state = 0;
  for (ff = &from->f; *ff; ff = &(*ff)->next)
    ;
  *ff = f;
  for (ft = filtab; ft->name; ft++) {
    if (strcmp(av[0], ft->name) == 0) {
      ft->func(f, ac - 1, av + 1);
      return;
    }
  }
  die(1, "unknown filter `%s'", av[0]);
}

/*----- Flooding ----------------------------------------------------------*/

typedef struct flood {
  peer *p;
  unsigned type;
  size_t sz;
  unsigned long t;
  sel_timer tm;
} flood;

static void setflood(flood *f);

static void floodtimer(struct timeval *tv, void *vv)
{
  flood *f = vv;
  octet buf[PKBUFSZ];
  size_t sz;

  sz = RND(f->sz);
  sz += RND(f->sz);
  sz += RND(f->sz);
  sz += RND(f->sz);
  sz /= 2;

  rng->ops->fill(rng, buf, sz);
  if (f->type < 0x100)
    buf[0] = f->type;
  puts("flood packet");
  PASS(f->p->f, buf, sz);
  setflood(f);
}
  
static void setflood(flood *f)
{
  struct timeval tv;
  gettimeofday(&tv, 0);
  TV_ADDL(&tv, &tv, 0, RND(f->t));
  sel_addtimer(&sel, &f->tm, &tv, floodtimer, f);
}

static void doflood(peer *p, unsigned ac, char **av)
{
  flood *f;
  if (ac > 3)
    die(1, "syntax: flood[:TYPE:MILLIS:SIZE]");
  f = CREATE(flood);
  f->p = p;
  if (ac > 0)
    f->type = strtoul(av[0], 0, 16);
  else
    f->type = 0x100;
  if (ac > 1)
    f->t = atoi(av[1]);
  else
    f->t = 10;
  if (ac > 2)
    f->sz = atoi(av[2]);
  else
    f->sz = 128;
  f->t *= 1000;
  setflood(f);
}

/*----- Configuration commands --------------------------------------------*/

static void parse(char *p);

static void addflood(unsigned ac, char **av) {
  doflood(&peers[0], ac, av);
  doflood(&peers[1], ac, av);
}
static void addlflood(unsigned ac, char **av) {
  doflood(&peers[0], ac, av);
}
static void addrflood(unsigned ac, char **av) {
  doflood(&peers[1], ac, av);
}

static void addfilter(unsigned ac, char **av) {
  dofilter(&peers[0], &peers[1], ac, av);
  dofilter(&peers[1], &peers[0], ac, av);
}
static void addlfilter(unsigned ac, char **av) {
  dofilter(&peers[0], &peers[1], ac, av);
}
static void addrfilter(unsigned ac, char **av) {
  dofilter(&peers[1], &peers[0], ac, av);
}

static void include(unsigned ac, char **av)
{
  FILE *fp;
  dstr d = DSTR_INIT;
  if (!ac)
    die(1, "syntax: include:FILE:...");
  while (*av) {
    if ((fp = fopen(*av, "r")) == 0)
      die(1, "fopen `%s': %s", *av, strerror(errno));
    while (dstr_putline(&d, fp) != EOF) {
      parse(d.buf);
      DRESET(&d);
    }
    fclose(fp);
    av++;
  }
}

const struct cmdtab {
  const char *name;
  void (*func)(unsigned /*ac*/, char **/*av*/);
} cmdtab[] = {
  { "peer",	addpeer },
  { "include",	include },
  { "filt",	addfilter },
  { "lfilt",	addlfilter },
  { "rfilt",	addrfilter },
  { "next",	nextfork },
  { "flood",	addflood },
  { "lflood",	addlflood },
  { "rflood",	addrflood },
  { 0,		0 }
};

#define AVMAX 16

static void parse(char *p)
{
  char *v[AVMAX];
  unsigned c = 0;
  const struct cmdtab *ct;

  p = strtok(p, ":");
  if (!p || *p == '#')
    return;
  do {
    v[c++] = p;
    p = strtok(0, ":");
  } while (p && c < AVMAX - 1);
  v[c] = 0;
  for (ct = cmdtab; ct->name; ct++) {
    if (strcmp(ct->name, v[0]) == 0) {
      ct->func(c - 1, v + 1);
      return;
    }
  }
  die(1, "unknown command `%s'", v[0]);
}

/*----- Main driver -------------------------------------------------------*/

static void version(FILE *fp)
{
  pquis(fp, "$, TrIPE version " VERSION "\n");
}

static void usage(FILE *fp)
{
  pquis(fp, "Usage: $ [-k KEYRING] DIRECTIVE...\n");
}

static void help(FILE *fp)
{
  version(fp);
  putc('\n', fp);
  usage(fp);
  fputs("\n\
Options:\n\
\n\
-h, --help		Show this help text.\n\
-v, --version		Show the version number.\n\
-u, --usage		Show terse usage summary.\n\
\n\
-k, --keyring=FILE	Fetch keys from FILE.\n\
\n\
Directives:\n\
  peer:NAME:LOCAL-PORT:REMOTE-ADDR:REMOTE-PORT\n\
  include:FILE\n\
  {,l,r}filt:FILTER:ARGS:...\n\
  next:TAG\n\
  {,l,r}flood:TYPE:MILLIS:SIZE\n\
\n\
Filters:\n\
  send\n\
  fork:TAG\n\
  delay:QLEN[:MILLIS:P-REPLAY]\n\
  corrupt[:P-CORRUPT]\n",
	fp);
}

int main(int argc, char *argv[])
{
  const char *kfname = "keyring.pub";
  int i;
  unsigned f = 0;
  char buf[16];

#define f_bogus 1u

  ego(argv[0]);
  for (;;) {
    static const struct option opt[] = {
      { "help",		0,		0,	'h' },
      { "version",	0,		0,	'v' },
      { "usage",	0,		0,	'u' },
      { "keyring",	OPTF_ARGREQ,	0,	'k' },
      { 0,		0,		0,	0 }
    };
    if ((i = mdwopt(argc, argv, "hvuk:", opt, 0, 0, 0)) < 0)
      break;
    switch (i) {
      case 'h':
	help(stdout);
	exit(0);
      case 'v':
	version(stdout);
	exit(0);
      case 'u':
	usage(stdout);
	exit(0);
      case 'k':
	kfname = optarg;
	break;
      default:
	f |= f_bogus;
	break;
    }
  }
  if (f & f_bogus) {
    usage(stderr);
    exit(1);
  }
  rand_noisesrc(RAND_GLOBAL, &noise_source);
  rand_seed(RAND_GLOBAL, 160);
  rand_get(RAND_GLOBAL, buf, sizeof(buf));
  rng = rc4_rand(buf, sizeof(buf));
  sel_init(&sel);
  if (key_open(&keys, kfname, KOPEN_READ, key_moan, 0))
    die(1, "couldn't open `%s': %s", kfname, strerror(errno));
  for (i = optind; i < argc; i++)
    parse(argv[i]);
  if (npeer != 2)
    die(1, "need two peers");
  for (;;)
    sel_select(&sel);

#undef f_bogus
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
50c74957	1	/* --c--
50c74957	2	*
2d752320	3	* $Id$
50c74957	4	*
	5	* An evil proxy for TrIPE
	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
50c74957	29	/----- Header files ------------------------------------------------------/
	30
	31	#include "config.h"
	32
	33	#include <assert.h>
	34	#include <errno.h>
	35	#include <stdio.h>
	36	#include <stdlib.h>
	37	#include <string.h>
	38	#include <time.h>
	39
	40	#include <sys/types.h>
	41	#include <sys/time.h>
	42	#include <unistd.h>
	43	#include <fcntl.h>
	44
	45	#include <sys/socket.h>
	46	#include <netinet/in.h>
	47	#include <arpa/inet.h>
	48	#include <netdb.h>
	49
	50	#include <mLib/alloc.h>
	51	#include <mLib/dstr.h>
	52	#include <mLib/fdflags.h>
	53	#include <mLib/mdwopt.h>
	54	#include <mLib/quis.h>
	55	#include <mLib/report.h>
	56	#include <mLib/sel.h>
	57	#include <mLib/sub.h>
	58	#include <mLib/tv.h>
	59
c953f4b5	60	#include <catacomb/buf.h>
c953f4b5	61
50c74957	62	#include <catacomb/key.h>
	63
	64	#include <catacomb/mp.h>
50c74957	65	#include <catacomb/mprand.h>
	66	#include <catacomb/dh.h>
	67
	68	#include <catacomb/noise.h>
	69	#include <catacomb/rand.h>
	70	#include <catacomb/rc4.h>
	71
50c74957	72
	73	/----- Data structures ---------------------------------------------------/
	74
	75	typedef struct peer {
	76	sel_file sf;
	77	dh_pub kpub;
	78	const char *name;
	79	struct filter *f;
	80	} peer;
	81
	82	typedef struct filter {
	83	struct filter *next;
	84	peer p_from, p_to;
	85	void (func)(struct filter /f/, const octet /buf/, size_t /sz*/);
	86	void *state;
	87	} filter;
	88
	89	typedef struct qnode {
	90	octet *buf;
	91	size_t sz;
	92	} qnode;
	93
	94	/----- Static variables --------------------------------------------------/
	95
	96	#define PKBUFSZ 65536
	97
	98	static sel_state sel;
	99	static peer peers[2];
	100	static unsigned npeer = 0;
	101	static key_file keys;
	102	static grand *rng;
	103
	104	#define PASS(f, buf, sz) ((f) ? (f)->func((f), (buf), (sz)) : (void)0)
	105	#define RND(i) (rng->ops->range(rng, (i)))
	106
	107	/----- Peer management ---------------------------------------------------/
	108
	109	static void dopacket(int fd, unsigned mode, void *vv)
	110	{
	111	octet buf[PKBUFSZ];
	112	peer *p = vv;
	113	int r = read(fd, buf, sizeof(buf));
	114	if (r >= 0) {
	115	printf("recv from `%s'\n", p->name);
	116	PASS(p->f, buf, r);
	117	}
	118	}
	119
	120	static void addpeer(unsigned ac, char **av)
	121	{
	122	key_packstruct kps[DH_PUBFETCHSZ];
	123	key_packdef *kp;
	124	struct hostent *h;
	125	struct sockaddr_in sin;
	126	int len = PKBUFSZ;
	127	peer *p;
	128	int fd;
	129	int e;
	130
	131	if (ac != 4)
	132	die(1, "syntax: peer:NAME:PORT:ADDR:PORT");
	133	if (npeer >= 2)
	134	die(1, "enough peers already");
	135	p = &peers[npeer++];
136	p->name = xstrdup(av[0]);
137	kp = key_fetchinit(dh_pubfetch, kps, &p->kpub);
138	e = key_fetchbyname(kp, &keys, av[0]);
139	key_fetchdone(kp);
140	if (e)
141	die(1, "key_fetch `%s': %s", av[0], key_strerror(e));
142	if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
143	die(1, "socket: %s", strerror(errno));
144	fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
145	memset(&sin, 0, sizeof(sin));
146	sin.sin_family = AF_INET;
147	sin.sin_addr.s_addr = INADDR_ANY;
148	sin.sin_port = htons(atoi(av[1]));
149	if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)))
150	die(1, "bind: %s", strerror(errno));
151	memset(&sin, 0, sizeof(sin));
152	sin.sin_family = AF_INET;
153	if ((h = gethostbyname(av[2])) == 0)
154	die(1, "gethostbyname `%s'", av[2]);
155	if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)) \|\|
156	setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len)))
157	die(1, "setsockopt: %s", strerror(errno));
158	memcpy(&sin.sin_addr, h->h_addr, sizeof(sin.sin_addr));
159	sin.sin_port = htons(atoi(av[3]));
160	if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)))
161	die(1, "connect: %s", strerror(errno));
162	sel_initfile(&sel, &p->sf, fd, SEL_READ, dopacket, p);
163	sel_addfile(&p->sf);
164	}
165
166	/----- Fork filter -------------------------------------------------------/
167
168	typedef struct forknode {
169	struct forknode *next;
170	filter *f;
171	} forknode;
172
173	typedef struct forkfilt {
174	const char *name;
175	forknode *fn;
176	} forkfilt;
177
178	static void dofork(filter f, const octet buf, size_t sz)
179	{
180	forkfilt *ff = f->state;
181	forknode *fn;
182	unsigned i = 0;
183
184	ff = f->state;
185	for (fn = ff->fn; fn; fn = fn->next) {
186	printf("fork branch %u of fork `%s'\n", i++, ff->name);
187	PASS(fn->f, buf, sz);
188	}
189	printf("fork branch %u of fork `%s'\n", i++, ff->name);
190	PASS(f->next, buf, sz);
191	}
192
193	static void addfork(filter f, unsigned ac, char *av)
194	{
195	forkfilt *ff;
196	if (ac != 1)
197	die(1, "syntax: filt:fork:NAME");
198	ff = CREATE(forkfilt);
199	ff->name = xstrdup(av[0]);
200	ff->fn = 0;
201	f->func = dofork;
202	f->state = ff;
203	}
204
205	static void nextfork(unsigned ac, char **av)
206	{
c953f4b5	207	unsigned i, j;
50c74957	208	filter *f;
	209	forkfilt *ff;
	210	forknode fn, *ffn;
	211	peer *p;
	212
c953f4b5	213	if (ac < 1)
c953f4b5	214	die(1, "syntax: next:NAME:...");
50c74957	215	for (i = 0; i < 2; i++) {
	216	p = &peers[i];
	217	for (f = p->f; f; f = f->next) {
	218	if (f->func != dofork)
	219	continue;
	220	ff = f->state;
c953f4b5	221	for (j = 0; j < ac; j++) {
	222	if (strcmp(av[j], ff->name) == 0)
	223	goto match;
	224	}
	225	continue;
	226	match:
50c74957	227	fn = CREATE(forknode);
	228	for (ffn = &ff->fn; ffn; ffn = &(ffn)->next)
	229	;
	230	fn->f = f->next;
	231	f->next = 0;
	232	fn->next = 0;
	233	*ffn = fn;
	234	}
	235	}
	236	}
	237
	238	/----- Corrupt filter ----------------------------------------------------/
	239
	240	typedef struct corrupt {
	241	unsigned p_corrupt;
	242	} corrupt;
	243
	244	static void docorrupt(filter f, const octet buf, size_t sz)
	245	{
	246	corrupt *c = f->state;
	247	octet b[PKBUFSZ];
	248	memcpy(b, buf, sz);
	249
	250	while (!RND(c->p_corrupt)) {
	251	puts("corrupt packet");
	252	b[RND(sz)] ^= RND(256);
	253	}
	254	PASS(f->next, b, sz);
	255	}
	256
	257	static void addcorrupt(filter f, unsigned ac, char *av)
	258	{
	259	corrupt *c;
	260	if (ac > 1)
	261	die(1, "syntax: filt:corrupt[:PCORRUPT]");
	262	c = CREATE(corrupt);
	263	if (ac > 0)
	264	c->p_corrupt = atoi(av[0]);
	265	else
	266	c->p_corrupt = 5;
	267	f->state = c;
	268	f->func = docorrupt;
	269	}
	270
	271	/----- Delay filter ------------------------------------------------------/
	272
	273	typedef struct delaynode {
	274	unsigned flag;
	275	sel_timer tm;
	276	unsigned i;
	277	struct delay *d;
	278	octet *buf;
	279	size_t sz;
	280	unsigned seq;
	281	} delaynode;
	282
	283	typedef struct delay {
	284	unsigned max, n;
	285	unsigned long t;
	286	unsigned p_replay;
	287	filter *f;
	288	delaynode *q;
	289	} delay;
	290
291	static void dtimer(struct timeval tv, void vv);
292
293	static void dinsert(delaynode *dn)
294	{
295	struct timeval tv;
296	sel_timer ta, tb;
297	unsigned long tdelta = RND(dn->d->t);
298	gettimeofday(&tv, 0);
299	TV_ADDL(&tv, &tv, 0, tdelta);
300	assert(!dn->flag);
301	sel_addtimer(&sel, &dn->tm, &tv, dtimer, dn);
302	dn->flag = 1;
303	for (ta = tb = sel.timers; ta; ta = ta->next) {
304	ta = ta->next; if (!ta) break; assert(ta != tb);
305	ta = ta->next; if (!ta) break; assert(ta != tb);
306	tb = tb->next;
307	}
308	printf(" delay %lu usecs", tdelta);
309	}
310
311	static void dsend(delaynode *dn, unsigned force)
312	{
313	delay *d = dn->d;
314	delaynode *ddn;
315	fputs(" send...\n", stdout);
316	assert(dn->buf);
317	PASS(d->f->next, dn->buf, dn->sz);
318	fputs("delay ...", stdout);
319	if (!force)
320	dinsert(dn);
321	else {
322	xfree(dn->buf);
323	dn->buf = 0;
324	d->n--;
325	if (dn->i < d->n) {
326	ddn = &d->q[d->n];
327	sel_rmtimer(&ddn->tm);
328	sel_addtimer(&sel, &dn->tm, &ddn->tm.tv, dtimer, dn);
329	dn->flag = 1;
330	dn->buf = ddn->buf;
331	dn->sz = ddn->sz;
332	dn->seq = ddn->seq;
333	ddn->buf = 0;
334	ddn->flag = 0;
335	printf(" move id %u from slot %u to slot %u", ddn->seq, ddn->i, dn->i);
336	}
337	{ unsigned i; for (i = 0; i < d->n; i++) assert(d->q[i].buf); }
338	fputs(" remove", stdout);
339	}
340	}
341
342	static void dtimer(struct timeval tv, void vv)
343	{
344	delaynode *dn = vv;
345	printf("delay timer peer `%s' id %u slot %u",
346	dn->d->f->p_from->name, dn->seq, dn->i);
347	dn->flag = 0;
348	dsend(dn, RND(dn->d->p_replay));
349	fputc('\n', stdout);
350	}
351
352	static void dodelay(filter f, const octet buf, size_t sz)
353	{
354	delay *d = f->state;
355	delaynode *dn;
356	static unsigned seq = 0;
357
358	fputs("delay", stdout);
359	if (d->n == d->max) {
360	dn = &d->q[RND(d->n)];
361	printf(" force uid %u", dn->seq);
362	sel_rmtimer(&dn->tm);
363	dn->flag = 0;
364	dsend(dn, 1);
365	fputc(';', stdout);
366	}
367	dn = &d->q[d->n++];
368	dn->seq = seq++;
369	printf(" new id %u in slot %u", dn->seq, dn->i);
370	dn->buf = xmalloc(sz);
371	dn->sz = sz;
372	memcpy(dn->buf, buf, sz);
373	dinsert(dn);
374	fputc('\n', stdout);
375	}
376
377	static void adddelay(filter f, unsigned ac, char *av)
378	{
379	delay *d;
380	unsigned i;
381
382	if (ac < 1 \|\| ac > 3)
383	die(1, "syntax: filt:delay:QLEN[:MILLIS:PREPLAY]");
384	d = CREATE(delay);
385	d->max = atoi(av[0]);
386	if (ac > 1)
387	d->t = strtoul(av[1], 0, 10);
388	else
389	d->t = 100;
390	d->t *= 1000;
391	if (ac > 2)
392	d->p_replay = atoi(av[2]);
393	else
394	d->p_replay = 20;
395	d->n = 0;
396	d->q = xmalloc(d->max * sizeof(delaynode));
397	d->f = f;
398	f->state = d;
399	f->func = dodelay;
400	for (i = 0; i < d->max; i++) {
401	d->q[i].d = d;
402	d->q[i].i = i;
403	d->q[i].buf = 0;
404	d->q[i].flag = 0;
405	}
406	}
407
408	/----- Filters -----------------------------------------------------------/
409
410	static void dosend(filter f, const octet buf, size_t sz)
411	{
412	printf("send to `%s'\n", f->p_to->name);
413	write(f->p_to->sf.fd, buf, sz);
414	}
415
416	static void addsend(filter f, unsigned ac, char *av)
417	{
418	if (ac)
419	die(1, "syntax: filt:send");
420	f->func = dosend;
421	}
422
423	const struct filtab {
424	const char *name;
425	void (func)(filter /f/, unsigned /ac/, char */av*/);
426	} filtab[] = {
427	{ "send", addsend },
428	{ "fork", addfork },
429	{ "delay", adddelay },
430	{ "corrupt", addcorrupt },
431	{ 0, 0 }
432	};
433
434	static void dofilter(peer from, peer to, unsigned ac, char **av)
435	{
436	filter *ff, f = CREATE(filter);
437	const struct filtab *ft;
438	if (ac < 1)
439	die(1, "syntax: {l,r,}filt:NAME:...");
440	f->next = 0;
441	f->p_from = from;
442	f->p_to = to;
443	f->state = 0;
444	for (ff = &from->f; ff; ff = &(ff)->next)
445	;
446	*ff = f;
447	for (ft = filtab; ft->name; ft++) {
448	if (strcmp(av[0], ft->name) == 0) {
449	ft->func(f, ac - 1, av + 1);
450	return;
451	}
452	}
453	die(1, "unknown filter `%s'", av[0]);
454	}
455
456	/----- Flooding ----------------------------------------------------------/
457
458	typedef struct flood {
459	peer *p;
460	unsigned type;
461	size_t sz;
462	unsigned long t;
463	sel_timer tm;
464	} flood;
465
466	static void setflood(flood *f);
467
468	static void floodtimer(struct timeval tv, void vv)
469	{
470	flood *f = vv;
471	octet buf[PKBUFSZ];
472	size_t sz;
473
474	sz = RND(f->sz);
475	sz += RND(f->sz);
476	sz += RND(f->sz);
477	sz += RND(f->sz);
478	sz /= 2;
479
480	rng->ops->fill(rng, buf, sz);
481	if (f->type < 0x100)
482	buf[0] = f->type;
483	puts("flood packet");
484	PASS(f->p->f, buf, sz);
485	setflood(f);
486	}
487
488	static void setflood(flood *f)
489	{
490	struct timeval tv;
491	gettimeofday(&tv, 0);
492	TV_ADDL(&tv, &tv, 0, RND(f->t));
493	sel_addtimer(&sel, &f->tm, &tv, floodtimer, f);
494	}
495
496	static void doflood(peer p, unsigned ac, char *av)
497	{
498	flood *f;
499	if (ac > 3)
500	die(1, "syntax: flood[:TYPE:MILLIS:SIZE]");
501	f = CREATE(flood);
502	f->p = p;
503	if (ac > 0)
504	f->type = strtoul(av[0], 0, 16);
505	else
506	f->type = 0x100;
507	if (ac > 1)
508	f->t = atoi(av[1]);
509	else
510	f->t = 10;
511	if (ac > 2)
512	f->sz = atoi(av[2]);
513	else
514	f->sz = 128;
515	f->t *= 1000;
516	setflood(f);
517	}
518
519	/----- Configuration commands --------------------------------------------/
520
521	static void parse(char *p);
522
523	static void addflood(unsigned ac, char **av) {
524	doflood(&peers[0], ac, av);
525	doflood(&peers[1], ac, av);
526	}
527	static void addlflood(unsigned ac, char **av) {
528	doflood(&peers[0], ac, av);
529	}
530	static void addrflood(unsigned ac, char **av) {
531	doflood(&peers[1], ac, av);
532	}
533
534	static void addfilter(unsigned ac, char **av) {
535	dofilter(&peers[0], &peers[1], ac, av);
536	dofilter(&peers[1], &peers[0], ac, av);
537	}
538	static void addlfilter(unsigned ac, char **av) {
539	dofilter(&peers[0], &peers[1], ac, av);
540	}
541	static void addrfilter(unsigned ac, char **av) {
542	dofilter(&peers[1], &peers[0], ac, av);
543	}
544
545	static void include(unsigned ac, char **av)
546	{
547	FILE *fp;
548	dstr d = DSTR_INIT;
549	if (!ac)
550	die(1, "syntax: include:FILE:...");
551	while (*av) {
552	if ((fp = fopen(*av, "r")) == 0)
553	die(1, "fopen `%s': %s", *av, strerror(errno));
554	while (dstr_putline(&d, fp) != EOF) {
555	parse(d.buf);
556	DRESET(&d);
557	}
558	fclose(fp);
559	av++;
560	}
561	}
562
563	const struct cmdtab {
564	const char *name;
565	void (func)(unsigned /ac/, char /av*/);
566	} cmdtab[] = {
567	{ "peer", addpeer },
568	{ "include", include },
569	{ "filt", addfilter },
570	{ "lfilt", addlfilter },
571	{ "rfilt", addrfilter },
572	{ "next", nextfork },
573	{ "flood", addflood },
574	{ "lflood", addlflood },
575	{ "rflood", addrflood },
576	{ 0, 0 }
577	};
578
579	#define AVMAX 16
580
581	static void parse(char *p)
582	{
583	char *v[AVMAX];
584	unsigned c = 0;
585	const struct cmdtab *ct;
586
587	p = strtok(p, ":");
588	if (!p \|\| *p == '#')
589	return;
590	do {
591	v[c++] = p;
592	p = strtok(0, ":");
593	} while (p && c < AVMAX - 1);
594	v[c] = 0;
595	for (ct = cmdtab; ct->name; ct++) {
596	if (strcmp(ct->name, v[0]) == 0) {
597	ct->func(c - 1, v + 1);
598	return;
599	}
600	}
601	die(1, "unknown command `%s'", v[0]);
602	}
603
604	/----- Main driver -------------------------------------------------------/
605
606	static void version(FILE *fp)
607	{
608	pquis(fp, "$, TrIPE version " VERSION "\n");
609	}
610
611	static void usage(FILE *fp)
612	{
2d752320	613	pquis(fp, "Usage: $ [-k KEYRING] DIRECTIVE...\n");
50c74957	614	}
	615
	616	static void help(FILE *fp)
	617	{
	618	version(fp);
	619	putc('\n', fp);
	620	usage(fp);
2d752320	621	fputs("\n\
3cdc3f3a	622	Options:\n\
	623	\n\
	624	-h, --help Show this help text.\n\
	625	-v, --version Show the version number.\n\
	626	-u, --usage Show terse usage summary.\n\
	627	\n\
	628	-k, --keyring=FILE Fetch keys from FILE.\n\
	629	\n\
2d752320	630	Directives:\n\
	631	peer:NAME:LOCAL-PORT:REMOTE-ADDR:REMOTE-PORT\n\
	632	include:FILE\n\
	633	{,l,r}filt:FILTER:ARGS:...\n\
	634	next:TAG\n\
	635	{,l,r}flood:TYPE:MILLIS:SIZE\n\
	636	\n\
	637	Filters:\n\
	638	send\n\
	639	fork:TAG\n\
	640	delay:QLEN[:MILLIS:P-REPLAY]\n\
	641	corrupt[:P-CORRUPT]\n",
	642	fp);
50c74957	643	}
	644
	645	int main(int argc, char *argv[])
	646	{
	647	const char *kfname = "keyring.pub";
	648	int i;
	649	unsigned f = 0;
	650	char buf[16];
	651
	652	#define f_bogus 1u
	653
	654	ego(argv[0]);
	655	for (;;) {
	656	static const struct option opt[] = {
	657	{ "help", 0, 0, 'h' },
	658	{ "version", 0, 0, 'v' },
	659	{ "usage", 0, 0, 'u' },
	660	{ "keyring", OPTF_ARGREQ, 0, 'k' },
	661	{ 0, 0, 0, 0 }
	662	};
	663	if ((i = mdwopt(argc, argv, "hvuk:", opt, 0, 0, 0)) < 0)
	664	break;
	665	switch (i) {
	666	case 'h':
	667	help(stdout);
	668	exit(0);
	669	case 'v':
	670	version(stdout);
	671	exit(0);
	672	case 'u':
	673	usage(stdout);
	674	exit(0);
	675	case 'k':
	676	kfname = optarg;
	677	break;
	678	default:
	679	f \|= f_bogus;
	680	break;
	681	}
	682	}
	683	if (f & f_bogus) {
	684	usage(stderr);
	685	exit(1);
	686	}
	687	rand_noisesrc(RAND_GLOBAL, &noise_source);
	688	rand_seed(RAND_GLOBAL, 160);
	689	rand_get(RAND_GLOBAL, buf, sizeof(buf));
	690	rng = rc4_rand(buf, sizeof(buf));
	691	sel_init(&sel);
	692	if (key_open(&keys, kfname, KOPEN_READ, key_moan, 0))
	693	die(1, "couldn't open `%s': %s", kfname, strerror(errno));
	694	for (i = optind; i < argc; i++)
	695	parse(argv[i]);
	696	if (npeer != 2)
	697	die(1, "need two peers");
	698	for (;;)
	699	sel_select(&sel);
	700
	701	#undef f_bogus
	702	}
	703
	704	/----- That's all, folks -------------------------------------------------/