## diffname ip/ipmux.c 1998/0324
## diff -e /dev/null /n/emeliedump/1998/0324/sys/src/brazil/ip/ipmux.c
0a
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"

#include "ip.h"

#define DPRINT if(0)print

typedef struct Iphdr	Iphdr;

enum
{
	IPHDR		= 20,		/* sizeof(Iphdr) */
};

struct Iphdr
{
	uchar	vihl;		/* Version and header length */
	uchar	tos;		/* Type of service */
	uchar	length[2];	/* packet length */
	uchar	id[2];		/* ip->identification */
	uchar	frag[2];	/* Fragment information */
	uchar	ttl;		/* Time to live */
	uchar	proto;		/* Protocol */
	uchar	cksum[2];	/* Header checksum */
	uchar	src[4];		/* IP source */
	uchar	dst[4];		/* IP destination */
};

enum
{
	Tproto,
	Tdata,
	Tdst,
	Tsrc,
	Tifc,
};

char *ftname[] = 
{
[Tproto]	"proto",
[Tdata]		"data",
[Tdst]		"dst",
[Tsrc]		"src",
[Tifc]		"ifc",
};

typedef struct Ipmux Ipmux;

struct Ipmux
{
	Ipmux	*yes;
	Ipmux	*no;
	uchar	type;
	ushort	len;		/* length in bytes of item to compare */
	ushort	off;		/* offset of comparison */
	int	n;		/* number of items val points to */
	uchar	*val;
	uchar	*mask;

	int	ref;		/* so we can garbage collect */
};

static char*
skipwhite(char *p)
{
	while(*p == ' ' || *p == '\t')
		p++;
	return p;
}

static char*
follows(char *p, char c)
{
	char *f;

	f = strchr(p, c);
	if(f == nil)
		return nil;
	*f++ = 0;
	f = skipwhite(f);
	if(*f == 0)
		return nil;
	return f;
}

static Ipmux*
parseop(char **pp)
{
	char *p = *pp;
	int type, off, end, len;
	Ipmux *f;

	off = 0;
	p = skipwhite(p);
	if(strncmp(p, "dst", 3) == 0){
		type = Tdst;
		len = IPaddrlen;
		p += 3;
	}
	else if(strncmp(p, "src", 3) == 0){
		type = Tsrc;
		len = IPaddrlen;
		p += 3;
	}
	else if(strncmp(p, "ifc", 3) == 0){
		type = Tifc;
		len = IPaddrlen;
		p += 3;
	}
	else if(strncmp(p, "proto", 5) == 0){
		type = Tproto;
		len = 1;
		p += 5;
	}
	else if(strncmp(p, "data", 4) == 0){
		type = Tdata;
		p += 4;
		p = skipwhite(p);
		if(*p != '[')
			return nil;
		p++;
		off = strtoul(p, &p, 0);
		p = skipwhite(p);
		if(*p != ':')
			end = off;
		else {
			p++;
			p = skipwhite(p);
			end = strtoul(p, &p, 0);
			if(end < off)
				return nil;
			p = skipwhite(p);
		}
		if(*p != ']')
			return nil;
		len = end - off + 1;
		p++;
	}
	else 
		return nil;

	f = smalloc(sizeof(*f));
	f->type = type;
	f->len = len;
	f->off = off;
	f->val = nil;
	f->mask = nil;
	f->n = 1;
	f->ref = 1;

	return f;	
}

static int
htoi(char x)
{
	if(x >= '0' && x <= '9')
		x -= '0';
	else if(x >= 'a' && x <= 'f')
		x -= 'a' - 10;
	else if(x >= 'A' && x <= 'F')
		x -= 'A' - 10;
	else
		x = 0;
	return x;
}

static int
hextoi(char *p)
{
	return (htoi(p[0])<<4) | htoi(p[1]);
}

static void
parseval(uchar *v, char *p, int len)
{
	while(*p && len-- > 0){
		*v++ = hextoi(p);
		p += 2;
	}
}

static Ipmux*
parsedemux(char *p)
{
	int n;
	Ipmux *f;
	char *val;
	char *mask;
	char *vals[20];
	uchar *v;

	/* parse operand */
	f = parseop(&p);
	if(f == nil)
		return nil;

	/* find value */
	val = follows(p, '=');
	if(val == nil)
		goto parseerror;

	/* parse mask */
	mask = follows(p, '&');
	if(mask != nil){
		switch(f->type){
		case Tsrc:
		case Tdst:
		case Tifc:
			f->mask = smalloc(f->len);
			parseipmask(f->mask, mask);
			break;
		case Tdata:
			f->mask = smalloc(f->len);
			parseval(f->mask, mask, f->len);
			break;
		default:
			goto parseerror;
		}
	} else
		f->mask = nil;

	/* parse vals */
	f->n = tokenize(val, vals, sizeof(vals)/sizeof(char*));
	if(f->n == 0)
		goto parseerror;
	f->val = smalloc(f->n*f->len);
	v = f->val;
	for(n = 0; n < f->n; n++){
		switch(f->type){
		case Tsrc:
		case Tdst:
		case Tifc:
			parseip(v, vals[n]);
			break;
		case Tproto:
		case Tdata:
			parseval(v, vals[n], f->len);
			break;
		}
		v += f->len;
	}

	return f;

parseerror:
	if(f->mask)
		free(f->mask);
	if(f->val)
		free(f->val);
	free(f);
	return nil;
}

