#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"../port/error.h"
#include	<libcrypt.h>
#include	<kernel.h>
#include	"ip.h"
#include	"ppp.h"

int	nocompress;

/*
 * Calculate FCS - rfc 1331
 */
ushort fcstab[256] =
{
      0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
      0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
      0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
      0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
      0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
      0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
      0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
      0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
      0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
      0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
      0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
      0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
      0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
      0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
      0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
      0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
      0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
      0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
      0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
      0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
      0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
      0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
      0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
      0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
      0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
      0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
      0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
      0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
      0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
      0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
      0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
      0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};

static char *snames[] =
{
	"Sidle",
	"Sclosing",
	"Sreqsent",
	"Sackrcvd",
	"Sacksent",
	"Sopened",
};

static void	init(PPP*);
static void	pinit(PPP*, Pstate*, int);
static void	ppptimer(PPP*);
static void	ptimer(PPP*, Pstate*);
static int	getframe(PPP*, Block**);
static Block*	putframe(PPP*, int, Block*);
static byte*	escapebyte(PPP*, ulong, byte*, ushort*);
static void	config(PPP*, Pstate*, int);
static int	getopts(PPP*, Pstate*, Block*);
static void	rejopts(PPP*, Pstate*, Block*, int);
static void	newstate(PPP*, Pstate*, int);
static void	rcv(PPP*, Pstate*, Block*);
static void	getchap(PPP*, Block*);
static void	getpap(PPP*, Block*);
static void	sendpap(PPP*);
static void	getlqm(PPP*, Block*);
static void	putlqm(PPP*);
static void	hangup(PPP*);
static void	remove(PPP*);

static	int		validv4(Ipaddr);
static	void		invalidate(Ipaddr);
static	void		ipconnect(PPP *);
static	void		setdefroute(PPP *, Ipaddr);
static	void		printopts(PPP *, Pstate*, Block*, int);

static void
errlog(PPP *ppp, char *err)
{
	int n;
	char msg[ERRLEN];

	n = snprint(msg, sizeof(msg), "%s\n", err);
	qproduce(ppp->ifc->conv->eq, msg, n);
}

/*
 *  change protocol to a new state.  set timers if necessary.
 */
static void
newstate(PPP *ppp, Pstate *p, int state)
{
	netlog(ppp->f, Logppp, "%ux %ux %s->%s ctlmap %lux/%lux flags %ux mtu %d mru %d\n", ppp, p->proto,
		snames[p->state], snames[state], ppp->rctlmap, ppp->xctlmap, p->flags,
		ppp->mtu, ppp->mru);

	if(p->proto == Pipcp && state == Sopened && validv4(ppp->local) && validv4(ppp->remote)){
		netlog(ppp->f, Logppp, "pppnewstate: local %I remote %I\n", ppp->local, ppp->remote);
		ipconnect(ppp);
		/* if this is the only network, set up a default route */
//		if(ppp->ifc->link==nil)		/* how??? */
			setdefroute(ppp, ppp->remote);
		errlog(ppp, Enoerror);
	}

	p->state = state;
}

static void
pinit(PPP *ppp, Pstate *p, int configrcvd)
{
	p->timeout = 0;

	switch(p->proto){
	case Plcp:
		ppp->magic = TK2MS(MACHP(0)->ticks);
		if(!configrcvd){
			ppp->xctlmap = 0xffffffff;
			ppp->period = 0;
			p->optmask = 0xffffffff;
		}
		ppp->rctlmap = 0;
		ppp->ipcp->state = Sidle;
		ppp->ipcp->optmask = 0xffffffff;

		/* quality goo */
		ppp->timeout = 0;
		memset(&ppp->in, 0, sizeof(ppp->in));
		memset(&ppp->out, 0, sizeof(ppp->out));
		memset(&ppp->pin, 0, sizeof(ppp->pin));
		memset(&ppp->pout, 0, sizeof(ppp->pout));
		memset(&ppp->sin, 0, sizeof(ppp->sin));
		break;
	case Pipcp:
		if(!configrcvd){
			p->optmask = 0xffffffff;
		}
		ppp->ctcp = compress_init(ppp->ctcp);
		break;
	}
	p->confid = p->rcvdconfid = -1;
	config(ppp, p, 1);
	newstate(ppp, p, Sreqsent);
}

static void
init(PPP* ppp)
{
	if(ppp->inbuf == nil){
		ppp->inbuf = allocb(4096);
		ppp->outbuf = allocb(4096);

		ppp->lcp = malloc(sizeof(Pstate));
		ppp->ipcp = malloc(sizeof(Pstate));
		if(ppp->lcp == nil || ppp->ipcp == nil)
			error("ppp init: malloc");

		ppp->lcp->proto = Plcp;
		ppp->lcp->state = Sidle;
		ppp->ipcp->proto = Pipcp;
		ppp->ipcp->state = Sidle;

		kproc("ppptimer", ppptimer, ppp);
	}

	pinit(ppp, ppp->lcp, 0);
	newstate(ppp, ppp->lcp, Sreqsent);
}

static void
remove(PPP *ppp)
{
	free(ppp->ipcp);
	ppp->ipcp = 0;
	free(ppp->ctcp);
	ppp->ctcp = 0;
	free(ppp->lcp);
	ppp->lcp = 0;
	if (ppp->inbuf) {
		freeb(ppp->inbuf);
		ppp->inbuf = nil;
	}
	if (ppp->outbuf) {
		freeb(ppp->outbuf);
		ppp->outbuf = nil;
	}
	free(ppp);
}

void
pppclose(PPP *ppp)
{
	hangup(ppp);
	remove(ppp);
}

