Merge/update ppp-2.2 kernel parts onto mainline.

Note that the old if_ppp.c has been split in half into if_ppp.c and
ppp_tty.c

1 files changed, 832 insertions, 1095 deletions

diff --git a/sys/net/if_ppp.c b/sys/net/if_ppp.c
index 1962ed6..a5f1dc4 100644
--- a/sys/net/if_ppp.c
+++ b/sys/net/if_ppp.c
@@ -69,27 +69,22 @@
  * Paul Mackerras (paulus@cs.anu.edu.au).
  */
 
-/* $Id: if_ppp.c,v 1.23 1995/10/26 20:30:15 julian Exp $ */
+/* $Id$ */
+/* from 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 <sys/kernel.h>
 
 #include <net/if.h>
@@ -111,86 +106,69 @@
 #endif
 
 #ifdef VJC
-#include <net/pppcompress.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/slcompress.h>
 #endif
 
+#include <net/ppp_defs.h>
 #include <net/if_ppp.h>
+#include <net/if_pppvar.h>
 #include <machine/cpu.h>
 
-static void pppattach __P((void *));
+#ifdef PPP_COMPRESS
+#define PACKETPTR	struct mbuf *
+#include <net/ppp_comp.h>
+#endif
+
+static void	pppattach __P((void *));
 PSEUDO_SET(pppattach, if_ppp);
 
-/* This is a FreeBSD-2.x kernel. */
-#define CCOUNT(q)	((q)->c_cc)
-
-#define	PPP_HIWAT	400	/* Don't start a new packet if HIWAT on que */
-#define	PPP_MAXMTU	16384	/* Largest MTU we allow */
-
-struct ppp_softc ppp_softc[NPPP];
-
-int	pppopen __P((dev_t dev, struct tty *tp));
-int	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	pppoutput __P((struct ifnet *, struct mbuf *,
-		       struct sockaddr *, struct rtentry *));
-int	pppinput __P((int c, struct tty *tp));
-int	pppioctl __P((struct ifnet *ifp, int cmd, caddr_t data));
-int	pppstart __P((struct tty *tp));
-
-static struct linesw pppdisc = {
-	pppopen, pppclose, pppread, pppwrite, ppptioctl,
-	pppinput, pppstart, ttymodem
-};
+int	pppsioctl __P((struct ifnet *ifp, int cmd, caddr_t data));
+void	pppintr __P((void));
 
-extern struct	ppp_softc *pppalloc __P((pid_t pid));
-extern void	pppdealloc __P((struct ppp_softc *sc));
-extern struct	mbuf *ppp_dequeue __P((struct ppp_softc *sc));
-extern int	ppppktin __P((struct ppp_softc *sc, struct mbuf *m, int ilen));
+static void	ppp_requeue __P((struct ppp_softc *));
+static void	ppp_outpkt __P((struct ppp_softc *));
+static void	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));
 