/*
 *  Compare relative ordering of two ipmuxs.  This doesn't compare the
 *  values, just the fields being looked at.  
 *
 *  returns:	<0 if a is a more specific match
 *		 0 if a and b are matching on the same fields
 *		>0 if b is a more specific match
 */
static int
ipmuxcmp(Ipmux *a, Ipmux *b)
{
	int n;

	/* compare types, lesser ones are more important */
	n = a->type - b->type;
	if(n != 0)
		return n;

	/* compare offsets, call earlier ones more specific */
	n = a->off - b->off;
	if(n != 0)
		return n;

	/* compare match lengths, longer ones are more specific */
	n = b->len - a->len;
	if(n != 0)
		return n;

	/*
	 *  if we get here we have two entries matching
	 *  the same bytes of the record.  Now check
	 *  the mask for equality.  Longer masks are
	 *  more specific.
	 */
	if(a->mask != nil && b->mask == nil)
		return -1;
	if(a->mask == nil && b->mask != nil)
		return 1;
	if(a->mask != nil && b->mask != nil){
		n = memcmp(b->mask, a->mask, a->len);
		if(n != 0)
			return n;
	}
	return 0;
}

/*
 *  Compare the values of two ipmuxs.  We're assuming that ipmuxcmp
 *  returned 0 comparing them.
 */
static int
ipmuxvalcmp(Ipmux *a, Ipmux *b)
{
	int n;

	n = b->len*b->n - a->len*a->n;
	if(n != 0)
		return n;
	return memcmp(a->val, b->val, a->len*a->n);
} 

/*
 *  add onto an existing ipmux chain in the canonical comparison
 *  order
 */
static void
ipmuxchain(Ipmux **l, Ipmux *f)
{
	for(; *l; l = &(*l)->yes)
		if(ipmuxcmp(f, *l) < 0)
			break;
	f->yes = *l;
	*l = f;
}

/*
 *  copy a tree
 */
static Ipmux*
ipmuxcopy(Ipmux *f)
{
	Ipmux *nf;

	if(f == nil)
		return nil;
	nf = smalloc(sizeof *nf);
	*nf = *f;
	nf->no = ipmuxcopy(f->no);
	nf->yes = ipmuxcopy(f->yes);
	nf->val = smalloc(f->n*f->len);
	memmove(nf->val, f->val, f->n*f->len);
	return nf;
}

static void
ipmuxfree(Ipmux *f)
{
	if(f->val != nil)
		free(f->val);
	free(f);
}

static void
ipmuxtreefree(Ipmux *f)
{
	if(f->no != nil)
		ipmuxfree(f->no);
	if(f->yes != nil)
		ipmuxfree(f->yes);
	ipmuxfree(f);
}

/*
 *  merge two trees
 */
static Ipmux*
ipmuxmerge(Ipmux *a, Ipmux *b)
{
	int n;
	Ipmux *f;

	if(a == nil)
		return b;
	if(b == nil)
		return a;
	n = ipmuxcmp(a, b);
	if(n < 0){
		f = ipmuxcopy(b);
		a->yes = ipmuxmerge(a->yes, b);
		a->no = ipmuxmerge(a->no, f);
		return a;
	}
	if(n > 0){
		f = ipmuxcopy(a);
		b->yes = ipmuxmerge(b->yes, a);
		b->no = ipmuxmerge(b->no, f);
		return b;
	}
	if(ipmuxvalcmp(a, b) == 0){
		a->yes = ipmuxmerge(a->yes, b->yes);
		a->no = ipmuxmerge(a->no, b->no);
		a->ref++;
		ipmuxfree(b);
		return a;
	}
	a->no = ipmuxmerge(a->no, b);
	return a;
}

/*
 *  remove a chain from a demux tree.  This is like merging accept that
 *  we remove instead of insert.
 */
int
ipmuxremove(Ipmux **l, Ipmux *f)
{
	int n, rv;
	Ipmux *ft;

	if(f == nil)
		return 0;		/* we've removed it all */
	if(*l == nil)
		return -1;

	ft = *l;
	n = ipmuxcmp(ft, f);
	if(n < 0){
		/* *l is maching an earlier field, descend both paths */
		rv = ipmuxremove(&ft->yes, f);
		rv += ipmuxremove(&ft->no, f);
		return rv;
	}
	if(n > 0){
		/* f represents an earlier field than *l, this should be impossible */
		return -1;
	}

	/* if we get here f and *l are comparing the same fields */
	if(ipmuxvalcmp(ft, f) != 0){
		/* different values mean mutually exclusive */
		return ipmuxremove(&ft->no, f);
	}

	/* we found a match */
	if(--(ft->ref) == 0){
		/*
		 *  a dead node implies the whole yes side is also dead.
		 *  since our chain is constrained to be on that side,
		 *  we're done.
		 */
		ipmuxtreefree(ft->yes);
		*l = ft->no;
		ipmuxfree(ft);
		return 0;
	}

	/*
	 *  free the rest of the chain.  it is constrained to match the
	 *  yes side.
	 */
	return ipmuxremove(&ft->yes, f->yes);
}