static void
dumpblock(Block *b)
{
	char x[256];
	int i;

	for(i = 0; i < (sizeof(x)-1)/3 && b->rp+i < b->wp; i++)
		sprint(&x[3*i], "%2.2ux ", b->rp[i]);
	print("%s\n", x);
}

/* returns (protocol, information) */
static int
getframe(PPP *ppp, Block **info)
{
	byte *p, *from, *to;
	int n, len, proto;
	ulong c;
	ushort fcs;
	Block *buf, *b;

	buf = ppp->inbuf;
	for(;;){
		/* read till we hit a frame byte or run out of room */
		for(p = buf->rp; buf->wp < buf->lim;){
			for(; p < buf->wp; p++)
				if(*p == HDLC_frame)
					goto break2;

			len = buf->lim - buf->wp;
			n = 0;
			if(ppp->dchan != nil)
				n = kchanio(ppp->dchan, buf->wp, len, OREAD);
			if(n <= 0){
				buf->wp = buf->rp;
//				if(n < 0)
//					print("ppp kchanio(%s) returned %d: %r",
//						ppp->dchan->path->elem, n);
				*info = nil;
				return 0;
			}
			buf->wp += n;
		}
break2:

		/* copy into block, undoing escapes, and caculating fcs */
		fcs = PPP_initfcs;
		b = allocb(p - buf->rp);
		to = b->wp;
		for(from = buf->rp; from != p;){
			c = *from++;
			if(c == HDLC_esc){
				if(from == p)
					break;
				c = *from++ ^ 0x20;
			} else if((c < 0x20) && (ppp->rctlmap & (1 << c)))
				continue;
			*to++ = c;
			fcs = (fcs >> 8) ^ fcstab[(fcs ^ c) & 0xff];
		}

		/* copy down what's left in buffer */
		p++;
		memmove(buf->rp, p, buf->wp - p);
		n = p - buf->rp;
		buf->wp -= n;
		b->wp = to - 2;

		/* return to caller if checksum matches */
		if(fcs == PPP_goodfcs){
			if(b->rp[0] == PPP_addr && b->rp[1] == PPP_ctl)
				b->rp += 2;
			proto = *b->rp++;
			if((proto & 0x1) == 0)
				proto = (proto<<8) | *b->rp++;
			if(b->rp < b->wp){
				ppp->in.bytes += n;
				ppp->in.packets++;
				*info = b;
				return proto;
			}
		} else if(BLEN(b) > 0){
			ppp->ifc->inerr++;
			ppp->in.discards++;
			netlog(ppp->f, Logppp, "len %d/%d cksum %ux (%ux %ux %ux %ux)\n",
				BLEN(b), BLEN(buf), fcs, b->rp[0],
				b->rp[1], b->rp[2], b->rp[3]);
		}

		freeblist(b);
	}
	*info = nil;
	return 0;
}

/* send a PPP frame */
static Block *
putframe(PPP *ppp, int proto, Block *b)
{
	Block *buf;
	byte *to, *from;
	ushort fcs;
	ulong ctlmap;
	byte c;
	Block *bp;

	if(ppp->dchan == nil){
		netlog(ppp->f, Logppp, "putframe: dchan down\n");
		errlog(ppp, Ehungup);
		return b;
	}
	//netlog(ppp->f, Logppp, "putframe %ux %d %d (%d bytes)\n", proto, b->rp[0], b->rp[1], BLEN(b));

	ppp->out.packets++;

	if(proto == Plcp)
		ctlmap = 0xffffffff;
	else
		ctlmap = ppp->xctlmap;

	/* make sure we have head room */
	if(b->rp - b->base < 4){
		b = padblock(b, 4);
		b->rp += 4;
	}

	/* add in the protocol and address, we'd better have left room */
	from = b->rp;
	*--from = proto;
	if(!(ppp->lcp->flags&Fpc) || proto > 0x100 || proto == Plcp)
		*--from = proto>>8;
	if(!(ppp->lcp->flags&Fac) || proto == Plcp){
		*--from = PPP_ctl;
		*--from = PPP_addr;
	}

	qlock(&ppp->outlock);
	buf = ppp->outbuf;

	/* escape and checksum the body */
	fcs = PPP_initfcs;
	to = buf->rp;

	*to++ = HDLC_frame;

	for(bp = b; bp; bp = bp->next){
		if(bp != b)
			from = bp->rp;
		for(; from < bp->wp; from++){
			c = *from;
			if(c == HDLC_frame || c == HDLC_esc
			   || (c < 0x20 && ((1<<c) & ctlmap))){
				*to++ = HDLC_esc;
				*to++ = c ^ 0x20;
			} else 
				*to++ = c;
			fcs = (fcs >> 8) ^ fcstab[(fcs ^ c) & 0xff];
		}
	}

	/* add on and escape the checksum */
	fcs = ~fcs;
	c = fcs;
	if(c == HDLC_frame || c == HDLC_esc
	   || (c < 0x20 && ((1<<c) & ctlmap))){
		*to++ = HDLC_esc;
		*to++ = c ^ 0x20;
	} else 
		*to++ = c;
	c = fcs>>8;
	if(c == HDLC_frame || c == HDLC_esc
	   || (c < 0x20 && ((1<<c) & ctlmap))){
		*to++ = HDLC_esc;
		*to++ = c ^ 0x20;
	} else 
		*to++ = c;

	/* add frame marker and send */
	*to++ = HDLC_frame;
	buf->wp = to;
	if(ppp->dchan == nil){
		netlog(ppp->f, Logppp, "putframe: dchan down\n");
		errlog(ppp, Ehungup);
	}
	else
	{
		kchanio(ppp->dchan, buf->rp, BLEN(buf), OWRITE);
		ppp->out.bytes += BLEN(buf);
	}

	qunlock(&ppp->outlock);
	return b;
}

#define IPB2LCP(b) ((Lcpmsg*)((b)->wp-4))

