26 files changed, 4395 insertions(+), 922 deletions(-)

M ip/arp.c
M ip/devip.c
M ip/esp.c
M ip/ethermedium.c
M ip/gre.c
M ip/icmp.c
A ip/icmp6.c
M ip/igmp.c
M ip/il.c
M ip/ip.c
M ip/ip.h
M ip/ipaux.c
M ip/ipifc.c
M ip/ipmux.c
M ip/iproute.c
A ip/ipv6.c
A ip/ipv6.h
M ip/loopbackmedium.c
M ip/netdevmedium.c
M ip/netlog.c
M ip/pktmedium.c
M ip/rudp.c
M ip/tcp.c
M ip/tripmedium.c
M ip/udp.c
M port/devnmouse.c

@@ 6,6 6,7 @@
 #include "../port/error.h"
 
 #include "ip.h"
+#include "ipv6.h"
 
 /*
  *  address resolution tables


@@ 27,12 28,6 @@ char *arpstate[] =
 	"WAIT",
 };
 
-enum
-{
-	CMadd,
-	CMflush,
-};
-
 /*
  *  one per Fs
  */


@@ 42,24 37,27 @@ struct Arp
 	Fs	*f;
 	Arpent	*hash[NHASH];
 	Arpent	cache[NCACHE];
-};
-
-static
-Cmdtab arpcmd[] =
-{
-	CMadd,	"add",	0,
-	CMflush,	"flush",	1,
+	Arpent	*rxmt;
+	Proc	*rxmitp;	/* neib sol re-transmit proc */
+	Rendez	rxmtq;
+	Block 	*dropf, *dropl;
 };
 
 char *Ebadarp = "bad arp";
 
 #define haship(s) ((s)[IPaddrlen-1]%NHASH)
 
+extern int 	ReTransTimer = RETRANS_TIMER;
+static void 	rxmitproc(void *v);
+
 void
 arpinit(Fs *f)
 {
 	f->arp = smalloc(sizeof(Arp));
 	f->arp->f = f;
+	f->arp->rxmt = nil;
+	f->arp->dropf = f->arp->dropl = nil;
+	kproc("rxmitproc", rxmitproc, f->arp);
 }
 
 static Arpent*


@@ 83,6 81,7 @@ newarp(Arp *arp, uchar *ip, Medium *m)
 	/* dump waiting packets */
 	xp = a->hold;
 	a->hold = nil;