void
printtree(Biobuf *b, Ipmux *f, int level)
{
	int i, j;
	uchar *p;

	if(f == nil) {
		Bprint(b, "\n");
		return;
	}
	for(i = 0; i < level; i++)
		Bprint(b, " ");
	Bprint(b, "%s", ftname[f->type]);
	if(f->type == Tdata)
		Bprint(b, "[%d:%d]", f->off, f->off+f->len-1);
	if(f->mask){
		switch(f->type){
		case Tifc:
		case Tsrc:
		case Tdst:
			Bprint(b, " & %M", f->mask);
			break;
		case Tproto:
		case Tdata:
			Bprint(b, " & ");
			for(j = 0; j < f->len; j++)
				Bprint(b, "%2.2ux", f->mask[j]);
			break;
		}
	}
	p = f->val;
	Bprint(b, " =");
	for(i = 0; i < f->n; i++){
		switch(f->type){
		case Tifc:
		case Tsrc:
		case Tdst:
			Bprint(b, " %I", p);
			break;
		case Tproto:
		case Tdata:
			Bprint(b, " ");
			for(j = 0; j < f->len; j++)
				Bprint(b, "%2.2ux", p[j]);
			break;
		}
		p += f->len;
	}
	Bprint(b, "\n");
	printtree(b, f->yes, level+1);
	printtree(b, f->no, level+1);
}

void
main(void)
{
	Ipmux *f, *f1, *f2, *f1copy, *f2copy;
	Ipmux *root;
	Biobuf out;

	Binit(&out, 1, OWRITE);
	fmtinstall('I', eipconv);
	fmtinstall('M', eipconv);

	Bprint(&out, "demux 1:\n");
	f1 = parsedemux("data[0:3] = 12345678 23456789 3456789a");
	f = parsedemux("ifc = 135.104.9.2");
	ipmuxchain(&f1, f);
	f = parsedemux("src & 255.255.255.0 = 135.104.9.2");
	ipmuxchain(&f1, f);
	f = parsedemux("proto = 17");
	ipmuxchain(&f1, f);
	printtree(&out, f1, 0);

	f1copy = ipmuxcopy(f1);

	Bprint(&out, "demux 2:\n");
	f2 = parsedemux("data[0:3] = 12345678 23456789 3456789a");
	f = parsedemux("ifc = 135.104.9.1");
	ipmuxchain(&f2, f);
	f = parsedemux("src & 255.255.255.0 = 135.104.9.3");
	ipmuxchain(&f2, f);
	printtree(&out, f2, 0);

	f2copy = ipmuxcopy(f2);

	Bprint(&out, "merged demux:\n");
	root = ipmuxmerge(f1, f2);
	printtree(&out, root, 0);
	
	Bprint(&out, "demux 1 removed:\n");
	ipmuxremove(&root, f1copy);
	printtree(&out, root, 0);
	
	Bprint(&out, "demux 2 removed:\n");
	ipmuxremove(&root, f2copy);
	printtree(&out, root, 0);
}

enum
{
	Tproto,
	Tdata,
	Tdst,
	Tsrc,
	Tifc,
};

char *ftname[] = 
{
[Tdata]	"data",
[Tdst]	"dst",
[Tsrc]	"src",
[Tifc]	"ifc",
};

struct Ipmux
{
	Ipmux	*yes;
	Ipmux	*no;
	uchar	type;
	ushort	len;		/* length in bytes of item to compare */
	ushort	off;		/* offset of comparison */
	int	n;		/* number of items val points to */
	uchar	*val;
	uchar	*mask;

	Conv	*c;
	int	ref;		/* so we can garbage collect */
};

/*
 *  connection request is a semi separated list of filters
 *  e.g. proto=17;dat[0:4]=11aa22bb;ifc=135.104.9.2
 *
 *  there's no protection against overlapping specs.
 */
static char*
ipmuxconnect(Conv *c, char **argv, int argc)
{
	int n, proto;
	char *field[10];
	Ipmux *mux, *chain;
	Fs *f;

	f = c->p->f;

	if(argc != 2)
		return Ebadarg;

	n = parsefields(argv[1], field, nelem(field), ";");
	if(n <= 0)
		return Ebadarg;

	chain = nil; 
	for(i = 0; i < n; i++){
		mux = ipmuxparse(field[i]);
		if(mux == nil){
			ipmuxtreefree(chain);
			return Ebadarg;
		}
		ipmuxchain(&chain, mux);
	}

	/* optimize the protocol into an array lookup */
	if(chain->type != Tproto){
		ipmuxtreefree(chain);
		return "need proto rule";
	}
	mux = chain;
	proto = mux->val;
	chain = chain->yes;
	ipmuxfree(mux);

	/* save a copy of the chain so we can later remove it */
	mux->conv = c;
	mux = ipmuxcopy(chain);
	*(Ipmux***)(c->ptcl) = chain;

	/* add the chain to the protocol demultiplexor tree */
	qlock(p);
	f->t2m[proto] = ipmuxmerge(f->t2m[proto], mux);
	qunlock(p);

	Fsconnected(c, nil);
	return nil;
}

static int
ipmuxstate(Conv *c, char *state, int n)
{
	USED(c);
	return snprint(state, n, "%s", "Datagram");
}

static void
ipmuxcreate(Conv *c)
{
	c->rq = qopen(64*1024, 0, 0, c);
	c->wq = qopen(64*1024, 0, 0, 0);
	*(IPmux**)(c->ptcl) = nil;
}

static char*
ipmuxannounce(Conv*, char**, int)
{
	return "ipmux does not support announce";
}