static Block*
alloclcp(int code, int id, int len)
{
	Block *b;
	Lcpmsg *m;

	/*
	 *  leave room for header
	 */
	b = allocb(len);

	m = (Lcpmsg*)b->wp;
	m->code = code;
	m->id = id;
	b->wp += 4;

	return b;
}

static void
putao(Block *b, int type, int aproto, int alg)
{
	*b->wp++ = type;
	*b->wp++ = 5;
	hnputs(b->wp, aproto);
	b->wp += 2;
	*b->wp++ = alg;
}

static void
putlo(Block *b, int type, ulong val)
{
	*b->wp++ = type;
	*b->wp++ = 6;
	hnputl(b->wp, val);
	b->wp += 4;
}

static void
putv4o(Block *b, int type, Ipaddr val)
{
	*b->wp++ = type;
	*b->wp++ = 6;
	if(v6tov4(b->wp, val) < 0)
		/*panic("putv4o")*/;
	b->wp += 4;
}

static void
putso(Block *b, int type, ulong val)
{
	*b->wp++ = type;
	*b->wp++ = 4;
	hnputs(b->wp, val);
	b->wp += 2;
}

static void
puto(Block *b, int type)
{
	*b->wp++ = type;
	*b->wp++ = 2;
}

/*
 *  send configuration request
 */
static void
config(PPP *ppp, Pstate *p, int newid)
{
	Block *b;
	Lcpmsg *m;
	int id;

	if(newid){
		id = ++(p->id);
		p->confid = id;
		p->timeout = Timeout;
	} else
		id = p->confid;
	b = alloclcp(Lconfreq, id, 256);
	m = IPB2LCP(b);
	USED(m);

	switch(p->proto){
	case Plcp:
		if(p->optmask & Fmagic)
			putlo(b, Omagic, ppp->magic);
		if(p->optmask & Fmtu)
			putso(b, Omtu, ppp->mru);
		if(p->optmask & Fac)
			puto(b, Oac);
		if(p->optmask & Fpc)
			puto(b, Opc);
		if(p->optmask & Fctlmap)
			putlo(b, Octlmap, 0);	/* we don't want anything escaped */
		break;
	case Pipcp:
		if(ppp->usepap){
			ppp->usepap = 0;
			sendpap(ppp);
		}
		if((p->optmask & Fipaddr) /*&& validv4(ppp->local)*/)
			putv4o(b, Oipaddr, ppp->local);
		if(!nocompress && (p->optmask & Fipcompress)){
			*b->wp++ = Oipcompress;
			*b->wp++ = 6;
			hnputs(b->wp, Pvjctcp);
			b->wp += 2;
			*b->wp++ = MAX_STATES-1;
			*b->wp++ = 1;
		}
		break;
	}

	hnputs(m->len, BLEN(b));
	b = putframe(ppp, p->proto, b);
	freeblist(b);
}

/*
 *  parse configuration request, sends an ack or reject packet
 *
 *	returns:	-1 if request was syntacticly incorrect
 *			 0 if packet was accepted
 *			 1 if packet was rejected
 */
static int
getopts(PPP *ppp, Pstate *p, Block *b)
{
	Lcpmsg *m, *repm;	
	Lcpopt *o;
	byte *cp;
	ulong rejecting, nacking, flags, proto;
	ulong mtu, ctlmap, period;
	ulong x;
	Block *repb;
	Ipaddr ipaddr;

	rejecting = 0;
	nacking = 0;
	flags = 0;

	/* defaults */
	invalidate(ipaddr);
	mtu = ppp->mtu;

	ctlmap = 0xffffffff;
	period = 0;

	m = (Lcpmsg*)b->rp;
	repb = alloclcp(Lconfack, m->id, BLEN(b));
	repm = IPB2LCP(repb);

	/* copy options into ack packet */
	memmove(repm->data, m->data, b->wp - m->data);
	repb->wp += b->wp - m->data;

	/* look for options we don't recognize or like */
	for(cp = m->data; cp < b->wp; cp += o->len){
		o = (Lcpopt*)cp;
		if(cp + o->len > b->wp){
			freeblist(repb);
			netlog(ppp->f, Logppp, "ppp %s: bad option length %ux\n", ppp->ifc->dev,
				o->type);
			return -1;
		}

		switch(p->proto){
		case Plcp:
			switch(o->type){
			case Oac:
				flags |= Fac;
				continue;
			case Opc:
				flags |= Fpc;
				continue;
			case Omtu:
				mtu = nhgets(o->data);
				if(mtu < ppp->ifc->m->minmtu){
					netlog(ppp->f, Logppp, "bogus mtu %d\n", mtu);
					mtu = ppp->ifc->m->minmtu;
				}
				continue;
			case Omagic:
				if(ppp->magic == nhgetl(o->data))
					netlog(ppp->f, Logppp, "ppp: possible loop\n");
				continue;
			case Octlmap:
				ctlmap = nhgetl(o->data);
				continue;
			case Oquality:
				proto = nhgets(o->data);
				if(proto != Plqm)
					break;
				x = nhgetl(o->data+2)*10;
				period = (x+Period-1)/Period;
				continue;
			case Oauth:
				proto = nhgets(o->data);
				if(proto == Ppap && ppp->chapname[0] && ppp->secret[0]){
					ppp->usepap = 1;
					netlog(ppp->f, Logppp, "PPP %s: select PAP\n", ppp->ifc->dev);
					continue;
				}
				if(proto != Pchap || o->data[2] != APmd5){
					if(!nacking){
						nacking = 1;
						repb->wp = repm->data;
						repm->code = Lconfnak;
					}
					putao(repb, Oauth, Pchap, APmd5);
				}
				ppp->usepap = 0;
				continue;
			}
			break;
		case Pipcp:
			switch(o->type){
			case Oipaddr:	
				v4tov6(ipaddr, o->data);
				if(!validv4(ppp->remote))
					continue;
				if(!validv4(ipaddr) && !rejecting){
					/* other side requesting an address */
					if(!nacking){
						nacking = 1;
						repb->wp = repm->data;
						repm->code = Lconfnak;
					}
					putv4o(repb, Oipaddr, ppp->remote);
				}
				continue;
			case Oipcompress:
				proto = nhgets(o->data);
				if(nocompress || proto != Pvjctcp || o->data[2] != MAX_STATES-1)
					break;
				continue;
			}
			break;
		}

		/* come here if option is not recognized */
		if(!rejecting){
			rejecting = 1;
			repb->wp = repm->data;
			repm->code = Lconfrej;
		}
		netlog(ppp->f, Logppp, "ppp %s: bad %ux option %d\n", ppp->ifc->dev, p->proto, o->type);
		memmove(repb->wp, o, o->len);
		repb->wp += o->len;
	}

	/* permanent changes only after we know that we liked the packet */
	if(!rejecting && !nacking){
		switch(p->proto){
		case Plcp:
			netlog(ppp->f, Logppp, "Plcp: mtu: %d %d x:%lux/r:%lux %lux\n", mtu, ppp->mtu, ppp->xctlmap, ppp->rctlmap, ctlmap);
			ppp->period = period;
			ppp->xctlmap = ctlmap;
			if(mtu > Maxmtu)
				mtu = Maxmtu;
			if(mtu < Minmtu)
				mtu = Minmtu;
			ppp->mtu = mtu;
			break;
		case Pipcp:
			if(validv4(ipaddr) && ppp->remotefrozen == 0)
 				ipmove(ppp->remote, ipaddr);
			break;
		}
		p->flags |= flags;
	}

	hnputs(repm->len, BLEN(repb));
	repb = putframe(ppp, p->proto, repb);
	freeblist(repb);

	return rejecting || nacking;
}

