Import the FreeBSD specific kernel parts of the ppp-2.2 package..

This is the unmodified files vendor branch import, the working stuff
will follow shortly..

2 files changed, 885 insertions, 1106 deletions

diff --git a/sys/net/if_ppp.c b/sys/net/if_ppp.c
index e484e228e0a3..d62251aa5dba 100644
--- a/sys/net/if_ppp.c
+++ b/sys/net/if_ppp.c
@@ -69,26 +69,22 @@
  * Paul Mackerras (paulus@cs.anu.edu.au).
  */
 
-/* $Id: if_ppp.c,v 1.7 1994/01/25 05:56:06 deraadt Exp paulus $ */
+/* $Id: if_ppp.c,v 1.5 1995/08/16 01:36:38 paulus Exp $ */
 /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
 
 #include "ppp.h"
 #if NPPP > 0
 
 #define VJC
+#define PPP_COMPRESS
 
 #include <sys/param.h>
+#include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/mbuf.h>
-#include <sys/buf.h>
-#include <sys/dkstat.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
-#include <sys/file.h>
-#include <sys/tty.h>
 #include <sys/kernel.h>
-#include <sys/conf.h>
-#include <sys/vnode.h>
 
 #include <net/if.h>
 #include <net/if_types.h>
@@ -109,73 +105,77 @@
 #endif
 
 #ifdef VJC
-#include <net/slcompress.h>
-#define HDROFF	MAX_HDR
-/* HDROFF should really be 128, but other parts of the system will
-   panic on TCP+IP headers bigger than MAX_HDR = MHLEN (100). */
-
-#else
-#define	HDROFF	(0)
+#include <net/pppcompress.h>
 #endif
 
+#include <net/ppp_defs.h>
 #include <net/if_ppp.h>
+#include <net/if_pppvar.h>
 #include <machine/cpu.h>
 
-/* This is a NetBSD-current kernel. */
-#define CCOUNT(q)	((q)->c_cc)
-
-#define	PPP_HIWAT	400	/* Don't start a new packet if HIWAT on que */
+#ifndef NETISR_PPP
+/* This definition should be moved to net/netisr.h */
+#define NETISR_PPP	26	/* PPP software interrupt */
+#endif
 
-struct ppp_softc ppp_softc[NPPP];
+#ifdef PPP_COMPRESS
+#define PACKETPTR	struct mbuf *
+#include <net/ppp-comp.h>
+#endif
 
 void	pppattach __P((void));
-int	pppopen __P((dev_t dev, struct tty *tp));
-void	pppclose __P((struct tty *tp, int flag));
-int	pppread __P((struct tty *tp, struct uio *uio, int flag));
-int	pppwrite __P((struct tty *tp, struct uio *uio, int flag));
-int	ppptioctl __P((struct tty *tp, int cmd, caddr_t data, int flag,
-		       struct proc *));
+int	pppioctl __P((struct ppp_softc *sc, int cmd, caddr_t data, int flag,
+		      struct proc *));
 int	pppoutput __P((struct ifnet *ifp, struct mbuf *m0,
-		       struct sockaddr *dst));
-void	pppinput __P((int c, struct tty *tp));
-int	pppioctl __P((struct ifnet *ifp, int cmd, caddr_t data));
-void	pppstart __P((struct tty *tp));
-
-static int	pppasyncstart __P((struct ppp_softc *));
-static u_short	pppfcs __P((u_short fcs, u_char *cp, int len));
-static int	pppgetm __P((struct ppp_softc *sc));
-static struct	mbuf *ppp_btom __P((struct ppp_softc *sc));
-static void	pppdumpm __P((struct mbuf *m0, int pktlen));
-static void	pppdumpb __P((u_char *b, int l));
-static void	ppplogchar __P((struct ppp_softc *, int));
+		       struct sockaddr *dst, struct rtentry *rtp));
+int	pppsioctl __P((struct ifnet *ifp, int cmd, caddr_t data));
+void	pppintr __P((void));
+
+static void	ppp_requeue __P((struct ppp_softc *));
+static void	ppp_outpkt __P((struct ppp_softc *));
+static int	ppp_ccp __P((struct ppp_softc *, struct mbuf *m, int rcvd));
+static void	ppp_ccp_closed __P((struct ppp_softc *));
+static void	ppp_inproc __P((struct ppp_softc *, struct mbuf *));
+static void	pppdumpm __P((struct mbuf *m0));
 
 /*
  * Some useful mbuf macros not in mbuf.h.
  */
+#define M_IS_CLUSTER(m)	((m)->m_flags & M_EXT)
+
 #define M_DATASTART(m)	\