static void
ipmuxclose(Conv *c)
{
	qclose(c->rq);
	qclose(c->wq);
	qclose(c->eq);
	ipmove(c->laddr, IPnoaddr);
	ipmove(c->raddr, IPnoaddr);
	c->lport = 0;
	c->rport = 0;

	unlock(c);
}

/*
 *  takes a fully formed ip packet and just passes it down
 *  the stack
 */
static void
ipmuxkick(Conv *c, int l)
{
}

static void
ipmuxiput(Proto *ipmux, uchar*, Block *bp)
{
}

int
ipmuxstats(Proto *ipmux, char *buf, int len)
{
	return 0;
}

void
ipmuxinit(Fs *fs)
{
	Proto *ipmux;

	ipmux = smalloc(sizeof(Proto));
	ipmux->priv = smalloc(sizeof(GREpriv));
	ipmux->name = "ipmux";
	ipmux->kick = ipmuxkick;
	ipmux->connect = ipmuxconnect;
	ipmux->announce = ipmuxannounce;
	ipmux->state = ipmuxstate;
	ipmux->create = ipmuxcreate;
	ipmux->close = ipmuxclose;
	ipmux->rcv = ipmuxiput;
	ipmux->ctl = nil;
	ipmux->advise = nil;
	ipmux->stats = ipmuxstats;
	ipmux->ipproto = -1;
	ipmux->nc = 64;
	ipmux->ptclsize = sizeof(Ipmux*);

	Fsproto(fs, ipmux);
}
.
## diffname ip/ipmux.c 1998/0325
## diff -e /n/emeliedump/1998/0324/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0325/sys/src/brazil/ip/ipmux.c
725c
	ipmux->ptclsize = sizeof(Ipmuxrock);
.
711c
	ipmux->priv = nil;
.
700c
ipmuxstats(Proto *p, char *buf, int len)
.
696a
	int len;
	Iphdr *ip;
	Fs *f = p->f;
	uchar *p;
	Conv *c;

	ip = bp->rptr;
	rlock(f);
	mux = f->t2m[ip->proto];
	if(mux == nil)
		goto out;

	/* run the v4 filter */
	len = BLEN(bp);
	if(len < 64 && bp->next){
		bp = concatblock(bp);
		len = BLEN(bp);
	}
	c = nil;
	while(mux != nil){
		while(mux){
			switch(mux->type){
			case Tia:
				p = ia;
				break;
			case Tsrc:
				p = ip->src;
				break;
			case Tdst:
				p = ip->dst;
				break;
			case Tdata:
				p = ip->data;
				if(mux->off+mux->len > len)
					goto no;
				break;
			}
		}
		if(mux->mask != nil){
		} else {
		}
no:
		mux = mux->no;
		continue;
	}
out:
	/* doesn't match any filter, hand it to the specific protocol handler */
	runlock(f);
	p = f->t2p[ip->proto];
	if(p)
		(*p->rcv)(p, ia, bp);
	else
		freeblist(bp);
	return;	
.
695c
ipmuxiput(Proto *p, uchar *ia, Block *bp)
.
681a
	wlock(f);
	ipmuxremove(&(f->t2m[r->proto]), r->chain);
	wunlock(f);
	ipmuxtreefree(f->chain);

.
673a
	Ipmuxrock *r;

	r = (Ipmuxrock*)(c->ptcl);
	r->chain = chain;
	r->proto = proto;

.
644c
	wunlock(f);
.
642c
	wlock(f);
.
639c
	r = (Ipmuxrock*)(c->ptcl);
	r->chain = chain;
	r->proto = proto;
.
604a
	Ipmuxrock *r;
.
462,592d
412c
static int
.
66a
/*
 *  someplace to hold per conversation data
 */
struct Ipmuxrock
{
	Ipmux	*chain;
	int	proto;
};

.
51,52c
/*
 *  a node in the decision tree
 */
.
30a
	uchar	data[1];	/* start of data */
.
12c
typedef struct Iphdr		Iphdr;
typedef struct Ipmuxrock	Ipmuxrock;
typedef struct Ipmux		Ipmux;
.
## diffname ip/ipmux.c 1998/0326
## diff -e /n/emeliedump/1998/0325/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0326/sys/src/brazil/ip/ipmux.c
631,634c
			
