diff options
| -rw-r--r-- | sys/net/if_ppp.c | 1927 | ||||
| -rw-r--r-- | sys/net/if_ppp.h | 156 | ||||
| -rw-r--r-- | sys/net/if_pppvar.h | 16 | ||||
| -rw-r--r-- | sys/net/ppp_comp.h | 5 | ||||
| -rw-r--r-- | sys/net/ppp_defs.h | 8 | ||||
| -rw-r--r-- | sys/net/ppp_tty.c | 169 |
6 files changed, 1061 insertions, 1220 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 = ⊤ *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 */ diff --git a/sys/net/if_ppp.h b/sys/net/if_ppp.h index 099b9be..e3fd618 100644 --- a/sys/net/if_ppp.h +++ b/sys/net/if_ppp.h @@ -1,3 +1,6 @@ +/* from Id: if_ppp.h,v 1.12 1995/04/24 02:40:23 paulus Exp */ +/* $Id$ */ + /* * if_ppp.h - Point-to-Point Protocol definitions. * @@ -15,118 +18,88 @@ * 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.3 1995/05/30 08:08:09 rgrimes 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_IPX 0x2b /* IPX Datagram (RFC1552) */ -#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_IPXCP 0x802b /* IPX Control Protocol (RFC1552) */ -#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]) +/* XXX this used to be self-contained. */ +#include <net/ppp_defs.h> +#include <net/if.h> /* * 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]; +#define PPP_MAXMTU 16384 /* Largest MTU we allow */ /* - * 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 */ @@ -140,9 +113,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_ */ diff --git a/sys/net/if_pppvar.h b/sys/net/if_pppvar.h index 196e54b..2ac4d8d 100644 --- a/sys/net/if_pppvar.h +++ b/sys/net/if_pppvar.h @@ -1,4 +1,5 @@ -/* $Id: if_pppvar.h,v 1.1 1994/12/15 22:28:09 paulus Exp $ */ +/* from Id: if_pppvar.h,v 1.1 1994/12/15 22:28:09 paulus Exp */ +/* $Id$ */ /* * if_pppvar.h - private structures and declarations for PPP. * @@ -53,21 +54,22 @@ */ struct ppp_softc { struct ifnet sc_if; /* network-visible interface */ - u_int sc_flags; /* control/status bits; see if_ppp.h */ +/*hi*/ u_int sc_flags; /* control/status bits; see if_ppp.h */ void *sc_devp; /* pointer to device-dep structure */ void (*sc_start) __P((struct ppp_softc *)); /* start output proc */ void (*sc_ctlp) __P((struct ppp_softc *)); /* rcvd control pkt */ void (*sc_relinq) __P((struct ppp_softc *)); /* relinquish ifunit */ + void (*sc_setmtu) __P((struct ppp_softc *)); /* set mtu */ short sc_mru; /* max receive unit */ pid_t sc_xfer; /* used in transferring unit */ - struct ifqueue sc_rawq; /* received packets */ - struct ifqueue sc_inq; /* queue of input packets for daemon */ - struct ifqueue sc_fastq; /* interactive output packet q */ +/*hi*/ struct ifqueue sc_rawq; /* received packets */ +/*net*/ struct ifqueue sc_inq; /* queue of input packets for daemon */ +/*net*/ struct ifqueue sc_fastq; /* interactive output packet q */ struct mbuf *sc_togo; /* output packet ready to go */ struct mbuf *sc_npqueue; /* output packets not to be sent yet */ struct mbuf **sc_npqtail; /* ptr to last next ptr in npqueue */ #ifdef VJC - struct vjcompress sc_comp; /* vjc control buffer */ + struct slcompress sc_comp; /* vjc control buffer */ #endif u_int sc_bytessent; /* count of octets sent */ u_int sc_bytesrcvd; /* count of octets received */ @@ -100,5 +102,7 @@ struct ppp_softc *pppalloc __P((pid_t pid)); void pppdealloc __P((struct ppp_softc *sc)); int pppioctl __P((struct ppp_softc *sc, int cmd, caddr_t data, int flag, struct proc *p)); +int pppoutput __P((struct ifnet *ifp, struct mbuf *m0, + struct sockaddr *dst, struct rtentry *rtp)); void ppppktin __P((struct ppp_softc *sc, struct mbuf *m, int lost)); struct mbuf *ppp_dequeue __P((struct ppp_softc *sc)); diff --git a/sys/net/ppp_comp.h b/sys/net/ppp_comp.h index e2579f8..c08bbb9 100644 --- a/sys/net/ppp_comp.h +++ b/sys/net/ppp_comp.h @@ -1,5 +1,5 @@ /* - * ppp-comp.h - Definitions for doing PPP packet compression. + * ppp_comp.h - Definitions for doing PPP packet compression. * * Copyright (c) 1994 The Australian National University. * All rights reserved. @@ -24,7 +24,8 @@ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, * OR MODIFICATIONS. * - * $Id: ppp-comp.h,v 1.7 1995/05/01 01:43:37 paulus Exp $ + * From: Id: ppp-comp.h,v 1.7 1995/05/01 01:43:37 paulus Exp + * $Id$ */ #ifndef _NET_PPP_COMP_H diff --git a/sys/net/ppp_defs.h b/sys/net/ppp_defs.h index 77f01bb..db3eda2 100644 --- a/sys/net/ppp_defs.h +++ b/sys/net/ppp_defs.h @@ -1,4 +1,5 @@ -/* $Id: ppp_defs.h,v 1.7 1995/08/10 06:49:35 paulus Exp $ */ +/* from Id: ppp_defs.h,v 1.7 1995/08/10 06:49:35 paulus Exp */ +/* $Id$ */ /* * ppp_defs.h - PPP definitions. @@ -54,10 +55,13 @@ * Protocol field values. */ #define PPP_IP 0x21 /* Internet Protocol */ +#define PPP_XNS 0x25 /* Xerox NS */ +#define PPP_IPX 0x2b /* IPX Datagram (RFC1552) */ #define PPP_VJC_COMP 0x2d /* VJ compressed TCP */ #define PPP_VJC_UNCOMP 0x2f /* VJ uncompressed TCP */ #define PPP_COMP 0xfd /* compressed packet */ #define PPP_IPCP 0x8021 /* IP Control Protocol */ +#define PPP_IPXCP 0x802b /* IPX Control Protocol (RFC1552) */ #define PPP_CCP 0x80fd /* Compression Control Protocol */ #define PPP_LCP 0xc021 /* Link Control Protocol */ #define PPP_PAP 0xc023 /* Password Authentication Protocol */ @@ -74,7 +78,7 @@ /* * A 32-bit unsigned integral type. */ -#if !defined(__BIT_TYPES_DEFINED__) && !defined(_BITYPES) +#if !defined(__BIT_TYPES_DEFINED__) && !defined(_BITYPES) && !defined(__FreeBSD__) #ifdef UINT32_T typedef UINT32_T u_int32_t; #else diff --git a/sys/net/ppp_tty.c b/sys/net/ppp_tty.c index 5ad17d2..d889873 100644 --- a/sys/net/ppp_tty.c +++ b/sys/net/ppp_tty.c @@ -70,7 +70,8 @@ * Paul Mackerras (paulus@cs.anu.edu.au). */ -/* $Id: ppp_tty.c,v 1.3 1995/08/16 01:36:40 paulus Exp $ */ +/* $Id$ */ +/* from Id: ppp_tty.c,v 1.3 1995/08/16 01:36:40 paulus Exp */ /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */ #include "ppp.h" @@ -90,7 +91,15 @@ #include <sys/tty.h> #include <sys/kernel.h> #include <sys/conf.h> -#include <sys/vnode.h> + +#undef KERNEL /* so that vnode.h does not try to include vnode_if.h */ +# include <sys/vnode.h> +#define KERNEL + +#ifdef i386 /* fiddle with the spl locking */ +# include <machine/spl.h> +# include <i386/isa/isa_device.h> +#endif #include <net/if.h> #include <net/if_types.h> @@ -99,14 +108,16 @@ #include <netinet/in.h> #include <netinet/in_systm.h> #include <netinet/ip.h> -#include <net/pppcompress.h> +#include <net/slcompress.h> #endif #include <net/ppp_defs.h> #include <net/if_ppp.h> #include <net/if_pppvar.h> -void pppasyncattach __P((void)); +void pppasyncattach __P((void *)); +PSEUDO_SET(pppasyncattach, ppp_tty); + 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)); @@ -120,6 +131,7 @@ static u_short pppfcs __P((u_short fcs, u_char *cp, int len)); static void pppasyncstart __P((struct ppp_softc *)); static void pppasyncctlp __P((struct ppp_softc *)); static void pppasyncrelinq __P((struct ppp_softc *)); +static void pppasyncsetmtu __P((struct ppp_softc *)); static void ppp_timeout __P((void *)); static void pppgetm __P((struct ppp_softc *sc)); static void pppdumpb __P((u_char *b, int l)); @@ -147,7 +159,7 @@ static void ppplogchar __P((struct ppp_softc *, int)); * Procedures for using an async tty interface for PPP. */ -/* This is a FreeBSD-2.0 kernel. */ +/* 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 */ @@ -161,16 +173,36 @@ static struct linesw pppdisc = { }; void -pppasyncattach() +pppasyncattach(dummy) + void *dummy; { +#ifdef i386 + int s; + + s = splhigh(); + + /* + * Make sure that the soft net "engine" cannot run while spltty code is + * active. The if_ppp.c code can walk down into b_to_q etc, and it is + * bad if the tty system was in the middle of another b_to_q... + */ + tty_imask |= SWI_NET_MASK; /* spltty() block spl[soft]net() */ + net_imask |= SWI_TTY_MASK; /* splimp() block splsofttty() */ + net_imask |= tty_imask; /* splimp() block spltty() */ + update_intr_masks(); + + splx(s); + printf("new masks: bio %x, tty %x, net %x\n", bio_imask, tty_imask, net_imask); +#endif + + /* register line discipline */ linesw[PPPDISC] = pppdisc; } -TEXT_SET(pseudo_set, pppasyncattach); - /* * Line specific open routine for async tty devices. * Attach the given tty to the first available ppp unit. + * Called from device open routine or ttioctl() at >= splsofttty() */ /* ARGSUSED */ int @@ -185,19 +217,24 @@ pppopen(dev, tp) if (error = suser(p->p_ucred, &p->p_acflag)) return (error); + s = spltty(); /* also netisr's, including NETISR_PPP */ + if (tp->t_line == PPPDISC) { sc = (struct ppp_softc *) tp->t_sc; - if (sc != NULL && sc->sc_devp == (void *) tp) + if (sc != NULL && sc->sc_devp == (void *) tp) { + splx(s); return (0); + } } - if ((sc = pppalloc(p->p_pid)) == NULL) + if ((sc = pppalloc(p->p_pid)) == NULL) { + splx(s); return ENXIO; + } if (sc->sc_relinq) (*sc->sc_relinq)(sc); /* get previous owner to relinquish the unit */ - s = splimp(); sc->sc_ilen = 0; sc->sc_m = NULL; bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); @@ -208,19 +245,33 @@ pppopen(dev, tp) sc->sc_start = pppasyncstart; sc->sc_ctlp = pppasyncctlp; sc->sc_relinq = pppasyncrelinq; + sc->sc_setmtu = pppasyncsetmtu; sc->sc_outm = NULL; pppgetm(sc); sc->sc_if.if_flags |= IFF_RUNNING; + sc->sc_if.if_baudrate = tp->t_ospeed; tp->t_sc = (caddr_t) sc; ttyflush(tp, FREAD | FWRITE); + + /* + * Pre-allocate cblocks to the "just right" amount. The 1 byte t_canq + * allocation helps avoid the need for select and/or FIONREAD. + * We also pass 1 byte tokens through t_canq... + */ + 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); + splx(s); return (0); } /* - * Line specific close routine. + * Line specific close routine, called from device close routine + * and from ttioctl at >= splsofttty(). * Detach the tty from the ppp unit. * Mimics part of ttyclose(). */ @@ -233,8 +284,10 @@ pppclose(tp, flag) struct mbuf *m; int s; - ttywflush(tp); - s = splimp(); /* paranoid; splnet probably ok */ + s = spltty(); /* also netisr's, including NETISR_PPP */ + ttyflush(tp, FREAD | FWRITE); + 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) { @@ -257,7 +310,7 @@ pppasyncrelinq(sc) { int s; - s = splimp(); + s = spltty(); /* also netisr's, including NETISR_PPP */ if (sc->sc_outm) { m_freem(sc->sc_outm); sc->sc_outm = NULL; @@ -274,7 +327,26 @@ pppasyncrelinq(sc) } /* + * This gets called from the upper layer to notify a mtu change + */ +static void +pppasyncsetmtu(sc) +register struct ppp_softc *sc; +{ + register struct tty *tp = (struct tty *) sc->sc_devp; + int s; + + s = spltty(); /* also netisr's, including NETISR_PPP */ + if (tp != NULL) + clist_alloc_cblocks(&tp->t_outq, sc->sc_if.if_mtu + PPP_HIWAT, + sc->sc_if.if_mtu + PPP_HIWAT); + splx(s); +} + +/* * Line specific (tty) read routine. + * called at no spl from the device driver in the response to user-level + * reads on the tty file descriptor (ie: pppd). */ int pppread(tp, uio, flag) @@ -293,7 +365,7 @@ pppread(tp, uio, flag) * Loop waiting for input, checking that nothing disasterous * happens in the meantime. */ - s = splimp(); + s = spltty(); /* also netisr's, including NETISR_PPP */ for (;;) { if (tp != (struct tty *) sc->sc_devp || tp->t_line != PPPDISC) { splx(s); @@ -301,7 +373,7 @@ pppread(tp, uio, flag) } if (sc->sc_inq.ifq_head != NULL) break; - if ((tp->t_state & TS_CONNECTED) == 0 && (tp->t_state & TS_ISOPEN)) { + if ((tp->t_state & TS_CONNECTED) == 0) { splx(s); return 0; /* end of file */ } @@ -332,6 +404,8 @@ pppread(tp, uio, flag) /* * Line specific (tty) write routine. + * called at no spl from the device driver in the response to user-level + * writes on the tty file descriptor (ie: pppd). */ int pppwrite(tp, uio, flag) @@ -342,7 +416,7 @@ pppwrite(tp, uio, flag) register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; struct mbuf *m, *m0, **mp; struct sockaddr dst; - int len, error; + int len, error, s; if ((tp->t_state & TS_CONNECTED) == 0) return 0; /* wrote 0 bytes */ @@ -353,10 +427,13 @@ pppwrite(tp, uio, flag) if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN || uio->uio_resid < PPP_HDRLEN) return (EMSGSIZE); + + s = spltty(); /* also netisr's, including NETISR_PPP */ for (mp = &m0; uio->uio_resid; mp = &m->m_next) { MGET(m, M_WAIT, MT_DATA); if ((*mp = m) == NULL) { m_freem(m0); + splx(s); return (ENOBUFS); } m->m_len = 0; @@ -367,6 +444,7 @@ pppwrite(tp, uio, flag) len = uio->uio_resid; if (error = uiomove(mtod(m, u_char *), len, uio)) { m_freem(m0); + splx(s); return (error); } m->m_len = len; @@ -375,7 +453,11 @@ pppwrite(tp, uio, flag) bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN); m0->m_data += PPP_HDRLEN; m0->m_len -= PPP_HDRLEN; - return (pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0)); + + /* call the upper layer to "transmit" it... */ + error = pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0); + splx(s); + return (error); } /* @@ -422,7 +504,7 @@ ppptioctl(tp, cmd, data, flag, p) case PPPIOCSXASYNCMAP: if (error = suser(p->p_ucred, &p->p_acflag)) break; - s = spltty(); + s = spltty(); /* also netisr's, including NETISR_PPP */ 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 */ @@ -506,30 +588,39 @@ pppasyncstart(sc) register struct tty *tp = (struct tty *) sc->sc_devp; int s; - s = splimp(); + s = spltty(); /* raise from splnet to spltty */ pppstart(tp); splx(s); } /* * This gets called when a received packet is placed on - * the inq. + * the inq. The pppd daemon is to be woken up to do a read(). */ static void pppasyncctlp(sc) struct ppp_softc *sc; { struct tty *tp; + int s; /* Put a placeholder byte in canq for ttselect()/ttnread(). */ + s = spltty(); /* raise from splnet to spltty */ tp = (struct tty *) sc->sc_devp; putc(0, &tp->t_canq); ttwakeup(tp); + splx(s); } /* * Start output on async tty interface. Get another datagram * to send from the interface queue and start sending it. + * + * Called from tty system at splsofttty() or spltty(). + * Called from the upper half at softnet, raised to spltty via asyncstart. + * + * Harmless to be called while the upper netisr code is preempted, but we + * do not want to be preempted by it again. */ int pppstart(tp) @@ -542,13 +633,15 @@ pppstart(tp) int n, s, ndone, done, idle; struct mbuf *m2; - if ((tp->t_state & TS_CONNECTED) == 0 - || sc == NULL || tp != (struct tty *) sc->sc_devp) { + if ((tp->t_state & TS_CONNECTED) == 0 + || sc == NULL || tp != (struct tty *) sc->sc_devp + || tp->t_line != PPPDISC) { if (tp->t_oproc != NULL) (*tp->t_oproc)(tp); return 0; } + s = spltty(); /* in case.. do not want netisrs to preempt us */ idle = 0; while (CCOUNT(&tp->t_outq) < PPP_HIWAT) { /* @@ -578,6 +671,7 @@ pppstart(tp) /* Calculate the FCS for the first mbuf's worth. */ sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len); + sc->sc_if.if_lastchange = time; } for (;;) { @@ -694,7 +788,7 @@ pppstart(tp) } /* - * Send anything that may be in the output queue. + * 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) @@ -709,6 +803,7 @@ pppstart(tp) timeout(ppp_timeout, (void *) sc, 1); sc->sc_flags |= SC_TIMEOUT; } + splx(s); return 0; } @@ -724,7 +819,7 @@ ppp_timeout(x) struct tty *tp = (struct tty *) sc->sc_devp; int s; - s = splimp(); + s = spltty(); /* also netisr's, including NETISR_PPP */ sc->sc_flags &= ~SC_TIMEOUT; pppstart(tp); splx(s); @@ -741,7 +836,7 @@ pppgetm(sc) int len; int s; - s = splimp(); + s = spltty(); /* also netisr's, including NETISR_PPP */ mp = &sc->sc_m; for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){ if ((m = *mp) == NULL) { @@ -765,6 +860,11 @@ static unsigned paritytab[8] = { 0x69969669, 0x96696996, 0x96696996, 0x69969669 }; +/* + * Called when character is available from device driver. + * Only guaranteed to be at splsofttty() or spltty() + * This is safe to be called while the upper half's netisr is preempted. + */ int pppinput(c, tp) int c; @@ -778,18 +878,25 @@ pppinput(c, tp) if (sc == NULL || tp != (struct tty *) sc->sc_devp) return 0; - s = spltty(); + s = spltty(); /* also netisr's, including NETISR_PPP */ ++tk_nin; ++sc->sc_bytesrcvd; - if (c & TTY_FE) { + 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) { /* 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); + printf("ppp%d: line error %x\n", sc->sc_if.if_unit, + c & TTY_ERRORMASK); goto flush; } - c &= 0xff; + c &= TTY_CHARMASK; if (c & 0x80) sc->sc_flags |= SC_RCV_B7_1; |