/*
 *  parse configuration rejection, just stop sending anything that they
 *  don't like (except for ipcp address nak).
 */
static void
rejopts(PPP *ppp, Pstate *p, Block *b, int code)
{
	Lcpmsg *m;
	Lcpopt *o;

	/* just give up trying what the other side doesn't like */
	m = (Lcpmsg*)b->rp;
	for(b->rp = m->data; b->rp < b->wp; b->rp += o->len){
		o = (Lcpopt*)b->rp;
		if(b->rp + o->len > b->wp){
			netlog(ppp->f, Logppp, "ppp %s: bad roption length %ux\n", ppp->ifc->dev,
				o->type);
			return;
		}

		if(code == Lconfrej){
			if(o->type < 8*sizeof(p->optmask))
				p->optmask &= ~(1<<o->type);
			netlog(ppp->f, Logppp, "ppp %s: %ux rejecting %d\n", ppp->ifc->dev, p->proto,
				o->type);
			continue;
		}

		switch(p->proto){
		case Plcp:
			switch(o->type){
			case Octlmap:
				ppp->rctlmap = nhgetl(o->data);
				break;
			default:
				if(o->type < 8*sizeof(p->optmask))
					p->optmask &= ~(1<<o->type);
				break;
			};
		case Pipcp:
			switch(o->type){
			case Oipaddr:
				if(!validv4(ppp->local))
					v4tov6(ppp->local, o->data);
//				if(o->type < 8*sizeof(p->optmask))
//					p->optmask &= ~(1<<o->type);
				break;
			default:
				if(o->type < 8*sizeof(p->optmask))
					p->optmask &= ~(1<<o->type);
				break;
			}
			break;
		}
	}
}


/*
 *  put a messages through the lcp or ipcp state machine.  They are
 *  very similar.
 */