-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));
 
 /*
  * 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 */
 
 /*
  * Called from boot code to establish ppp interfaces.
@@ -202,8 +180,6 @@ pppattach(dummy)
     register struct ppp_softc *sc;
     register int i = 0;
 
-    linesw[PPPDISC] = pppdisc;
-
     for (sc = ppp_softc; i < NPPP; sc++) {
 	sc->sc_if.if_name = "ppp";
 	sc->sc_if.if_unit = i++;
@@ -211,16 +187,18 @@ pppattach(dummy)
 	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
     }
+    register_netisr(NETISR_PPP, pppintr);
 }
 
 /*
@@ -230,44 +208,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);
+    sl_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 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;
@@ -279,218 +272,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;
-
-    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);
-    /*
-     * XXX we fudge t_canq to avoid providing pppselect() and FIONREAD.
-     * I hope one char is enough.  The following actually gives CBSIZE
-     * chars.
-     */
-    clist_alloc_cblocks(&tp->t_canq, 1, 1);
-    clist_alloc_cblocks(&tp->t_outq, sc->sc_if.if_mtu + PPP_HIWAT,
-			sc->sc_if.if_mtu + PPP_HIWAT);
-    clist_alloc_cblocks(&tp->t_rawq, 0, 0);
-
-    return (0);
-}
-
-/*
- * Line specific close routine.
- * Detach the tty from the ppp unit.
- * Mimics part of ttyclose().
- */
-int
-pppclose(tp, flag)
-    struct tty *tp;
-    int flag;
-{
-    register struct ppp_softc *sc;
-    int s;
-
-    ttyflush(tp, FREAD | FWRITE);
-    s = splimp();		/* paranoid; splnet probably ok */
-    clist_free_cblocks(&tp->t_canq);
-    clist_free_cblocks(&tp->t_outq);
-    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);
-    return (0);			/* success */
-}
-
-/*
- * 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_CONNECTED) == 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, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH, "pppin", 0);
-	if (error)
-	    return error;
+    while ((m = sc->sc_npqueue) != NULL) {
+	sc->sc_npqueue = m->m_nextpkt;
+	m_freem(m);
     }
-    if (tp->t_line != PPPDISC) {
-	splx(s);
-	return (-1);
+    if (sc->sc_togo != NULL) {
+	m_freem(sc->sc_togo);
+	sc->sc_togo = NULL;
     }
-
-    /* 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);
+#ifdef PPP_COMPRESS
+    ppp_ccp_closed(sc);
+    sc->sc_xc_state = NULL;
+    sc->sc_rc_state = NULL;
+#endif /* PPP_COMPRESS */
 }
 
 /*
- * Line specific (tty) write routine.
+ * Ioctl routine for generic ppp devices.
  */
 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_CONNECTED) == 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);
-	}
-	m->m_len=0;
-	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;
-    }
-    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, (struct rtentry *)0));
-}
-
-/*
- * 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.
- */
-/* 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:
@@ -509,57 +323,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:
@@ -570,7 +349,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();
+	sl_compress_init(&sc->sc_comp, *(int *)data);
+	splx(s);
 	break;
 #endif
 
@@ -580,6 +361,100 @@ 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;
+		if (odp->transmit) {
+		    s = splnet();
+		    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;
+		    splx(s);
+		} else {
+		    s = splnet();
+		    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 = splnet();
+		sc->sc_npmode[npx] = npi->mode;
+		if (npi->mode != NPMODE_QUEUE) {
+		    ppp_requeue(sc);
+		    (*sc->sc_start)(sc);
+		}
+		splx(s);
+	    }
+	}
+	break;
+
+    case PPPIOCGIDLE:
+	s = splnet();
+	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);
     }
@@ -587,67 +462,119 @@ ppptioctl(tp, cmd, data, flag, p)
 }
 
 /*
- * FCS lookup table as calculated by genfcstab.
- */
-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.
+ * Process an ioctl request to the ppp network interface.
  */
-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;
+	if (ifr->ifr_mtu > PPP_MAXMTU)
+	    error = EINVAL;
+	else {
+	    sc->sc_if.if_mtu = ifr->ifr_mtu;
+	    (*sc->sc_setmtu)(sc);
+	}
+	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 = ENOTTY;
+    }
+    splx(s);
+    return (error);
 }
 
 /*
  * Queue a packet.  Start transmission if not active.
  * Packet is placed in Information field of PPP frame.
+ * Called at splnet as the if->if_output handler.
+ * Called at splnet from pppwrite().
  */
 int