.
629a
			if(v == ve){
				if(mux->c != nil)
					c = mux->c;
				mux = mux->yes;
				if(
				
.
613,628c
		v = mux->val;
		for(e = v + mux->n*mux->len; v < e; v = ve){
			m = mux->mask;
			hp = h + mux->off;
			for(ve = v + mux->len; v < ve; v++){
				if((*hp++ & *m++) != *v++)
					break;
.
610a
	memmove(h, ia+IPv4off, ia);

	/* run the v4 filter */
.
605,609c
	/* make interface address part of packet */
	h = bp->rptr - IPHDR - IPv4addrlen;
	if(h < bp->base){
		bp = padblock(bp, IPHDR + IPv4addrlen);
		h = bp->rptr;
		bp->rptr += IPHDR + IPv4addrlen;
.
599d
596c
	uchar *m, *h, *v, *e, *ve, *hp;
.
594d
62c
	uchar	len;		/* length in bytes of item to compare */
.
## diffname ip/ipmux.c 1998/0327
## diff -e /n/emeliedump/1998/0326/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0327/sys/src/brazil/ip/ipmux.c
673c
	f->ipmux = ipmux;			/* hack for Fsrcvpcol */

	Fsproto(f, ipmux);
.
652c
ipmuxinit(Fs *f)
.
648c
	int n;
	Fs *f = p->f;

	rlock(f);
	n = ipmuxsprint(p->priv, 0, buf, len);
	runlock(f);

	return n;
.
645c
static int
ipmuxsprint(Ipmux *mux, int level, char *buf, int len)
{
	int i, j, n;

	n = 0;
	if(mux == nil)
		return n;
	for(i = 0; i < level; i++)
		n += snprint(buf+n, len-n, " ");
	n += snprint(buf+n, len-n, "h[%d:%d] & ", mux->off, mux->off+mux->len-1);
	for(i = 0; i < mux->len; i++)
		n += snprint(buf+n, len - n, "%2.2ux", mux->mask[i]);
	for(j = 0; j < mux->n; j++){
		for(i = 0; i < mux->len; i++)
			n += snprint(buf+n, len - n, "%2.2ux", mux->mask[i]);
		n += snprint(buf+n, len-n, "|");
	}
	level++;
	n += ipmuxsprint(mux->no, level, buf+n, len-n);
	n += ipmuxsprint(mux->yes, level, buf+n, len-n);
	return n;
}

static int
.
642c
	return;
.
636a

	if(c != nil){
		bp->rp -= IPHDR;
		if(bp->next){
			bp = concatblock(bp);
			if(bp == 0)
				panic("ilpullup");
		}
		qpass(c->rq, bp);
	}

nomatch:
	/* doesn't match any filter, hand it to the specific protocol handler */
	ip = (Iphdr*)bp->rp;
.
634,635d
630,632c
		if(v == e)
			mux = mux->no;
.
627,628c
				break;
			}
.
624,625c
				if(mux->conv != nil)
					c = mux->conv;
.
614a
		if(mux->len + mux->off > len){
			mux = mux->no;
			continue;
		}
.
613a
	mux = f->ipmux->priv;
.
612c
	/* run the v4 filter (needs optimizing) */
	rlock(f);
.
610c
	memmove(h, ia+IPv4off, IPv4addrlen);
	len = BLEN(bp);
.
607,608c
		h = bp->rp;
		bp->rp += IPHDR + IPv4addrlen;
.
604c
	h = bp->rp - IPHDR - IPv4addrlen;
.
598,601c
	if(p->priv == nil)
		goto nomatch;
.
596a
	Ipmux *mux;
	Iphdr *ip;
.
587a
	Block *bp;

	bp = qget(c->wq);
	if(bp == nil)
		return;
	ipoput(c->p->f, bp, 0, 0);
.
586c
ipmuxkick(Conv *c, int)
.
576c
	ipmuxtreefree(r->chain);
.
574c
	ipmuxremove(&(c->p->priv), r->chain);
.
562,563d
559a
	Fs *f = c->p->f;
.
547c
	r = (Ipmuxrock*)(c->ptcl);
	r->chain = nil;
.
544a
	Ipmuxrock *r;

.
528c
	f->ipmux->priv = ipmuxmerge(f->ipmux->priv, mux);
.
524d
520d
509,518d
507a
	if(chain == nil)
		return Ebadarg;
	mux->conv = c;
.
501c
		mux = parsemux(field[i]);
.
499c
	chain = nil;
	mux = nil;
.
484c
	int i, n;
.
376a
	if(f == nil)
		return;
.
241c
	f->n = parsefields(val, vals, sizeof(vals)/sizeof(char*), "|");
.
237,238c
	} else {
		f->mask = smalloc(f->len);
		memset(f->mask, 0xff, f->len);
	}
.
201c
parsemux(char *p)
.
154a
		len = end - off + 1;
		off += ((ulong)(ipoff->data)) - IPHDR;
.
153d
139a
		if(off < 0 || off > (64-IPHDR))
			return nil;
.
128a
		off = ((ulong)&(ipoff->proto)) - IPHDR;
.
124c
		off = -IPv4addrlen - IPHDR;
		len = IPv4addrlen;
.
119c
		off = ((ulong)(ipoff->src)) - IPHDR;
		len = IPv4addrlen;
.
114c
		off = ((ulong)(ipoff->dst)) - IPHDR;
		len = IPv4addrlen;
.
110d
77d
68a
	Conv	*conv;
.
34a
Iphdr *ipoff = 0;
.
## diffname ip/ipmux.c 1998/0328
## diff -e /n/emeliedump/1998/0327/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0328/sys/src/brazil/ip/ipmux.c
691a
	n += snprint(buf+n, len-n, "\n");
.
689c
			n += snprint(buf+n, len - n, "%2.2ux", *v++);
.
686a
	n += snprint(buf+n, len-n, "=");
	v = mux->val;
.
684c
	if(mux == nil){
		n += snprint(buf+n, len-n, "\n");
		return n;
	}
	n += snprint(buf+n, len-n, "h[%d:%d]&", mux->off, mux->off+mux->len-1);
.
680,681d
677a
	uchar *v;
.
660a
		return;
.
654d
648,649c
		mux = mux->no;
match:;
.
645c
				goto match;
.
638c
				if((*hp++ & *m++) != *v)
.
621c
	h = bp->rp;
	memmove(h-IPv4addrlen, ia+IPv4off, IPv4addrlen);
.
615,619c
	if(bp->rp - bp->base < IPv4addrlen){
		bp = padblock(bp, IPv4addrlen);
		bp->rp += IPv4addrlen;
.
581a
	r->chain = nil;
.
541,542c
	Ipmuxrock *r;
	
	r = (Ipmuxrock*)(c->ptcl);
	return ipmuxsprint(r->chain, 0, state, n);
.
260c
			v4parseip(v, vals[n]);
.
235c
			v4parseip(f->mask, mask);
.
161c
		off += (ulong)(ipoff->data);
.
132c
		off = (ulong)&(ipoff->proto);
.
126c
		off = -IPv4addrlen;
.
120c
		off = (ulong)(ipoff->src);
.
114c
		off = (ulong)(ipoff->dst);
.
80a
static int	ipmuxsprint(Ipmux*, int, char*, int);

.
64c
	short	off;		/* offset of comparison */
.
## diffname ip/ipmux.c 1998/0401
## diff -e /n/emeliedump/1998/0328/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0401/sys/src/brazil/ip/ipmux.c
653d
638c
		for(e = mux->e; v < e; v = ve){
.
631a
match:
.
372a
	nf->e = nf->val + f->n*f->len;
.
271a
	f->e = f->val + f->n*f->len;
.
67a
	uchar	*e;		/* val + n*len */
.
65d
63a
	uchar	n;		/* number of items val points to */
.
62c
	uchar	type;		/* type of field (Txxxx) */
.
## diffname ip/ipmux.c 1998/0402
## diff -e /n/emeliedump/1998/0401/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0402/sys/src/brazil/ip/ipmux.c
658,669d
656a
		continue;
yes:
		if(mux->conv != nil)
			c = mux->conv;
		mux = mux->yes;
.
649,654d
641,647c
		hp = h + mux->off;
		switch(mux->ctype){
		case Cbyte:
			if(*mux->val == *hp)
				goto yes;
			break;
		case Cmbyte:
			if((*mux->val & *mux->mask) == *hp)
				goto yes;
			break;
		case Cshort:
			if(*((ushort*)mux->val) == *(ushort*)hp)
				goto yes;
			break;
		case Cmshort:
			if((*((ushort*)mux->val) & (*((ushort*)mux->mask))) == *(ushort*)hp)
				goto yes;
			break;
		case Clong:
			if(*((ulong*)mux->val) == *(ulong*)hp)
				goto yes;
			break;
		case Cmlong:
			if((*((ulong*)mux->val) & (*((ulong*)mux->mask))) == *(ulong*)hp)
				goto yes;
			break;
		case Cifc:
			if(*((ulong*)mux->val) == *(ulong*)ia)
				goto yes;
			break;
		case Cmifc:
			if((*((ulong*)mux->val) & (*((ulong*)mux->mask))) == *(ulong*)ia)
				goto yes;
			break;
		default:
			v = mux->val;
			for(e = mux->e; v < e; v = ve){
				m = mux->mask;
				hp = h + mux->off;
				for(ve = v + mux->len; v < ve; v++){
					if((*hp++ & *m++) != *v)
						break;
				}
				if(v == ve)
					goto yes;
.
637c
		if(mux->eoff > len){
.
635d
631c
	/* run the v4 filter */
.
628d
622,626d
375c
	nf->e = nf->val + f->len*f->n;
.
273a
	f->ctype = Cother;
	if(f->n == 1){
		switch(f->len){
		case 1:
			f->ctype = nomask ? Cbyte : Cmbyte;
			break;
		case 2:
			f->ctype = nomask ? Cshort : Cmshort;
			break;
		case 4:
			if(f->type == Cifc)
				f->ctype = nomask ? Cifc : Cmifc;
			else
				f->ctype = nomask ? Clong : Cmlong;
			break;
		}
	}
.
272a
	f->eoff = f->off + f->len;
.
247a
		nomask = 1;
.
246a
		nomask = 0;
.
213c
	int n, nomask;
.
65a
	short	eoff;		/* end offset of comparison */
.
62a
	uchar	ctype;		/* tupe of comparison (Cxxxx) */
.
43a

	Cother = 0,
	Cbyte,		/* single byte */
	Cmbyte,		/* single byte with mask */
	Cshort,		/* single short */
	Cmshort,	/* single short with mask */
	Clong,		/* single long */
	Cmlong,		/* single long with mask */
	Cifc,
	Cmifc,
.
## diffname ip/ipmux.c 1998/0403
## diff -e /n/emeliedump/1998/0402/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0403/sys/src/brazil/ip/ipmux.c
719a
	if(c != nil){
		qpass(c->rq, bp);
		return;
	}
	runlock(f);
.
## diffname ip/ipmux.c 1998/0414
## diff -e /n/emeliedump/1998/0403/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0414/sys/src/brazil/ip/ipmux.c
724c

.
719a
	runlock(f);

.
638c

	ih = (Iphdr*)(bp->rp);

	ipoput(c->p->f, bp, 0, ih->ttl);
.
633a
	Iphdr *ih;
.
## diffname ip/ipmux.c 1998/0502
## diff -e /n/emeliedump/1998/0414/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0502/sys/src/brazil/ip/ipmux.c
525c
 *  e.g. proto=17;dat[0:4]=11aa22bb;ifc=135.104.9.2&255.255.255.0
.
## diffname ip/ipmux.c 1998/0507
## diff -e /n/emeliedump/1998/0502/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0507/sys/src/brazil/ip/ipmux.c
701c
			if((*(ulong*)(ia + IPv4off) & (*((ulong*)mux->mask))) == *((ulong*)mux->val))
.
697c
			if(*((ulong*)mux->val) == *(ulong*)(ia + IPv4off))
.
693c
			if((*(ulong*)hp & (*((ulong*)mux->mask))) == *((ulong*)mux->val))
.
685c
			if((*(ushort*)hp & (*((ushort*)mux->mask))) == *((ushort*)mux->val))
.
677c
			if((*hp & *mux->mask) == *mux->val)
.
299c
			if(f->type == Tifc)
.
## diffname ip/ipmux.c 1998/0602
## diff -e /n/emeliedump/1998/0507/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0602/sys/src/brazil/ip/ipmux.c
726a
		/* tack on interface address */
		bp = padblock(bp, IPaddrlen);
		ipmove(bp->rp, ia);
.
## diffname ip/ipmux.c 1998/0627
## diff -e /n/emeliedump/1998/0602/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0627/sys/src/brazil/ip/ipmux.c
730c
		bp = concatblock(bp);
		if(bp != nil)
			qpass(c->rq, bp);
.
## diffname ip/ipmux.c 1998/0630
## diff -e /n/emeliedump/1998/0627/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0630/sys/src/brazil/ip/ipmux.c
727,732c
		qpass(c->rq, bp);
.
## diffname ip/ipmux.c 1998/0701
## diff -e /n/emeliedump/1998/0630/sys/src/brazil/ip/ipmux.c /n/emeliedump/1998/0701/sys/src/brazil/ip/ipmux.c
727c
		/* tack on interface address */
		bp = padblock(bp, IPaddrlen);
		ipmove(bp->rp, ia);
		bp = concatblock(bp);
		if(bp != nil)
			if (qpass(c->rq, bp) < 0)
				print("Q");
.
## diffname ip/ipmux.c 1999/0302
## diff -e /n/emeliedump/1998/0701/sys/src/brazil/ip/ipmux.c /n/emeliedump/1999/0302/sys/src/brazil/ip/ipmux.c
623c
	qunlock(c);
.
## diffname ip/ipmux.c 1999/0817
## diff -e /n/emeliedump/1999/0302/sys/src/brazil/ip/ipmux.c /n/emeliedump/1999/0817/sys/src/brazil/ip/ipmux.c
642c
	ipoput(c->p->f, bp, 0, ih->ttl, ih->tos);
.
## diffname ip/ipmux.c 2000/0308
## diff -e /n/emeliedump/1999/0817/sys/src/brazil/ip/ipmux.c /n/emeliedump/2000/0308/sys/src/9/ip/ipmux.c
543c
	n = getfields(argv[1], field, nelem(field), 1, ";");
.
267c
	f->n = getfields(val, vals, sizeof(vals)/sizeof(char*), 1, "|");
.
## diffname ip/ipmux.c 2000/1220
## diff -e /n/emeliedump/2000/0308/sys/src/9/ip/ipmux.c /n/emeliedump/2000/1220/sys/src/9/ip/ipmux.c
622,623d
## diffname ip/ipmux.c 2001/0127
## diff -e /n/emeliedump/2000/1220/sys/src/9/ip/ipmux.c /n/emeliedump/2001/0127/sys/src/9/ip/ipmux.c
589c
	c->rq = qopen(64*1024, 1, 0, c);
.
## diffname ip/ipmux.c 2001/0306
## diff -e /n/emeliedump/2001/0127/sys/src/9/ip/ipmux.c /n/emeliedump/2001/0306/sys/src/9/ip/ipmux.c
629c
ipmuxkick(Conv *c)
.
## diffname ip/ipmux.c 2001/0623
## diff -e /n/emeliedump/2001/0306/sys/src/9/ip/ipmux.c /n/emeliedump/2001/0623/sys/src/9/ip/ipmux.c
740c
		(*p->rcv)(p, ifc, bp);
.
652a
	ia = ifc->lifc->local;

.
651a
	uchar *ia;
.
644c
ipmuxiput(Proto *p, Ipifc *ifc, Block *bp)
.
## diffname ip/ipmux.c 2002/0507
## diff -e /n/emeliedump/2001/0623/sys/src/9/ip/ipmux.c /n/emeliedump/2002/0507/sys/src/9/ip/ipmux.c
762c
	n += snprint(buf+n, len-n, "h[%d:%d]&", 
               mux->off+((int)mux->skiphdr)*((int)ipoff->data), 
               mux->off+(((int)mux->skiphdr)*((int)ipoff->data))+mux->len-1);
.
740,742c
	ip = (Ip4hdr*)bp->rp;
	if((ip->vihl&0xF0)==0x40) {
		p = f->t2p[ip->proto];
	} else {
		ip6 = (Ip6hdr*)bp->rp;
		p = f->t2p[ip6->proto];
	}
	if(p && p->rcv)
.
733c
			if(qpass(c->rq, bp) < 0)
.
730c
		ipmove(bp->rp, ifc->lifc->local);
.
702c
			if((*(ulong*)(ifc->lifc->local + IPv4off) & (*((ulong*)mux->mask))) == *((ulong*)mux->val))
.
698c
			if(*((ulong*)mux->val) == *(ulong*)(ifc->lifc->local + IPv4off))
.
671c
		hp = h + mux->off + ((int)mux->skiphdr)*hl;
.
654c
  ip = (Ip4hdr*)bp->rp;
  hl = (ip->vihl&0x0F)<<2;
.
651,652c
	Ip4hdr *ip;
	Ip6hdr *ip6;
.
646c
	int len, hl;
.
637,640c
	else {
		Ip4hdr *ih4 = (Ip4hdr*)(bp->rp);
		if((ih4->vihl)&0xF0 != 0x60)
			ipoput4(c->p->f, bp, 0, ih4->ttl, ih4->tos);
		else {
			ih6 = (struct Ip6hdr*)ih4;
			ipoput6(c->p->f, bp, 0, ih6->ttl, 0);
		}
	}
.
632c
	struct Ip6hdr *ih6;
.
336c
	n = (a->off+((int)a->skiphdr)*(ulong)ipoff->data) - 
      (b->off+((int)b->skiphdr)*(ulong)ipoff->data);
.
280a
    case Tiph:
.
252a
    case Tiph:
.
188a
  if(type == Tdata)
    f->skiphdr = 1;
  else
    f->skiphdr = 0;
.
178c
	else
.
176d
151,153c
	else if(strncmp(p, "data", 4) == 0 || strncmp(p, "iph", 3) == 0){
    if(strncmp(p, "data", 4) == 0) {
		  type = Tdata;
      p += 4;
    }
    else {
      type = Tiph;
	    p += 3;
    }
.
72,77c
	uchar	type;		 /* type of field (Txxxx) */
	uchar	ctype;   /* tupe of comparison (Cxxxx) */
	uchar	len;		 /* length in bytes of item to compare */
	uchar	n;		   /* number of items val points to */
	short	off;		 /* offset of comparison */
	short	eoff;		 /* end offset of comparison */
  uchar skiphdr; /* should offset start after ip header */
.
59a
[Tiph]	  "iph",
.
40a
  Tiph,
.
36a
struct Ip6hdr
{
  uchar vcf[4];  /* version, class label, and flow label */ 
  uchar ploadlen[2];  /* payload length */
  uchar proto; /* next header, i.e. proto */
  uchar ttl;   /* hop limit, i.e. ttl */
  uchar src[16]; /* IP source */
  uchar dst[16]; /* IP destination */
};


.
35c
Ip4hdr *ipoff = 0;
.
21c
struct Ip4hdr
.
18c
	IPHDR		= 20,		/* sizeof(Ip4hdr) */
.
12,14c
typedef struct Ipmuxrock  Ipmuxrock;
typedef struct Ipmux      Ipmux;
typedef struct Ip4hdr     Ip4hdr;
typedef struct Ip6hdr     Ip6hdr;
.
9d
## diffname ip/ipmux.c 2002/0711
## diff -e /n/emeliedump/2002/0507/sys/src/9/ip/ipmux.c /n/emeliedump/2002/0711/sys/src/9/ip/ipmux.c
615c
	c->rq = qopen(64*1024, Qmsg, 0, c);
.
## diffname ip/ipmux.c 2002/0712
## diff -e /n/emeliedump/2002/0711/sys/src/9/ip/ipmux.c /n/emeliedump/2002/0712/sys/src/9/ip/ipmux.c
839d
656a
	Conv *c = x;
.
655c
ipmuxkick(void *x)
.
616c
	c->wq = qopen(64*1024, Qkick, ipmuxkick, c);
.
108a
static void	ipmuxkick(void *x);
.
## diffname ip/ipmux.c 2002/1108
## diff -e /n/emeliedump/2002/0712/sys/src/9/ip/ipmux.c /n/emeliedump/2002/1108/sys/src/9/ip/ipmux.c
687,688c
	ip = (Ip4hdr*)bp->rp;
	hl = (ip->vihl&0x0F)<<2;
.
363c
		(b->off+((int)b->skiphdr)*(ulong)ipoff->data);
.
306c
		case Tiph:
.
277c
		case Tiph:
.
209,212c
	if(type == Tdata)
		f->skiphdr = 1;
	else
		f->skiphdr = 0;
.
167,174c
		if(strncmp(p, "data", 4) == 0) {
			type = Tdata;
			p += 4;
		}
		else {
			type = Tiph;
			p += 3;
		}
.
94c
	uchar	*e;		/* val+n*len*/
.
85,91c
	uchar	type;		/* type of field(Txxxx) */
	uchar	ctype;		/* tupe of comparison(Cxxxx) */
	uchar	len;		/* length in bytes of item to compare */
	uchar	n;		/* number of items val points to */
	short	off;		/* offset of comparison */
	short	eoff;		/* end offset of comparison */
	uchar	skiphdr;	/* should offset start after ipheader */
.
72c
[Tiph]	 	"iph",
.
52c
	Tiph,
.
39,44c
	uchar vcf[4];		/* version, class label, and flow label */ 
	uchar ploadlen[2];	/* payload length */
	uchar proto;		/* next header, i.e. proto */
	uchar ttl;		/* hop limit, i.e. ttl */
	uchar src[16];		/* IP source */
	uchar dst[16];		/* IP destination */
.
## diffname ip/ipmux.c 2003/0308
## diff -e /n/emeliedump/2002/1108/sys/src/9/ip/ipmux.c /n/emeliedump/2003/0308/sys/src/9/ip/ipmux.c
671c
			ipoput6(c->p->f, bp, 0, ih6->ttl, 0, nil);
.
668c
			ipoput4(c->p->f, bp, 0, ih4->ttl, ih4->tos, nil);
.