static void
rcv(PPP *ppp, Pstate *p, Block *b)
{
	ulong len;
	int err;
	Lcpmsg *m;

	if(BLEN(b) < 4){
		netlog(ppp->f, Logppp, "ppp %s: short lcp message\n", ppp->ifc->dev);
		freeblist(b);
		return;
	}
	m = (Lcpmsg*)b->rp;
	len = nhgets(m->len);
	if(BLEN(b) < len){
		netlog(ppp->f, Logppp, "ppp %s: short lcp message\n", ppp->ifc->dev);
		freeblist(b);
		return;
	}

	netlog(ppp->f, Logppp, "ppp: %ux rcv %d len %d id %d/%d/%d\n",
		p->proto, m->code, len, m->id, p->confid, p->id);

	if(p->proto != Plcp && ppp->lcp->state != Sopened){
		netlog(ppp->f, Logppp, "ppp: non-lcp with lcp not open\n");
		freeb(b);
		return;
	}

	qlock(ppp);
	switch(m->code){
	case Lconfreq:
		/* flush the output queue */
		if(p->state == Sopened && p->proto == Plcp)
			kchanio(ppp->cchan, "f", 1, OWRITE);

		printopts(ppp, p, b, 0);
		err = getopts(ppp, p, b);
		if(err < 0)
			break;

		if(m->id == p->rcvdconfid)
			break;			/* don't change state for duplicates */
		p->rcvdconfid = m->id;

		switch(p->state){
		case Sackrcvd:
			if(err)
				break;
			newstate(ppp, p, Sopened);
			if(p->proto == Plcp && ppp->ipcp->state == Sidle){
				pinit(ppp, ppp->ipcp, 0);
				newstate(ppp, ppp->ipcp, Sreqsent);
			}
			break;
		case Sidle:
		case Sopened:
			if(err == 0){
				pinit(ppp, p, 1);
				newstate(ppp, p, Sacksent);
			} else {
				pinit(ppp, p, 0);
				newstate(ppp, p, Sreqsent);
			}
			break;
		case Sreqsent:
		case Sacksent:
			if(err == 0)
				newstate(ppp, p, Sacksent);
			else
				newstate(ppp, p, Sreqsent);
			break;
		}
		break;
	case Lconfack:
		if(p->confid != m->id){
			/* ignore if it isn't the message we're sending */
			netlog(ppp->f, Logppp, "ppp: dropping confack\n");
			break;
		}
		p->confid = -1;		/* ignore duplicates */
		p->id++;		/* avoid sending duplicates */

		switch(p->state){
		case Sreqsent:
			newstate(ppp, p, Sackrcvd);
			break;
		case Sacksent:
			newstate(ppp, p, Sopened);
			if(p->proto == Plcp && ppp->ipcp->state == Sidle){
				pinit(ppp, ppp->ipcp, 0);
				newstate(ppp, ppp->ipcp, Sreqsent);
			}
			break;
		}
		break;
	case Lconfrej:
	case Lconfnak:
		if(p->confid != m->id) {
			/* ignore if it isn't the message we're sending */
			netlog(ppp->f, Logppp, "ppp: dropping confrej or confnak\n");
			break;
		}
		p->confid = -1;		/* ignore duplicates */
		p->id++;		/* avoid sending duplicates */

		switch(p->state){
		case Sreqsent:
		case Sacksent:
			printopts(ppp, p, b, 0);
			rejopts(ppp, p, b, m->code);
			config(ppp, p, 1);
			break;
		}
		break;
	case Ltermreq:
		m->code = Ltermack;
		b = putframe(ppp, p->proto, b);

		switch(p->state){
		case Sackrcvd:
		case Sacksent:
			newstate(ppp, p, Sreqsent);
			break;
		case Sopened:
			newstate(ppp, p, Sclosing);
			break;
		}
		break;
	case Ltermack:
		if(p->id != m->id)	/* ignore if it isn't the message we're sending */
			break;

		switch(p->state){
		case Sclosing:
			if(p->proto == Plcp)
				ppp->ipcp->state = Sidle;
			newstate(ppp, p, Sidle);
			break;
		case Sackrcvd:
			newstate(ppp, p, Sreqsent);
			break;
		case Sopened:
			pinit(ppp, p, 0);
			newstate(ppp, p, Sreqsent);
			break;
		}
		break;
	case Lcoderej:
		netlog(ppp->f, Logppp, "ppp %s: code reject %d\n", ppp->ifc->dev, m->data[0]);
		break;
	case Lprotorej:
		netlog(ppp->f, Logppp, "ppp %s: proto reject %lux\n", ppp->ifc->dev, nhgets(m->data));
		break;
	case Lechoreq:
		m->code = Lechoack;
		b = putframe(ppp, p->proto, b);
		break;
	case Lechoack:
	case Ldiscard:
		/* nothing to do */
		break;
	}

	qunlock(ppp);
	freeblist(b);
}

/*
 *  timer for protocol state machine
 */
static void
ptimer(PPP *ppp, Pstate *p)
{
	p->timeout--;
	switch(p->state){
	case Sreqsent:
	case Sacksent:
	case Sclosing:
		if(p->timeout <= 0){
			if(p->proto && ppp->cchan != nil)
				kchanio(ppp->cchan, "f", 1, OWRITE); /* flush output queue */
			pinit(ppp, p, 0);
			newstate(ppp, p, Sreqsent);
		} else {
			config(ppp, p, 0);
		}
		break;
	case Sackrcvd:
		if(p->timeout <= 0){
			if(p->proto && ppp->cchan != nil)
				kchanio(ppp->cchan, "f", 1, OWRITE); /* flush output queue */
			pinit(ppp, p, 0);
			newstate(ppp, p, Sreqsent);
		}
		break;
	}
}

/*
 *  timer for ppp
 */
static void
ppptimer(PPP *ppp)
{
	ppp->timep = up;
	if(waserror()){
		netlog(ppp->f, Logppp, "ppptimer: %I: %s\n", ppp->local, up->env->error);
		ppp->timep = 0;
		pexit("hangup", 1);
	}
	for(;;){
		tsleep(&up->sleep, return0, nil, Period);
		if (ppp->pppup)
		{
			qlock(ppp);

			ptimer(ppp, ppp->lcp);
			if(ppp->lcp->state == Sopened)
				ptimer(ppp, ppp->ipcp);

			if(ppp->period && --(ppp->timeout) <= 0){
				ppp->timeout = ppp->period;
				putlqm(ppp);
			}

			qunlock(ppp);
		}
	}
}

static void
setdefroute(PPP *ppp, Ipaddr gate)
{
	int fd, n;
	char path[128], msg[128];

	snprint(path, sizeof path, "#I%d/iproute", ppp->f->dev);
	fd = kopen(path, ORDWR);
	if(fd < 0)
		return;
	n = snprint(msg, sizeof(msg), "add 0 0 %I", gate);
	kwrite(fd, msg, n);
	kclose(fd);
}

static void
ipconnect(PPP *ppp)
{
	int fd, n;
	char path[128], msg[128];

	snprint(path, sizeof path, "#I%d/ipifc/%d/ctl", ppp->f->dev, ppp->ifc->conv->x);
	fd = kopen(path, ORDWR);
	if(fd < 0)
		return;
	n = snprint(msg, sizeof(msg), "connect %I 255.255.255.255 %I", ppp->local, ppp->remote);
	if (kwrite(fd, msg, n) != n)
		print("ppp ipconnect: %s: %r\n", msg);
	kclose(fd);
}