-pppoutput(ifp, m0, dst, rt)
-	struct ifnet *ifp;
-	struct mbuf *m0;
-	struct sockaddr *dst;
-	struct rtentry *rt;
+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;
@@ -656,6 +583,7 @@ pppoutput(ifp, m0, dst, rt)
     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) {
@@ -666,36 +594,22 @@ pppoutput(ifp, m0, dst, rt)
     /*
      * 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;
-	}
-
-      /*
-       * Most high-priority services set IPTOS_LOWDELAY.  This is a much more
-       * generic mechanism than specific port numbers.  This same mechanism
-       * is used by slip.
-       */
-      if (ip->ip_tos & IPTOS_LOWDELAY)
-          ifq = &sc->sc_fastq;
-
+	ip = mtod(m0, struct ip *);
+	if (ip->ip_tos & IPTOS_LOWDELAY)
+	    m0->m_flags |= M_HIGHPRI;
 	break;
 #endif
 #ifdef IPX
@@ -703,16 +617,11 @@ pppoutput(ifp, m0, dst, rt)
 	protocol = PPP_IPX;
 	break;
 #endif
-#ifdef NS
-    case AF_NS:
-	protocol = PPP_XNS;
-	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);
@@ -721,6 +630,18 @@ pppoutput(ifp, m0, dst, rt)
     }
 
     /*
+     * 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.)
      */
@@ -743,11 +664,13 @@ pppoutput(ifp, m0, dst, rt)
 
     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
@@ -755,20 +678,26 @@ pppoutput(ifp, m0, dst, rt)
     /*
      * 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 = splnet();	/* redundant */
+    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 {
+	/* fastq and if_snd are emptied at splnet now */
+	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);
+    sc->sc_if.if_lastchange = time;
 
     splx(s);
     return (0);
@@ -779,77 +708,225 @@ 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 splnet.
+ */
+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;
+
+    sc = ppp_softc;
+    for (i = 0; i < NPPP; ++i, ++sc) {
+	s = splimp();
+	if (!(sc->sc_flags & SC_TBUSY) && sc->sc_togo == NULL
+	    && (sc->sc_if.if_snd.ifq_head || sc->sc_fastq.ifq_head)) {
+	    splx(s);
+	    ppp_outpkt(sc);
+	} else
+	    splx(s);
+	for (;;) {
+	    s = splimp();
+	    IF_DEQUEUE(&sc->sc_rawq, m);
+	    splx(s);
+	    if (m == NULL)
+		break;
+	    ppp_inproc(sc, m);
+	}
+    }
+}
+
+/*
+ * 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 = 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;
+		}
+		cp[3] = protocol;	/* update protocol in PPP header */
 	    }
-	    cp[3] = protocol;	/* update protocol in PPP header */
 	}
-    }
 #endif	/* VJC */
+	break;
 
-#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
+    case PPP_CCP:
+	ppp_ccp(sc, m, 0);
+	break;
+#endif	/* PPP_COMPRESS */
+    }
+
+#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.
@@ -871,358 +948,340 @@ ppp_dequeue(sc)
 	--m->m_len;
     }
 
-    return m;
+    /*
+     * potential race here.  We could write to sc_togo at softnet priority.
+     * the tty system could interrupt and steal the sc_togo before sc_start
+     * is called.  Either way, it's sent... No big deal.. :-)
+     */
+    sc->sc_togo = m;
+    (*sc->sc_start)(sc);
 }
 
+#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 int
-pppasyncstart(sc)
-    register struct ppp_softc *sc;
+static void
+ppp_ccp(sc, m, rcvd)
+    struct ppp_softc *sc;
+    struct mbuf *m;
+    int rcvd;
 {
-    register struct tty *tp = (struct tty *) sc->sc_devp;
-
-    pppstart(tp);
-    return 0;
-}
+    u_char *dp, *ep;
+    struct mbuf *mp;
+    int slen, s;
 