-	((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf : \
+	(M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
 	    (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
 
 #define M_DATASIZE(m)	\
-	((m)->m_flags & M_EXT ? (m)->m_ext.ext_size : \
+	(M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
 	    (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
 
 /*
- * The following disgusting hack gets around the problem that IP TOS
- * can't be set yet.  We want to put "interactive" traffic on a high
- * priority queue.  To decide if traffic is interactive, we check that
- * a) it is TCP and b) one of its ports is telnet, rlogin or ftp control.
+ * We steal two bits in the mbuf m_flags, to mark high-priority packets
+ * for output, and received packets following lost/corrupted packets.
  */
-static u_short interactive_ports[8] = {
-	0,	513,	0,	0,
-	0,	21,	0,	23,
-};
-#define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p))
+#define M_HIGHPRI	0x2000	/* output packet for sc_fastq */
+#define M_ERRMARK	0x4000	/* steal a bit in mbuf m_flags */
+
 
+#ifdef PPP_COMPRESS
 /*
- * Does c need to be escaped?
+ * List of compressors we know about.
+ * We leave some space so maybe we can modload compressors.
  */
-#define ESCAPE_P(c)	(sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
+
+extern struct compressor ppp_bsd_compress;
+
+struct compressor *ppp_compressors[8] = {
+#if DO_BSD_COMPRESS
+    &ppp_bsd_compress,
+#endif
+    NULL
+};
+#endif /* PPP_COMPRESS */
+
+TEXT_SET(pseudo_set, pppattach);
 
 /*
  * Called from boot code to establish ppp interfaces.
@@ -185,24 +185,27 @@ pppattach()
 {
     register struct ppp_softc *sc;
     register int i = 0;
+    extern void (*netisrs[])__P((void));
 
     for (sc = ppp_softc; i < NPPP; sc++) {
 	sc->sc_if.if_name = "ppp";
 	sc->sc_if.if_unit = i++;
 	sc->sc_if.if_mtu = PPP_MTU;
-	sc->sc_if.if_flags = IFF_POINTOPOINT;
+	sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
 	sc->sc_if.if_type = IFT_PPP;
 	sc->sc_if.if_hdrlen = PPP_HDRLEN;
-	sc->sc_if.if_ioctl = pppioctl;
+	sc->sc_if.if_ioctl = pppsioctl;
 	sc->sc_if.if_output = pppoutput;
 	sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
 	sc->sc_inq.ifq_maxlen = IFQ_MAXLEN;
 	sc->sc_fastq.ifq_maxlen = IFQ_MAXLEN;
+	sc->sc_rawq.ifq_maxlen = IFQ_MAXLEN;
 	if_attach(&sc->sc_if);
 #if NBPFILTER > 0
 	bpfattach(&sc->sc_bpf, &sc->sc_if, DLT_PPP, PPP_HDRLEN);
 #endif
     }
+    netisrs[NETISR_PPP] = ppp_intr;
 }
 
 /*
@@ -212,43 +215,59 @@ struct ppp_softc *
 pppalloc(pid)
     pid_t pid;
 {
-    int nppp;
+    int nppp, i;
     struct ppp_softc *sc;
 
     for (nppp = 0, sc = ppp_softc; nppp < NPPP; nppp++, sc++)
 	if (sc->sc_xfer == pid) {
 	    sc->sc_xfer = 0;
-	    break;
+	    return sc;
 	}
-    if (nppp >= NPPP)
-	for (nppp = 0, sc = ppp_softc; nppp < NPPP; nppp++, sc++)
-	    if (sc->sc_devp == NULL)
-		break;
+    for (nppp = 0, sc = ppp_softc; nppp < NPPP; nppp++, sc++)
+	if (sc->sc_devp == NULL)
+	    break;
     if (nppp >= NPPP)
 	return NULL;
 
     sc->sc_flags = 0;
     sc->sc_mru = PPP_MRU;
+    sc->sc_relinq = NULL;
 #ifdef VJC
-    sl_compress_init(&sc->sc_comp);
+    vj_compress_init(&sc->sc_comp, -1);
 #endif
-    sc->sc_if.if_flags |= IFF_RUNNING;
+#ifdef PPP_COMPRESS
+    sc->sc_xc_state = NULL;
+    sc->sc_rc_state = NULL;
+#endif /* PPP_COMPRESS */
+    for (i = 0; i < NUM_NP; ++i)
+	sc->sc_npmode[i] = NPMODE_ERROR;
+    sc->sc_npqueue = NULL;
+    sc->sc_npqtail = &sc->sc_npqueue;
+    sc->sc_last_sent = sc->sc_last_recv = time.tv_sec;
 
     return sc;
 }
 
 /*
- * Deallocate a ppp unit.
+ * Deallocate a ppp unit.  Must be called at splnet or higher.
  */
+void
 pppdealloc(sc)
     struct ppp_softc *sc;
 {
     struct mbuf *m;
 
     if_down(&sc->sc_if);
+    sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
     sc->sc_devp = NULL;
     sc->sc_xfer = 0;
     for (;;) {
+	IF_DEQUEUE(&sc->sc_rawq, m);
+	if (m == NULL)
+	    break;
+	m_freem(m);
+    }
+    for (;;) {
 	IF_DEQUEUE(&sc->sc_inq, m);
 	if (m == NULL)
 	    break;
@@ -260,206 +279,39 @@ pppdealloc(sc)
 	    break;
 	m_freem(m);
     }
-    sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
-}
-    
-/*
- * Line specific open routine for async tty devices.
- * Attach the given tty to the first available ppp unit.
- */
-/* ARGSUSED */
-int
-pppopen(dev, tp)
-    dev_t dev;
-    register struct tty *tp;
-{
-    struct proc *p = curproc;		/* XXX */
-    register struct ppp_softc *sc;
-    int error, s, i;
-
-    if (error = suser(p->p_ucred, &p->p_acflag))
-	return (error);
-
-    if (tp->t_line == PPPDISC) {
-	sc = (struct ppp_softc *) tp->t_sc;
-	if (sc != NULL && sc->sc_devp == (void *) tp)
-	    return (0);
-    }
-
-    if ((sc = pppalloc(p->p_pid)) == NULL)
-	return ENXIO;
-
-    if (sc->sc_outm != NULL) {
-	m_freem(sc->sc_outm);
-	sc->sc_outm = NULL;
-    }
-	
-    if (pppgetm(sc) == 0) {
-	sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
-	return (ENOBUFS);
-    }
-
-    sc->sc_ilen = 0;
-    bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
-    sc->sc_asyncmap[0] = 0xffffffff;
-    sc->sc_asyncmap[3] = 0x60000000;
-    sc->sc_rasyncmap = 0;
-    sc->sc_devp = (void *) tp;
-    sc->sc_start = pppasyncstart;
-
-    tp->t_sc = (caddr_t) sc;
-    ttyflush(tp, FREAD | FWRITE);
-
-    return (0);
-}
-
-/*
- * Line specific close routine.
- * Detach the tty from the ppp unit.
- * Mimics part of ttyclose().
- */
-void
-pppclose(tp, flag)
-    struct tty *tp;
-    int flag;
-{
-    register struct ppp_softc *sc;
-    struct mbuf *m;
-    int s;
-
-    ttywflush(tp);
-    s = splimp();		/* paranoid; splnet probably ok */
-    tp->t_line = 0;
-    sc = (struct ppp_softc *)tp->t_sc;
-    if (sc != NULL) {
-	tp->t_sc = NULL;
-	if (tp == (struct tty *) sc->sc_devp) {
-	    m_freem(sc->sc_outm);
-	    sc->sc_outm = NULL;
-	    m_freem(sc->sc_m);
-	    sc->sc_m = NULL;
-	    pppdealloc(sc);
-	}
-    }
-    splx(s);
-}
-
-/*
- * Line specific (tty) read routine.
- */
-int
-pppread(tp, uio, flag)
-    register struct tty *tp;
-    struct uio *uio;
-    int flag;
-{
-    register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
-    struct mbuf *m, *m0;
-    register int s;
-    int error = 0;
-
-    if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
-	return 0;		/* end of file */
-    if (sc == NULL || tp != (struct tty *) sc->sc_devp)
-	return 0;
-    s = splimp();
-    while (sc->sc_inq.ifq_head == NULL && tp->t_line == PPPDISC) {
-	if (tp->t_state & TS_ASYNC || flag & IO_NDELAY) {
-	    splx(s);
-	    return (EWOULDBLOCK);
-	}
-	error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI|PCATCH, ttyin, 0);
-	if (error)
-	    return error;
-    }
-    if (tp->t_line != PPPDISC) {
-	splx(s);
-	return (-1);
+    while ((m = sc->sc_npqueue) != NULL) {
+	sc->sc_npqueue = m->m_nextpkt;
+	m_freem(m);
     }
-
-    /* Pull place-holder byte out of canonical queue */
-    getc(&tp->t_canq);
-
-    /* Get the packet from the input queue */
-    IF_DEQUEUE(&sc->sc_inq, m0);
-    splx(s);
-
-    for (m = m0; m && uio->uio_resid; m = m->m_next)
-	if (error = uiomove(mtod(m, u_char *), m->m_len, uio))
-	    break;
-    m_freem(m0);
-    return (error);
-}
-
-/*
- * Line specific (tty) write routine.
- */
-int
-pppwrite(tp, uio, flag)
-    register struct tty *tp;
-    struct uio *uio;
-    int flag;
-{
-    register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
-    struct mbuf *m, *m0, **mp;
-    struct sockaddr dst;
-    struct ppp_header *ph1, *ph2;
-    int len, error;
-
-    if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
-	return 0;		/* wrote 0 bytes */
-    if (tp->t_line != PPPDISC)
-	return (EINVAL);
-    if (sc == NULL || tp != (struct tty *) sc->sc_devp)
-	return EIO;
-    if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN ||
-	uio->uio_resid < PPP_HDRLEN)
-	return (EMSGSIZE);
-    for (mp = &m0; uio->uio_resid; mp = &m->m_next) {
-	MGET(m, M_WAIT, MT_DATA);
-	if ((*mp = m) == NULL) {
-	    m_freem(m0);
-	    return (ENOBUFS);
-	}
-	if (uio->uio_resid >= MCLBYTES / 2)
-	    MCLGET(m, M_DONTWAIT);
-	len = M_TRAILINGSPACE(m);
-	if (len > uio->uio_resid)
-	    len = uio->uio_resid;
-	if (error = uiomove(mtod(m, u_char *), len, uio)) {
-	    m_freem(m0);
-	    return (error);
-	}
-	m->m_len = len;
+    if (sc->sc_togo != NULL) {
+	m_freem(sc->sc_togo);
+	sc->sc_togo = NULL;
     }
-    dst.sa_family = AF_UNSPEC;
-    ph1 = (struct ppp_header *) &dst.sa_data;
-    ph2 = mtod(m0, struct ppp_header *);
-    *ph1 = *ph2;
-    m0->m_data += PPP_HDRLEN;
-    m0->m_len -= PPP_HDRLEN;
-    return (pppoutput(&sc->sc_if, m0, &dst));
+#ifdef PPP_COMPRESS
+    ppp_ccp_closed(sc);
+    sc->sc_xc_state = NULL;
+    sc->sc_rc_state = NULL;
+#endif /* PPP_COMPRESS */
 }
 
 /*
- * Line specific (tty) ioctl routine.
- * Provide a way to get the ppp unit number.
- * This discipline requires that tty device drivers call
- * the line specific l_ioctl routine from their ioctl routines.
+ * Ioctl routine for generic ppp devices.
  */
-/* ARGSUSED */
 int
-ppptioctl(tp, cmd, data, flag, p)
-    struct tty *tp;
+pppioctl(sc, cmd, data, flag, p)
+    struct ppp_softc *sc;
     caddr_t data;
     int cmd, flag;
     struct proc *p;
 {
-    register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
-    int s, error, flags, mru;
-
-    if (sc == NULL || tp != (struct tty *) sc->sc_devp)
-	return -1;
+    int s, error, flags, mru, nb, npx;
+    struct ppp_option_data *odp;
+    struct compressor **cp;
+    struct npioctl *npi;
+    time_t t;
+#ifdef	PPP_COMPRESS
+    u_char ccp_option[CCP_MAX_OPTION_LENGTH];
+#endif
 
     switch (cmd) {
     case FIONREAD:
@@ -478,57 +330,22 @@ ppptioctl(tp, cmd, data, flag, p)
 	if (error = suser(p->p_ucred, &p->p_acflag))
 	    return (error);
 	flags = *(int *)data & SC_MASK;
-	s = splimp();
+	s = splnet();
+#ifdef PPP_COMPRESS
+	if (sc->sc_flags & SC_CCP_OPEN && !(flags & SC_CCP_OPEN))
+	    ppp_ccp_closed(sc);
+#endif
+	splimp();
 	sc->sc_flags = (sc->sc_flags & ~SC_MASK) | flags;
 	splx(s);
 	break;
 
-    case PPPIOCSASYNCMAP:
-	if (error = suser(p->p_ucred, &p->p_acflag))
-	    return (error);
-	sc->sc_asyncmap[0] = *(u_int *)data;
-	break;
-
-    case PPPIOCGASYNCMAP:
-	*(u_int *)data = sc->sc_asyncmap[0];
-	break;
-
-    case PPPIOCSRASYNCMAP:
-	if (error = suser(p->p_ucred, &p->p_acflag))
-	    return (error);
-	sc->sc_rasyncmap = *(u_int *)data;
-	break;
-
-    case PPPIOCGRASYNCMAP:
-	*(u_int *)data = sc->sc_rasyncmap;
-	break;
-
-    case PPPIOCSXASYNCMAP:
-	if (error = suser(p->p_ucred, &p->p_acflag))
-	    return (error);
-	bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
-	sc->sc_asyncmap[1] = 0;		    /* mustn't escape 0x20 - 0x3f */
-	sc->sc_asyncmap[2] &= ~0x40000000;  /* mustn't escape 0x5e */
-	sc->sc_asyncmap[3] |= 0x60000000;   /* must escape 0x7d, 0x7e */
-	break;
-
-    case PPPIOCGXASYNCMAP:
-	bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
-	break;
-
     case PPPIOCSMRU:
 	if (error = suser(p->p_ucred, &p->p_acflag))
 	    return (error);
 	mru = *(int *)data;
-	if (mru >= PPP_MRU && mru <= PPP_MAXMRU) {
+	if (mru >= PPP_MRU && mru <= PPP_MAXMRU)
 	    sc->sc_mru = mru;
-	    if (pppgetm(sc) == 0) {
-		error = ENOBUFS;
-		sc->sc_mru = PPP_MRU;
-		if (pppgetm(sc) == 0)
-		    sc->sc_if.if_flags &= ~IFF_UP;
-	    }
-	}
 	break;
 
     case PPPIOCGMRU:
@@ -539,7 +356,9 @@ ppptioctl(tp, cmd, data, flag, p)
     case PPPIOCSMAXCID:
 	if (error = suser(p->p_ucred, &p->p_acflag))
 	    return (error);
-	sl_compress_setup(&sc->sc_comp, *(int *)data);
+	s = splnet();
+	vj_compress_init(&sc->sc_comp, *(int *)data);
+	splx(s);
 	break;
 #endif
 
@@ -549,6 +368,98 @@ ppptioctl(tp, cmd, data, flag, p)
 	sc->sc_xfer = p->p_pid;
 	break;
 
+#ifdef PPP_COMPRESS
+    case PPPIOCSCOMPRESS:
+	if (error = suser(p->p_ucred, &p->p_acflag))
+	    return (error);
+	odp = (struct ppp_option_data *) data;
+	nb = odp->length;
+	if (nb > sizeof(ccp_option))
+	    nb = sizeof(ccp_option);
+	if (error = copyin(odp->ptr, ccp_option, nb))
+	    return (error);
+	if (ccp_option[1] < 2)	/* preliminary check on the length byte */
+	    return (EINVAL);
+	for (cp = ppp_compressors; *cp != NULL; ++cp)
+	    if ((*cp)->compress_proto == ccp_option[0]) {
+		/*
+		 * Found a handler for the protocol - try to allocate
+		 * a compressor or decompressor.
+		 */
+		error = 0;
+		s = splnet();
+		if (odp->transmit) {
+		    if (sc->sc_xc_state != NULL)
+			(*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
+		    sc->sc_xcomp = *cp;
+		    sc->sc_xc_state = (*cp)->comp_alloc(ccp_option, nb);
+		    if (sc->sc_xc_state == NULL) {
+			if (sc->sc_flags & SC_DEBUG)
+			    printf("ppp%d: comp_alloc failed\n",
+			       sc->sc_if.if_unit);
+			error = ENOBUFS;
+		    }
+		    splimp();
+		    sc->sc_flags &= ~SC_COMP_RUN;
+		} else {
+		    if (sc->sc_rc_state != NULL)
+			(*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
+		    sc->sc_rcomp = *cp;
+		    sc->sc_rc_state = (*cp)->decomp_alloc(ccp_option, nb);
+		    if (sc->sc_rc_state == NULL) {
+			if (sc->sc_flags & SC_DEBUG)
+			    printf("ppp%d: decomp_alloc failed\n",
+			       sc->sc_if.if_unit);
+			error = ENOBUFS;
+		    }
+		    splimp();
+		    sc->sc_flags &= ~SC_DECOMP_RUN;
+		}
+		splx(s);
+		return (error);
+	    }
+	if (sc->sc_flags & SC_DEBUG)
+	    printf("ppp%d: no compressor for [%x %x %x], %x\n",
+		   sc->sc_if.if_unit, ccp_option[0], ccp_option[1],
+		   ccp_option[2], nb);
+	return (EINVAL);	/* no handler found */
+#endif /* PPP_COMPRESS */
+
+    case PPPIOCGNPMODE:
+    case PPPIOCSNPMODE:
+	npi = (struct npioctl *) data;
+	switch (npi->protocol) {
+	case PPP_IP:
+	    npx = NP_IP;
+	    break;
+	default:
+	    return EINVAL;
+	}
+	if (cmd == PPPIOCGNPMODE) {
+	    npi->mode = sc->sc_npmode[npx];
+	} else {
+	    if (error = suser(p->p_ucred, &p->p_acflag))
+		return (error);
+	    if (npi->mode != sc->sc_npmode[npx]) {
+		s = splimp();
+		sc->sc_npmode[npx] = npi->mode;
+		if (npi->mode != NPMODE_QUEUE) {
+		    ppp_requeue(sc);
+		    (*sc->sc_start)(sc);
+		}
+		splx(s);
+	    }
+	}
+	break;
+
+    case PPPIOCGIDLE:
+	s = splimp();
+	t = time.tv_sec;
+	((struct ppp_idle *)data)->xmit_idle = t - sc->sc_last_sent;
+	((struct ppp_idle *)data)->recv_idle = t - sc->sc_last_recv;
+	splx(s);
+	break;
+
     default:
 	return (-1);
     }
@@ -556,55 +467,100 @@ ppptioctl(tp, cmd, data, flag, p)
 }
 
 /*
- * FCS lookup table as calculated by genfcstab.
+ * Process an ioctl request to the ppp network interface.
  */
-static u_short 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
-};
-
-/*
- * Calculate a new FCS given the current FCS and the new data.
- */
-static u_short
-pppfcs(fcs, cp, len)
-    register u_short fcs;
-    register u_char *cp;
-    register int len;
+int
+pppsioctl(ifp, cmd, data)
+    register struct ifnet *ifp;
+    int cmd;
+    caddr_t data;
 {
-    while (len--)
-	fcs = PPP_FCS(fcs, *cp++);
-    return (fcs);
+    struct proc *p = curproc;	/* XXX */
+    register struct ppp_softc *sc = &ppp_softc[ifp->if_unit];
+    register struct ifaddr *ifa = (struct ifaddr *)data;
+    register struct ifreq *ifr = (struct ifreq *)data;
+    struct ppp_stats *psp;
+#ifdef	PPP_COMPRESS
+    struct ppp_comp_stats *pcp;
+#endif
+    int s = splimp(), error = 0;
+
+    switch (cmd) {
+    case SIOCSIFFLAGS:
+	if ((ifp->if_flags & IFF_RUNNING) == 0)
+	    ifp->if_flags &= ~IFF_UP;
+	break;
+
+    case SIOCSIFADDR:
+	if (ifa->ifa_addr->sa_family != AF_INET)
+	    error = EAFNOSUPPORT;
+	break;
+
+    case SIOCSIFDSTADDR:
+	if (ifa->ifa_addr->sa_family != AF_INET)
+	    error = EAFNOSUPPORT;
+	break;
+
+    case SIOCSIFMTU:
+	if (error = suser(p->p_ucred, &p->p_acflag))
+	    break;
+	sc->sc_if.if_mtu = ifr->ifr_mtu;
+	break;
+
+    case SIOCGIFMTU:
+	ifr->ifr_mtu = sc->sc_if.if_mtu;
+	break;
+
+    case SIOCADDMULTI:
+    case SIOCDELMULTI:
+	switch(ifr->ifr_addr.sa_family) {
+#ifdef INET
+	case AF_INET:
+	    break;
+#endif
+	default:
+	    error = EAFNOSUPPORT;
+	    break;
+	}
+	break;
+
+    case SIOCGPPPSTATS:
+	psp = &((struct ifpppstatsreq *) data)->stats;
+	bzero(psp, sizeof(*psp));
+	psp->p.ppp_ibytes = sc->sc_bytesrcvd;
+	psp->p.ppp_ipackets = ifp->if_ipackets;
+	psp->p.ppp_ierrors = ifp->if_ierrors;
+	psp->p.ppp_obytes = sc->sc_bytessent;
+	psp->p.ppp_opackets = ifp->if_opackets;
+	psp->p.ppp_oerrors = ifp->if_oerrors;
+#ifdef VJC
+	psp->vj.vjs_packets = sc->sc_comp.sls_packets;
+	psp->vj.vjs_compressed = sc->sc_comp.sls_compressed;
+	psp->vj.vjs_searches = sc->sc_comp.sls_searches;
+	psp->vj.vjs_misses = sc->sc_comp.sls_misses;
+	psp->vj.vjs_uncompressedin = sc->sc_comp.sls_uncompressedin;
+	psp->vj.vjs_compressedin = sc->sc_comp.sls_compressedin;
+	psp->vj.vjs_errorin = sc->sc_comp.sls_errorin;
+	psp->vj.vjs_tossed = sc->sc_comp.sls_tossed;
+#endif /* VJC */
+	break;
+
+#ifdef PPP_COMPRESS
+    case SIOCGPPPCSTATS:
+	pcp = &((struct ifpppcstatsreq *) data)->stats;
+	bzero(pcp, sizeof(*pcp));
+	if (sc->sc_xc_state != NULL)
+	    (*sc->sc_xcomp->comp_stat)(sc->sc_xc_state, &pcp->c);
+	if (sc->sc_rc_state != NULL)
+	    (*sc->sc_rcomp->decomp_stat)(sc->sc_rc_state, &pcp->d);
+	break;
+#endif /* PPP_COMPRESS */
+
+    default:
+	error = EINVAL;
+    }
+    splx(s);
+    return (error);
 }
 
 /*
@@ -612,10 +568,11 @@ pppfcs(fcs, cp, len)
  * Packet is placed in Information field of PPP frame.
  */
 int
-pppoutput(ifp, m0, dst)
+pppoutput(ifp, m0, dst, rtp)
     struct ifnet *ifp;
     struct mbuf *m0;
     struct sockaddr *dst;
+    struct rtentry *rtp;
 {
     register struct ppp_softc *sc = &ppp_softc[ifp->if_unit];
     struct ppp_header *ph;
@@ -624,6 +581,7 @@ pppoutput(ifp, m0, dst)
     int s, error;
     struct ip *ip;
     struct ifqueue *ifq;
+    enum NPmode mode;
 
     if (sc->sc_devp == NULL || (ifp->if_flags & IFF_RUNNING) == 0
 	|| (ifp->if_flags & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC) {
@@ -634,39 +592,29 @@ pppoutput(ifp, m0, dst)
     /*
      * Compute PPP header.
      */
-    address = PPP_ALLSTATIONS;
-    control = PPP_UI;
-    ifq = &ifp->if_snd;
+    m0->m_flags &= ~M_HIGHPRI;
     switch (dst->sa_family) {
 #ifdef INET
     case AF_INET:
+	address = PPP_ALLSTATIONS;
+	control = PPP_UI;
 	protocol = PPP_IP;
-	if ((sc->sc_flags & SC_ENABLE_IP) == 0) {
-	    error = ENETDOWN;
-	    goto bad;
-	}
-	
+	mode = sc->sc_npmode[NP_IP];
+
 	/*
-	 * If this is a TCP packet to or from an "interactive" port,
-	 * put the packet on the fastq instead.
+	 * If this packet has the "low delay" bit set in the IP header,
+	 * put it on the fastq instead.
 	 */
-	if ((ip = mtod(m0, struct ip *))->ip_p == IPPROTO_TCP) {
-	    register int p = ntohl(((int *)ip)[ip->ip_hl]);
-	    if (INTERACTIVE(p & 0xffff) || INTERACTIVE(p >> 16))
-		ifq = &sc->sc_fastq;
-	}
-	break;
-#endif
-#ifdef NS
-    case AF_NS:
-	protocol = PPP_XNS;
+	ip = mtod(m0, struct ip *);
+	if (ip->ip_tos & IPTOS_LOWDELAY)
+	    m0->m_flags |= M_HIGHPRI;
 	break;
 #endif
     case AF_UNSPEC:
-	ph = (struct ppp_header *) dst->sa_data;
-	address = ph->ph_address;
-	control = ph->ph_control;
-	protocol = ntohs(ph->ph_protocol);
+	address = PPP_ADDRESS(dst->sa_data);
+	control = PPP_CONTROL(dst->sa_data);
+	protocol = PPP_PROTOCOL(dst->sa_data);
+	mode = NPMODE_PASS;
 	break;
     default:
 	printf("ppp%d: af%d not supported\n", ifp->if_unit, dst->sa_family);
@@ -675,6 +623,18 @@ pppoutput(ifp, m0, dst)
     }
 
     /*
+     * Drop this packet, or return an error, if necessary.
+     */
+    if (mode == NPMODE_ERROR) {
+	error = ENETDOWN;
+	goto bad;
+    }
+    if (mode == NPMODE_DROP) {
+	error = 0;
+	goto bad;
+    }
+
+    /*
      * Add PPP header.  If no space in first mbuf, allocate another.
      * (This assumes M_LEADINGSPACE is always 0 for a cluster mbuf.)
      */
@@ -697,11 +657,13 @@ pppoutput(ifp, m0, dst)
 
     if (sc->sc_flags & SC_LOG_OUTPKT) {
 	printf("ppp%d output: ", ifp->if_unit);
-	pppdumpm(m0, -1);
+	pppdumpm(m0);
     }
 
 #if NBPFILTER > 0
-    /* See if bpf wants to look at the packet. */
+    /*
+     * See if bpf wants to look at the packet.
+     */
     if (sc->sc_bpf)
 	bpf_mtap(sc->sc_bpf, m0);
 #endif
@@ -709,20 +671,24 @@ pppoutput(ifp, m0, dst)
     /*
      * Put the packet on the appropriate queue.
      */
-    s = splimp();
-    if (IF_QFULL(ifq)) {
-	IF_DROP(ifq);
-	splx(s);
-	sc->sc_if.if_oerrors++;
-	error = ENOBUFS;
-	goto bad;
+    s = splimp();		/* splnet should be OK now */
+    if (mode == NPMODE_QUEUE) {
+	/* XXX we should limit the number of packets on this queue */
+	*sc->sc_npqtail = m0;
+	m0->m_nextpkt = NULL;
+	sc->sc_npqtail = &m0->m_nextpkt;
+    } else {
+	ifq = (m0->m_flags & M_HIGHPRI)? &sc->sc_fastq: &ifp->if_snd;
+	if (IF_QFULL(ifq)) {
+	    IF_DROP(ifq);
+	    splx(s);
+	    sc->sc_if.if_oerrors++;
+	    error = ENOBUFS;
+	    goto bad;
+	}
+	IF_ENQUEUE(ifq, m0);
+	(*sc->sc_start)(sc);
     }
-    IF_ENQUEUE(ifq, m0);
-
-    /*
-     * Tell the device to send it out.
-     */
-    (*sc->sc_start)(sc);
 
     splx(s);
     return (0);
@@ -733,77 +699,221 @@ bad:
 }
 
 /*
- * Grab another packet off a queue and apply VJ compression,
- * address/control and/or protocol compression if appropriate.
+ * After a change in the NPmode for some NP, move packets from the
+ * npqueue to the send queue or the fast queue as appropriate.
+ * Should be called at splimp (actually splnet would probably suffice).
+ */
+static void
+ppp_requeue(sc)
+    struct ppp_softc *sc;
+{
+    struct mbuf *m, **mpp;
+    struct ifqueue *ifq;
+    enum NPmode mode;
+
+    for (mpp = &sc->sc_npqueue; (m = *mpp) != NULL; ) {
+	switch (PPP_PROTOCOL(mtod(m, u_char *))) {
+	case PPP_IP:
+	    mode = sc->sc_npmode[NP_IP];
+	    break;
+	default:
+	    mode = NPMODE_PASS;
+	}
+
+	switch (mode) {
+	case NPMODE_PASS:
+	    /*
+	     * This packet can now go on one of the queues to be sent.
+	     */
+	    *mpp = m->m_nextpkt;
+	    m->m_nextpkt = NULL;
+	    ifq = (m->m_flags & M_HIGHPRI)? &sc->sc_fastq: &sc->sc_if.if_snd;
+	    if (IF_QFULL(ifq)) {
+		IF_DROP(ifq);
+		sc->sc_if.if_oerrors++;
+	    } else
+		IF_ENQUEUE(ifq, m);
+	    break;
+
+	case NPMODE_DROP:
+	case NPMODE_ERROR:
+	    *mpp = m->m_nextpkt;
+	    m_freem(m);
+	    break;
+
+	case NPMODE_QUEUE:
+	    mpp = &m->m_nextpkt;
+	    break;
+	}
+    }
+    sc->sc_npqtail = mpp;
+}
+
+/*
+ * Get a packet to send.  This procedure is intended to be called
+ * at spltty()/splimp(), so it takes little time.  If there isn't
+ * a packet waiting to go out, it schedules a software interrupt
+ * to prepare a new packet; the device start routine gets called
+ * again when a packet is ready.
  */
 struct mbuf *
 ppp_dequeue(sc)
     struct ppp_softc *sc;
 {
-    int s;
     struct mbuf *m;
+    int s = splimp();
+
+    m = sc->sc_togo;
+    if (m) {
+	/*
+	 * Had a packet waiting - send it.
+	 */
+	sc->sc_togo = NULL;
+	sc->sc_flags |= SC_TBUSY;
+	splx(s);
+	return m;
+    }
+    /*
+     * Remember we wanted a packet and schedule a software interrupt.
+     */
+    sc->sc_flags &= ~SC_TBUSY;
+    schednetisr(NETISR_PPP);
+    splx(s);
+    return NULL;
+}
+
+/*
+ * Software interrupt routine, called at splnet().
+ */
+void
+pppintr()
+{
+    struct ppp_softc *sc;
+    int i, s;
+    struct mbuf *m;
+
+    s = splnet();
+    sc = ppp_softc;
+    for (i = 0; i < NPPP; ++i, ++sc) {
+	if (!(sc->sc_flags & SC_TBUSY) && sc->sc_togo == NULL
+	    && (sc->sc_if.if_snd.ifq_head || sc->sc_fastq.ifq_head))
+	    ppp_outpkt(sc);
+	for (;;) {
+	    IF_DEQUEUE(&sc->sc_rawq, m);
+	    if (m == NULL)
+		break;
+	    ppp_inproc(sc, m);
+	}
+    }
+    splx(s);
+}
+
+/*
+ * Grab another packet off a queue and apply VJ compression,
+ * packet compression, address/control and/or protocol compression
+ * if enabled.  Should be called at splnet.
+ */
+static void
+ppp_outpkt(sc)
+    struct ppp_softc *sc;
+{
+    int s;
+    struct mbuf *m, *mp;
     u_char *cp;
     int address, control, protocol;
+    enum NPmode mode;
 
-    s = splimp();
+    /*
+     * Grab a packet to send: first try the fast queue, then the
+     * normal queue.
+     */
     IF_DEQUEUE(&sc->sc_fastq, m);
     if (m == NULL)
 	IF_DEQUEUE(&sc->sc_if.if_snd, m);
-    splx(s);
     if (m == NULL)
-	return NULL;
+	return;
 
     /*
      * Extract the ppp header of the new packet.
      * The ppp header will be in one mbuf.
      */
     cp = mtod(m, u_char *);
-    address = cp[0];
-    control = cp[1];
-    protocol = (cp[2] << 8) + cp[3];
+    address = PPP_ADDRESS(cp);
+    control = PPP_CONTROL(cp);
+    protocol = PPP_PROTOCOL(cp);
 
-#ifdef VJC
-    /*
-     * If the packet is a TCP/IP packet, see if we can compress it.
-     */
-    if (protocol == PPP_IP && sc->sc_flags & SC_COMP_TCP) {
-	struct ip *ip;
-	int type;
-	struct mbuf *mp;
+    switch (protocol) {
+    case PPP_IP:
+	/*
+	 * Update the time we sent the most recent packet.
+	 */
+	sc->sc_last_sent = time.tv_sec;
 
-	mp = m;
-	ip = (struct ip *) (cp + PPP_HDRLEN);
-	if (mp->m_len <= PPP_HDRLEN) {
-	    mp = mp->m_next;
-	    ip = mtod(mp, struct ip *);
-	}
-	/* this code assumes the IP/TCP header is in one non-shared mbuf */
-	if (ip->ip_p == IPPROTO_TCP) {
-	    type = sl_compress_tcp(mp, ip, &sc->sc_comp,
-				   !(sc->sc_flags & SC_NO_TCP_CCID));
-	    switch (type) {
-	    case TYPE_UNCOMPRESSED_TCP:
-		protocol = PPP_VJC_UNCOMP;
-		break;
-	    case TYPE_COMPRESSED_TCP:
-		protocol = PPP_VJC_COMP;
-		cp = mtod(m, u_char *);
-		cp[0] = address;	/* header has moved */
-		cp[1] = control;
-		cp[2] = 0;
-		break;
+#ifdef VJC
+	/*
+	 * If the packet is a TCP/IP packet, see if we can compress it.
+	 */
+	if (sc->sc_flags & SC_COMP_TCP) {
+	    struct ip *ip;
+	    int type;
+
+	    mp = m;
+	    ip = (struct ip *) (cp + PPP_HDRLEN);
+	    if (mp->m_len <= PPP_HDRLEN) {
+		mp = mp->m_next;
+		if (mp == NULL)
+		    break;
+		ip = mtod(mp, struct ip *);
+	    }
+	    /* this code assumes the IP/TCP header is in one non-shared mbuf */
+	    if (ip->ip_p == IPPROTO_TCP) {
+		type = vj_compress_tcp(mp, ip, &sc->sc_comp,
+				       !(sc->sc_flags & SC_NO_TCP_CCID));
+		switch (type) {
+		case TYPE_UNCOMPRESSED_TCP:
+		    protocol = PPP_VJC_UNCOMP;
+		    break;
+		case TYPE_COMPRESSED_TCP:
+		    protocol = PPP_VJC_COMP;
+		    cp = mtod(m, u_char *);
+		    cp[0] = address;	/* header has moved */
+		    cp[1] = control;
+		    cp[2] = 0;
+		    break;
+		}
+		cp[3] = protocol;	/* update protocol in PPP header */
 	    }
-	    cp[3] = protocol;	/* update protocol in PPP header */
 	}
-    }
 #endif	/* VJC */
+	break;
+
+#ifdef PPP_COMPRESS
+    case PPP_CCP:
+	ppp_ccp(sc, m, 0);
+	break;
+#endif	/* PPP_COMPRESS */
+    }
 
-#ifdef BSD_COMP
-    if (protocol < PPP_COMP && (sc->sc_flags & SC_BSD_COMP)) {
-	slen = m_totallen(m0);
-	clen = pf_bsd_comp(sc->sc_bsd_db, cbuf, proto, m0, slen);
+#ifdef PPP_COMPRESS
+    if (protocol != PPP_LCP && protocol != PPP_CCP
+	&& sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN)) {
+	struct mbuf *mcomp = NULL;
+	int slen, clen;
+
+	slen = 0;
+	for (mp = m; mp != NULL; mp = mp->m_next)
+	    slen += mp->m_len;
+	clen = (*sc->sc_xcomp->compress)
+	    (sc->sc_xc_state, &mcomp, m, slen,
+	     (sc->sc_flags & SC_CCP_UP? sc->sc_if.if_mtu: 0));
+	if (mcomp != NULL) {
+	    m_freem(m);
+	    m = mcomp;
+	    cp = mtod(m, u_char *);
+	    protocol = cp[3];
+	}
     }
-#endif	/* BSD_COMP */
+#endif	/* PPP_COMPRESS */
 
     /*
      * Compress the address/control and protocol, if possible.
@@ -825,356 +935,336 @@ ppp_dequeue(sc)
 	--m->m_len;
     }
 
-    return m;
+    s = splimp();
+    sc->sc_togo = m;
+    (*sc->sc_start)(sc);
+    splx(s);
 }
 
+#ifdef PPP_COMPRESS
 /*
- * This gets called from pppoutput when a new packet is
- * put on a queue.
+ * Handle a CCP packet.  `rcvd' is 1 if the packet was received,
+ * 0 if it is about to be transmitted.
  */
-static
-pppasyncstart(sc)
-    register struct ppp_softc *sc;
+static int
+ppp_ccp(sc, m, rcvd)
+    struct ppp_softc *sc;
+    struct mbuf *m;
+    int rcvd;
 {
-    register struct tty *tp = (struct tty *) sc->sc_devp;
+    u_char *dp, *ep;
+    struct mbuf *mp;
+    int slen, s;
 
-    pppstart(tp);
-}
+    /*
+     * Get a pointer to the data after the PPP header.
+     */
+    if (m->m_len <= PPP_HDRLEN) {
+	mp = m->m_next;
+	if (mp == NULL)
+	    return;
+	dp = (mp != NULL)? mtod(mp, u_char *): NULL;
+    } else {
+	mp = m;
+	dp = mtod(mp, u_char *) + PPP_HDRLEN;
+    }
 
-/*
- * Start output on async tty interface.  Get another datagram
- * to send from the interface queue and start sending it.
- */
-void
-pppstart(tp)
-    register struct tty *tp;
-{
-    register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
-    register struct mbuf *m;
-    register int len;
-    register u_char *start, *stop, *cp;
-    int n, s, ndone, done;
-    struct mbuf *m2;
-
-    if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) {
-	/* sorry, I can't talk now */
+    ep = mtod(mp, u_char *) + mp->m_len;
+    if (dp + CCP_HDRLEN > ep)
 	return;
-    }
-    if (sc == NULL || tp != (struct tty *) sc->sc_devp) {
-	(*tp->t_oproc)(tp);
+    slen = CCP_LENGTH(dp);
+    if (dp + slen > ep) {
+	if (sc->sc_flags & SC_DEBUG)
+	    printf("if_ppp/ccp: not enough data in mbuf (%x+%x > %x+%x)\n",
+		   dp, slen, mtod(mp, u_char *), mp->m_len);
 	return;
     }
 
-    for (;;) {
-	/*
-	 * If there is more in the output queue, just send it now.
-	 * We are being called in lieu of ttstart and must do what
-	 * it would.
-	 */
-	if (CCOUNT(&tp->t_outq) != 0 && tp->t_oproc != NULL) {
-	    (*tp->t_oproc)(tp);
-	    if (CCOUNT(&tp->t_outq) > PPP_HIWAT)
-		return;
-	}
-
-	/*
-	 * See if we have an existing packet partly sent.
-	 * If not, get a new packet and start sending it.
-	 * We take packets on the priority queue ahead of those
-	 * on the normal queue.
-	 */
-	m = sc->sc_outm;
-	if (m == NULL) {
-	    /*
-	     * Get another packet to be sent
-	     */
-	    m = ppp_dequeue(sc);
-	    if (m == NULL)
-		return;
-
-	    /*
-	     * The extra PPP_FLAG will start up a new packet, and thus
-	     * will flush any accumulated garbage.  We do this whenever
-	     * the line may have been idle for some time.
-	     */
-	    if (CCOUNT(&tp->t_outq) == 0) {
-		++sc->sc_bytessent;
-		(void) putc(PPP_FLAG, &tp->t_outq);
-	    }
-
-	    /* Calculate the FCS for the first mbuf's worth. */
-	    sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
+    switch (CCP_CODE(dp)) {
+    case CCP_CONFREQ:
+    case CCP_TERMREQ:
+    case CCP_TERMACK:
+	/* CCP must be going down - disable compression */
+	if (sc->sc_flags & SC_CCP_UP) {
+	    s = splimp();
+	    sc->sc_flags &= ~(SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
+	    splx(s);
 	}
+	break;
 
-	for (;;) {
-	    start = mtod(m, u_char *);
-	    len = m->m_len;
-	    stop = start + len;
-	    while (len > 0) {
-		/*
-		 * Find out how many bytes in the string we can
-		 * handle without doing something special.
-		 */
-		for (cp = start; cp < stop; cp++)
-		    if (ESCAPE_P(*cp))
-			break;
-		n = cp - start;
-		if (n) {
-		    /* NetBSD (0.9 or later), 4.3-Reno or similar. */
-		    ndone = n - b_to_q(start, n, &tp->t_outq);
-		    len -= ndone;
-		    start += ndone;
-		    sc->sc_bytessent += ndone;
-
-		    if (ndone < n)
-			break;	/* packet doesn't fit */
+    case CCP_CONFACK:
+	if (sc->sc_flags & SC_CCP_OPEN && !(sc->sc_flags & SC_CCP_UP)
+	    && slen >= CCP_HDRLEN + CCP_OPT_MINLEN
+	    && slen >= CCP_OPT_LENGTH(dp + CCP_HDRLEN) + CCP_HDRLEN) {
+	    if (!rcvd) {
+		/* we're agreeing to send compressed packets. */
+		if (sc->sc_xc_state != NULL
+		    && (*sc->sc_xcomp->comp_init)
+			(sc->sc_xc_state, dp + CCP_HDRLEN, slen - CCP_HDRLEN,
+			 sc->sc_if.if_unit, 0, sc->sc_flags & SC_DEBUG)) {
+		    s = splimp();
+		    sc->sc_flags |= SC_COMP_RUN;
+		    splx(s);
 		}
-		/*
-		 * If there are characters left in the mbuf,
-		 * the first one must be special..
-		 * Put it out in a different form.
-		 */
-		if (len) {
-		    if (putc(PPP_ESCAPE, &tp->t_outq))
-			break;
-		    if (putc(*start ^ PPP_TRANS, &tp->t_outq)) {
-			(void) unputc(&tp->t_outq);
-			break;
-		    }
-		    sc->sc_bytessent += 2;
-		    start++;
-		    len--;
+	    } else {
+		/* peer is agreeing to send compressed packets. */
+		if (sc->sc_rc_state != NULL
+		    && (*sc->sc_rcomp->decomp_init)
+			(sc->sc_rc_state, dp + CCP_HDRLEN, slen - CCP_HDRLEN,
+			 sc->sc_if.if_unit, 0, sc->sc_mru,
+			 sc->sc_flags & SC_DEBUG)) {
+		    s = splimp();
+		    sc->sc_flags |= SC_DECOMP_RUN;
+		    sc->sc_flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
+		    splx(s);
 		}
 	    }
-	    /*
-	     * If we didn't empty this mbuf, remember where we're up to.
-	     * If we emptied the last mbuf, try to add the FCS and closing
-	     * flag, and if we can't, leave sc_outm pointing to m, but with
-	     * m->m_len == 0, to remind us to output the FCS and flag later.
-	     */
-	    done = len == 0;
-	    if (done && m->m_next == NULL) {
-		u_char *p, *q;
-		int c;
-		u_char endseq[8];
-
-		/*
-		 * We may have to escape the bytes in the FCS.
-		 */
-		p = endseq;
-		c = ~sc->sc_outfcs & 0xFF;
-		if (ESCAPE_P(c)) {
-		    *p++ = PPP_ESCAPE;
-		    *p++ = c ^ PPP_TRANS;
-		} else
-		    *p++ = c;
-		c = (~sc->sc_outfcs >> 8) & 0xFF;
-		if (ESCAPE_P(c)) {
-		    *p++ = PPP_ESCAPE;
-		    *p++ = c ^ PPP_TRANS;
-		} else
-		    *p++ = c;
-		*p++ = PPP_FLAG;
-
-		/*
-		 * Try to output the FCS and flag.  If the bytes
-		 * don't all fit, back out.
-		 */
-		for (q = endseq; q < p; ++q)
-		    if (putc(*q, &tp->t_outq)) {
-			done = 0;
-			for (; q > endseq; --q)
-			    unputc(&tp->t_outq);
-			break;
-		    }
-	    }
+	}
+	break;
 
-	    if (!done) {
-		m->m_data = start;
-		m->m_len = len;
-		sc->sc_outm = m;
-		if (tp->t_oproc != NULL)
-		    (*tp->t_oproc)(tp);
-		return;		/* can't do any more at the moment */
+    case CCP_RESETACK:
+	if (sc->sc_flags & SC_CCP_UP) {
+	    if (!rcvd) {
+		if (sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN))
+		    (*sc->sc_xcomp->comp_reset)(sc->sc_xc_state);
+	    } else {
+		if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
+		    (*sc->sc_rcomp->decomp_reset)(sc->sc_rc_state);
+		    s = splimp();
+		    sc->sc_flags &= ~SC_DC_ERROR;
+		    splx(s);
+		}
 	    }
-
-	    /* Finished with this mbuf; free it and move on. */
-	    MFREE(m, m2);
-	    if (m2 == NULL)
-		break;
-
-	    m = m2;
-	    sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
 	}
-
-	/* Finished a packet */
-	sc->sc_outm = NULL;
-	sc->sc_bytessent++;	/* account for closing flag */
-	sc->sc_if.if_opackets++;
-	sc->sc_if.if_obytes = sc->sc_bytessent;
+	break;
     }
 }
 
 /*
- * Allocate enough mbuf to handle current MRU.
+ * CCP is down; free (de)compressor state if necessary.
  */
-static int
-pppgetm(sc)
-    register struct ppp_softc *sc;
+static void
+ppp_ccp_closed(sc)
+    struct ppp_softc *sc;
 {
-    struct mbuf *m, **mp;
-    int len = HDROFF + sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN;
-    int s;
-
-    s = splimp();
-    for (mp = &sc->sc_m; (m = *mp) != NULL; mp = &m->m_next)
-	if ((len -= M_DATASIZE(m)) <= 0) {
-	    splx(s);
-	    return (1);
-	}
-
-    for (;; mp = &m->m_next) {
-	MGETHDR(m, M_DONTWAIT, MT_DATA);
-	if (m == 0) {
-	    m_freem(sc->sc_m);
-	    sc->sc_m = NULL;
-	    splx(s);
-	    printf("ppp%d: can't allocate mbuf\n", sc->sc_if.if_unit);
-	    return (0);
-	}
-	*mp = m;
-	MCLGET(m, M_DONTWAIT);
-	if ((len -= M_DATASIZE(m)) <= 0) {
-	    splx(s);
-	    return (1);
-	}
+    if (sc->sc_xc_state) {
+	(*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
+	sc->sc_xc_state = NULL;
+    }
+    if (sc->sc_rc_state) {
+	(*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
+	sc->sc_rc_state = NULL;
     }
 }
+#endif /* PPP_COMPRESS */
 
 /*
- * Copy mbuf chain.  Would like to use m_copy(), but we need a real copy
- * of the data, not just copies of pointers to the data.
+ * PPP packet input routine.
+ * The caller has checked and removed the FCS and has inserted
+ * the address/control bytes and the protocol high byte if they
+ * were omitted.
  */
-static struct mbuf *
-ppp_btom(sc)
+void
+ppppktin(sc, m, lost)
     struct ppp_softc *sc;
+    struct mbuf *m;
+    int lost;
 {
-    register struct mbuf *m, **mp;
-    struct mbuf *top = sc->sc_m;
-
-    /*
-     * First check current mbuf.  If we have more than a small mbuf,
-     * return the whole cluster and set beginning of buffer to the
-     * next mbuf.
-     * Else, copy the current bytes into a small mbuf, attach the new
-     * mbuf to the end of the chain and set beginning of buffer to the
-     * current mbuf.
-     */
-
-    if (sc->sc_mc->m_len > MHLEN) {
-	sc->sc_m = sc->sc_mc->m_next;
-	sc->sc_mc->m_next = NULL;
-    }
-    else {
-	/* rather than waste a whole cluster on <= MHLEN bytes,
-	   alloc a small mbuf and copy to it */
-	MGETHDR(m, M_DONTWAIT, MT_DATA);
-	if (m == NULL)
-	    return (NULL);
-
-	bcopy(mtod(sc->sc_mc, caddr_t), mtod(m, caddr_t), sc->sc_mc->m_len);
-	m->m_len = sc->sc_mc->m_len;
-	for (mp = &top; *mp != sc->sc_mc; mp = &(*mp)->m_next)
-	    ;
-	*mp = m;
-	sc->sc_m = sc->sc_mc;
-    }
-
-    /*
-     * Try to allocate enough extra mbufs to handle the next packet.
-     */
-    if (pppgetm(sc) == 0) {
-	m_freem(top);
-	if (pppgetm(sc) == 0)
-	    sc->sc_if.if_flags &= ~IFF_UP;
-	return (NULL);
-    }
+    int s = splimp();
 
-    return (top);
+    if (lost)
+	m->m_flags |= M_ERRMARK;
+    IF_ENQUEUE(&sc->sc_rawq, m);
+    schednetisr(NETISR_PPP);
+    splx(s);
 }
 
 /*
- * PPP packet input routine.
- * The caller has checked and removed the FCS.
- * The return value is 1 if the packet was put on sc->sc_inq,
- * 0 otherwise.
+ * Process a received PPP packet, doing decompression as necessary.
  */
 #define COMPTYPE(proto)	((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: \
 			 TYPE_UNCOMPRESSED_TCP)
 
-int
-ppppktin(sc, m, ilen)
+static void
+ppp_inproc(sc, m)
     struct ppp_softc *sc;
     struct mbuf *m;
-    int ilen;
 {
     struct ifqueue *inq;
-    int s, xlen, proto, rv;
-    struct ppp_header hdr;
+    int s, ilen, xlen, proto, rv;
+    u_char *cp, adrs, ctrl;
+    struct mbuf *mp, *dmp = NULL;
+    u_char *iphdr;
+    u_int hlen;
 
     sc->sc_if.if_ipackets++;
-    rv = 0;
 
-    hdr = *mtod(m, struct ppp_header *);
-    proto = ntohs(hdr.ph_protocol);
+    if (sc->sc_flags & SC_LOG_INPKT) {
+	printf("ppp%d: got %d bytes\n", sc->sc_if.if_unit, ilen);
+	pppdumpm(m);
+    }
+
+    cp = mtod(m, u_char *);
+    adrs = PPP_ADDRESS(cp);
+    ctrl = PPP_CONTROL(cp);
+    proto = PPP_PROTOCOL(cp);
+
+    if (m->m_flags & M_ERRMARK) {
+	m->m_flags &= ~M_ERRMARK;
+	s = splimp();
+	sc->sc_flags |= SC_VJ_RESET;
+	splx(s);
+    }
+
+#ifdef PPP_COMPRESS
+    /*
+     * Decompress this packet if necessary, update the receiver's
+     * dictionary, or take appropriate action on a CCP packet.
+     */
+    if (proto == PPP_COMP && sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)
+	&& !(sc->sc_flags & SC_DC_ERROR) && !(sc->sc_flags & SC_DC_FERROR)) {
+	/* decompress this packet */
+	rv = (*sc->sc_rcomp->decompress)(sc->sc_rc_state, m, &dmp);
+	if (rv == DECOMP_OK) {
+	    m_freem(m);
+	    if (dmp == NULL) {
+		/* no error, but no decompressed packet produced */
+		return;
+	    }
+	    m = dmp;
+	    cp = mtod(m, u_char *);
+	    proto = PPP_PROTOCOL(cp);
+
+	} else {
+	    /*
+	     * An error has occurred in decompression.
+	     * Pass the compressed packet up to pppd, which may take
+	     * CCP down or issue a Reset-Req.
+	     */
+	    if (sc->sc_flags & SC_DEBUG)
+		printf("ppp%d: decompress failed %d\n", sc->sc_if.if_unit, rv);
+	    s = splimp();
+	    sc->sc_flags |= SC_VJ_RESET;
+	    if (rv == DECOMP_ERROR)
+		sc->sc_flags |= SC_DC_ERROR;
+	    else
+		sc->sc_flags |= SC_DC_FERROR;
+	    splx(s);
+	}
+
+    } else {
+	if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
+	    (*sc->sc_rcomp->incomp)(sc->sc_rc_state, m);
+	}
+	if (proto == PPP_CCP) {
+	    ppp_ccp(sc, m, 1);
+	}
+    }
+#endif
+
+    ilen = 0;
+    for (mp = m; mp != NULL; mp = mp->m_next)
+	ilen += mp->m_len;
 
 #ifdef VJC
+    if (sc->sc_flags & SC_VJ_RESET) {
+	/*
+	 * If we've missed a packet, we must toss subsequent compressed
+	 * packets which don't have an explicit connection ID.
+	 */
+	vj_uncompress_tcp(NULL, 0, TYPE_ERROR, &sc->sc_comp);
+	s = splimp();
+	sc->sc_flags &= ~SC_VJ_RESET;
+	splx(s);
+    }
+
     /*
      * See if we have a VJ-compressed packet to uncompress.
      */
-    if (proto == PPP_VJC_COMP || proto == PPP_VJC_UNCOMP) {
-	char *pkttype = proto == PPP_VJC_COMP? "": "un";
+    if (proto == PPP_VJC_COMP) {
+	if (sc->sc_flags & SC_REJ_COMP_TCP)
+	    goto bad;
 
-	if (sc->sc_flags & SC_REJ_COMP_TCP) {
+	xlen = vj_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN,
+				      ilen - PPP_HDRLEN, TYPE_COMPRESSED_TCP,
+				      &sc->sc_comp, &iphdr, &hlen);
+
+	if (xlen <= 0) {
 	    if (sc->sc_flags & SC_DEBUG)
-		printf("ppp%d: %scomp pkt w/o compression; flags 0x%x\n",
-			sc->sc_if.if_unit, pkttype, sc->sc_flags);
-	    sc->sc_if.if_ierrors++;
-	    return 0;
+		printf("ppp%d: VJ uncompress failed on type comp\n",
+			sc->sc_if.if_unit);
+	    goto bad;
 	}
 
-	m->m_data += PPP_HDRLEN;
-	m->m_len -= PPP_HDRLEN;
-	ilen -= PPP_HDRLEN;
-	xlen = sl_uncompress_tcp_part((u_char **)(&m->m_data),
-					m->m_len, ilen,
-					COMPTYPE(proto), &sc->sc_comp);
+	/* Copy the PPP and IP headers into a new mbuf. */
+	MGETHDR(mp, M_DONTWAIT, MT_DATA);
+	if (mp == NULL)
+	    goto bad;
+	mp->m_len = 0;
+	mp->m_next = NULL;
+	if (hlen + PPP_HDRLEN > MHLEN) {
+	    MCLGET(mp, M_DONTWAIT);
+	    if (M_TRAILINGSPACE(mp) < hlen + PPP_HDRLEN) {
+		m_freem(mp);
+		goto bad;	/* lose if big headers and no clusters */
+	    }
+	}
+	cp = mtod(mp, u_char *);
+	cp[0] = adrs;
+	cp[1] = ctrl;
+	cp[2] = 0;
+	cp[3] = PPP_IP;
+	proto = PPP_IP;
+	bcopy(iphdr, cp + PPP_HDRLEN, hlen);
+	mp->m_len = hlen + PPP_HDRLEN;
+
+	/*
+	 * Trim the PPP and VJ headers off the old mbuf
+	 * and stick the new and old mbufs together.
+	 */
+	m->m_data += PPP_HDRLEN + xlen;
+	m->m_len -= PPP_HDRLEN + xlen;
+	if (m->m_len <= M_TRAILINGSPACE(mp)) {
+	    bcopy(mtod(m, u_char *), mtod(mp, u_char *) + mp->m_len, m->m_len);
+	    mp->m_len += m->m_len;
+	    MFREE(m, mp->m_next);
+	} else
+	    mp->m_next = m;
+	m = mp;
+	ilen += hlen - xlen;
+
+    } else if (proto == PPP_VJC_UNCOMP) {
+	if (sc->sc_flags & SC_REJ_COMP_TCP)
+	    goto bad;
 
-	if (xlen == 0) {
+	xlen = vj_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN,
+				      ilen - PPP_HDRLEN, TYPE_UNCOMPRESSED_TCP,
+				      &sc->sc_comp, &iphdr, &hlen);
+
+	if (xlen < 0) {
 	    if (sc->sc_flags & SC_DEBUG)
-		printf("ppp%d: sl_uncompress failed on type %scomp\n",
-			sc->sc_if.if_unit, pkttype);
-	    sc->sc_if.if_ierrors++;
-	    return 0;
+		printf("ppp%d: VJ uncompress failed on type uncomp\n",
+			sc->sc_if.if_unit);
+	    goto bad;
 	}
 
-	/* adjust the first mbuf by the decompressed amt */
-	xlen += PPP_HDRLEN;
-	m->m_len += xlen - ilen;
-	ilen = xlen;
-	m->m_data -= PPP_HDRLEN;
 	proto = PPP_IP;
-
-	/* put the ppp header back in place */
-	hdr.ph_protocol = htons(PPP_IP);
-	*mtod(m, struct ppp_header *) = hdr;
+	cp[3] = PPP_IP;
     }
 #endif /* VJC */
 
-    /* get this packet as an mbuf chain */
-    if ((m = ppp_btom(sc)) == NULL) {
-	sc->sc_if.if_ierrors++;
-	return 0;
+    /*
+     * If the packet will fit in a header mbuf, don't waste a
+     * whole cluster on it.
+     */
+    if (ilen <= MHLEN && M_IS_CLUSTER(m)) {
+	MGETHDR(mp, M_DONTWAIT, MT_DATA);
+	if (mp != NULL) {
+	    m_copydata(m, 0, ilen, mtod(mp, caddr_t));
+	    m_freem(m);
+	    m = mp;
+	    m->m_len = ilen;
+	}
     }
     m->m_pkthdr.len = ilen;
     m->m_pkthdr.rcvif = &sc->sc_if;
@@ -1185,6 +1275,7 @@ ppppktin(sc, m, ilen)
 	bpf_mtap(sc->sc_bpf, m);
 #endif
 
+    rv = 0;
     switch (proto) {
 #ifdef INET
     case PPP_IP:
@@ -1192,16 +1283,17 @@ ppppktin(sc, m, ilen)
 	 * IP packet - take off the ppp header and pass it up to IP.
 	 */
 	if ((sc->sc_if.if_flags & IFF_UP) == 0
-	    || (sc->sc_flags & SC_ENABLE_IP) == 0) {
+	    || sc->sc_npmode[NP_IP] != NPMODE_PASS) {
 	    /* interface is down - drop the packet. */
 	    m_freem(m);
-	    return 0;
+	    return;
 	}
 	m->m_pkthdr.len -= PPP_HDRLEN;
 	m->m_data += PPP_HDRLEN;
 	m->m_len -= PPP_HDRLEN;
 	schednetisr(NETISR_IP);
 	inq = &ipintrq;
+	sc->sc_last_recv = time.tv_sec;	/* update time of last pkt rcvd */
 	break;
 #endif
 
@@ -1220,298 +1312,40 @@ ppppktin(sc, m, ilen)
     s = splimp();
     if (IF_QFULL(inq)) {
 	IF_DROP(inq);
+	splx(s);
 	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: queue full\n", sc->sc_if.if_unit);
-	sc->sc_if.if_ierrors++;
+	    printf("ppp%d: input queue full\n", sc->sc_if.if_unit);
 	sc->sc_if.if_iqdrops++;
-	m_freem(m);
-	rv = 0;
-    } else
-	IF_ENQUEUE(inq, m);
-
-    splx(s);
-    return rv;
-}
-
-/*
- * tty interface receiver interrupt.
- */
-static unsigned paritytab[8] = {
-    0x96696996, 0x69969669, 0x69969669, 0x96696996,
-    0x69969669, 0x96696996, 0x96696996, 0x69969669
-};
-
-void
-pppinput(c, tp)
-    int c;
-    register struct tty *tp;
-{
-    register struct ppp_softc *sc;
-    struct mbuf *m;
-    int ilen;
-
-    tk_nin++;
-    sc = (struct ppp_softc *) tp->t_sc;
-    if (sc == NULL || tp != (struct tty *) sc->sc_devp)
-	return;
-
-    ++sc->sc_bytesrcvd;
-
-    if (c & TTY_FE) {
-	/* framing error or overrun on this char - abort packet */
-	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: bad char %x\n", sc->sc_if.if_unit, c);
-	goto flush;
-    }
-
-    c &= 0xff;
-
-    if (c & 0x80)
-	sc->sc_flags |= SC_RCV_B7_1;
-    else
-	sc->sc_flags |= SC_RCV_B7_0;
-    if (paritytab[c >> 5] & (1 << (c & 0x1F)))
-	sc->sc_flags |= SC_RCV_ODDP;
-    else
-	sc->sc_flags |= SC_RCV_EVNP;
-
-    if (sc->sc_flags & SC_LOG_RAWIN)
-	ppplogchar(sc, c);
-
-    if (c == PPP_FLAG) {
-	ilen = sc->sc_ilen;
-	sc->sc_ilen = 0;
-	sc->sc_if.if_ibytes = sc->sc_bytesrcvd;
-
-	if (sc->sc_rawin_count > 0) 
-	    ppplogchar(sc, -1);
-
-	/*
-	 * If SC_ESCAPED is set, then we've seen the packet
-	 * abort sequence "}~".
-	 */
-	if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
-	    || ilen > 0 && sc->sc_fcs != PPP_GOODFCS) {
-#ifdef VJC
-	    /*
-	     * If we've missed a packet, we must toss subsequent compressed
-	     * packets which don't have an explicit connection ID.
-	     */
-	    sl_uncompress_tcp(NULL, 0, TYPE_ERROR, &sc->sc_comp);
-#endif
-	    if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
-		if (sc->sc_flags & SC_DEBUG)
-		    printf("ppp%d: bad fcs\n", sc->sc_if.if_unit);
-		sc->sc_if.if_ierrors++;
-	    } else
-		sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
-	    return;
-	}
-
-	if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
-	    if (ilen) {
-		if (sc->sc_flags & SC_DEBUG)
-		    printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen);
-		sc->sc_if.if_ierrors++;
-	    }
-	    return;
-	}
-
-	/*
-	 * Remove FCS trailer.  Somewhat painful...
-	 */
-	ilen -= 2;
-	if (--sc->sc_mc->m_len == 0) {
-	    for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
-		;
-	    sc->sc_mc = m;
-	}
-	sc->sc_mc->m_len--;
-
-	m = sc->sc_m;
-
-	if (sc->sc_flags & SC_LOG_INPKT) {
-	    printf("ppp%d: got %d bytes\n", sc->sc_if.if_unit, ilen);
-	    pppdumpm(m, ilen);
-	}
-
-	if (ppppktin(sc, m, ilen)) {
-	    /* Put a placeholder byte in canq for ttselect()/ttnread(). */
-	    putc(0, &tp->t_canq);
-	    ttwakeup(tp);
-	}
-	return;
-    }
-
-    if (sc->sc_flags & SC_FLUSH) {
-	if (sc->sc_flags & SC_LOG_FLUSH)
-	    ppplogchar(sc, c);
-	return;
-    }
-
-    if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
-	return;
-
-    if (sc->sc_flags & SC_ESCAPED) {
-	sc->sc_flags &= ~SC_ESCAPED;
-	c ^= PPP_TRANS;
-    } else if (c == PPP_ESCAPE) {
-	sc->sc_flags |= SC_ESCAPED;
-	return;
-    }
-
-    /*
-     * Initialize buffer on first octet received.
-     * First octet could be address or protocol (when compressing
-     * address/control).
-     * Second octet is control.
-     * Third octet is first or second (when compressing protocol)
-     * octet of protocol.
-     * Fourth octet is second octet of protocol.
-     */
-    if (sc->sc_ilen == 0) {
-	/* reset the first input mbuf */
-	m = sc->sc_m;
-	m->m_len = 0;
-	m->m_data = M_DATASTART(sc->sc_m) + HDROFF;
-	sc->sc_mc = m;
-	sc->sc_mp = mtod(m, char *);
-	sc->sc_fcs = PPP_INITFCS;
-	if (c != PPP_ALLSTATIONS) {
-	    if (sc->sc_flags & SC_REJ_COMP_AC) {
-		if (sc->sc_flags & SC_DEBUG)
-		    printf("ppp%d: garbage received: 0x%x (need 0xFF)\n",
-			   sc->sc_if.if_unit, c);
-		goto flush;
-	    }
-	    *sc->sc_mp++ = PPP_ALLSTATIONS;
-	    *sc->sc_mp++ = PPP_UI;
-	    sc->sc_ilen += 2;
-	    m->m_len += 2;
-	}
-    }
-    if (sc->sc_ilen == 1 && c != PPP_UI) {
-	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: missing UI (0x3), got 0x%x\n",
-		   sc->sc_if.if_unit, c);
-	goto flush;
-    }
-    if (sc->sc_ilen == 2 && (c & 1) == 1) {
-	/* a compressed protocol */
-	*sc->sc_mp++ = 0;
-	sc->sc_ilen++;
-	sc->sc_mc->m_len++;
-    }
-    if (sc->sc_ilen == 3 && (c & 1) == 0) {
-	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: bad protocol %x\n", sc->sc_if.if_unit,
-		   (sc->sc_mp[-1] << 8) + c);
-	goto flush;
-    }
-
-    /* packet beyond configured mru? */
-    if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
-	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: packet too big\n", sc->sc_if.if_unit);
-	goto flush;
+	goto bad;
     }
+    IF_ENQUEUE(inq, m);
+    splx(s);
 
-    /* is this mbuf full? */
-    m = sc->sc_mc;
-    if (M_TRAILINGSPACE(m) <= 0) {
-	sc->sc_mc = m = m->m_next;
-	if (m == NULL) {
-	    printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit);
-	    goto flush;
-	}
-	m->m_len = 0;
-	m->m_data = M_DATASTART(m);
-	sc->sc_mp = mtod(m, char *);
-    }
+    if (rv)
+	(*sc->sc_ctlp)(sc);
 
-    ++m->m_len;
-    *sc->sc_mp++ = c;
-    sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
     return;
 
- flush:
-    if (!(sc->sc_flags & SC_FLUSH)) {
-	sc->sc_if.if_ierrors++;
-	sc->sc_flags |= SC_FLUSH;
-	if (sc->sc_flags & SC_LOG_FLUSH)
-	    ppplogchar(sc, c);
-    }
-}
-
-/*
- * Process an ioctl request to interface.
- */
-pppioctl(ifp, cmd, data)
-    register struct ifnet *ifp;
-    int cmd;
-    caddr_t data;
-{
-    struct proc *p = curproc;	/* XXX */
-    register struct ppp_softc *sc = &ppp_softc[ifp->if_unit];
-    register struct ifaddr *ifa = (struct ifaddr *)data;
-    register struct ifreq *ifr = (struct ifreq *)data;
-    int s = splimp(), error = 0;
-
-
-    switch (cmd) {
-    case SIOCSIFFLAGS:
-	if ((ifp->if_flags & IFF_RUNNING) == 0)
-	    ifp->if_flags &= ~IFF_UP;
-	break;
-
-    case SIOCSIFADDR:
-	if (ifa->ifa_addr->sa_family != AF_INET)
-	    error = EAFNOSUPPORT;
-	break;
-
-    case SIOCSIFDSTADDR:
-	if (ifa->ifa_addr->sa_family != AF_INET)
-	    error = EAFNOSUPPORT;
-	break;
-
-    case SIOCSIFMTU:
-	if (error = suser(p->p_ucred, &p->p_acflag))
-	    return (error);
-	sc->sc_if.if_mtu = ifr->ifr_mtu;
-	break;
-
-    case SIOCGIFMTU:
-	ifr->ifr_mtu = sc->sc_if.if_mtu;
-	break;
-
-    default:
-	error = EINVAL;
-    }
-    splx(s);
-    return (error);
+ bad:
+    m_freem(m);
+    sc->sc_if.if_ierrors++;
 }
 
 #define MAX_DUMP_BYTES	128
 
 static void
-pppdumpm(m0, pktlen)
+pppdumpm(m0)
     struct mbuf *m0;
-    int pktlen;
 {
     char buf[3*MAX_DUMP_BYTES+4];
     char *bp = buf;
     struct mbuf *m;
     static char digits[] = "0123456789abcdef";
 
-    for (m = m0; m && pktlen; m = m->m_next) {
+    for (m = m0; m; m = m->m_next) {
 	int l = m->m_len;
 	u_char *rptr = (u_char *)m->m_data;
 
-	if (pktlen > 0) {
-	    if (l > pktlen)
-		l = pktlen;
-	    pktlen -= l;
-	}
 	while (l--) {
 	    if (bp > buf + sizeof(buf) - 4)
 		goto done;
@@ -1527,49 +1361,10 @@ pppdumpm(m0, pktlen)
 	    *bp++ = ' ';
     }
 done:
-    if (m && pktlen)
+    if (m)
 	*bp++ = '>';
     *bp = 0;
     printf("%s\n", buf);
 }
 
-static void
-ppplogchar(sc, c)
-    struct ppp_softc *sc;
-    int c;
-{
-    if (c >= 0)
-	sc->sc_rawin[sc->sc_rawin_count++] = c;
-    if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
-	|| c < 0 && sc->sc_rawin_count > 0) {
-	printf("ppp%d input: ", sc->sc_if.if_unit);
-	pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
-	sc->sc_rawin_count = 0;
-    }
-}
-
-static void
-pppdumpb(b, l)
-    u_char *b;
-    int l;
-{
-    char buf[3*MAX_DUMP_BYTES+4];
-    char *bp = buf;
-    static char digits[] = "0123456789abcdef";
-
-    while (l--) {
-	if (bp >= buf + sizeof(buf) - 3) {
-	    *bp++ = '>';
-	    break;
-	}
-	*bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
-	*bp++ = digits[*b++ & 0xf];
-	*bp++ = ' ';
-    }
-
-    *bp = 0;
-    printf("%s\n", buf);
-}
-
-
 #endif	/* NPPP > 0 */
diff --git a/sys/net/if_ppp.h b/sys/net/if_ppp.h
index 9f70af092353..5433cfbda3c7 100644
--- a/sys/net/if_ppp.h
+++ b/sys/net/if_ppp.h
@@ -1,3 +1,5 @@
+/*	$Id: if_ppp.h,v 1.12 1995/04/24 02:40:23 paulus Exp $	*/
+
 /*
  * if_ppp.h - Point-to-Point Protocol definitions.
  *
@@ -15,116 +17,83 @@
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
- *
- * $Id: if_ppp.h,v 1.5 1994/01/25 05:56:08 deraadt Exp $
  */
 
 #ifndef _IF_PPP_H_
 #define _IF_PPP_H_
 
 /*
- * Standard PPP header.
- */
-struct ppp_header {
-	u_char	ph_address;	/* Address Field */
-	u_char	ph_control;	/* Control Field */
-	u_short	ph_protocol;	/* Protocol Field */
-};
-
-#define PPP_HDRLEN	4	/* sizeof(struct ppp_header) must be 4 */
-#define PPP_FCSLEN	2	/* octets for FCS */
-
-#define	PPP_ALLSTATIONS	0xff	/* All-Stations broadcast address */
-#define	PPP_UI		0x03	/* Unnumbered Information */
-#define	PPP_FLAG	0x7e	/* Flag Sequence */
-#define	PPP_ESCAPE	0x7d	/* Asynchronous Control Escape */
-#define	PPP_TRANS	0x20	/* Asynchronous transparency modifier */
-
-/*
- * Protocol field values.
- */
-#define PPP_IP		0x21	/* Internet Protocol */
-#define	PPP_XNS		0x25	/* Xerox NS */
-#define	PPP_VJC_COMP	0x2d	/* VJ compressed TCP */
-#define	PPP_VJC_UNCOMP	0x2f	/* VJ uncompressed TCP */
-#define PPP_COMP	0xfd	/* compressed packet */
-#define PPP_LCP		0xc021	/* Link Control Protocol */
-#define PPP_CCP		0x80fd	/* Compression Control Protocol */
-
-/*
- * Important FCS values.
- */
-#define PPP_INITFCS	0xffff	/* Initial FCS value */
-#define PPP_GOODFCS	0xf0b8	/* Good final FCS value */
-#define PPP_FCS(fcs, c)	(((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
-
-/*
  * Packet sizes
  */
 #define	PPP_MTU		1500	/* Default MTU (size of Info field) */
-#define PPP_MRU		1500	/* Default MRU (max receive unit) */
 #define PPP_MAXMRU	65000	/* Largest MRU we allow */
 
-/* Extended asyncmap - allows any character to be escaped. */
-typedef u_long	ext_accm[8];
-
 /*
- * Structure describing each ppp unit.
+ * Bit definitions for flags.
  */
-struct ppp_softc {
-	struct ifnet sc_if;	/* network-visible interface */
-	u_int	sc_flags;	/* see below */
-	void	*sc_devp;	/* pointer to device-dependent structure */
-	int	(*sc_start) __P((struct ppp_softc *));	/* start routine */
-	short	sc_mru;		/* max receive unit */
-	pid_t	sc_xfer;	/* used in xferring unit to another dev */
-	struct	ifqueue sc_inq;	/* TTY side input queue */
-	struct	ifqueue sc_fastq; /* IP interactive output packet queue */
-#ifdef	VJC
-	struct	slcompress sc_comp; /* vjc control buffer */
-#endif
-	u_int	sc_bytessent;	/* count of octets sent */
-	u_int	sc_bytesrcvd;	/* count of octets received */
-	caddr_t	sc_bpf;		/* hook for BPF */
-	
-	/* Device-dependent part for async lines. */
-	ext_accm sc_asyncmap;	/* async control character map */
-	u_long	sc_rasyncmap;	/* receive async control char map */
-	struct	mbuf *sc_outm;	/* mbuf chain being output currently */
-	struct	mbuf *sc_m;	/* pointer to input mbuf chain */
-	struct	mbuf *sc_mc;	/* pointer to current input mbuf */
-	char	*sc_mp;		/* pointer to next char in input mbuf */
-	short	sc_ilen;	/* length of input-packet-so-far */
-	u_short	sc_fcs;		/* FCS so far (input) */
-	u_short	sc_outfcs;	/* FCS so far for output packet */
-	u_char	sc_rawin[16];	/* chars as received */
-	int	sc_rawin_count;	/* # in sc_rawin */
-};
-
-/* flags */
 #define SC_COMP_PROT	0x00000001	/* protocol compression (output) */
 #define SC_COMP_AC	0x00000002	/* header compression (output) */
 #define	SC_COMP_TCP	0x00000004	/* TCP (VJ) compression (output) */
 #define SC_NO_TCP_CCID	0x00000008	/* disable VJ connection-id comp. */
 #define SC_REJ_COMP_AC	0x00000010	/* reject adrs/ctrl comp. on input */
 #define SC_REJ_COMP_TCP	0x00000020	/* reject TCP (VJ) comp. on input */
-#define SC_ENABLE_IP	0x00000100	/* IP packets may be exchanged */
+#define SC_CCP_OPEN	0x00000040	/* Look at CCP packets */
+#define SC_CCP_UP	0x00000080	/* May send/recv compressed packets */
 #define SC_DEBUG	0x00010000	/* enable debug messages */
 #define SC_LOG_INPKT	0x00020000	/* log contents of good pkts recvd */
 #define SC_LOG_OUTPKT	0x00040000	/* log contents of pkts sent */
 #define SC_LOG_RAWIN	0x00080000	/* log all chars received */
 #define SC_LOG_FLUSH	0x00100000	/* log all chars flushed */
-#define	SC_MASK		0x0fffffff	/* bits that user can change */
-
-/* state bits */
-#define	SC_ESCAPED	0x80000000	/* saw a PPP_ESCAPE */
-#define	SC_FLUSH	0x40000000	/* flush input until next PPP_FLAG */
 #define SC_RCV_B7_0	0x01000000	/* have rcvd char with bit 7 = 0 */
-#define SC_RCV_B7_1	0x02000000	/* have rcvd char with bit 7 = 0 */
+#define SC_RCV_B7_1	0x02000000	/* have rcvd char with bit 7 = 1 */
 #define SC_RCV_EVNP	0x04000000	/* have rcvd char with even parity */
 #define SC_RCV_ODDP	0x08000000	/* have rcvd char with odd parity */
+#define	SC_MASK		0x0fff00ff	/* bits that user can change */
+
+/*
+ * State bits in sc_flags, not changeable by user.
+ */
+#define SC_TIMEOUT	0x00000400	/* timeout is currently pending */
+#define SC_VJ_RESET	0x00000800	/* need to reset VJ decomp */
+#define SC_COMP_RUN	0x00001000	/* compressor has been inited */
+#define SC_DECOMP_RUN	0x00002000	/* decompressor has been inited */
+#define SC_DC_ERROR	0x00004000	/* non-fatal decomp error detected */
+#define SC_DC_FERROR	0x00008000	/* fatal decomp error detected */
+#define SC_TBUSY	0x10000000	/* xmitter doesn't need a packet yet */
+#define SC_PKTLOST	0x20000000	/* have lost or dropped a packet */
+#define	SC_FLUSH	0x40000000	/* flush input until next PPP_FLAG */
+#define	SC_ESCAPED	0x80000000	/* saw a PPP_ESCAPE */
+
+/*
+ * Ioctl definitions.
+ */
+
+struct npioctl {
+    int		protocol;	/* PPP procotol, e.g. PPP_IP */
+    enum NPmode	mode;
+};
+
+/* Structure describing a CCP configuration option, for PPPIOCSCOMPRESS */
+struct ppp_option_data {
+	u_char	*ptr;
+	u_int	length;
+	int	transmit;
+};
+
+struct ifpppstatsreq {
+    char ifr_name[IFNAMSIZ];
+    struct ppp_stats stats;
+};
+
+struct ifpppcstatsreq {
+    char ifr_name[IFNAMSIZ];
+    struct ppp_comp_stats stats;
+};
+
+/*
+ * Ioctl definitions.
+ */
 
-/* this stuff doesn't belong here... */
 #define	PPPIOCGFLAGS	_IOR('t', 90, int)	/* get configuration flags */
 #define	PPPIOCSFLAGS	_IOW('t', 89, int)	/* set configuration flags */
 #define	PPPIOCGASYNCMAP	_IOR('t', 88, int)	/* get async map */
@@ -138,9 +107,24 @@ struct ppp_softc {
 #define PPPIOCGXASYNCMAP _IOR('t', 80, ext_accm) /* get extended ACCM */
 #define PPPIOCSXASYNCMAP _IOW('t', 79, ext_accm) /* set extended ACCM */
 #define PPPIOCXFERUNIT	_IO('t', 78)		/* transfer PPP unit */
+#define PPPIOCSCOMPRESS	_IOW('t', 77, struct ppp_option_data)
+#define PPPIOCGNPMODE	_IOWR('t', 76, struct npioctl) /* get NP mode */
+#define PPPIOCSNPMODE	_IOW('t', 75, struct npioctl)  /* set NP mode */
+#define PPPIOCGIDLE	_IOR('t', 74, struct ppp_idle) /* get idle time */
+
+/* PPPIOC[GS]MTU are alternatives to SIOC[GS]IFMTU, used under Ultrix */
+#define PPPIOCGMTU	_IOR('t', 73, int)	/* get interface MTU */
+#define PPPIOCSMTU	_IOW('t', 72, int)	/* set interface MTU */
+
+/*
+ * These two are interface ioctls so that pppstats can do them on
+ * a socket without having to open the serial device.
+ */
+#define SIOCGPPPSTATS	_IOWR('i', 123, struct ifpppstatsreq)
+#define SIOCGPPPCSTATS	_IOWR('i', 122, struct ifpppcstatsreq)
 
 #if !defined(ifr_mtu)
-#define ifr_mtu	ifr_metric
+#define ifr_mtu	ifr_ifru.ifru_metric
 #endif
 
 #endif /* _IF_PPP_H_ */