PPP*
pppopen(PPP *ppp, char *dev,
	Ipaddr ipaddr, Ipaddr remip,
	int mtu, int framing,
	char *chapname, char *secret)
{
	int fd, cfd;
	char ctl[2*NAMELEN];

	invalidate(ppp->remote);
	invalidate(ppp->local);
	ppp->mtu = Defmtu;
	ppp->mru = mtu;
	ppp->framing = framing;

	if(remip != nil && validv4(remip)){
		ipmove(ppp->remote, remip);
		ppp->remotefrozen = 1;
	}
	if(ipaddr != nil && validv4(ipaddr)){
		ipmove(ppp->local, ipaddr);
		ppp->localfrozen = 1;
	}

	/* authentication goo */
	ppp->secret[0] = 0;
	if(secret != nil)
		strncpy(ppp->secret, secret, sizeof(ppp->secret));
	ppp->chapname[0] = 0;
	if(chapname != nil)
		strncpy(ppp->chapname, chapname, sizeof(ppp->chapname));

	if(strchr(dev, '!'))
		fd = kdial(dev, nil, nil, nil);
	else
		fd = kopen(dev, ORDWR);
	if(fd < 0){
		netlog(ppp->f, Logppp, "ppp: can't open %s\n", dev);
		return nil;
	}
	ppp->dchan = fdtochan(up->env->fgrp, fd, ORDWR, 0, 1);
	kclose(fd);

	/* set up serial line */
/* XXX this stuff belongs in application, not driver */
	sprint(ctl, "%sctl", dev);
	cfd = kopen(ctl, ORDWR);
	if(cfd >= 0){
		ppp->cchan = fdtochan(up->env->fgrp, cfd, ORDWR, 0, 1);
		kclose(cfd);
		kchanio(ppp->cchan, "m1", 2, OWRITE);	/* cts/rts flow control/fifo's) on */
		kchanio(ppp->cchan, "q64000", 6, OWRITE);/* increas q size to 64k */
		kchanio(ppp->cchan, "n1", 2, OWRITE);	/* nonblocking writes on */
		kchanio(ppp->cchan, "r1", 2, OWRITE);	/* rts on */
		kchanio(ppp->cchan, "d1", 2, OWRITE);	/* dtr on */
	}

	ppp->pppup = 1;
	init(ppp);
	return ppp;
}

static void
hangup(PPP *ppp)
{
	qlock(ppp);
	if(waserror()){
		qunlock(ppp);
		nexterror();
	}
	netlog(ppp->f, Logppp, "PPP Hangup\n");
	errlog(ppp, Ehungup);
	if(ppp->pppup && ppp->cchan != nil){
		kchanio(ppp->cchan, "f", 1, OWRITE);	/* flush */
		kchanio(ppp->cchan, "h", 1, OWRITE);	/* hangup */
	}
	cclose(ppp->dchan);
	cclose(ppp->cchan);
	ppp->dchan = nil;
	ppp->cchan = nil;
	ppp->pppup = 0;
	qunlock(ppp);
	poperror();
}

/* return next input IP packet */
Block*
pppread(PPP *ppp)
{
	Block *b;
	int proto;
	Lcpmsg *m;

	for(;;){
		proto = getframe(ppp, &b);
		if(b == nil)
			return nil;
		switch(proto){
		case Plcp:
			rcv(ppp, ppp->lcp, b);
			break;
		case Pipcp:
			rcv(ppp, ppp->ipcp, b);
			break;
		case Pip:
			if(ppp->ipcp->state == Sopened)
				return b;
			freeblist(b);
			break;
		case Plqm:
			getlqm(ppp, b);
			break;
		case Pchap:
			getchap(ppp, b);
			break;
		case Ppap:
			getpap(ppp, b);
			break;
		case Pvjctcp:
		case Pvjutcp:
			if(ppp->ipcp->state == Sopened){
				b = tcpuncompress(ppp->ctcp, b, proto, ppp->f);
				if(b != nil)
					return b;
			}
			freeblist(b);
			break;
		default:
			netlog(ppp->f, Logppp, "unknown proto %ux\n", proto);
			if(ppp->lcp->state == Sopened){
				/* reject the protocol */
				b->rp -= 6;
				m = (Lcpmsg*)b->rp;
				m->code = Lprotorej;
				m->id = ppp->lcp->id++;
				hnputs(m->data, proto);
				hnputs(m->len, BLEN(b));
				b = putframe(ppp, Plcp, b);
			}
			freeblist(b);
			break;
		}
	}
	return nil;		/* compiler confused */
}

/* transmit an IP packet */
int
pppwrite(PPP *ppp, Block *b)
{
	ushort proto;
	int r;

	/* can't send ip packets till we're established */
	if(ppp->ipcp->state != Sopened)
		goto ret;

	/* link hung up */
	if(ppp->dchan == nil)
		goto ret;

	b = concatblock(b);		/* or else compression will barf */

	proto = Pip;
	if(ppp->ipcp->flags & Fipcompress)
		proto = compress(ppp->ctcp, b, ppp->f);
	b = putframe(ppp, proto, b);

ret:
	r = blocklen(b);
	freeblist(b);
	return r;
}

/*
 *  link quality management
 */