-/*
- * Start output on async tty interface.  Get another datagram
- * to send from the interface queue and start sending it.
- */
-int
-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, ndone, done;
-    struct mbuf *m2;
-
-    if ((tp->t_state & TS_CONNECTED) == 0) {
-	/* sorry, I can't talk now */
-	return 0;
-    }
-    if (sc == NULL || tp != (struct tty *) sc->sc_devp) {
-	(*tp->t_oproc)(tp);
-	return 0;
+    /*
+     * 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;
     }
 
-    for (;;) {
-	/*
-	 * Call output process whether or not there is any output.
-	 * We are being called in lieu of ttstart and must do what
-	 * it would.
-	 */
-	if (tp->t_oproc != NULL) {
-	    (*tp->t_oproc)(tp);
-	    if (CCOUNT(&tp->t_outq) > PPP_HIWAT)
-		return 0;
-	}
-
-	/*
-	 * 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 0;
-
-	    /*
-	     * 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);
-	    }
+    ep = mtod(mp, u_char *) + mp->m_len;
+    if (dp + CCP_HDRLEN > ep)
+	return;
+    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;
+    }
 
-	    /* 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 0;	/* 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;
     }
-    return 0;
 }
 
 /*
- * 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 = 0, 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;
+    sc->sc_if.if_lastchange = time;
 
-    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.
+	 */
+	sl_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 = sl_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;
 
-	if (xlen == 0) {
+    } else if (proto == PPP_VJC_UNCOMP) {
+	if (sc->sc_flags & SC_REJ_COMP_TCP)
+	    goto bad;
+
+	xlen = sl_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;
@@ -1233,6 +1292,7 @@ ppppktin(sc, m, ilen)
 	bpf_mtap(sc->sc_bpf, m);
 #endif
 
+    rv = 0;
     switch (proto) {
 #ifdef INET
     case PPP_IP:
@@ -1240,16 +1300,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
 
@@ -1268,326 +1329,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
-};
-
-int
-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 0;
-
-    ++sc->sc_bytesrcvd;
-
-    if ((tp->t_state & TS_CONNECTED) == 0) {
-	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: no carrier\n", sc->sc_if.if_unit);
-	goto flush;
-    }
-    if (c & TTY_ERRORMASK) {
-	if (sc->sc_flags & SC_DEBUG)
-	    printf("ppp%d: line error %x\n", sc->sc_if.if_unit, c & TTY_ERRORMASK);
-	goto flush;
-    }
-
-    c &= TTY_CHARMASK;
-
-    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 0;
-	}
-
-	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 0;
-	}
-
-	/*
-	 * 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 0;
-    }
-
-    if (sc->sc_flags & SC_FLUSH) {
-	if (sc->sc_flags & SC_LOG_FLUSH)
-	    ppplogchar(sc, c);
-	return 0;
-    }
-
-    if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
-	return 0;
-
-    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 0;
-    }
-
-    /*
-     * 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;
-    }
-
-    /* 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 *);
-    }
-
-    ++m->m_len;
-    *sc->sc_mp++ = c;
-    sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
-    return 0;
-
- 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);
+	goto bad;
     }
-    return 0;
-}
-
-/*
- * Process an ioctl request to interface.
- */
-int
-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;
+    IF_ENQUEUE(inq, m);
+    splx(s);
 
-    case SIOCSIFDSTADDR:
-	if (ifa->ifa_addr->sa_family != AF_INET)
-	    error = EAFNOSUPPORT;
-	break;
+    if (rv)
+	(*sc->sc_ctlp)(sc);
 
-    case SIOCSIFMTU:
-	if (error = suser(p->p_ucred, &p->p_acflag))
-	    return (error);
-	if (ifr->ifr_mtu > PPP_MAXMTU)
-	    error = EINVAL;
-	else {
-	    struct tty *tp;
+    return;
 
-	    sc->sc_if.if_mtu = ifr->ifr_mtu;
-	    tp = (struct tty *) sc->sc_devp;
-	    if (tp != NULL)
-		clist_alloc_cblocks(&tp->t_outq, sc->sc_if.if_mtu + PPP_HIWAT,
-				    sc->sc_if.if_mtu + PPP_HIWAT);
-	}
-	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;
-
-    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;
@@ -1603,48 +1378,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 */