+
 	while(xp){
 		next = xp->list;
 		freeblist(xp);


@@ 92,7 91,74 @@ newarp(Arp *arp, uchar *ip, Medium *m)
 	/* take out of current chain */
 	l = &arp->hash[haship(a->ip)];
 	for(f = *l; f; f = f->hash){
-		if(f == a) {
+		if(f == a){
+			*l = a->hash;
+			break;
+		}
+		l = &f->hash;
+	}
+
+	/* insert into new chain */
+	l = &arp->hash[haship(ip)];
+	a->hash = *l;
+	*l = a;
+	memmove(a->ip, ip, sizeof(a->ip));
+	a->used = msec;
+	a->time = 0;
+	a->type = m;
+
+	return a;
+}
+
+static Arpent*
+newarp6(Arp *arp, uchar *ip, Ipifc *ifc, int addrxt)
+{
+	uint t;
+	Block *next, *xp;
+	Arpent *a, *e, *f, **l;
+	Medium *m = ifc->m;
+	int empty;
+
+	/* find oldest entry */
+	e = &arp->cache[NCACHE];
+	a = arp->cache;
+	t = a->used;
+	for(f = a; f < e; f++){
+		if(f->used < t){
+			t = f->used;
+			a = f;
+		}
+	}
+
+	/* dump waiting packets */
+	xp = a->hold;
+	a->hold = nil;
+
+	if(isv4(a->ip)){
+		while(xp){
+			next = xp->list;
+			freeblist(xp);
+			xp = next;
+		}
+	}
+	else {	// queue icmp unreachable for rxmitproc later on, w/o arp lock
+		if(xp){
+			if(arp->dropl == nil) 
+				arp->dropf = xp;
+			else
+				arp->dropl->list = xp;
+
+			for(next = xp->list; next; next = next->list)
+				xp = next;
+			arp->dropl = xp;
+			wakeup(&arp->rxmtq);
+		}
+	}
+
+	/* take out of current chain */
+	l = &arp->hash[haship(a->ip)];
+	for(f = *l; f; f = f->hash){
+		if(f == a){
 			*l = a->hash;
 			break;
 		}


@@ 103,36 169,107 @@ newarp(Arp *arp, uchar *ip, Medium *m)
 	l = &arp->hash[haship(ip)];
 	a->hash = *l;
 	*l = a;
+
 	memmove(a->ip, ip, sizeof(a->ip));
 	a->used = msec;
 	a->time = 0;
 	a->type = m;
 
+	a->rxtat = msec + ReTransTimer;
+	a->rxtsrem = MAX_MULTICAST_SOLICIT;
+	a->ifc = ifc;
+	a->ifcid = ifc->ifcid;
+
+	/* put to the end of re-transmit chain; addrxt is 0 when isv4(a->ip) */
+	if(!ipismulticast(a->ip) && addrxt){
+		l = &arp->rxmt;
+		empty = (*l==nil);
+
+		for(f = *l; f; f = f->nextrxt){
+			if(f == a){
+				*l = a->nextrxt;
+				break;
+			}
+			l = &f->nextrxt;
+		}
+		for(f = *l; f; f = f->nextrxt){
+			l = &f->nextrxt;
+		}
+		*l = a;
+		if(empty) 
+			wakeup(&arp->rxmtq);
+	}
+
+	a->nextrxt = nil;
+
 	return a;
 }
 
+/* called with arp qlocked */
+
+void
+cleanarpent(Arp *arp, Arpent *a)
+{
+	Arpent *f, **l;
+
+	a->used = 0;
+	a->time = 0;
+	a->type = 0;
+	a->state = 0;
+	
+	/* take out of current chain */
+	l = &arp->hash[haship(a->ip)];
+	for(f = *l; f; f = f->hash){
+		if(f == a){
+			*l = a->hash;
+			break;
+		}
+		l = &f->hash;
+	}
+
+	/* take out of re-transmit chain */
+	l = &arp->rxmt;
+	for(f = *l; f; f = f->nextrxt){
+		if(f == a){
+			*l = a->nextrxt;
+			break;
+		}
+		l = &f->nextrxt;
+	}
+	a->nextrxt = nil;
+	a->hash = nil;
+	a->hold = nil;
+	a->last = nil;
+	a->ifc = nil;
+}
+
 Arpent*
-arpget(Arp *arp, Block *bp, int version, Medium *type, uchar *ip, uchar *mac)
+arpget(Arp *arp, Block *bp, int version, Ipifc *ifc, uchar *ip, uchar *mac)
 {
 	int hash;
 	Arpent *a;
+	Medium *type = ifc->m;
 	uchar v6ip[IPaddrlen];
 
-	if(version == V4) {
+	if(version == V4){
 		v4tov6(v6ip, ip);
 		ip = v6ip;
 	}
 
 	qlock(arp);
 	hash = haship(ip);
-	for(a = arp->hash[hash]; a; a = a->hash) {
+	for(a = arp->hash[hash]; a; a = a->hash){
 		if(memcmp(ip, a->ip, sizeof(a->ip)) == 0)
 		if(type == a->type)
 			break;
 	}
 
 	if(a == nil){
-		a = newarp(arp, ip, type);
+		//a = newarp6(arp, ip, ifc, (version != V4));
+		if(version == V4)
+			a = newarp(arp, ip, type);
+		else 
+			a = newarp6(arp, ip, ifc, 1);
 		a->state = AWAIT;
 	}
 	a->used = msec;


@@ 169,6 306,18 @@ Block*
 arpresolve(Arp *arp, Arpent *a, Medium *type, uchar *mac)
 {
 	Block *bp;
+	Arpent *f, **l;
+
+	if(!isv4(a->ip)){
+		l = &arp->rxmt;
+		for(f = *l; f; f = f->nextrxt){
+			if(f == a){
+				*l = a->nextrxt;
+				break;
+			}
+			l = &f->nextrxt;
+		}
+	}
 
 	memmove(a->mac, mac, type->maclen);
 	a->type = type;


@@ 186,7 335,7 @@ arpenter(Fs *fs, int version, uchar *ip, uchar *mac, int n, int refresh)
 {
 	Arp *arp;
 	Route *r;
-	Arpent *a;
+	Arpent *a, *f, **l;
 	Ipifc *ifc;
 	Medium *type;
 	Block *bp, *next;


@@ 194,12 343,12 @@ arpenter(Fs *fs, int version, uchar *ip, uchar *mac, int n, int refresh)
 
 	arp = fs->arp;
 
-	if(n != 6) {
+	if(n != 6){
 //		print("arp: len = %d\n", n);
 		return;
 	}
 
-	if(version == V4) {
+	if(version == V4){
 		r = v4lookup(fs, ip);
 		v4tov6(v6ip, ip);
 		ip = v6ip;


@@ 207,7 356,7 @@ arpenter(Fs *fs, int version, uchar *ip, uchar *mac, int n, int refresh)
 	else
 		r = v6lookup(fs, ip);
 
-	if(r == nil) {
+	if(r == nil){
 //		print("arp: no route for entry\n");
 		return;
 	}


@@ 216,19 365,35 @@ arpenter(Fs *fs, int version, uchar *ip, uchar *mac, int n, int refresh)
 	type = ifc->m;
 
 	qlock(arp);
-	for(a = arp->hash[haship(ip)]; a; a = a->hash) {
+	for(a = arp->hash[haship(ip)]; a; a = a->hash){
 		if(a->type != type || (a->state != AWAIT && a->state != AOK))
 			continue;
 
-		if(ipcmp(a->ip, ip) == 0) {
+		if(ipcmp(a->ip, ip) == 0){
 			a->state = AOK;
 			memmove(a->mac, mac, type->maclen);
+
+			if(version == V6){
+				/* take out of re-transmit chain */
+				l = &arp->rxmt;
+				for(f = *l; f; f = f->nextrxt){
+					if(f == a){
+						*l = a->nextrxt;
+						break;
+					}
+					l = &f->nextrxt;
+				}
+			}
+
+			a->hold = nil;
+			a->ifc = ifc;
+			a->ifcid = ifc->ifcid;
 			bp = a->hold;
 			a->hold = nil;
 			if(version == V4)
 				ip += IPv4off;
 			qunlock(arp);
-			while(bp) {
+			while(bp){
 				next = bp->list;
 				if(ifc != nil){
 					if(waserror()){


@@ 252,7 417,12 @@ arpenter(Fs *fs, int version, uchar *ip, uchar *mac, int n, int refresh)
 	}
 
 	if(refresh == 0){
-		a = newarp(arp, ip, type);
+		//a = newarp6(arp, ip, ifc, 0);
+		if(version == 4)
+			a = newarp(arp, ip, type);
+		else 
+			a = newarp6(arp, ip, ifc, 0);
+
 		a->state = AOK;
 		a->type = type;
 		memmove(a->mac, mac, type->maclen);


@@ 269,40 439,63 @@ arpwrite(Fs *fs, char *s, int len)
 	Arp *arp;
 	Block *bp;
 	Arpent *a;
-	Cmdbuf *cb;
-	Cmdtab *ct;
 	Medium *m;
+	char *f[4], buf[256];
 	uchar ip[IPaddrlen], mac[MAClen];
 
 	arp = fs->arp;
 
-	cb = parsecmd(s, len);
-	if(waserror()){
-		free(cb);
-		nexterror();
-	}
-
-	ct = lookupcmd(cb, arpcmd, nelem(arpcmd));
-
-	switch(ct->index){
-	case CMadd:
-		switch(cb->nf) {
+	if(len == 0)
+		error(Ebadarp);
+	if(len >= sizeof(buf))
+		len = sizeof(buf)-1;
+	strncpy(buf, s, len);
+	buf[len] = 0;
+	if(len > 0 && buf[len-1] == '\n')
+		buf[len-1] = 0;
+
+	n = getfields(buf, f, 4, 1, " ");
+	if(strcmp(f[0], "flush") == 0){
+		qlock(arp);
+		for(a = arp->cache; a < &arp->cache[NCACHE]; a++){
+			memset(a->ip, 0, sizeof(a->ip));
+			memset(a->mac, 0, sizeof(a->mac));
+			a->hash = nil;
+			a->state = 0;
+			a->used = 0;
+			while(a->hold != nil){
+				bp = a->hold->list;
+				freeblist(a->hold);
+				a->hold = bp;
+			}
+		}
+		memset(arp->hash, 0, sizeof(arp->hash));
+// clear all pkts on these lists (rxmt, dropf/l)
+		arp->rxmt = nil;
+		arp->dropf = nil;
+		arp->dropl = nil;
+		qunlock(arp);
+	} else if(strcmp(f[0], "add") == 0){
+		switch(n){
 		default:
-			cmderror(cb, Ecmdargs);
+			error(Ebadarg);
 		case 3:
-			parseip(ip, cb->f[1]);
-			r = v4lookup(fs, ip+IPv4off);
+			parseip(ip, f[1]);
+			if(isv4(ip))
+				r = v4lookup(fs, ip+IPv4off);
+			else
+				r = v6lookup(fs, ip);
 			if(r == nil)
-				error("destination unreachable");
+				error("Destination unreachable");
 			m = r->ifc->m;
-			n = parsemac(mac, cb->f[2], m->maclen);
+			n = parsemac(mac, f[2], m->maclen);
 			break;
 		case 4:
-			m = ipfindmedium(cb->f[1]);
+			m = ipfindmedium(f[1]);
 			if(m == nil)
 				error(Ebadarp);
-			parseip(ip, cb->f[2]);
-			n = parsemac(mac, cb->f[3], m->maclen);
+			parseip(ip, f[2]);
+			n = parsemac(mac, f[3], m->maclen);
 			break;
 		}
 


@@ 310,38 503,18 @@ arpwrite(Fs *fs, char *s, int len)
 			error(Ebadarp);
 
 		m->ares(fs, V6, ip, mac, n, 0);
-		break;
-
-	case CMflush:
-		qlock(arp);
-		for(a = arp->cache; a < &arp->cache[NCACHE]; a++){
-			memset(a->ip, 0, sizeof(a->ip));
-			memset(a->mac, 0, sizeof(a->mac));
-			a->hash = nil;
-			a->state = 0;
-			a->used = 0;
-			while(a->hold != nil) {
-				bp = a->hold->list;
-				freeblist(a->hold);
-				a->hold = bp;
-			}
-		}
-		memset(arp->hash, 0, sizeof(arp->hash));
-		qunlock(arp);
-		break;
-	}
+	} else
+		error(Ebadarp);
 
-	poperror();
-	free(cb);
 	return len;
 }
 
 enum
 {
-	Alinelen=	66,
+	Alinelen=	90,
 };
 
-char *aformat = "%-6.6s %-8.8s %-16.16I %-32.32s\n";
+char *aformat = "%-6.6s %-8.8s %-40.40I %-32.32s\n";
 
 static void
 convmac(char *p, uchar *mac, int n)


@@ 380,3 553,136 @@ arpread(Arp *arp, char *p, ulong offset, int len)
 
 	return n;
 }
+
+extern int
+rxmitsols(Arp *arp)
+{
+	uint sflag;
+	Block *next, *xp;
+	Arpent *a, *b, **l;
+	Fs *f;
+	uchar ipsrc[IPaddrlen];
+	Ipifc *ifc = nil;
+	long nrxt;
+
+	qlock(arp);
+	f = arp->f;
+
+	a = arp->rxmt;
+	if(a==nil){
+		nrxt = 0;
+		goto dodrops; 		//return nrxt;
+	}
+	nrxt = a->rxtat - msec;
+	if(nrxt > 3*ReTransTimer/4) 
+		goto dodrops; 		//return nrxt;
+
+	for(; a; a = a->nextrxt){
+		ifc = a->ifc;
+		assert(ifc != nil);
+		if((a->rxtsrem <= 0) || !(canrlock(ifc)) || (a->ifcid != ifc->ifcid)){
+			xp = a->hold;
+			a->hold = nil;
+
+			if(xp){
+				if(arp->dropl == nil) 
+					arp->dropf = xp;
+				else
+					arp->dropl->list = xp;
+			}
+
+			cleanarpent(arp, a);
+		}
+		else
+			break;
+	}
+
+	 /* need to unlock arp, else will deadlock when icmpns 
+	  * wants to lock arp later.
+	  */
+	
+	qunlock(arp);
+
+	if(a == nil) 
+		goto dodrops; 		// return 0;
+
+	if(sflag = ipv6anylocal(ifc, ipsrc)) 
+		icmpns(f, ipsrc, sflag, a->ip, TARG_MULTI, ifc->mac); 
+
+	runlock(ifc);
+
+	/* grab lock on arp again */
+
+	qlock(arp);	
+
+	/* put to the end of re-transmit chain */
+	l = &arp->rxmt;
+	for(b = *l; b; b = b->nextrxt){
+		if(b == a){
+			*l = a->nextrxt;
+			break;
+		}
+		l = &b->nextrxt;
+	}
+	for(b = *l; b; b = b->nextrxt){
+		l = &b->nextrxt;
+	}
+	*l = a;
+	a->rxtsrem--;
+	a->nextrxt = nil;
+	a->time = msec;
+	a->rxtat = msec + ReTransTimer;
+
+	a = arp->rxmt;
+	if(a==nil)
+		nrxt = 0;
+	else 
+		nrxt = a->rxtat - msec;
+
+dodrops:
+	xp = arp->dropf;
+	arp->dropf = nil;
+	arp->dropl = nil;
+	qunlock(arp);
+
+	for(; xp; xp = next){
+		next = xp->list;
+		icmphostunr(f, ifc, xp, icmp6_adr_unreach, 1);
+	}
+
+	return nrxt;
+
+}
+
+static int
+rxready(void *v)
+{
+	Arp *arp = (Arp *) v;
+	int x;
+
+	x = ((arp->rxmt != nil) || (arp->dropf != nil));
+
+	return x;
+}
+
+static void
+rxmitproc(void *v)
+{
+	Arp *arp = v;
+	long wakeupat;
+
+	arp->rxmitp = up;
+	print("arp rxmitproc started\n");
+	if(waserror()){
+		arp->rxmitp = 0;
+		pexit("hangup", 1);
+	}
+	for(;;){
+		wakeupat = rxmitsols(arp);
+		if(wakeupat == 0) 
+			sleep(&arp->rxmtq, rxready, v); 
+		else if(wakeupat > ReTransTimer/4) 
+			tsleep(&arp->rxmtq, return0, 0, wakeupat); 
+	}
+}
+

@@ 15,6 15,7 @@ enum
 	Qndb,
 	Qiproute,
 	Qipselftab,
+	Qipgate6,
 	Qlog,
 
 	Qprotodir,			/* directory for a protocol */


@@ 54,30 55,6 @@ QLock	fslock;
 Fs	*ipfs[Nfs];	/* attached fs's */
 Queue	*qlog;
 
-enum
-{
-	CMaddmulti,
-	CMannounce,
-	CMbind,
-	CMconnect,
-	CMremmulti,
-	CMtos,
-	CMttl,
-	CMwildcard,
-};
-
-Cmdtab ipctlmsg[] =
-{
-	CMaddmulti,	"addmulti",	0,
-	CMannounce,	"announce",	0,
-	CMbind,		"bind",		0,
-	CMconnect,	"connect",	0,
-	CMremmulti,	"remmulti",	0,
-	CMtos,		"tos",		0,
-	CMttl,		"ttl",			0,
-	CMwildcard,	"*",			0,
-};
-
 extern	void nullmediumlink(void);
 extern	void pktmediumlink(void);
 	long ndbwrite(Fs *f, char *a, ulong off, int n);


@@ 166,7 143,6 @@ ip1gen(Chan *c, int i, Dir *dp)
 	case Qndb:
 		p = "ndb";
 		len = strlen(f->ndb);
-		q.vers = f->ndbvers;
 		break;
 	case Qiproute:
 		p = "iproute";


@@ 175,13 151,15 @@ ip1gen(Chan *c, int i, Dir *dp)
 		p = "ipselftab";
 		prot = 0444;
 		break;
+	case Qipgate6:
+		p = "ipgate6";
+		prot = 0444;
+		break;
 	case Qlog:
 		p = "log";
 		break;
 	}
 	devdir(c, q, p, len, network, prot, dp);
-	if(i == Qndb)
-		dp->mtime = f->ndbmtime;
 	return 1;
 }
 


@@ 217,6 195,7 @@ ipgen(Chan *c, char*, Dirtab*, int, int s, Dir *dp)
 	case Qlog:
 	case Qiproute:
 	case Qipselftab:
+	case Qipgate6:
 		return ip1gen(c, TYPE(c->qid), dp);
 	case Qprotodir:
 		if(s == DEVDOTDOT){


@@ 346,6 325,7 @@ ipwalk(Chan* c, Chan *nc, char **name, int nname)
 	return w;
 }
 
+
 static int
 ipstat(Chan* c, uchar* db, int n)
 {


@@ 384,12 364,10 @@ ipopen(Chan* c, int omode)
 	default:
 		break;
 	case Qndb:
-		if((omode & (OWRITE|OTRUNC)) && !iseve())
+		if(omode & (OWRITE|OTRUNC) && !iseve())
 			error(Eperm);
-		if((omode & (OWRITE|OTRUNC)) == (OWRITE|OTRUNC)){
+		if((omode & (OWRITE|OTRUNC)) == (OWRITE|OTRUNC))
 			f->ndb[0] = 0;
-			f->ndbvers++;
-		}
 		break;
 	case Qlog:
 		netlogopen(f);


@@ 405,6 383,7 @@ ipopen(Chan* c, int omode)
 	case Qstats:
 	case Qbootp:
 	case Qipselftab:
+	case Qipgate6:
 		if(omode != OREAD)
 			error(Eperm);
 		break;


@@ 497,14 476,25 @@ ipopen(Chan* c, int omode)
 	c->mode = openmode(omode);
 	c->flag |= COPEN;
 	c->offset = 0;
-	c->iounit = qiomaxatomic;
 	return c;
 }
 
+static void
+ipcreate(Chan*, char*, int, ulong)
+{
+	error(Eperm);
+}
+
+static void
+ipremove(Chan*)
+{
+	error(Eperm);
+}
+
 static int
 ipwstat(Chan *c, uchar *dp, int n)
 {
-	Dir *d;
+	Dir d;
 	Conv *cv;
 	Fs *f;
 	Proto *p;


@@ 519,26 509,16 @@ ipwstat(Chan *c, uchar *dp, int n)
 		break;
 	}
 
-	d = smalloc(n + sizeof(Dir));
-	if(waserror()){
-		free(d);
-		nexterror();
+	n = convM2D(dp, n, &d, nil);
+	if(n > 0){
+		p = f->p[PROTO(c->qid)];
+		cv = p->conv[CONV(c->qid)];
+		if(!iseve() && strcmp(ATTACHER(c), cv->owner) != 0)
+			error(Eperm);
+		if(d.uid[0])
+			kstrdup(&cv->owner, d.uid);
+		cv->perm = d.mode & 0777;
 	}
-	n = convM2D(dp, n, d, nil);
-	if(n == 0)
-		error(Eshortstat);
-
-	p = f->p[PROTO(c->qid)];
-	cv = p->conv[CONV(c->qid)];
-	if(!iseve() && strcmp(ATTACHER(c), cv->owner) != 0)
-		error(Eperm);
-	if(!emptystr(d->uid))
-		kstrdup(&cv->owner, d->uid);
-	if(d->mode != ~0UL)
-		cv->perm = d->mode & 0777;
-
-	poperror();
-	free(d);
 	return n;
 }
 


@@ 631,6 611,8 @@ ipread(Chan *ch, void *a, long n, vlong off)
 		return routeread(f, a, offset, n);
 	case Qipselftab:
 		return ipselftabread(f, a, offset, n);
+	case Qipgate6:
+		return ipgateread6(f, a, offset, n);
 	case Qlog:
 		return netlogread(f, a, offset, n);
 	case Qctl:


@@ 749,6 731,7 @@ setluniqueport(Conv* c, int lport)
 	return nil;
 }
 
+
 /*
  *  pick a local port and set it
  */


@@ 1037,7 1020,6 @@ ipwrite(Chan* ch, void *v, long n, vlong off)
 	Proto *x;
 	char *p;
 	Cmdbuf *cb;
-	Cmdtab *ct;
 	uchar ia[IPaddrlen], ma[IPaddrlen];
 	Fs *f;
 	char *a;


@@ 1080,26 1062,21 @@ ipwrite(Chan* ch, void *v, long n, vlong off)
 			free(cb);
 			nexterror();
 		}
-		ct = lookupcmd(cb, ipctlmsg, nelem(ipctlmsg));
-		switch(ct->index){
-		case CMconnect:
+		if(cb->nf < 1)
+			error("short control request");
+		if(strcmp(cb->f[0], "connect") == 0)
 			connectctlmsg(x, c, cb);
-			break;
-		case CMannounce:
+		else if(strcmp(cb->f[0], "announce") == 0)
 			announcectlmsg(x, c, cb);
-			break;
-		case CMbind:
+		else if(strcmp(cb->f[0], "bind") == 0)
 			bindctlmsg(x, c, cb);
-			break;
-		case CMttl:
+		else if(strcmp(cb->f[0], "ttl") == 0)
 			ttlctlmsg(c, cb);
-			break;
-		case CMtos:
+		else if(strcmp(cb->f[0], "tos") == 0)
 			tosctlmsg(c, cb);
-			break;
-		case CMaddmulti:
-			if(cb->nf != 2 && cb->nf != 3)
-				cmderror(cb, Ecmdargs);
+		else if(strcmp(cb->f[0], "addmulti") == 0){
+			if(cb->nf < 2)
+				error("addmulti needs interface address");
 			if(cb->nf == 2){
 				if(!ipismulticast(c->raddr))
 					error("addmulti for a non multicast address");


@@ 1112,23 1089,19 @@ ipwrite(Chan* ch, void *v, long n, vlong off)
 				parseip(ia, cb->f[1]);
 				ipifcaddmulti(c, ma, ia);
 			}
-			break;
-		case CMremmulti:
+		} else if(strcmp(cb->f[0], "remmulti") == 0){
 			if(cb->nf < 2)
 				error("remmulti needs interface address");
 			if(!ipismulticast(c->raddr))
 				error("remmulti for a non multicast address");
 			parseip(ia, cb->f[1]);
 			ipifcremmulti(c, c->raddr, ia);
-			break;
-		case CMwildcard:
-			if(x->ctl == nil)
-				cmderror(cb, "unknown control request");
+		} else if(x->ctl != nil) {
 			p = x->ctl(c, cb->f, cb->nf);
 			if(p != nil)
 				error(p);
-		}
-
+		} else 
+			error("unknown control request");
 		qunlock(c);
 		free(cb);
 		poperror();


@@ 1175,13 1148,13 @@ Dev ipdevtab = {
 	ipwalk,
 	ipstat,
 	ipopen,
-	devcreate,
+	ipcreate,
 	ipclose,
 	ipread,
 	ipbread,
 	ipwrite,
 	ipbwrite,
-	devremove,
+	ipremove,
 	ipwstat,
 };
 


@@ 1375,8 1348,6 @@ ndbwrite(Fs *f, char *a, ulong off, int n)
 		error(Eio);
 	memmove(f->ndb+off, a, n);
 	f->ndb[off+n] = 0;
-	f->ndbvers++;
-	f->ndbmtime = seconds();
 	return n;
 }
 

@@ 23,7 23,7 @@ enum
 {
 	IP_ESPPROTO	= 50,
 	EsphdrSize	= 28,	// includes IP header
-	IphdrSize	= 20,	// options have been stripped
+	IphdrSize	= 20,	// options have been striped
 	EsptailSize	= 2,	// does not include pad or auth data
 	UserhdrSize	= 4,	// user visable header size - if enabled
 };


@@ 285,6 285,7 @@ espkick(Conv *c)
 	auth = bp->rp + EsphdrSize + payload + pad + EsptailSize;
 
 	// fill in head
+	eh->vihl = IP_VER4;
 	hnputl(eh->espspi, ecb->spi);
 	hnputl(eh->espseq, ++ecb->seq);
 	v6tov4(eh->espsrc, c->laddr);


@@ 296,8 297,8 @@ espkick(Conv *c)
 	ecb->auth(ecb, bp->rp+IphdrSize, (EsphdrSize-IphdrSize)+payload+pad+EsptailSize, auth);
 
 	qunlock(c);
-//print("esp: pass down: %uld\n", BLEN(bp));
-	ipoput(c->p->f, bp, 0, c->ttl, c->tos);
+	//print("esp: pass down: %uld\n", BLEN(bp));
+	ipoput4(c->p->f, bp, 0, c->ttl, c->tos);
 }
 
 void

@@ 6,6 6,7 @@
 #include "../port/error.h"
 
 #include "ip.h"
+#include "ipv6.h"
 
 typedef struct Etherhdr Etherhdr;
 struct Etherhdr


@@ 15,7 16,8 @@ struct Etherhdr
 	uchar	t[2];
 };
 
-static void	etherread(void *a);
+static void	etherread4(void *a);
+static void	etherread6(void *a);
 static void	etherbind(Ipifc *ifc, int argc, char **argv);
 static void	etherunbind(Ipifc *ifc);
 static void	etherbwrite(Ipifc *ifc, Block *bp, int version, uchar *ip);


@@ 26,6 28,8 @@ static void	sendarp(Ipifc *ifc, Arpent *a);
 static void	sendgarp(Ipifc *ifc, uchar*);
 static int	multicastea(uchar *ea, uchar *ip);
 static void	recvarpproc(void*);
+static void	resolveaddr6(Ipifc *ifc, Arpent *a);
+static void	etherpref2addr(uchar *pref, uchar *ea);
 
 Medium ethermedium =
 {


@@ 41,6 45,7 @@ Medium ethermedium =
 .remmulti=	etherremmulti,
 .ares=		arpenter,
 .areg=		sendgarp,
+.pref2addr=	etherpref2addr,
 };
 
 Medium gbemedium =


@@ 57,6 62,7 @@ Medium gbemedium =
 .remmulti=	etherremmulti,
 .ares=		arpenter,
 .areg=		sendgarp,
+.pref2addr=	etherpref2addr,
 };
 
 typedef struct	Etherrock Etherrock;


@@ 64,10 70,13 @@ struct Etherrock
 {
 	Fs	*f;		/* file system we belong to */
 	Proc	*arpp;		/* arp process */
-	Proc	*readp;		/* reading process */
-	Chan	*mchan;		/* Data channel */
+	Proc	*read4p;	/* reading process (v4)*/
+	Proc	*read6p;	/* reading process (v6)*/
+	Chan	*mchan4;	/* Data channel for v4 */
 	Chan	*achan;		/* Arp channel */
-	Chan	*cchan;		/* Control channel */
+	Chan	*cchan4;	/* Control channel for v4 */
+	Chan	*mchan6;	/* Data channel for v6 */
+	Chan	*cchan6;	/* Control channel for v6 */
 };
 
 /*


@@ 76,10 85,12 @@ struct Etherrock
 enum
 {
 	ETARP		= 0x0806,
-	ETIP		= 0x0800,
+	ETIP4		= 0x0800,
+	ETIP6		= 0x86DD,
 	ARPREQUEST	= 1,
 	ARPREPLY	= 2,
 };
+
 typedef struct Etherarp Etherarp;
 struct Etherarp
 {


@@ 97,7 108,6 @@ struct Etherarp
 	uchar	tpa[4];
 };
 
-
 /*
  *  called to bind an IP ifc to an ethernet device
  *  called with ifc wlock'd


@@ 105,9 115,9 @@ struct Etherarp
 static void
 etherbind(Ipifc *ifc, int argc, char **argv)
 {
-	Chan *mchan, *cchan, *achan;
-	char addr[Maxpath];
-	char dir[Maxpath];
+	Chan *mchan4, *cchan4, *achan, *mchan6, *cchan6;
+	char addr[Maxpath];	//char addr[2*KNAMELEN];
+	char dir[Maxpath];	//char dir[2*KNAMELEN];
 	char *buf;
 	int n;
 	char *ptr;


@@ 116,15 126,19 @@ etherbind(Ipifc *ifc, int argc, char **argv)
 	if(argc < 2)
 		error(Ebadarg);
 
-	mchan = cchan = achan = nil;
+	mchan4 = cchan4 = achan = mchan6 = cchan6 = nil;
 	buf = nil;
 	if(waserror()){
-		if(mchan != nil)
-			cclose(mchan);
-		if(cchan != nil)
-			cclose(cchan);
+		if(mchan4 != nil)
+			cclose(mchan4);
+		if(cchan4 != nil)
+			cclose(cchan4);
 		if(achan != nil)
 			cclose(achan);
+		if(mchan6 != nil)
+			cclose(mchan6);
+		if(cchan6 != nil)
+			cclose(cchan6);
 		if(buf != nil)
 			free(buf);
 		nexterror(); 


@@ 137,7 151,7 @@ etherbind(Ipifc *ifc, int argc, char **argv)
 	 *  this device.
 	 */
 	snprint(addr, sizeof(addr), "%s!0x800", argv[2]);
-	mchan = chandial(addr, nil, dir, &cchan);
+	mchan4 = chandial(addr, nil, dir, &cchan4);
 
 	/*
 	 *  get mac address


@@ 162,18 176,30 @@ etherbind(Ipifc *ifc, int argc, char **argv)
 	snprint(addr, sizeof(addr), "%s!0x806", argv[2]);
 	achan = chandial(addr, nil, nil, nil);
 
+	/*
+	 *  open ip conversation
+	 *
+	 *  the dial will fail if the type is already open on
+	 *  this device.
+	 */
+	snprint(addr, sizeof(addr), "%s!0x86DD", argv[2]);
+	mchan6 = chandial(addr, nil, dir, &cchan6);
+
 	er = smalloc(sizeof(*er));
-	er->mchan = mchan;
-	er->cchan = cchan;
+	er->mchan4 = mchan4;
+	er->cchan4 = cchan4;
 	er->achan = achan;
+	er->mchan6 = mchan6;
+	er->cchan6 = cchan6;
 	er->f = ifc->conv->p->f;
 	ifc->arg = er;
 
 	free(buf);
 	poperror();
 
-	kproc("etherread", etherread, ifc);
+	kproc("etherread4", etherread4, ifc);
 	kproc("recvarpproc", recvarpproc, ifc);
+	kproc("etherread6", etherread6, ifc);
 }
 
 /*


@@ 184,21 210,27 @@ etherunbind(Ipifc *ifc)
 {
 	Etherrock *er = ifc->arg;
 
-	if(er->readp)
-		postnote(er->readp, 1, "unbind", 0);
+	if(er->read4p)
+		postnote(er->read4p, 1, "unbind", 0);
+	if(er->read6p)
+		postnote(er->read6p, 1, "unbind", 0);
 	if(er->arpp)
 		postnote(er->arpp, 1, "unbind", 0);
 
 	/* wait for readers to die */
-	while(er->arpp != 0 || er->readp != 0)
+	while(er->arpp != 0 || er->read4p != 0 || er->read6p != 0)
 		tsleep(&up->sleep, return0, 0, 300);
 
-	if(er->mchan != nil)
-		cclose(er->mchan);
+	if(er->mchan4 != nil)
+		cclose(er->mchan4);
 	if(er->achan != nil)
 		cclose(er->achan);
-	if(er->cchan != nil)
-		cclose(er->cchan);
+	if(er->cchan4 != nil)
+		cclose(er->cchan4);
+	if(er->mchan6 != nil)
+		cclose(er->mchan6);
+	if(er->cchan6 != nil)
+		cclose(er->cchan6);
 
 	free(er);
 }


@@ 215,12 247,15 @@ etherbwrite(Ipifc *ifc, Block *bp, int version, uchar *ip)
 	Etherrock *er = ifc->arg;
 
 	/* get mac address of destination */
-	a = arpget(er->f->arp, bp, version, ifc->m, ip, mac);
+	a = arpget(er->f->arp, bp, version, ifc, ip, mac);
 	if(a){
 		/* check for broadcast or multicast */
 		bp = multicastarp(er->f, a, ifc->m, mac);
-		if(bp == nil){
-			sendarp(ifc, a);
+		if(bp==nil){
+			if(version == V4) 
+				sendarp(ifc, a);
+			else 
+				resolveaddr6(ifc, a);
 			return;
 		}
 	}


@@ 236,26 271,67 @@ etherbwrite(Ipifc *ifc, Block *bp, int version, uchar *ip)
 	/* copy in mac addresses and ether type */
 	memmove(eh->s, ifc->mac, sizeof(eh->s));
 	memmove(eh->d, mac, sizeof(eh->d));
-	switch(version){
+
+ 	switch(version){
 	case V4:
 		eh->t[0] = 0x08;
 		eh->t[1] = 0x00;
+		devtab[er->mchan4->type]->bwrite(er->mchan4, bp, 0);
 		break;
 	case V6:
 		eh->t[0] = 0x86;
 		eh->t[1] = 0xDD;
+		devtab[er->mchan6->type]->bwrite(er->mchan6, bp, 0);
 		break;
 	}
-
-	devtab[er->mchan->type]->bwrite(er->mchan, bp, 0);
 	ifc->out++;
 }
 
+
 /*
  *  process to read from the ethernet
  */
 static void
-etherread(void *a)
+etherread4(void *a)
+{
+	Ipifc *ifc;
+	Block *bp;
+	Etherrock *er;
+
+	ifc = a;
+	er = ifc->arg;
+	er->read4p = up;	/* hide identity under a rock for unbind */
+	if(waserror()){
+		er->read4p = 0;
+		pexit("hangup", 1);
+	}
+	for(;;){
+		bp = devtab[er->mchan4->type]->bread(er->mchan4, ifc->maxmtu, 0);
+		if(!canrlock(ifc)){
+			freeb(bp);
+			continue;
+		}
+		if(waserror()){
+			runlock(ifc);
+			nexterror();
+		}
+		ifc->in++;
+		bp->rp += ifc->m->hsize;
+		if(ifc->lifc == nil)
+			freeb(bp);
+		else
+			ipiput4(er->f, ifc, bp);
+		runlock(ifc);
+		poperror();
+	}
+}
+
+
+/*
+ *  process to read from the ethernet, IPv6
+ */
+static void
+etherread6(void *a)
 {
 	Ipifc *ifc;
 	Block *bp;


@@ 263,13 339,13 @@ etherread(void *a)
 
 	ifc = a;
 	er = ifc->arg;
-	er->readp = up;	/* hide identity under a rock for unbind */
+	er->read6p = up;	/* hide identity under a rock for unbind */
 	if(waserror()){
-		er->readp = 0;
+		er->read6p = 0;
 		pexit("hangup", 1);
 	}
 	for(;;){
-		bp = devtab[er->mchan->type]->bread(er->mchan, ifc->maxmtu, 0);
+		bp = devtab[er->mchan6->type]->bread(er->mchan6, ifc->maxmtu, 0);
 		if(!canrlock(ifc)){
 			freeb(bp);
 			continue;


@@ 283,7 359,7 @@ etherread(void *a)
 		if(ifc->lifc == nil)
 			freeb(bp);
 		else
-			ipiput(er->f, ifc, bp);
+			ipiput6(er->f, ifc, bp);
 		runlock(ifc);
 		poperror();
 	}


@@ 295,10 371,14 @@ etheraddmulti(Ipifc *ifc, uchar *a, uchar *)
 	uchar mac[6];
 	char buf[64];
 	Etherrock *er = ifc->arg;
+	int type;
 
-	multicastea(mac, a);
+	type = multicastea(mac, a);
 	sprint(buf, "addmulti %E", mac);
-	devtab[er->cchan->type]->write(er->cchan, buf, strlen(buf), 0);
+	if(type == V4) 
+		devtab[er->cchan4->type]->write(er->cchan4, buf, strlen(buf), 0);
+	else if(type == V6) 
+		devtab[er->cchan6->type]->write(er->cchan6, buf, strlen(buf), 0);
 }
 
 static void


@@ 307,10 387,14 @@ etherremmulti(Ipifc *ifc, uchar *a, uchar *)
 	uchar mac[6];
 	char buf[64];
 	Etherrock *er = ifc->arg;
+	int type;
 
-	multicastea(mac, a);
+	type = multicastea(mac, a);
 	sprint(buf, "remmulti %E", mac);
-	devtab[er->cchan->type]->write(er->cchan, buf, strlen(buf), 0);
+	if(type == V4) 
+		devtab[er->cchan4->type]->write(er->cchan4, buf, strlen(buf), 0);
+	else if(type == V6) 
+		devtab[er->cchan6->type]->write(er->cchan6, buf, strlen(buf), 0);
 }
 
 /*


@@ 357,7 441,7 @@ sendarp(Ipifc *ifc, Arpent *a)
 
 	hnputs(e->type, ETARP);
 	hnputs(e->hrd, 1);
-	hnputs(e->pro, ETIP);
+	hnputs(e->pro, ETIP4);
 	e->hln = sizeof(e->sha);
 	e->pln = sizeof(e->spa);
 	hnputs(e->op, ARPREQUEST);


@@ 368,6 452,43 @@ sendarp(Ipifc *ifc, Arpent *a)
 		print("arp: send: %r\n");
 }
 
+static void
+resolveaddr6(Ipifc *ifc, Arpent *a)
+{
+	int sflag;
+	Block *bp;
+	Etherrock *er = ifc->arg;
+	uchar ipsrc[IPaddrlen];
+
+	/* don't do anything if it's been less than a second since the last */
+	if(msec - a->time < ReTransTimer){
+		arprelease(er->f->arp, a);
+		return;
+	}
+
+	/* remove all but the last message */
+	while((bp = a->hold) != nil){
+		if(bp == a->last)
+			break;
+		a->hold = bp->list;
+		freeblist(bp);
+	}
+
+	/* try to keep it around for a second more */
+	a->time = msec;
+	a->rxtat = msec + ReTransTimer;
+	if(a->rxtsrem <= 0) {
+		arprelease(er->f->arp, a);
+		return;
+	}
+
+	a->rxtsrem--;
+	arprelease(er->f->arp, a);
+
+	if(sflag = ipv6anylocal(ifc, ipsrc)) 
+		icmpns(er->f, ipsrc, sflag, a->ip, TARG_MULTI, ifc->mac);
+}
+
 /*
  *  send a gratuitous arp to refresh arp caches
  */


@@ 397,7 518,7 @@ sendgarp(Ipifc *ifc, uchar *ip)
 
 	hnputs(e->type, ETARP);
 	hnputs(e->hrd, 1);
-	hnputs(e->pro, ETIP);
+	hnputs(e->pro, ETIP4);
 	e->hln = sizeof(e->sha);
 	e->pln = sizeof(e->spa);
 	hnputs(e->op, ARPREQUEST);


@@ 429,13 550,6 @@ recvarp(Ipifc *ifc)
 		break;
 
 	case ARPREPLY:
-		if(iplocalonifc(ifc, ip) || ipproxyifc(er->f, ifc, ip)){
-			if(memcmp(e->sha, ifc->mac, sizeof(e->sha)) != 0){
-				print("arprep: 0x%E/0x%E also has ip addr %V\n",
-					e->s, e->sha, e->spa);
-				break;
-			}
-		}
 		arpenter(er->f, V4, e->spa, e->sha, sizeof(e->sha), 0);
 		break;
 


@@ 447,11 561,8 @@ recvarp(Ipifc *ifc)
 		/* check for someone that think's they're me */
 		v4tov6(ip, e->spa);
 		if(iplocalonifc(ifc, ip) || ipproxyifc(er->f, ifc, ip)){
-			if(memcmp(e->sha, ifc->mac, sizeof(e->sha)) != 0){
-				print("arpreq: 0x%E/0x%E also has ip addr %V\n",
-					e->s, e->sha, e->spa);
-				break;
-			}
+			if(memcmp(e->sha, ifc->mac, sizeof(e->sha)) != 0)
+				print("arp: 0x%E also has ip addr %V\n", e->sha, e->spa);
 		} else {
 			if(memcmp(e->sha, ifc->mac, sizeof(e->sha)) == 0){
 				print("arp: %V also has ether addr %E\n", e->spa, e->sha);


@@ 468,8 579,6 @@ recvarp(Ipifc *ifc)
 		if(!ipproxyifc(er->f, ifc, ip))
 			break;
 
-/* print("arp: rem %I %E (for %I)\n", e->spa, e->sha, e->tpa); /**/
-
 		n = sizeof(Etherarp);
 		if(n < ifc->minmtu)
 			n = ifc->minmtu;


@@ 478,7 587,7 @@ recvarp(Ipifc *ifc)
 		memset(r, 0, sizeof(Etherarp));
 		hnputs(r->type, ETARP);
 		hnputs(r->hrd, 1);
-		hnputs(r->pro, ETIP);
+		hnputs(r->pro, ETIP4);
 		r->hln = sizeof(r->sha);
 		r->pln = sizeof(r->spa);
 		hnputs(r->op, ARPREPLY);


@@ 526,14 635,14 @@ multicastea(uchar *ea, uchar *ip)
 		ea[4] = ip[14];
 		ea[5] = ip[15];
 		break;
-	case V6:
-		ea[0] = 0x33;
-		ea[1] = 0x33;
-		ea[2] = ip[12];
+ 	case V6:
+ 		ea[0] = 0x33;
+ 		ea[1] = 0x33;
+ 		ea[2] = ip[12];
 		ea[3] = ip[13];
-		ea[4] = ip[14];
-		ea[5] = ip[15];
-		break;
+ 		ea[4] = ip[14];
+ 		ea[5] = ip[15];
+ 		break;
 	}
 	return x;
 }


@@ 573,3 682,17 @@ ethermediumlink(void)
 	addipmedium(&ethermedium);
 	addipmedium(&gbemedium);
 }
+
+
+static void 
+etherpref2addr(uchar *pref, uchar *ea)
+{
+	pref[8]  = ea[0] | 0x2;
+	pref[9]  = ea[1];
+	pref[10] = ea[2];
+	pref[11] = 0xFF;
+	pref[12] = 0xFE;
+	pref[13] = ea[3];
+	pref[14] = ea[4];
+	pref[15] = ea[5];
+}

@@ 140,6 140,7 @@ grekick(Conv *c)
 		return;
 
 	ghp = (GREhdr *)(bp->rp);
+	ghp->vihl = IP_VER4;
 
 	v4tov6(raddr, ghp->dst);
 	if(ipcmp(raddr, v4prefix) == 0)


@@ 156,7 157,7 @@ grekick(Conv *c)
 	ghp->frag[0] = 0;
 	ghp->frag[1] = 0;
 
-	ipoput(c->p->f, bp, 0, c->ttl, c->tos);
+	ipoput4(c->p->f, bp, 0, c->ttl, c->tos);
 }
 
 static void

@@ 28,7 28,6 @@ typedef struct Icmp {
 
 enum {			/* Packet Types */
 	EchoReply	= 0,
-	UnreachableV6	= 1,
 	Unreachable	= 3,
 	SrcQuench	= 4,
 	Redirect	= 5,


@@ 52,7 51,6 @@ enum
 
 char *icmpnames[Maxtype+1] =
 {
-[UnreachableV6]		"UnreachableV6",
 [EchoReply]		"EchoReply",
 [Unreachable]		"Unreachable",
 [SrcQuench]		"SrcQuench",


@@ 106,7 104,7 @@ struct Icmppriv
 	ulong	out[Maxtype+1];
 };
 
-static char*
+extern char*
 icmpconnect(Conv *c, char **argv, int argc)
 {
 	char *e;


@@ 117,21 115,21 @@ icmpconnect(Conv *c, char **argv, int argc)
 	return e;
 }
 
-static int
+extern int
 icmpstate(Conv *c, char *state, int n)
 {
 	USED(c);
 	return snprint(state, n, "%s", "Datagram");
 }
 
-static void
+extern void
 icmpcreate(Conv *c)
 {
 	c->rq = qopen(64*1024, 1, 0, c);
 	c->wq = qopen(64*1024, 0, 0, 0);
 }
 
-static char*
+extern char*
 icmpannounce(Conv *c, char **argv, int argc)
 {
 	char *e;


@@ 144,7 142,7 @@ icmpannounce(Conv *c, char **argv, int argc)
 	return nil;
 }
 
-static void
+extern void
 icmpclose(Conv *c)
 {
 	qclose(c->rq);


@@ 154,7 152,7 @@ icmpclose(Conv *c)
 	c->lport = 0;
 }
 
-static void
+extern void
 icmpkick(Conv *c)
 {
 	Icmp *p;


@@ 170,6 168,7 @@ icmpkick(Conv *c)
 		return;
 	}
 	p = (Icmp *)(bp->rp);
+	p->vihl = IP_VER4;
 	ipriv = c->p->priv;
 	if(p->type <= Maxtype)	
 		ipriv->out[p->type]++;


@@ 181,23 180,24 @@ icmpkick(Conv *c)
 	memset(p->cksum, 0, sizeof(p->cksum));
 	hnputs(p->cksum, ptclcsum(bp, ICMP_IPSIZE, blocklen(bp) - ICMP_IPSIZE));
 	ipriv->stats[OutMsgs]++;
-	ipoput(c->p->f, bp, 0, c->ttl, c->tos);
+	ipoput4(c->p->f, bp, 0, c->ttl, c->tos);
 }
 
 extern void
-icmpttlexceeded(Fs *f, Ipifc *ifc, Block *bp)
+icmpttlexceeded(Fs *f, uchar *ia, Block *bp)
 {
 	Block	*nbp;
 	Icmp	*p, *np;
 
 	p = (Icmp *)bp->rp;
+	p->vihl = IP_VER4;
 
 	netlog(f, Logicmp, "sending icmpttlexceeded -> %V\n", p->src);
 	nbp = allocb(ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8);
 	nbp->wp += ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8;
 	np = (Icmp *)nbp->rp;
 	memmove(np->dst, p->src, sizeof(np->dst));
-	v6tov4(np->src, ifc->lifc->local);
+	v6tov4(np->src, ia);
 	memmove(np->data, bp->rp, ICMP_IPSIZE + 8);
 	np->type = TimeExceed;
 	np->code = 0;


@@ 206,7 206,7 @@ icmpttlexceeded(Fs *f, Ipifc *ifc, Block *bp)
 	hnputs(np->seq, 0);
 	memset(np->cksum, 0, sizeof(np->cksum));
 	hnputs(np->cksum, ptclcsum(nbp, ICMP_IPSIZE, blocklen(nbp) - ICMP_IPSIZE));
-	ipoput(f, nbp, 0, MAXTTL, DFLTTOS);
+	ipoput4(f, nbp, 0, MAXTTL, DFLTTOS);
 
 }
 


@@ 219,6 219,7 @@ icmpnoconv(Fs *f, Block *bp)
 	uchar	addr[IPaddrlen];
 
 	p = (Icmp *)bp->rp;
+	p->vihl = IP_VER4;
 
 	/* only do this for unicast sources and destinations */
 	v4tov6(addr, p->dst);


@@ 244,7 245,7 @@ icmpnoconv(Fs *f, Block *bp)
 	hnputs(np->seq, 0);
 	memset(np->cksum, 0, sizeof(np->cksum));
 	hnputs(np->cksum, ptclcsum(nbp, ICMP_IPSIZE, blocklen(nbp) - ICMP_IPSIZE));
-	ipoput(f, nbp, 0, MAXTTL, DFLTTOS);
+	ipoput4(f, nbp, 0, MAXTTL, DFLTTOS);
 }
 
 static void


@@ 279,6 280,7 @@ mkechoreply(Block *bp)
 	uchar	ip[4];
 
 	q = (Icmp *)bp->rp;
+	q->vihl = IP_VER4;
 	memmove(ip, q->src, sizeof(q->dst));
 	memmove(q->src, q->dst, sizeof(q->src));
 	memmove(q->dst, ip,  sizeof(q->dst));


@@ 295,7 297,7 @@ static char *unreachcode[] =
 [1]	"host unreachable",
 [2]	"protocol unreachable",
 [3]	"port unreachable",
-[4]	"unfragmentable",
+[4]	"fragmentation needed and DF set",
 [5]	"source route failed",
 };
 


@@ 309,9 311,6 @@ icmpiput(Proto *icmp, Ipifc*, Block *bp)
 	char	*msg;
 	char	m2[128];
 	Icmppriv *ipriv;
-	int	code;
-	ushort	x;
-	uchar	dst[IPaddrlen];
 
 	ipriv = icmp->priv;
 	


@@ 346,27 345,13 @@ icmpiput(Proto *icmp, Ipifc*, Block *bp)
 	case EchoRequest:
 		r = mkechoreply(bp);
 		ipriv->out[EchoReply]++;
-		ipoput(icmp->f, r, 0, MAXTTL, DFLTTOS);
+		ipoput4(icmp->f, r, 0, MAXTTL, DFLTTOS);
 		break;
 	case Unreachable:
-		code = p->code;
-		x = 0;
-		switch(code){
-		default:
+		if(p->code > 5 || p->code < 0)
 			msg = unreachcode[1];
-			break;
-		case 5:
-			x = nhgets(p->seq);
-			msg = unreachcode[p->code];
-			break;
-		case 0:
-		case 1:
-		case 2:
-		case 3:
-		case 4:
+		else
 			msg = unreachcode[p->code];
-			break;
-		}
 
 		bp->rp += ICMP_IPSIZE+ICMP_HDRSIZE;
 		if(blocklen(bp) < MinAdvise){


@@ 374,10 359,6 @@ icmpiput(Proto *icmp, Ipifc*, Block *bp)
 			goto raise;
 		}
 		p = (Icmp *)bp->rp;
-		if(code == 5){
-			v4tov6(dst, p->dst);
-			update_mtucache(dst, x);
-		}
 		pr = Fsrcvpcolx(icmp->f, p->proto);
 		if(pr != nil && pr->advise != nil) {
 			(*pr->advise)(pr, bp, msg);

@@ 0,0 1,923 @@
+#include "u.h"
+#include "../port/lib.h"
+#include "mem.h"
+#include "dat.h"
+#include "fns.h"
+#include "../port/error.h"
+#include "ip.h"
+#include "ipv6.h"
+
+typedef struct ICMPpkt ICMPpkt;
+typedef struct IPICMP IPICMP;
+typedef struct Ndpkt Ndpkt;
+typedef struct NdiscC NdiscC;
+
+struct ICMPpkt {
+	uchar	type;
+	uchar	code;
+	uchar	cksum[2];
+	uchar	icmpid[2];
+	uchar	seq[2];
+};
+
+struct IPICMP {
+	Ip6hdr;
+	ICMPpkt;
+};
+
+struct NdiscC
+{
+	IPICMP;
+	uchar target[IPaddrlen];
+};
+
+struct Ndpkt
+{
+	NdiscC;
+	uchar otype;
+	uchar olen;	// length in units of 8 octets(incl type, code),
+				// 1 for IEEE 802 addresses
+	uchar lnaddr[6];	// link-layer address
+};
+
+enum {	
+	// ICMPv6 types
+	EchoReply	= 0,
+	UnreachableV6	= 1,
+	PacketTooBigV6	= 2,
+	TimeExceedV6	= 3,
+	SrcQuench	= 4,
+	ParamProblemV6	= 4,
+	Redirect	= 5,
+	EchoRequest	= 8,
+	TimeExceed	= 11,
+	InParmProblem	= 12,
+	Timestamp	= 13,
+	TimestampReply	= 14,
+	InfoRequest	= 15,
+	InfoReply	= 16,
+	AddrMaskRequest = 17,
+	AddrMaskReply   = 18,
+	EchoRequestV6	= 128,
+	EchoReplyV6	= 129,
+	RouterSolicit	= 133,
+	RouterAdvert	= 134,
+	NbrSolicit	= 135,
+	NbrAdvert	= 136,
+	RedirectV6	= 137,
+
+	Maxtype6	= 137,
+};
+
+char *icmpnames6[Maxtype6+1] =
+{
+[EchoReply]		"EchoReply",
+[UnreachableV6]		"UnreachableV6",
+[PacketTooBigV6]	"PacketTooBigV6",
+[TimeExceedV6]		"TimeExceedV6",
+[SrcQuench]		"SrcQuench",
+[Redirect]		"Redirect",
+[EchoRequest]		"EchoRequest",
+[TimeExceed]		"TimeExceed",
+[InParmProblem]		"InParmProblem",
+[Timestamp]		"Timestamp",
+[TimestampReply]	"TimestampReply",
+[InfoRequest]		"InfoRequest",
+[InfoReply]		"InfoReply",
+[AddrMaskRequest]	"AddrMaskRequest",
+[AddrMaskReply]		"AddrMaskReply",
+[EchoRequestV6]		"EchoRequestV6",
+[EchoReplyV6]		"EchoReplyV6",
+[RouterSolicit]		"RouterSolicit",
+[RouterAdvert]		"RouterAdvert",
+[NbrSolicit]		"NbrSolicit",
+[NbrAdvert]		"NbrAdvert",
+[RedirectV6]		"RedirectV6",
+};
+
+enum
+{
+	InMsgs6,
+	InErrors6,
+	OutMsgs6,
+	CsumErrs6,
+	LenErrs6,
+	HlenErrs6,
+	HoplimErrs6,
+	IcmpCodeErrs6,
+	TargetErrs6,
+	OptlenErrs6,
+	AddrmxpErrs6,
+	RouterAddrErrs6,
+
+	Nstats6,
+};
+
+static char *statnames6[Nstats6] =
+{
+[InMsgs6]	"InMsgs",
+[InErrors6]	"InErrors",
+[OutMsgs6]	"OutMsgs",
+[CsumErrs6]	"CsumErrs",
+[LenErrs6]	"LenErrs",
+[HlenErrs6]	"HlenErrs",
+[HoplimErrs6]	"HoplimErrs",
+[IcmpCodeErrs6]	"IcmpCodeErrs",
+[TargetErrs6]	"TargetErrs",
+[OptlenErrs6]	"OptlenErrs",
+[AddrmxpErrs6]	"AddrmxpErrs",
+[RouterAddrErrs6]	"RouterAddrErrs",
+};
+
+typedef struct Icmppriv6
+{
+	ulong	stats[Nstats6];
+
+	/* message counts */
+	ulong	in[Maxtype6+1];
+	ulong	out[Maxtype6+1];
+} Icmppriv6;
+
+typedef struct Icmpcb6 
+{
+	QLock;
+	uchar headers;
+} Icmpcb6;
+
+static char *unreachcode[] =
+{
+[icmp6_no_route]	"no route to destination",
+[icmp6_ad_prohib]	"comm with destination administratively prohibited",
+[icmp6_unassigned]	"icmp unreachable: unassigned error code (2)",
+[icmp6_adr_unreach]	"address unreachable",
+[icmp6_port_unreach]	"port unreachable",
+[icmp6_unkn_code]	"icmp unreachable: unknown code",
+};
+
+enum {
+	ICMP_USEAD6	= 40,
+};
+
+enum {
+	Oflag	= 1<<5,
+	Sflag	= 1<<6,
+	Rflag	= 1<<7,
+};
+
+enum {
+	slladd	= 1,
+	tlladd	= 2,
+	prfinfo	= 3,
+	redhdr	= 4,
+	mtuopt	= 5,
+};
+
+static void
+set_cksum(Block *bp)
+{
+	IPICMP *p = (IPICMP *)(bp->rp);
+
+	hnputl(p->vcf, 0);  // borrow IP header as pseudoheader
+	hnputs(p->ploadlen, blocklen(bp)-IPV6HDR_LEN);
+	p->proto = 0;
+	p->ttl = ICMPv6;	// ttl gets set later
+	hnputs(p->cksum, 0);
+	hnputs(p->cksum, ptclcsum(bp, 0, blocklen(bp)));
+	p->proto = ICMPv6;
+}
+
+static Block *
+newIPICMP(int packetlen)
+{
+	Block	*nbp;
+	nbp = allocb(packetlen);
+	nbp->wp += packetlen;
+	memset(nbp->rp, 0, packetlen);
+	return nbp;
+}
+
+
+char*
+icmpconnect6(Conv *c, char **argv, int argc)
+{
+	char *e;
+
+	e = Fsstdconnect(c, argv, argc);
+	Fsconnected(c, e);
+
+	return e;
+}
+
+void
+icmpadvise6(Proto *icmp, Block *bp, char *msg)
+{
+	Conv	**c, *s;
+	IPICMP	*p;
+	ushort	recid;
+
+	p = (IPICMP *) bp->rp;
+	recid = nhgets(p->icmpid);
+
+	for(c = icmp->conv; *c; c++) {
+		s = *c;
+		if(s->lport == recid)
+		if(ipcmp(s->raddr, p->dst) == 0){
+			qhangup(s->rq, msg);
+			qhangup(s->wq, msg);
+			break;
+		}
+	}
+	freeblist(bp);
+}
+
+void
+icmpkick6(Conv *c)
+{
+	IPICMP *p;
+	Block *bp;
+	uchar laddr[IPaddrlen], raddr[IPaddrlen];
+	Icmppriv6 *ipriv = c->p->priv;
+	Icmpcb6 *icb = (Icmpcb6*)c->ptcl;
+
+	bp = qget(c->wq);
+	if(bp == nil)
+		return;
+
+	if(icb->headers==6) {
+		/* get user specified addresses */
+//print("icmpkick6: headers\n");
+		bp = pullupblock(bp, ICMP_USEAD6);
+		if(bp == nil)
+			return;
+		bp->rp += 8;
+		ipmove(laddr, bp->rp);
+		bp->rp += IPaddrlen;
+		ipmove(raddr, bp->rp);
+		bp->rp += IPaddrlen;
+		bp = padblock(bp, sizeof(Ip6hdr));
+	}
+
+	if(blocklen(bp) < sizeof(IPICMP)){
+		freeblist(bp);
+		return;
+	}
+	p = (IPICMP *)(bp->rp);
+	if(icb->headers == 6) {
+		ipmove(p->dst, raddr);
+		ipmove(p->src, laddr);
+	} else {
+		ipmove(p->dst, c->raddr);
+		ipmove(p->src, c->laddr);
+		hnputs(p->icmpid, c->lport);
+	}
+
+	set_cksum(bp);
+	p->vcf[0] = 0x06 << 4;
+	if(p->type <= Maxtype6)	
+		ipriv->out[p->type]++;
+//print("icmpkick6: src %I dst %I\n", p->src, p->dst);
+	ipoput6(c->p->f, bp, 0, c->ttl, c->tos);
+}
+
+char*
+icmpctl6(Conv *c, char **argv, int argc)
+{
+	Icmpcb6 *icb;
+
+	icb = (Icmpcb6*) c->ptcl;
+
+	if(argc==1) {
+		if(strcmp(argv[0], "headers")==0) {
+			icb->headers = 6;
+			return nil;
+		}
+	}
+	return "unknown control request";
+}
+
+static void
+goticmpkt6(Proto *icmp, Block *bp, int muxkey)
+{
+	Conv	**c, *s;
+	IPICMP	*p = (IPICMP *)bp->rp;
+	ushort	recid; 
+	uchar 	*addr;
+
+	if(muxkey == 0) {
+		recid = nhgets(p->icmpid);
+		addr = p->src;
+	}
+	else {
+		recid = muxkey;
+		addr = p->dst;
+	}
+
+	for(c = icmp->conv; *c; c++){
+		s = *c;
+		if(s->lport == recid && ipcmp(s->raddr, addr) == 0){
+			bp = concatblock(bp);
+			if(bp != nil)
+				qpass(s->rq, bp);
+			return;
+		}
+	}
+
+	freeblist(bp);
+}
+
+static Block *
+mkechoreply6(Block *bp)
+{
+	IPICMP *p = (IPICMP *)(bp->rp);
+	uchar	addr[IPaddrlen];
+
+	ipmove(addr, p->src);
+	ipmove(p->src, p->dst);
+	ipmove(p->dst, addr);
+	p->type = EchoReplyV6;
+	set_cksum(bp);
+	return bp;
+}
+
+/*
+ * sends out an ICMPv6 neighbor solicitation
+ * 	suni == SRC_UNSPEC or SRC_UNI, 
+ *	tuni == TARG_MULTI => multicast for address resolution,
+ * 	and tflag == TARG_UNI => neighbor reachability.
+ */
+
+extern void
+icmpns(Fs *f, uchar* src, int suni, uchar* targ, int tuni, uchar* mac)
+{
+	Block	*nbp;
+	Ndpkt *np;
+	Proto *icmp = f->t2p[ICMPv6];
+	Icmppriv6 *ipriv = icmp->priv;
+
+
+	nbp = newIPICMP(sizeof(Ndpkt));
+	np = (Ndpkt*) nbp->rp;
+
+
+	if(suni == SRC_UNSPEC) 
+		memmove(np->src, v6Unspecified, IPaddrlen);
+	else 
+		memmove(np->src, src, IPaddrlen);
+
+	if(tuni == TARG_UNI)
+		memmove(np->dst, targ, IPaddrlen);
+	else
+		ipv62smcast(np->dst, targ);
+
+	np->type = NbrSolicit;
+	np->code = 0;
+	memmove(np->target, targ, IPaddrlen);
+	if(suni != SRC_UNSPEC) {
+		np->otype = SRC_LLADDRESS;
+		np->olen = 1;	/* 1+1+6 = 8 = 1 8-octet */
+		memmove(np->lnaddr, mac, sizeof(np->lnaddr));
+	}
+	else {
+		int r = sizeof(Ndpkt)-sizeof(NdiscC);
+		nbp->wp -= r;
+	}
+
+	set_cksum(nbp);
+	np = (Ndpkt*) nbp->rp;
+	np->ttl = HOP_LIMIT;
+	np->vcf[0] = 0x06 << 4;
+	ipriv->out[NbrSolicit]++;
+	netlog(f, Logicmp, "sending neighbor solicitation %I\n", targ);
+	ipoput6(f, nbp, 0, MAXTTL, DFLTTOS);
+}
+
+/*
+ * sends out an ICMPv6 neighbor advertisement. pktflags == RSO flags.
+ */
+extern void
+icmpna(Fs *f, uchar* src, uchar* dst, uchar* targ, uchar* mac, uchar flags)
+{
+	Block	*nbp;
+	Ndpkt *np;
+	Proto *icmp = f->t2p[ICMPv6];
+	Icmppriv6 *ipriv = icmp->priv;
+
+	nbp = newIPICMP(sizeof(Ndpkt));
+	np = (Ndpkt*) nbp->rp;
+
+	memmove(np->src, src, IPaddrlen);
+	memmove(np->dst, dst, IPaddrlen);
+
+	np->type = NbrAdvert;
+	np->code = 0;
+	np->icmpid[0] = flags;
+	memmove(np->target, targ, IPaddrlen);
+
+	np->otype = TARGET_LLADDRESS;
+	np->olen = 1;	
+	memmove(np->lnaddr, mac, sizeof(np->lnaddr));
+
+	set_cksum(nbp);
+	np = (Ndpkt*) nbp->rp;
+	np->ttl = HOP_LIMIT;
+	np->vcf[0] = 0x06 << 4;
+	ipriv->out[NbrAdvert]++;
+	netlog(f, Logicmp, "sending neighbor advertisement %I\n", src);
+	ipoput6(f, nbp, 0, MAXTTL, DFLTTOS);
+}
+
+extern void
+icmphostunr(Fs *f, Ipifc *ifc, Block *bp, int code, int free)
+{
+	Block *nbp;
+	IPICMP *np;
+	Ip6hdr	*p;
+	int osz = BLEN(bp);
+	int sz = MIN(sizeof(IPICMP) + osz, v6MINTU);
+	Proto	*icmp = f->t2p[ICMPv6];
+	Icmppriv6 *ipriv = icmp->priv;
+
+	p = (Ip6hdr *) bp->rp;
+
+	if(isv6mcast(p->src)) 
+		goto clean;
+
+	nbp = newIPICMP(sz);
+	np = (IPICMP *) nbp->rp;
+
+	rlock(ifc);
+	if(ipv6anylocal(ifc, np->src)) {
+		netlog(f, Logicmp, "send icmphostunr -> s%I d%I\n", p->src, p->dst);
+	}
+	else {
+		netlog(f, Logicmp, "icmphostunr fail -> s%I d%I\n", p->src, p->dst);
+		freeblist(nbp);
+		if(free) 
+			goto clean;
+		else
+			return;
+	}
+
+	memmove(np->dst, p->src, IPaddrlen);
+	np->type = UnreachableV6;
+	np->code = code;
+	memmove(nbp->rp + sizeof(IPICMP), bp->rp, sz - sizeof(IPICMP));
+	set_cksum(nbp);
+	np->ttl = HOP_LIMIT;
+	np->vcf[0] = 0x06 << 4;
+	ipriv->out[UnreachableV6]++;
+
+	if(free)
+		ipiput6(f, ifc, nbp);
+	else {
+		ipoput6(f, nbp, 0, MAXTTL, DFLTTOS);
+		return;
+	}
+
+clean:
+	runlock(ifc);
+	freeblist(bp);
+}
+
+extern void
+icmpttlexceeded6(Fs *f, Ipifc *ifc, Block *bp)
+{
+	Block *nbp;
+	IPICMP *np;
+	Ip6hdr	*p;
+	int osz = BLEN(bp);
+	int sz = MIN(sizeof(IPICMP) + osz, v6MINTU);
+	Proto	*icmp = f->t2p[ICMPv6];
+	Icmppriv6 *ipriv = icmp->priv;
+
+	p = (Ip6hdr *) bp->rp;
+
+	if(isv6mcast(p->src)) 
+		return;
+
+	nbp = newIPICMP(sz);
+	np = (IPICMP *) nbp->rp;
+
+	if(ipv6anylocal(ifc, np->src)) {
+		netlog(f, Logicmp, "send icmpttlexceeded6 -> s%I d%I\n", p->src, p->dst);
+	}
+	else {
+		netlog(f, Logicmp, "icmpttlexceeded6 fail -> s%I d%I\n", p->src, p->dst);
+		return;
+	}
+
+	memmove(np->dst, p->src, IPaddrlen);
+	np->type = TimeExceedV6;
+	np->code = 0;
+	memmove(nbp->rp + sizeof(IPICMP), bp->rp, sz - sizeof(IPICMP));
+	set_cksum(nbp);
+	np->ttl = HOP_LIMIT;
+	np->vcf[0] = 0x06 << 4;
+	ipriv->out[TimeExceedV6]++;
+	ipoput6(f, nbp, 0, MAXTTL, DFLTTOS);
+}
+
+extern void
+icmppkttoobig6(Fs *f, Ipifc *ifc, Block *bp)
+{
+	Block *nbp;
+	IPICMP *np;
+	Ip6hdr	*p;
+	int osz = BLEN(bp);
+	int sz = MIN(sizeof(IPICMP) + osz, v6MINTU);
+	Proto	*icmp = f->t2p[ICMPv6];
+	Icmppriv6 *ipriv = icmp->priv;
+
+	p = (Ip6hdr *) bp->rp;
+
+	if(isv6mcast(p->src)) 
+		return;
+
+	nbp = newIPICMP(sz);
+	np = (IPICMP *) nbp->rp;
+
+	if(ipv6anylocal(ifc, np->src)) {
+		netlog(f, Logicmp, "send icmppkttoobig6 -> s%I d%I\n", p->src, p->dst);
+	}
+	else {
+		netlog(f, Logicmp, "icmppkttoobig6 fail -> s%I d%I\n", p->src, p->dst);
+		return;
+	}
+
+	memmove(np->dst, p->src, IPaddrlen);
+	np->type = PacketTooBigV6;
+	np->code = 0;
+	hnputl(np->icmpid, ifc->maxmtu - ifc->m->hsize);
+	memmove(nbp->rp + sizeof(IPICMP), bp->rp, sz - sizeof(IPICMP));
+	set_cksum(nbp);
+	np->ttl = HOP_LIMIT;
+	np->vcf[0] = 0x06 << 4;
+	ipriv->out[PacketTooBigV6]++;
+	ipoput6(f, nbp, 0, MAXTTL, DFLTTOS);
+}
+
+/*
+ * RFC 2461, pages 39-40, pages 57-58.
+ */
+static int
+valid(Proto *icmp, Ipifc *ifc, Block *bp, Icmppriv6 *ipriv) {
+	int 	sz, osz, unsp, n, ttl, iplen;
+	int 	pktsz = BLEN(bp);
+	uchar	*packet = bp->rp;
+	IPICMP	*p = (IPICMP *) packet;
+	Ndpkt	*np;
+
+	USED(ifc);
+	n = blocklen(bp);
+	if(n < sizeof(IPICMP)) {
+		ipriv->stats[HlenErrs6]++;
+		netlog(icmp->f, Logicmp, "icmp hlen %d\n", n);
+		goto err;
+	}
+
+	iplen = nhgets(p->ploadlen);
+	if(iplen > n-IPV6HDR_LEN || (iplen % 1)) {
+		ipriv->stats[LenErrs6]++;
+		netlog(icmp->f, Logicmp, "icmp length %d\n", iplen);
+		goto err;
+	}
+
+	// Rather than construct explicit pseudoheader, overwrite IPv6 header
+	if(p->proto != ICMPv6) {
+		// This code assumes no extension headers!!!
+		netlog(icmp->f, Logicmp, "icmp error: extension header\n");
+		goto err;
+	}
+	memset(packet, 0, 4);
+	ttl = p->ttl;
+	p->ttl = p->proto;
+	p->proto = 0;
+	if(ptclcsum(bp, 0, iplen + IPV6HDR_LEN)) {
+		ipriv->stats[CsumErrs6]++;
+		netlog(icmp->f, Logicmp, "icmp checksum error\n");
+		goto err;
+	}
+	p->proto = p->ttl;
+	p->ttl = ttl;
+
+	/* additional tests for some pkt types */
+	if( (p->type == NbrSolicit) ||
+		(p->type == NbrAdvert) ||
+		(p->type == RouterAdvert) ||
+		(p->type == RouterSolicit) ||
+		(p->type == RedirectV6) ) {
+
+		if(p->ttl != HOP_LIMIT) {
+			ipriv->stats[HoplimErrs6]++; 
+			goto err; 
+		}
+		if(p->code != 0) {
+			ipriv->stats[IcmpCodeErrs6]++; 
+			goto err; 
+		}
+
+		switch (p->type) {
+		case NbrSolicit:
+		case NbrAdvert:
+			np = (Ndpkt*) p;
+			if(isv6mcast(np->target)) {
+				ipriv->stats[TargetErrs6]++; 
+				goto err; 
+			}
+			if(optexsts(np) && (np->olen == 0)) {
+				ipriv->stats[OptlenErrs6]++; 
+				goto err; 
+			}
+		
+			if(p->type == NbrSolicit) {
+				if(ipcmp(np->src, v6Unspecified) == 0) { 
+					if(!issmcast(np->dst) || optexsts(np))  {
+						ipriv->stats[AddrmxpErrs6]++; 
+						goto err;
+					}
+				}
+			}
+		
+			if(p->type == NbrAdvert) {
+				if((isv6mcast(np->dst))&&(nhgets(np->icmpid) & Sflag)){
+					ipriv->stats[AddrmxpErrs6]++; 
+					goto err; 
+				}
+			}
+			break;
+	
+		case RouterAdvert:
+			if(pktsz - sizeof(Ip6hdr) < 16) {
+				ipriv->stats[HlenErrs6]++; 
+				goto err; 
+			}
+			if(!islinklocal(p->src)) {
+				ipriv->stats[RouterAddrErrs6]++; 
+				goto err; 
+			}
+			sz = sizeof(IPICMP) + 8;
+			while ((sz+1) < pktsz) {
+				osz = *(packet+sz+1);
+				if(osz <= 0) {
+					ipriv->stats[OptlenErrs6]++; 
+					goto err; 
+				}	
+				sz += 8*osz;
+			}
+			break;
+	
+		case RouterSolicit:
+			if(pktsz - sizeof(Ip6hdr) < 8) {
+				ipriv->stats[HlenErrs6]++; 
+				goto err; 
+			}
+			unsp = (ipcmp(p->src, v6Unspecified) == 0);
+			sz = sizeof(IPICMP) + 8;
+			while ((sz+1) < pktsz) {
+				osz = *(packet+sz+1);
+				if((osz <= 0) ||
+					(unsp && (*(packet+sz) == slladd)) ) {
+					ipriv->stats[OptlenErrs6]++; 
+					goto err; 
+				}
+				sz += 8*osz;
+			}
+			break;
+	
+		case RedirectV6:
+			//to be filled in
+			break;
+	
+		default:
+			goto err;
+		}
+	}
+
+	return 1;
+
+err:
+	ipriv->stats[InErrors6]++; 
+	return 0;
+}
+
+static int
+targettype(Fs *f, Ipifc *ifc, uchar *target)
+{
+	Iplifc *lifc;
+	int t;
+
+	rlock(ifc);
+	if(ipproxyifc(f, ifc, target)) {
+		runlock(ifc);
+		return t_uniproxy;
+	}
+
+	for(lifc = ifc->lifc; lifc; lifc = lifc->next) {
+		if(ipcmp(lifc->local, target) == 0) {
+			t = (lifc->tentative) ? t_unitent : t_unirany; 
+			runlock(ifc);
+			return t;
+		}
+	}
+
+	runlock(ifc);
+	return 0;
+}
+
+static void
+icmpiput6(Proto *icmp, Ipifc *ipifc, Block *bp)
+{
+	uchar	*packet = bp->rp;
+	IPICMP	*p = (IPICMP *)packet;
+	Icmppriv6 *ipriv = icmp->priv;
+	Block	*r;
+	Proto	*pr;
+	char	*msg, m2[128];
+	Ndpkt* np;
+	uchar pktflags;
+	uchar lsrc[IPaddrlen];
+	int refresh = 1;
+	Iplifc *lifc;
+
+	if(!valid(icmp, ipifc, bp, ipriv)) 
+		goto raise;
+
+	if(p->type <= Maxtype6)
+		ipriv->in[p->type]++;
+
+	switch(p->type) {
+	case EchoRequestV6:
+		r = mkechoreply6(bp);
+		ipriv->out[EchoReply]++;
+		ipoput6(icmp->f, r, 0, MAXTTL, DFLTTOS);
+		break;
+
+	case UnreachableV6:
+		if(p->code > 4 || p->code < 0)
+			msg = unreachcode[icmp6_unkn_code];
+		else
+			msg = unreachcode[p->code];
+
+		bp->rp += sizeof(IPICMP);
+		if(blocklen(bp) < 8){
+			ipriv->stats[LenErrs6]++;
+			goto raise;
+		}
+		p = (IPICMP *)bp->rp;
+		pr = Fsrcvpcolx(icmp->f, p->proto);
+		if(pr != nil && pr->advise != nil) {
+			(*pr->advise)(pr, bp, msg);
+			return;
+		}
+
+		bp->rp -= sizeof(IPICMP);
+		goticmpkt6(icmp, bp, 0);
+		break;
+
+	case TimeExceedV6:
+		if(p->code == 0){
+			sprint(m2, "ttl exceeded at %I", p->src);
+
+			bp->rp += sizeof(IPICMP);
+			if(blocklen(bp) < 8){
+				ipriv->stats[LenErrs6]++;
+				goto raise;
+			}
+			p = (IPICMP *)bp->rp;
+			pr = Fsrcvpcolx(icmp->f, p->proto);
+			if(pr != nil && pr->advise != nil) {
+				(*pr->advise)(pr, bp, m2);
+				return;
+			}
+			bp->rp -= sizeof(IPICMP);
+		}
+
+		goticmpkt6(icmp, bp, 0);
+		break;
+
+	case RouterAdvert:
+	case RouterSolicit:
+		/* using lsrc as a temp, munge hdr for goticmp6 
+		memmove(lsrc, p->src, IPaddrlen);
+		memmove(p->src, p->dst, IPaddrlen);
+		memmove(p->dst, lsrc, IPaddrlen); */
+
+		goticmpkt6(icmp, bp, p->type);
+		break;
+
+	case NbrSolicit:
+		np = (Ndpkt*) p;
+		pktflags = 0;
+		switch (targettype(icmp->f, ipifc, np->target)) {
+		case t_unirany:
+			pktflags |= Oflag;
+			/* fall through */
+
+		case t_uniproxy: 
+			if(ipcmp(np->src, v6Unspecified) != 0) {
+				arpenter(icmp->f, V6, np->src, np->lnaddr, 8*np->olen-2, 0);
+				pktflags |= Sflag;
+			}
+			if(ipv6local(ipifc, lsrc)) {
+				icmpna(icmp->f, lsrc, 
+				   (ipcmp(np->src, v6Unspecified)==0)?v6allnodesL:np->src,
+				   np->target, ipifc->mac, pktflags); 
+			}
+			else
+				freeblist(bp);
+			break;
+
+		case t_unitent:
+			/* not clear what needs to be done. send up
+			 * an icmp mesg saying don't use this address? */
+
+		default:
+			freeblist(bp);
+		}
+
+		ipriv->out[NbrSolicit]++;
+		break;
+
+	case NbrAdvert:
+		np = (Ndpkt*) p;
+
+		/* if the target address matches one of the local interface 
+		 * address and the local interface address has tentative bit set, 
+		 * then insert into ARP table. this is so the duplication address 
+		 * detection part of ipconfig can discover duplication through 
+		 * the arp table
+		 */
+		lifc = iplocalonifc(ipifc, np->target);
+		if(lifc && lifc->tentative)
+			refresh = 0;
+		arpenter(icmp->f, V6, np->target, np->lnaddr, 8*np->olen-2, refresh);
+		freeblist(bp);
+		break;
+
+	case PacketTooBigV6:
+
+	default:
+		goticmpkt6(icmp, bp, 0);
+		break;
+	}
+	return;
+
+raise:
+	freeblist(bp);
+
+}
+
+int
+icmpstats6(Proto *icmp6, char *buf, int len)
+{
+	Icmppriv6 *priv;
+	char *p, *e;
+	int i;
+
+	priv = icmp6->priv;
+	p = buf;
+	e = p+len;
+	for(i = 0; i < Nstats6; i++)
+		p = seprint(p, e, "%s: %lud\n", statnames6[i], priv->stats[i]);
+	for(i = 0; i <= Maxtype6; i++){
+		if(icmpnames6[i])
+			p = seprint(p, e, "%s: %lud %lud\n", icmpnames6[i], priv->in[i], priv->out[i]);
+/*		else
+			p = seprint(p, e, "%d: %lud %lud\n", i, priv->in[i], priv->out[i]);
+*/
+	}
+	return p - buf;
+}
+
+
+// need to import from icmp.c
+extern int	icmpstate(Conv *c, char *state, int n);
+extern char*	icmpannounce(Conv *c, char **argv, int argc);
+extern void	icmpcreate(Conv *c);
+extern void	icmpclose(Conv *c);
+
+void
+icmp6init(Fs *fs)
+{
+	Proto *icmp6 = smalloc(sizeof(Proto));
+
+	icmp6->priv = smalloc(sizeof(Icmppriv6));
+	icmp6->name = "icmpv6";
+	icmp6->kick = icmpkick6;
+	icmp6->connect = icmpconnect6;
+	icmp6->announce = icmpannounce;
+	icmp6->state = icmpstate;
+	icmp6->create = icmpcreate;
+	icmp6->close = icmpclose;
+	icmp6->rcv = icmpiput6;
+	icmp6->stats = icmpstats6;
+	icmp6->ctl = icmpctl6;
+	icmp6->advise = icmpadvise6;
+	icmp6->gc = nil;
+	icmp6->ipproto = ICMPv6;
+	icmp6->nc = 16;
+	icmp6->ptclsize = sizeof(Icmpcb6);
+
+	Fsproto(fs, icmp6);
+}
+

@@ 86,6 86,7 @@ igmpsendreport(Media *m, byte *addr)
 	if(bp == nil)
 		return;
 	p = (IGMPpkt*)bp->wp;
+	p->vihl = IP_VER4;
 	bp->wp += sizeof(IGMPpkt);
 	memset(bp->rp, 0, sizeof(IGMPpkt));
 	hnputl(p->src, Mediagetaddr(m));


@@ 96,7 97,7 @@ igmpsendreport(Media *m, byte *addr)
 	hnputs(p->igmpcksum, ptclcsum(bp, IGMP_IPHDRSIZE, IGMP_HDRSIZE));
 	netlog(Logigmp, "igmpreport %I\n", p->group);
 	stats.outreports++;
-	ipoput(bp, 0, 1, DFLTTOS);	/* TTL of 1 */
+	ipoput4(bp, 0, 1, DFLTTOS);	/* TTL of 1 */
 }
 
 static int


@@ 166,7 167,7 @@ igmpproc(void *a)
 }
 
 void
-igmpiput(Media *m, Ipifc*, Block *bp)
+igmpiput(Media *m, Ipifc *, Block *bp)
 {
 	int n;
 	IGMPpkt *ghp;

@@ 367,6 367,7 @@ ilkick(Conv *c)
 	/* Make space to fit il & ip */
 	bp = padblock(bp, IL_IPSIZE+IL_HDRSIZE);
 	ih = (Ilhdr *)(bp->rp);
+	ih->vihl = IP_VER4;
 
 	/* Ip fields */
 	ih->frag[0] = 0;


@@ 408,7 409,7 @@ ilkick(Conv *c)
 
 	if(later(msec, ic->timeout, nil))
 		ilsettimeout(ic);
-	ipoput(f, bp, 0, c->ttl, c->tos);
+	ipoput4(f, bp, 0, c->ttl, c->tos);
 	priv->stats[OutMsgs]++;
 }
 


@@ 803,6 804,7 @@ ilrexmit(Ilcb *ic)
 		return;
 
 	h = (Ilhdr*)nb->rp;
+	h->vihl = IP_VER4;
 
 	h->iltype = Ildataquery;
 	hnputl(h->ilack, ic->recvd);


@@ 819,7 821,7 @@ ilrexmit(Ilcb *ic)
 
 	ilbackoff(ic);
 
-	ipoput(c->p->f, nb, 0, ic->conv->ttl, ic->conv->tos);
+	ipoput4(c->p->f, nb, 0, ic->conv->ttl, ic->conv->tos);
 
 	/* statistics */
 	ic->rxtot++;


@@ 979,6 981,7 @@ ilsendctl(Conv *ipc, Ilhdr *inih, int type, ulong id, ulong ack, int ilspec)
 	bp->wp += IL_IPSIZE+IL_HDRSIZE;
 
 	ih = (Ilhdr *)(bp->rp);
+	ih->vihl = IP_VER4;
 
 	/* Ip fields */
 	ih->proto = IP_ILPROTO;


@@ 1015,6 1018,7 @@ ilsendctl(Conv *ipc, Ilhdr *inih, int type, ulong id, ulong ack, int ilspec)
 
 	if(ilcksum)
 		hnputs(ih->ilsum, ptclcsum(bp, IL_IPSIZE, IL_HDRSIZE));
+
 if(ipc==nil)
 	panic("ipc is nil caller is %.8lux", getcallerpc(&ipc));
 if(ipc->p==nil)


@@ 1024,7 1028,7 @@ if(ipc->p==nil)
 		iltype[ih->iltype], nhgetl(ih->ilid), nhgetl(ih->ilack), 
 		nhgets(ih->ilsrc), nhgets(ih->ildst));
 
-	ipoput(ipc->p->f, bp, 0, ttl, tos);
+	ipoput4(ipc->p->f, bp, 0, ttl, tos);
 }
 
 void


@@ 1037,6 1041,7 @@ ilreject(Fs *f, Ilhdr *inih)
 	bp->wp += IL_IPSIZE+IL_HDRSIZE;
 
 	ih = (Ilhdr *)(bp->rp);
+	ih->vihl = IP_VER4;
 
 	/* Ip fields */
 	ih->proto = IP_ILPROTO;


@@ 1057,7 1062,7 @@ ilreject(Fs *f, Ilhdr *inih)
 	if(ilcksum)
 		hnputs(ih->ilsum, ptclcsum(bp, IL_IPSIZE, IL_HDRSIZE));
 
-	ipoput(f, bp, 0, MAXTTL, DFLTTOS);
+	ipoput4(f, bp, 0, MAXTTL, DFLTTOS);
 }
 
 void

@@ 5,52 5,41 @@
 #include	"fns.h"
 #include	"../port/error.h"
 
-#include	"../ip/ip.h"
+#include	"ip.h"
 
-typedef struct Iphdr	Iphdr;
-typedef struct Fragment	Fragment;
-typedef struct Ipfrag	Ipfrag;
+typedef struct Ip4hdr		Ip4hdr;
+typedef struct	IP	IP;
+typedef struct	Fragment4	Fragment4;
+typedef struct	Fragment6	Fragment6;
+typedef struct	Ipfrag	Ipfrag;
 
 enum
 {
-	IPHDR		= 20,		/* sizeof(Iphdr) */
-	IP_VER		= 0x40,		/* Using IP version 4 */
-	IP_HLEN		= 0x05,		/* Header length in words */
+	IP4HDR		= 20,		/* sizeof(Ip4hdr) */
+	IP6HDR		= 40,		/* sizeof(Ip6hdr) */
+	IP_HLEN4	= 0x05,		/* Header length in words */
 	IP_DF		= 0x4000,	/* Don't fragment */
 	IP_MF		= 0x2000,	/* More fragments */
+	IP6FHDR		= 8, 		/* sizeof(Fraghdr6) */
 	IP_MAX		= (32*1024),	/* Maximum Internet packet size */
 };
 
-struct Iphdr
+#define BLKIPVER(xp)	(((Ip4hdr*)((xp)->rp))->vihl&0xF0)
+
+struct Ip4hdr
 {
 	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	ttl;      	/* Time to live */
 	uchar	proto;		/* Protocol */
 	uchar	cksum[2];	/* Header checksum */
 	uchar	src[4];		/* IP source */
 	uchar	dst[4];		/* IP destination */
 };
 
-struct Fragment
-{
-	Block*	blist;
-	Fragment* next;
-	ulong 	src;
-	ulong 	dst;
-	ushort	id;
-	ulong 	age;
-};
-
-struct Ipfrag
-{
-	ushort	foff;
-	ushort	flen;
-};
-
 /* MIB II counters */
 enum
 {


@@ 77,6 66,50 @@ enum
 	Nstats,
 };
 
+struct Fragment4
+{
+	Block*	blist;
+	Fragment4*	next;
+	ulong 	src;
+	ulong 	dst;
+	ushort	id;
+	ulong 	age;
+};
+
+struct Fragment6
+{
+	Block*	blist;
+	Fragment6*	next;
+	uchar 	src[IPaddrlen];
+	uchar 	dst[IPaddrlen];
+	uint	id;
+	ulong 	age;
+};
+
+struct Ipfrag
+{
+	ushort	foff;
+	ushort	flen;
+};
+
+/* an instance of IP */
+struct IP
+{
+	ulong		stats[Nstats];
+
+	QLock		fraglock4;
+	Fragment4*	flisthead4;
+	Fragment4*	fragfree4;
+	Ref		id4;
+
+	QLock		fraglock6;
+	Fragment6*	flisthead6;
+	Fragment6*	fragfree6;
+	Ref		id6;
+
+	int		iprouting;	/* true if we route like a gateway */
+};
+
 static char *statnames[] =
 {
 [Forwarding]	"Forwarding",


@@ 100,20 133,7 @@ static char *statnames[] =
 [FragCreates]	"FragCreates",
 };
 
-/* an instance of IP */
-struct IP
-{
-	ulong		stats[Nstats];
-
-	QLock		fraglock;
-	Fragment*	flisthead;
-	Fragment*	fragfree;
-
-	Ref		id;
-	int		iprouting;			/* true if we route like a gateway */
-};
-
-#define BLKIP(xp)	((Iphdr*)((xp)->rp))
+#define BLKIP(xp)	((Ip4hdr*)((xp)->rp))
 /*
  * This sleazy macro relies on the media header size being
  * larger than sizeof(Ipfrag). ipreassemble checks this is true


@@ 121,9 141,62 @@ struct IP
 #define BKFG(xp)	((Ipfrag*)((xp)->base))
 
 ushort		ipcsum(uchar*);
-Block*		ipreassemble(IP*, int, Block*, Iphdr*);
-void		ipfragfree(IP*, Fragment*);
-Fragment*	ipfragallo(IP*);
+Block*		ip4reassemble(IP*, int, Block*, Ip4hdr*);
+void		ipfragfree4(IP*, Fragment4*);
+Fragment4*	ipfragallo4(IP*);
+
+
+void
+ip_init_6(Fs *f)
+{
+	v6params *v6p;
+
+	v6p = smalloc(sizeof(v6params));
+	
+	v6p->rp.mflag		= 0;		// default not managed
+	v6p->rp.oflag		= 0;
+	v6p->rp.maxraint	= 600000;	// millisecs
+	v6p->rp.minraint	= 200000;
+	v6p->rp.linkmtu		= 0;		// no mtu sent
+	v6p->rp.reachtime	= 0;
+	v6p->rp.rxmitra		= 0;
+	v6p->rp.ttl		= MAXTTL;
+	v6p->rp.routerlt	= 3*(v6p->rp.maxraint);	
+
+	v6p->hp.rxmithost	= 1000;		// v6 RETRANS_TIMER
+
+	v6p->cdrouter 		= -1;
+
+	f->v6p			= v6p;
+
+}
+
+void
+initfrag(IP *ip, int size)
+{
+	Fragment4 *fq4, *eq4;
+	Fragment6 *fq6, *eq6;
+
+	ip->fragfree4 = (Fragment4*)malloc(sizeof(Fragment4) * size);
+	if(ip->fragfree4 == nil)
+		panic("initfrag");
+
+	eq4 = &ip->fragfree4[size];
+	for(fq4 = ip->fragfree4; fq4 < eq4; fq4++)
+		fq4->next = fq4+1;
+
+	ip->fragfree4[size-1].next = nil;
+
+	ip->fragfree6 = (Fragment6*)malloc(sizeof(Fragment6) * size);
+	if(ip->fragfree6 == nil)
+		panic("initfrag");
+
+	eq6 = &ip->fragfree6[size];
+	for(fq6 = ip->fragfree6; fq6 < eq6; fq6++)
+		fq6->next = fq6+1;
+
+	ip->fragfree6[size-1].next = nil;
+}
 
 void
 ip_init(Fs *f)


@@ 133,6 206,8 @@ ip_init(Fs *f)
 	ip = smalloc(sizeof(IP));
 	initfrag(ip, 100);
 	f->ip = ip;
+
+	ip_init_6(f);
 }
 
 void


@@ 146,13 221,13 @@ iprouting(Fs *f, int on)
 }
 
 void
-ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
+ipoput4(Fs *f, Block *bp, int gating, int ttl, int tos)
 {
 	Ipifc *ifc;
 	uchar *gate;
 	ulong fragoff;
 	Block *xp, *nb;
-	Iphdr *eh, *feh;
+	Ip4hdr *eh, *feh;
 	int lid, len, seglen, chunk, dlen, blklen, offset, medialen;
 	Route *r, *sr;
 	IP *ip;


@@ 160,7 235,7 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 	ip = f->ip;
 
 	/* Fill out the ip header */
-	eh = (Iphdr*)(bp->rp);
+	eh = (Ip4hdr*)(bp->rp);
 
 	ip->stats[OutRequests]++;
 


@@ 204,7 279,7 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 		gate = r->v4.gate;
 
 	if(!gating)
-		eh->vihl = IP_VER|IP_HLEN;
+		eh->vihl = IP_VER4|IP_HLEN4;
 	eh->ttl = ttl;
 	if(!gating)
 		eh->tos = tos;


@@ 222,7 297,7 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 	medialen = ifc->maxmtu - ifc->m->hsize;
 	if(len <= medialen) {
 		if(!gating)
-			hnputs(eh->id, incref(&ip->id));
+			hnputs(eh->id, incref(&ip->id4));
 		hnputs(eh->length, len);
 		if(!gating){
 			eh->frag[0] = 0;


@@ 231,8 306,6 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 		eh->cksum[0] = 0;
 		eh->cksum[1] = 0;
 		hnputs(eh->cksum, ipcsum(&eh->vihl));
-
-/*		print("ipoput %V->%V via %V\n", eh->src, eh->dst, gate); /**/
 		ifc->m->bwrite(ifc, bp, V4, gate);
 		runlock(ifc);
 		poperror();


@@ 246,7 319,7 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 		goto raise;
 	}
 
-	seglen = (medialen - IPHDR) & ~7;
+	seglen = (medialen - IP4HDR) & ~7;
 	if(seglen < 8){
 		ip->stats[FragFails]++;
 		ip->stats[OutDiscards]++;


@@ 254,14 327,14 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 		goto raise;
 	}
 
-	dlen = len - IPHDR;
+	dlen = len - IP4HDR;
 	xp = bp;
 	if(gating)
 		lid = nhgets(eh->id);
 	else
-		lid = incref(&ip->id);
+		lid = incref(&ip->id4);
 
-	offset = IPHDR;
+	offset = IP4HDR;
 	while(xp != nil && offset && offset >= BLEN(xp)) {
 		offset -= BLEN(xp);
 		xp = xp->next;


@@ 274,11 347,11 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 		fragoff = 0;
 	dlen += fragoff;
 	for(; fragoff < dlen; fragoff += seglen) {
-		nb = allocb(IPHDR+seglen);
-		feh = (Iphdr*)(nb->rp);
+		nb = allocb(IP4HDR+seglen);
+		feh = (Ip4hdr*)(nb->rp);
 
-		memmove(nb->wp, eh, IPHDR);
-		nb->wp += IPHDR;
+		memmove(nb->wp, eh, IP4HDR);
+		nb->wp += IP4HDR;
 
 		if((fragoff + seglen) >= dlen) {
 			seglen = dlen - fragoff;


@@ 287,7 360,7 @@ ipoput(Fs *f, Block *bp, int gating, int ttl, int tos)
 		else	
 			hnputs(feh->frag, (fragoff>>3)|IP_MF);
 
-		hnputs(feh->length, seglen + IPHDR);
+		hnputs(feh->length, seglen + IP4HDR);
 		hnputs(feh->id, lid);
 
 		/* Copy up the data area */


@@ 326,43 399,26 @@ free:
 }
 
 void
-initfrag(IP *ip, int size)
-{
-	Fragment *fq, *eq;
-
-	ip->fragfree = (Fragment*)malloc(sizeof(Fragment) * size);
-	if(ip->fragfree == nil)
-		panic("initfrag");
-
-	eq = &ip->fragfree[size];
-	for(fq = ip->fragfree; fq < eq; fq++)
-		fq->next = fq+1;
-
-	ip->fragfree[size-1].next = nil;
-}
-
-#define DBG(x)	if((logmask & Logipmsg) && (iponly == 0 || x == iponly))netlog
-
-void
-ipiput(Fs *f, Ipifc *ifc, Block *bp)
+ipiput4(Fs *f, Ipifc *ifc, Block *bp)
 {
 	int hl;
-	Iphdr *h;
+	int hop, tos, proto, olen;
+	Ip4hdr *h;
 	Proto *p;
 	ushort frag;
 	int notforme;
 	uchar *dp, v6dst[IPaddrlen];
 	IP *ip;
 	Route *r, *sr;
-	int olen;
+
+	if(BLKIPVER(bp) != IP_VER4) {
+		ipiput6(f, ifc, bp);
+		return;
+	}
 
 	ip = f->ip;
 	ip->stats[InReceives]++;
 
-//	h = (Iphdr *)(bp->rp);
-//	DBG(nhgetl(h->src))(Logipmsg, "ipiput %V %V len %d proto %d\n",
-//				h->src, h->dst, BLEN(bp), h->proto);
-
 	/*
 	 *  Ensure we have all the header info in the first
 	 *  block.  Make life easier for other protocols by


@@ 370,15 426,16 @@ ipiput(Fs *f, Ipifc *ifc, Block *bp)
 	 */
 	if(BLEN(bp) < 64) {
 		hl = blocklen(bp);
-		if(hl < IPHDR)
-			hl = IPHDR;
+		if(hl < IP4HDR)
+			hl = IP4HDR;
 		if(hl > 64)
 			hl = 64;
 		bp = pullupblock(bp, hl);
 		if(bp == nil)
 			return;
 	}
-	h = (Iphdr *)(bp->rp);
+
+	h = (Ip4hdr*)(bp->rp);
 
 	/* dump anything that whose header doesn't checksum */
 	if(ipcsum(&h->vihl)) {


@@ 387,28 444,27 @@ ipiput(Fs *f, Ipifc *ifc, Block *bp)
 		freeblist(bp);
 		return;
 	}
-
 	v4tov6(v6dst, h->dst);
 	notforme = ipforme(f, v6dst) == 0;
 
 	/* Check header length and version */
-	if(h->vihl != (IP_VER|IP_HLEN)) {
+	if((h->vihl&0x0F) != IP_HLEN4) {
 		hl = (h->vihl&0xF)<<2;
-		if((h->vihl&0xF0) != IP_VER || hl < (IP_HLEN<<2)) {
+		if(hl < (IP_HLEN4<<2)) {
 			ip->stats[InHdrErrors]++;
 			netlog(f, Logip, "ip: %V bad hivl %ux\n", h->src, h->vihl);
 			freeblist(bp);
 			return;
 		}
-		/* If this is not routed strip off the options */
+	  /* If this is not routed strip off the options */
 		if(notforme == 0) {
 			olen = nhgets(h->length);
-			dp = bp->rp + (hl - (IP_HLEN<<2));
-			memmove(dp, h, IP_HLEN<<2);
+			dp = bp->rp + (hl - (IP_HLEN4<<2));
+			memmove(dp, h, IP_HLEN4<<2);
 			bp->rp = dp;
-			h = (Iphdr *)(bp->rp);
-			h->vihl = (IP_VER|IP_HLEN);
-			hnputs(h->length, olen-hl+(IP_HLEN<<2));
+			h = (Ip4hdr*)(bp->rp);
+			h->vihl = (IP_VER4|IP_HLEN4);
+			hnputs(h->length, olen-hl+(IP_HLEN4<<2));
 		}
 	}
 


@@ 418,10 474,10 @@ ipiput(Fs *f, Ipifc *ifc, Block *bp)
 			freeb(bp);
 			return;
 		}
-
 		/* don't forward to source's network */
 		sr = v4lookup(f, h->src);
 		r = v4lookup(f, h->dst);
+
 		if(r == nil || sr == r){
 			ip->stats[OutDiscards]++;
 			freeblist(bp);


@@ 429,13 485,14 @@ ipiput(Fs *f, Ipifc *ifc, Block *bp)
 		}
 
 		/* don't forward if packet has timed out */
-		if(h->ttl <= 1){
+		hop = h->ttl;
+		if(hop < 1) {
 			ip->stats[InHdrErrors]++;
-			icmpttlexceeded(f, ifc, bp);
+			icmpttlexceeded(f, ifc->lifc->local, bp);
 			freeblist(bp);
 			return;
 		}
-		
+
 		/* reassemble if the interface expects it */
 		if(r->ifc->reassemble){
 			frag = nhgets(h->frag);


@@ 443,32 500,33 @@ ipiput(Fs *f, Ipifc *ifc, Block *bp)
 				h->tos = 0;
 				if(frag & IP_MF)
 					h->tos = 1;
-				bp = ipreassemble(ip, frag, bp, h);
+				bp = ip4reassemble(ip, frag, bp, h);
 				if(bp == nil)
 					return;
-				h = (Iphdr *)(bp->rp);
+				h = (Ip4hdr*)(bp->rp);
 			}
 		}
 
 		ip->stats[ForwDatagrams]++;
-		ipoput(f, bp, 1, h->ttl - 1, h->tos);
-
+		tos = h->tos;
+		hop = h->ttl;
+		ipoput4(f, bp, 1, hop - 1, tos);
 		return;
 	}
 
-	/* reassemble */
 	frag = nhgets(h->frag);
 	if(frag) {
 		h->tos = 0;
 		if(frag & IP_MF)
 			h->tos = 1;
-		bp = ipreassemble(ip, frag, bp, h);
+		bp = ip4reassemble(ip, frag, bp, h);
 		if(bp == nil)
 			return;
-		h = (Iphdr *)(bp->rp);
+		h = (Ip4hdr*)(bp->rp);
 	}
 
-	p = Fsrcvpcol(f, h->proto);
+	proto = h->proto;
+	p = Fsrcvpcol(f, proto);
 	if(p != nil && p->rcv != nil) {
 		ip->stats[InDelivers]++;
 		(*p->rcv)(p, ifc, bp);


@@ 497,11 555,11 @@ ipstats(Fs *f, char *buf, int len)
 }
 
 Block*
-ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
+ip4reassemble(IP *ip, int offset, Block *bp, Ip4hdr *ih)
 {
 	int fend;
 	ushort id;
-	Fragment *f, *fnext;
+	Fragment4 *f, *fnext;
 	ulong src, dst;
 	Block *bl, **l, *last, *prev;
 	int ovlap, len, fragsize, pktposn;


@@ 515,21 573,21 @@ ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
 	 */
 	if(bp->next){
 		bp = pullupblock(bp, blocklen(bp));
-		ih = (Iphdr *)(bp->rp);
+		ih = (Ip4hdr*)(bp->rp);
 	}
 
-	qlock(&ip->fraglock);
+	qlock(&ip->fraglock4);
 
 	/*
 	 *  find a reassembly queue for this fragment
 	 */
-	for(f = ip->flisthead; f; f = fnext){
-		fnext = f->next;	/* because ipfragfree changes the list */
+	for(f = ip->flisthead4; f; f = fnext){
+		fnext = f->next;	/* because ipfragfree4 changes the list */
 		if(f->src == src && f->dst == dst && f->id == id)
 			break;
 		if(f->age < msec){
 			ip->stats[ReasmTimeout]++;
-			ipfragfree(ip, f);
+			ipfragfree4(ip, f);
 		}
 	}
 


@@ 540,10 598,10 @@ ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
 	 */
 	if(!ih->tos && (offset & ~(IP_MF|IP_DF)) == 0) {
 		if(f != nil) {
-			ipfragfree(ip, f);
+			ipfragfree4(ip, f);
 			ip->stats[ReasmFails]++;
 		}
-		qunlock(&ip->fraglock);
+		qunlock(&ip->fraglock4);
 		return bp;
 	}
 


@@ 553,18 611,18 @@ ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
 	}
 
 	BKFG(bp)->foff = offset<<3;
-	BKFG(bp)->flen = nhgets(ih->length)-IPHDR;
+	BKFG(bp)->flen = nhgets(ih->length)-IP4HDR;
 
 	/* First fragment allocates a reassembly queue */
 	if(f == nil) {
-		f = ipfragallo(ip);
+		f = ipfragallo4(ip);
 		f->id = id;
 		f->src = src;
 		f->dst = dst;
 
 		f->blist = bp;
 
-		qunlock(&ip->fraglock);
+		qunlock(&ip->fraglock4);
 		ip->stats[ReasmReqds]++;
 		return nil;
 	}


@@ 587,7 645,7 @@ ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
 		if(ovlap > 0) {
 			if(ovlap >= BKFG(bp)->flen) {
 				freeblist(bp);
-				qunlock(&ip->fraglock);
+				qunlock(&ip->fraglock4);
 				return nil;
 			}
 			BKFG(prev)->flen -= ovlap;


@@ 611,7 669,7 @@ ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
 				BKFG(*l)->flen -= ovlap;
 				BKFG(*l)->foff += ovlap;
 				/* move up ih hdrs */
-				memmove((*l)->rp + ovlap, (*l)->rp, IPHDR);
+				memmove((*l)->rp + ovlap, (*l)->rp, IP4HDR);
 				(*l)->rp += ovlap;
 				break;
 			}


@@ 641,32 699,32 @@ ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
 			for(bl = bl->next; bl; bl = bl->next) {
 				fragsize = BKFG(bl)->flen;
 				len += fragsize;
-				bl->rp += IPHDR;
+				bl->rp += IP4HDR;
 				bl->wp = bl->rp + fragsize;
 			}
 
 			bl = f->blist;
 			f->blist = nil;
-			ipfragfree(ip, f);
+			ipfragfree4(ip, f);
 			ih = BLKIP(bl);
 			hnputs(ih->length, len);
-			qunlock(&ip->fraglock);
+			qunlock(&ip->fraglock4);
 			ip->stats[ReasmOKs]++;
 			return bl;		
 		}
 		pktposn += BKFG(bl)->flen;
 	}
-	qunlock(&ip->fraglock);
+	qunlock(&ip->fraglock4);
 	return nil;
 }
 
 /*
- * ipfragfree - Free a list of fragments - assume hold fraglock
+ * ipfragfree4 - Free a list of fragments - assume hold fraglock4
  */
 void
-ipfragfree(IP *ip, Fragment *frag)
+ipfragfree4(IP *ip, Fragment4 *frag)
 {
-	Fragment *fl, **l;
+	Fragment4 *fl, **l;
 
 	if(frag->blist)
 		freeblist(frag->blist);


@@ 675,7 733,7 @@ ipfragfree(IP *ip, Fragment *frag)
 	frag->id = 0;
 	frag->blist = nil;
 
-	l = &ip->flisthead;
+	l = &ip->flisthead4;
 	for(fl = *l; fl; fl = fl->next) {
 		if(fl == frag) {
 			*l = frag->next;


@@ 684,29 742,29 @@ ipfragfree(IP *ip, Fragment *frag)
 		l = &fl->next;
 	}
 
-	frag->next = ip->fragfree;
-	ip->fragfree = frag;
+	frag->next = ip->fragfree4;
+	ip->fragfree4 = frag;
 
 }
 
 /*
- * ipfragallo - allocate a reassembly queue - assume hold fraglock
+ * ipfragallo4 - allocate a reassembly queue - assume hold fraglock4
  */
-Fragment *
-ipfragallo(IP *ip)
+Fragment4 *
+ipfragallo4(IP *ip)
 {
-	Fragment *f;
+	Fragment4 *f;
 
-	while(ip->fragfree == nil) {
+	while(ip->fragfree4 == nil) {
 		/* free last entry on fraglist */
-		for(f = ip->flisthead; f->next; f = f->next)
+		for(f = ip->flisthead4; f->next; f = f->next)
 			;
-		ipfragfree(ip, f);
+		ipfragfree4(ip, f);
 	}
-	f = ip->fragfree;
-	ip->fragfree = f->next;
-	f->next = ip->flisthead;
-	ip->flisthead = f;
+	f = ip->fragfree4;
+	ip->fragfree4 = f->next;
+	f->next = ip->flisthead4;
+	ip->flisthead4 = f;
 	f->age = msec + 30000;
 
 	return f;


@@ 733,70 791,4 @@ ipcsum(uchar *addr)
 	return (sum^0xffff);
 }
 
-enum
-{
-	Nmtucache=	128,
-};
-
-typedef struct MTUcache MTUcache;
-
-struct MTUcache
-{
-	uchar	ip[IPaddrlen];
-	ulong	mtu;
-	ulong	ms;
-};
-
-static struct {
-	Lock;
-	MTUcache c[Nmtucache];
-} mc;
-
-void
-update_mtucache(uchar *ip, ulong mtu)
-{
-	MTUcache *oldest, *p;
-
-	if(mtu < 512)
-		return;
-
-	lock(&mc);
-	oldest = mc.c;
-	for(p = mc.c; p < &mc.c[Nmtucache]; p++){
-		if(ipcmp(ip, p->ip) == 0){
-			p->mtu = mtu;
-			p->ms = msec;
-			break;
-		}
-		if(p->ms < oldest->ms)
-			oldest = p;
-	}
-	if(p == &mc.c[Nmtucache]){
-		ipmove(oldest->ip, ip);
-		oldest->mtu = mtu;
-		oldest->ms = msec;
-	}
-	unlock(&mc);
-}
-
-ulong
-restrict_mtu(uchar *ip, ulong mtu)
-{
-	MTUcache *p;
 
-	lock(&mc);
-	for(p = mc.c; p < &mc.c[Nmtucache]; p++){
-		if(p->ms + 1000*10*60 < msec){
-			memset(p->ip, 0, sizeof(p->ip));
-			p->ms = 0;
-		}
-		if(ipcmp(ip, p->ip) == 0){
-			if(p->mtu < mtu)
-				mtu = p->mtu;
-			break;
-		}
-	}
-	unlock(&mc);
-
-	return mtu;
-}

@@ 24,6 24,11 @@ typedef struct	Arpent	Arpent;
 typedef struct	Arp Arp;
 typedef struct	Route	Route;
 
+typedef struct	Routerparams	Routerparams;
+typedef struct 	Hostparams	Hostparams;
+typedef struct 	v6router	v6router;
+typedef struct	v6params	v6params;
+
 enum
 {
 	Addrlen=	64,


@@ 44,9 49,11 @@ enum
 	/* ip versions */
 	V4=		4,
 	V6=		6,
+	IP_VER4= 	0x40,
+	IP_VER6=	0x60,
 
 	/* 2^Lroot trees in the root table */
-	Lroot	= 10,
+	Lroot=		10,
 
 	Maxpath =	64,
 };


@@ 78,7 85,7 @@ struct Conv
 	uint	ttl;			/* max time to live */
 	uint	tos;			/* type of service */
 
-	char	*owner		;	/* protections */
+	char	*owner;			/* protections */
 	int	perm;
 	int	inuse;			/* opens of listen/data/ctl */
 	int	length;


@@ 138,6 145,9 @@ struct Medium
 	void	(*ares)(Fs*, int, uchar*, uchar*, int, int);	/* resolve */
 	void	(*areg)(Ipifc*, uchar*);			/* register */
 
+	/* v6 address generation */
+	void	(*pref2addr)(uchar *pref, uchar *ea);
+
 	int	unbindonclose;	/* if non-zero, unbind on last close */
 };
 


@@ 148,6 158,12 @@ struct Iplifc
 	uchar	mask[IPaddrlen];
 	uchar	remote[IPaddrlen];
 	uchar	net[IPaddrlen];
+	uchar	tentative;	/* =1 => v6 dup disc on, =0 => confirmed unique */
+	uchar	onlink;		/* =1 => onlink, =0 offlink. */
+	uchar	autoflag;	/* v6 autonomous flag */
+	long 	validlt;	/* v6 valid lifetime */
+	long 	preflt;		/* v6 preferred lifetime */
+	long	origint;	/* time when addr was added */
 	Iplink	*link;		/* addresses linked to this lifc */
 	Iplifc	*next;
 };


@@ 164,6 180,25 @@ struct Iplink
 	int	ref;
 };
 
+/* rfc 2461, pp.40--43. */
+
+/* default values, one per stack */
+struct Routerparams {
+	int	mflag;
+	int	oflag;
+	int 	maxraint;
+	int	minraint;
+	int	linkmtu;
+	int	reachtime;
+	int	rxmitra;
+	int	ttl;
+	int	routerlt;	
+};
+
+struct Hostparams {
+	int	rxmithost;
+};
+
 struct Ipifc
 {
 	RWlock;


@@ 189,6 224,11 @@ struct Ipifc
 
 	ulong	in, out;	/* message statistics */
 	ulong	inerr, outerr;	/* ... */
+
+	uchar	sendra6;	/* == 1 => send router advs on this ifc	*/
+	uchar	recvra6;	/* == 1 => recv router advs on this ifc */
+	Routerparams rp;	/* router parameters as in RFC 2461, pp.40--43. 
+					used only if node is router */
 };
 
 /*


@@ 267,6 307,7 @@ struct Proto
 	void		*priv;
 };
 
+
 /*
  *  one per IP protocol stack
  */


@@ 284,6 325,7 @@ struct Fs
 	IP	*ip;
 	Ipselftab	*self;
 	Arp	*arp;
+	v6params	*v6p;
 
 	Route	*v4root[1<<Lroot];	/* v4 routing forest */
 	Route	*v6root[1<<Lroot];	/* v6 routing forest */


@@ 293,10 335,28 @@ struct Fs
 	Ifclog	*ilog;
 
 	char	ndb[1024];		/* an ndb entry for this interface */
-	int	ndbvers;
-	long	ndbmtime;
 };
 
+/* one per default router known to host */
+struct v6router {
+	uchar	inuse;
+	Ipifc	*ifc;
+	int	ifcid;
+	uchar	routeraddr[IPaddrlen];
+	long	ltorigin;
+	Routerparams	rp;
+};
+
+struct v6params
+{
+	Routerparams	rp;		/* v6 params, one copy per node now */
+	Hostparams	hp;
+	v6router	v6rlist[3];	/* max 3 default routers, currently */
+	int		cdrouter;	/* uses only v6rlist[cdrouter] if   */ 
+					/* cdrouter >= 0. */
+};
+
+
 int	Fsconnected(Conv*, char*);
 Conv*	Fsnewcall(Conv*, uchar*, ushort, uchar*, ushort);
 int	Fspcolstats(char*, int);


@@ 310,7 370,6 @@ char*	Fsstdannounce(Conv*, char**, int);
 char*	Fsstdbind(Conv*, char**, int);
 ulong	scalednconv(void);
 void	closeconv(Conv*);
-
 /* 
  *  logging
  */


@@ 449,19 508,24 @@ struct Arpent
 {
 	uchar	ip[IPaddrlen];
 	uchar	mac[MAClen];
-	Medium	*type;		/* media type */
+	Medium	*type;			/* media type */
 	Arpent*	hash;
 	Block*	hold;
 	Block*	last;
 	uint	time;
 	uint	used;
 	uchar	state;
+	Arpent	*nextrxt;		/* re-transmit chain */
+	uint	rxtat;
+	uchar	rxtsrem;
+	Ipifc	*ifc;
+	uchar	ifcid;			/* must match ifc->id */
 };
 
 extern void	arpinit(Fs*);
 extern int	arpread(Arp*, char*, ulong, int);
 extern int	arpwrite(Fs*, char*, int);
-extern Arpent*	arpget(Arp*, Block *bp, int version, Medium *type, uchar *ip, uchar *h);
+extern Arpent*	arpget(Arp*, Block *bp, int version, Ipifc *ifc, uchar *ip, uchar *h);
 extern void	arprelease(Arp*, Arpent *a);
 extern Block*	arpresolve(Arp*, Arpent *a, Medium *type, uchar *mac);
 extern void	arpenter(Fs*, int version, uchar *ip, uchar *mac, int len, int norefresh);


@@ 509,6 573,7 @@ extern Medium	tripmedium;
 extern Medium*	ipfindmedium(char *name);
 extern void	addipmedium(Medium *med);
 extern int	ipforme(Fs*, uchar *addr);
+extern int	iptentative(Fs*, uchar *addr);
 extern int	ipisbm(uchar *);
 extern int	ipismulticast(uchar *);
 extern Ipifc*	findipifc(Fs*, uchar *remote, int type);


@@ 516,6 581,7 @@ extern void	findprimaryip(Fs*, uchar*);
 extern void	findlocalip(Fs*, uchar *local, uchar *remote);
 extern int	ipv4local(Ipifc *ifc, uchar *addr);
 extern int	ipv6local(Ipifc *ifc, uchar *addr);
+extern int	ipv6anylocal(Ipifc *ifc, uchar *addr);
 extern Iplifc*	iplocalonifc(Ipifc *ifc, uchar *ip);
 extern int	ipproxyifc(Fs *f, Ipifc *ifc, uchar *ip);
 extern int	ipismulticast(uchar *ip);


@@ 528,27 594,30 @@ extern void	ipifcremroute(Fs*, int, uchar*, uchar*);
 extern void	ipifcremmulti(Conv *c, uchar *ma, uchar *ia);
 extern void	ipifcaddmulti(Conv *c, uchar *ma, uchar *ia);
 extern char*	ipifcrem(Ipifc *ifc, char **argv, int argc, int dolock);
-extern char*	ipifcadd(Ipifc *ifc, char **argv, int argc);
+extern char*	ipifcadd(Ipifc *ifc, char **argv, int argc, int tentative, Iplifc *lifcp);
 extern long	ipselftabread(Fs*, char *a, ulong offset, int n);
-
+extern char*	ipifcaddgate6(Fs *f, Ipifc *ifc, char**argv, int argc);
+extern char*	ipifcaddpref6(Ipifc *ifc, char**argv, int argc);
+extern void	ipsendra6(Fs *f, int on);
+extern long	ipgateread6(Fs *f, char *cp, ulong offset, int n);
 /*
  *  ip.c
  */
 extern void	iprouting(Fs*, int);
 extern void	closeifcconv(Ifcconv*);
 extern void	icmpnoconv(Fs*, Block*);
-extern void	icmpttlexceeded(Fs*, Ipifc*, Block*);
-extern void	initfrag(IP*, int);
+extern void	icmpttlexceeded(Fs*, uchar*, Block*);
 extern ushort	ipcsum(uchar*);
-extern void	ipiput(Fs*, Ipifc*, Block*);
-extern void	ipoput(Fs*, Block*, int, int, int);
+extern void	ipiput4(Fs*, Ipifc*, Block*);
+extern void	ipiput6(Fs*, Ipifc*, Block*);
+extern void	ipoput4(Fs*, Block*, int, int, int);
+extern void	ipoput6(Fs*, Block*, int, int, int);
 extern int	ipstats(Fs*, char*, int);
 extern ushort	ptclbsum(uchar*, int);
 extern ushort	ptclcsum(Block*, int, int);
 extern void	ip_init(Fs*);
 extern void	update_mtucache(uchar*, ulong);
 extern ulong	restrict_mtu(uchar*, ulong);
-
 /*
  * bootp.c
  */


@@ 573,3 642,4 @@ extern Chan*	chandial(char*, char*, char*, Chan**);
 extern int	debug;
 extern Fs	fs;
 extern void	(*igmpreportfn)(Ipifc*, uchar*);
+

@@ 5,6 5,7 @@
 #include	"fns.h"
 #include	"../port/error.h"
 #include	"ip.h"
+#include  "ipv6.h"
 
 /*
  *  well known IP addresses


@@ 33,6 34,7 @@ uchar IPallbits[IPaddrlen] = {
 	0xff, 0xff, 0xff, 0xff,
 	0xff, 0xff, 0xff, 0xff
 };
+
 uchar IPnoaddr[IPaddrlen];
 
 /*


@@ 46,6 48,151 @@ uchar v4prefix[IPaddrlen] = {
 };
 
 
+char *v6hdrtypes[Maxhdrtype] =
+{
+	[HBH]		"HopbyHop",
+	[ICMP]		"ICMP",
+	[IGMP]		"IGMP",
+	[GGP]		"GGP",
+	[IPINIP]		"IP",
+	[ST]		"ST",
+	[TCP]		"TCP",
+	[UDP]		"UDP",
+	[ISO_TP4]	"ISO_TP4",
+	[RH]		"Routinghdr",
+	[FH]		"Fraghdr",
+	[IDRP]		"IDRP",
+	[RSVP]		"RSVP",
+	[AH]		"Authhdr",
+	[ESP]		"ESP",
+	[ICMPv6]	"ICMPv6",
+	[NNH]		"Nonexthdr",
+	[ISO_IP]	"ISO_IP",
+	[IGRP]		"IGRP",
+	[OSPF]		"OSPF",
+};
+
+/*
+ *  well known IPv6 addresses
+ */
+uchar v6Unspecified[IPaddrlen] = {
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+uchar v6loopback[IPaddrlen] = {
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x01
+};
+uchar v6linklocal[IPaddrlen] = {
+	0xfe, 0x80, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+uchar v6linklocalmask[IPaddrlen] = {
+	0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+int v6linklocalprefix = 8;
+uchar v6sitelocal[IPaddrlen] = {
+	0xfe, 0xc0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+uchar v6sitelocalmask[IPaddrlen] = {
+	0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+int v6sitelocalprefix = 6;
+uchar v6glunicast[IPaddrlen] = {
+	0x08, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+uchar v6multicast[IPaddrlen] = {
+	0xff, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+uchar v6multicastmask[IPaddrlen] = {
+	0xff, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+int v6multicastprefix = 1;
+uchar v6allnodesN[IPaddrlen] = {
+	0xff, 0x01, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x01
+};
+uchar v6allnodesNmask[IPaddrlen] = {
+	0xff, 0xff, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+int v6allnodesprefix = 2;
+uchar v6allnodesL[IPaddrlen] = {
+	0xff, 0x02, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x01
+};
+uchar v6allnodesLmask[IPaddrlen] = {
+	0xff, 0xff, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0
+};
+int v6allnodesLprefix = 2;
+uchar v6allroutersN[IPaddrlen] = {
+	0xff, 0x01, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x02
+};
+uchar v6allroutersL[IPaddrlen] = {
+	0xff, 0x02, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x02
+};
+uchar v6allroutersS[IPaddrlen] = {
+	0xff, 0x05, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x02
+};
+uchar v6solicitednode[IPaddrlen] = {
+	0xff, 0x02, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0x01,
+	0xff, 0, 0, 0
+};
+uchar v6solicitednodemask[IPaddrlen] = {
+	0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff,
+	0xff, 0x0, 0x0, 0x0
+};
+int v6solicitednodeprefix = 13;
+
+
+
+
 ushort
 ptclcsum(Block *bp, int offset, int len)
 {


@@ 135,16 282,13 @@ eipfmt(Fmt *f)
 	switch(f->r) {
 	case 'E':		/* Ethernet address */
 		p = va_arg(f->args, uchar*);
-		snprint(buf, sizeof buf, efmt, p[0], p[1], p[2], p[3], p[4], p[5]);
-		return fmtstrcpy(f, buf);
+		return fmtprint(f, efmt, p[0], p[1], p[2], p[3], p[4], p[5]);
 
 	case 'I':		/* Ip address */
 		p = va_arg(f->args, uchar*);
 common:
-		if(memcmp(p, v4prefix, 12) == 0){
-			snprint(buf, sizeof buf, ifmt, p[12], p[13], p[14], p[15]);
-			return fmtstrcpy(f, buf);
-		}
+		if(memcmp(p, v4prefix, 12) == 0)
+			return fmtprint(f, ifmt, p[12], p[13], p[14], p[15]);
 
 		/* find longest elision */
 		eln = eli = -1;


@@ 182,8 326,7 @@ common:
 
 	case 'V':		/* v4 ip address */
 		p = va_arg(f->args, uchar*);
-		snprint(buf, sizeof buf, ifmt, p[0], p[1], p[2], p[3]);
-		return fmtstrcpy(f, buf);
+		return fmtprint(f, ifmt, p[0], p[1], p[2], p[3]);
 
 	case 'M':		/* ip mask */
 		p = va_arg(f->args, uchar*);


@@ 203,10 346,10 @@ common:
 			n = 8*16;
 
 		/* got one, use /xx format */
-		snprint(buf, sizeof buf, "/%d", n);
-		return fmtstrcpy(f, buf);
+		return fmtprint(f, "/%d", n);
+
 	}
-	return fmtstrcpy(f, "(eipfmt)");
+	return fmtprint(f, "(eipfmt)");
 }
 
 #define CLASS(p) ((*(uchar*)(p))>>6)


@@ 230,7 373,7 @@ v4parseip(uchar *to, char *from)
 			to[3] = to[2];
 			to[2] = to[1];
 			to[1] = 0;
-		} else if (i == 2){
+		} else if(i == 2){
 			to[3] = to[1];
 			to[1] = 0;
 		}


@@ 395,9 538,34 @@ uchar classmask[4][16] = {
 uchar*
 defmask(uchar *ip)
 {
-	return classmask[ip[IPv4off]>>6];
+	if(isv4(ip))
+		return classmask[ip[IPv4off]>>6];
+	else {
+		if(ipcmp(ip, v6loopback) == 0)
+			return IPallbits;
+		else if(memcmp(ip, v6linklocal, v6linklocalprefix) == 0)
+			return v6linklocalmask;
+		else if(memcmp(ip, v6sitelocal, v6sitelocalprefix) == 0)
+			return v6sitelocalmask;
+		else if(memcmp(ip, v6solicitednode, v6solicitednodeprefix) == 0)
+			return v6solicitednodemask;
+		else if(memcmp(ip, v6multicast, v6multicastprefix) == 0)
+			return v6multicastmask;
+		return IPallbits;
+	}
 }
 
+void
+ipv62smcast(uchar *smcast, uchar *a)
+{
+	assert(IPaddrlen == 16);
+	memmove(smcast, v6solicitednode, IPaddrlen);
+	smcast[13] = a[13];
+	smcast[14] = a[14];
+	smcast[15] = a[15];
+}
+
+
 /*
  *  parse a hex mac address
  */