static void
getlqm(PPP *ppp, Block *b)
{
	Qualpkt *p;

	p = (Qualpkt*)b->rp;
	if(BLEN(b) == sizeof(Qualpkt)){
		ppp->in.reports++;
		ppp->pout.reports = nhgetl(p->peeroutreports);
		ppp->pout.packets = nhgetl(p->peeroutpackets);
		ppp->pout.bytes = nhgetl(p->peeroutbytes);
		ppp->pin.reports = nhgetl(p->peerinreports);
		ppp->pin.packets = nhgetl(p->peerinpackets);
		ppp->pin.discards = nhgetl(p->peerindiscards);
		ppp->pin.errors = nhgetl(p->peerinerrors);
		ppp->pin.bytes = nhgetl(p->peerinbytes);

		/* save our numbers at time of reception */
		memmove(&ppp->sin, &ppp->in, sizeof(Qualstats));

	}
	freeblist(b);
	if(ppp->period == 0)
		putlqm(ppp);

}
static void
putlqm(PPP *ppp)
{
	Qualpkt *p;
	Block *b;

	b = allocb(sizeof(Qualpkt));
	b->wp += sizeof(Qualpkt);
	p = (Qualpkt*)b->rp;
	hnputl(p->magic, 0);

	/* heresay (what he last told us) */
	hnputl(p->lastoutreports, ppp->pout.reports);
	hnputl(p->lastoutpackets, ppp->pout.packets);
	hnputl(p->lastoutbytes, ppp->pout.bytes);

	/* our numbers at time of last reception */
	hnputl(p->peerinreports, ppp->sin.reports);
	hnputl(p->peerinpackets, ppp->sin.packets);
	hnputl(p->peerindiscards, ppp->sin.discards);
	hnputl(p->peerinerrors, ppp->sin.errors);
	hnputl(p->peerinbytes, ppp->sin.bytes);

	/* our numbers now */
	hnputl(p->peeroutreports, ppp->out.reports+1);
	hnputl(p->peeroutpackets, ppp->out.packets+1);
	hnputl(p->peeroutbytes, ppp->out.bytes+53/*hack*/);

	b = putframe(ppp, Plqm, b);
	freeblist(b);
	ppp->out.reports++;
}

/*
 *  challenge response dialog
 */
static void
getchap(PPP *ppp, Block *b)
{
	Lcpmsg *m;
	int len, vlen, n;
	char md5buf[512];

	m = (Lcpmsg*)b->rp;
	len = nhgets(m->len);
	if(BLEN(b) < len){
		netlog(ppp->f, Logppp, "ppp %s: short chap message\n", ppp->ifc->dev);
		freeblist(b);
		return;
	}

	switch(m->code){
	case Cchallenge:
		vlen = m->data[0];
		if(vlen > len - 5)
			netlog(ppp->f, Logppp, "PPP %s: bad challenge len\n", ppp->ifc->dev);

		netlog(ppp->f, Logppp, "PPP %s: CHAP Challenge\n", ppp->ifc->dev);
		/* create string to hash */
		md5buf[0] = m->id;
		strcpy(md5buf+1, ppp->secret);
		n = strlen(ppp->secret) + 1;
		memmove(md5buf+n, m->data+1, vlen);
		n += vlen;
		freeblist(b);

		/* send reply */
		len = 4 + 1 + 16 + strlen(ppp->chapname);
		b = alloclcp(2, md5buf[0], len);
		m = IPB2LCP(b);
		m->data[0] = 16;
		md5((uchar*)md5buf, n, m->data+1, 0);
		strcpy((char*)m->data+17, ppp->chapname);
		hnputs(m->len, len);
		b->wp += len-4;
		b = putframe(ppp, Pchap, b);
		break;
	case Cresponse:
		netlog(ppp->f, Logppp, "PPP %s: chap response?\n", ppp->ifc->dev);
		break;
	case Csuccess:
		netlog(ppp->f, Logppp, "PPP %s: chap succeeded\n", ppp->ifc->dev);
		break;
	case Cfailure:
		netlog(ppp->f, Logppp, "PPP %s: chap failed: %.*s\n", ppp->ifc->dev, len-4, m->data);
		errlog(ppp, Eperm);
		break;
	default:
		netlog(ppp->f, Logppp, "PPP %s: chap code %d?\n", ppp->ifc->dev, m->code);
		break;
	}
	freeblist(b);
}

/*
 *  password authentication protocol dialog
 *	-- obsolete but all we know how to use with NT just now
 */
static void
sendpap(PPP *ppp)
{
	Lcpmsg *m;
	int clen, slen, len;
	Block *b;
	byte *p;

	clen = strlen(ppp->chapname);
	slen = strlen(ppp->secret);
	len = 4 + 1 + clen + 1 + slen;
	ppp->papid = ++ppp->lcp->id;
	b = alloclcp(Cpapreq, ppp->papid, len);
	m = IPB2LCP(b);
	p = m->data;
	p[0] = clen;
	memmove(p+1, ppp->chapname, clen);
	p += clen + 1;
	p[0] = slen;
	memmove(p+1, ppp->secret, slen);
	hnputs(m->len, len);
	b->wp += len-4;
	b = putframe(ppp, Ppap, b);
	netlog(ppp->f, Logppp, "PPP %s: sent pap auth req (%d)\n", ppp->ifc->dev, len);
	freeblist(b);
}

static void
getpap(PPP *ppp, Block *b)
{
	Lcpmsg *m;
	int len;

	m = (Lcpmsg*)b->rp;
	len = nhgets(m->len);
	if(BLEN(b) < len){
		netlog(ppp->f, Logppp, "ppp %s: short pap message\n", ppp->ifc->dev);
		freeblist(b);
		return;
	}

	switch(m->code){
	case Cpapreq:
		netlog(ppp->f, Logppp, "PPP %s: pap request?\n", ppp->ifc->dev);
		break;
	case Cpapack:
		netlog(ppp->f, Logppp, "PPP %s: PAP succeeded\n", ppp->ifc->dev);
		ppp->authed = 1;
		break;
	case Cpapnak:
		if(m->data[0])
			netlog(ppp->f, Logppp, "PPP %s: PAP failed: %.*s\n", ppp->ifc->dev, len-5, m->data+1);
		else
			netlog(ppp->f, Logppp, "PPP %s: PAP failed\n", ppp->ifc->dev);
		errlog(ppp, Eperm);
		ppp->authed = 0;
		break;
	default:
		netlog(ppp->f, Logppp, "PPP %s: pap code %d?\n", ppp->ifc->dev, m->code);
		break;
	}
	freeblist(b);
}

static void
printopts(PPP *ppp, Pstate *p, Block *b, int send)
{
	Lcpmsg *m;	
	Lcpopt *o;
	int proto, x, period;
	uchar *cp;
	char *code, *dir;

	m = (Lcpmsg*)b->rp;
	switch(m->code) {
	default: code = "<unknown>"; break;
	case Lconfreq: code = "confrequest"; break;
	case Lconfack: code = "confack"; break;
	case Lconfnak: code = "confnak"; break;
	case Lconfrej: code = "confreject"; break;
	}

	if(send)
		dir = "send";
	else
		dir = "recv";

	netlog(ppp->f, Logppp, "ppp: %s %s: id=%d\n", dir, code, m->id);

	for(cp = m->data; cp < b->wp; cp += o->len){
		o = (Lcpopt*)cp;
		if(cp + o->len > b->wp){
			netlog(ppp->f, Logppp, "\tbad option length %ux\n", o->type);
			return;
		}

		switch(p->proto){
		case Plcp:
			switch(o->type){
			default:
				netlog(ppp->f, Logppp, "\tunknown %d len=%d\n", o->type, o->len);
				break;
			case Omtu:
				netlog(ppp->f, Logppp, "\tmtu = %d\n", nhgets(o->data));
				break;
			case Octlmap:
				netlog(ppp->f, Logppp, "\tctlmap = %ux\n", nhgetl(o->data));
				break;
			case Oauth:
				netlog(ppp->f, Logppp, "\tauth = ", nhgetl(o->data));
				proto = nhgets(o->data);
				switch(proto) {
				default:
					netlog(ppp->f, Logppp, "unknown auth proto %d\n", proto);
					break;
				case Ppap:
					netlog(ppp->f, Logppp, "password\n");
					break;
				case Pchap:
					netlog(ppp->f, Logppp, "chap %ux\n", o->data[2]);
					break;
				}
				break;
			case Oquality:
				proto = nhgets(o->data);
				switch(proto) {
				default:
					netlog(ppp->f, Logppp, "\tunknown quality proto %d\n", proto);
					break;
				case Plqm:
					x = nhgetl(o->data+2)*10;
					period = (x+Period-1)/Period;
					netlog(ppp->f, Logppp, "\tlqm period = %d\n", period);
					break;
				}
			case Omagic:
				netlog(ppp->f, Logppp, "\tmagic = %ux\n", nhgetl(o->data));
				break;
			case Opc:
				netlog(ppp->f, Logppp, "\tprotocol compress\n");
				break;
			case Oac:
				netlog(ppp->f, Logppp, "\taddr compress\n");
				break;
			}
			break;
		case Pccp:
			switch(o->type){
			default:
				netlog(ppp->f, Logppp, "\tunknown %d len=%d\n", o->type, o->len);
				break;
			case Ocoui:	
				netlog(ppp->f, Logppp, "\tOUI\n");
				break;
			case Ocstac:
				netlog(ppp->f, Logppp, "\tstac LZS\n");
				break;
			case Ocmppc:	
				netlog(ppp->f, Logppp, "\tMicrosoft PPC len=%d %ux\n", o->len, nhgetl(o->data));
				break;
			}
			break;
		case Pecp:
			switch(o->type){
			default:
				netlog(ppp->f, Logppp, "\tunknown %d len=%d\n", o->type, o->len);
				break;
			case Oeoui:	
				netlog(ppp->f, Logppp, "\tOUI\n");
				break;
			case Oedese:
				netlog(ppp->f, Logppp, "\tDES\n");
				break;
			}
			break;
		case Pipcp:
			switch(o->type){
			default:
				netlog(ppp->f, Logppp, "\tunknown %d len=%d\n", o->type, o->len);
				break;
			case Oipaddrs:	
				netlog(ppp->f, Logppp, "\tip addrs - deprecated\n");
				break;
			case Oipcompress:
				netlog(ppp->f, Logppp, "\tip compress\n");
				break;
			case Oipaddr:	
				netlog(ppp->f, Logppp, "\tip addr %V\n", o->data);
				break;
			case Oipdns:	
				netlog(ppp->f, Logppp, "\tdns addr %V\n", o->data);
				break;
			case Oipwins:	
				netlog(ppp->f, Logppp, "\twins addr %V\n", o->data);
				break;
			case Oipdns2:	
				netlog(ppp->f, Logppp, "\tdns2 addr %V\n", o->data);
				break;
			case Oipwins2:	
				netlog(ppp->f, Logppp, "\twins2 addr %V\n", o->data);
				break;
			}
			break;
		}
	}
}

static void
sendtermreq(PPP *ppp, Pstate *p)
{
	Block *b;
	Lcpmsg *m;

	p->termid = ++(p->id);
	b = alloclcp(Ltermreq, p->termid, 4);
	m = IPB2LCP(b);
	hnputs(m->len, 4);
	putframe(ppp, p->proto, b);
	freeb(b);
	newstate(ppp, p, Sclosing);
}

static void
sendechoreq(PPP *ppp, Pstate *p)
{
	Block *b;
	Lcpmsg *m;

	p->termid = ++(p->id);
	b = alloclcp(Lechoreq, p->id, 4);
	m = IPB2LCP(b);
	hnputs(m->len, 4);
	putframe(ppp, p->proto, b);
	freeb(b);
}

/*
 *  return non-zero if this is a valid v4 address
 */
static int
validv4(Ipaddr addr)
{
	return memcmp(addr, v4prefix, IPv4off) == 0;
}

static void
invalidate(Ipaddr addr)
{
	ipmove(addr, IPnoaddr);
}