From: Paul Mackerras Date: Mon, 21 Nov 1994 04:50:36 +0000 (+0000) Subject: Initial revision X-Git-Tag: RELEASE_2_3_6~823 X-Git-Url: https://git.ozlabs.org/?p=ppp.git;a=commitdiff_plain;h=6a84744492d24866cfaeb2b4a5c75e2ceef6721f;hp=41c8ffa6a890e3fa0f65ba266800d065d445c1ad Initial revision --- diff --git a/ultrix/if_ppp.c b/ultrix/if_ppp.c new file mode 100644 index 0000000..82d7d6c --- /dev/null +++ b/ultrix/if_ppp.c @@ -0,0 +1,1945 @@ +/* + * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver. + * + * Copyright (c) 1989 Carnegie Mellon University. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by Carnegie Mellon University. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * 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. + * + * Drew D. Perkins + * Carnegie Mellon University + * 4910 Forbes Ave. + * Pittsburgh, PA 15213 + * (412) 268-8576 + * ddp@andrew.cmu.edu + * + * Based on: + * @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89 + * + * Copyright (c) 1987 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * 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. + * + * Serial Line interface + * + * Rick Adams + * Center for Seismic Studies + * 1300 N 17th Street, Suite 1450 + * Arlington, Virginia 22209 + * (703)276-7900 + * rick@seismo.ARPA + * seismo!rick + * + * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris). + * Converted to 4.3BSD Beta by Chris Torek. + * Other changes made at Berkeley, based in part on code by Kirk Smith. + * + * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com) + * Added VJ tcp header compression; more unified ioctls + * + * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au). + * Cleaned up a lot of the mbuf-related code to fix bugs that + * caused system crashes and packet corruption. Changed pppstart + * so that it doesn't just give up with a collision if the whole + * packet doesn't fit in the output ring buffer. + * + * Added priority queueing for interactive IP packets, following + * the model of if_sl.c, plus hooks for bpf. + * Paul Mackerras (paulus@cs.anu.edu.au). + * + * Ultrix port by Per Sundstrom , + * Robert Olsson and Paul Mackerras. + */ + +/* $Id: if_ppp.c,v 1.1 1994/11/21 04:50:03 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 "../h/param.h" +#include "../h/user.h" +#include "../h/proc.h" +#include "../h/mbuf.h" +#include "../h/buf.h" +#include "../h/socket.h" +#include "../h/ioctl.h" +#include "../h/file.h" +#include "../h/tty.h" +#include "../h/kernel.h" +#include "../h/conf.h" +#include "../h/uio.h" +#include "../h/systm.h" + +#include "../net/net/if.h" +#include "../net/net/netisr.h" +#include "../net/net/route.h" +#if INET +#include "../net/netinet/in.h" +#include "../net/netinet/in_systm.h" +#include "../net/netinet/in_var.h" +#include "../net/netinet/ip.h" +#endif + +#ifdef VJC +#include "slcompress.h" +#endif + +#include "ppp_defs.h" +#include "if_ppp.h" +#include "if_pppvar.h" + +#ifdef PPP_COMPRESS +#define PACKET struct mbuf +#include "ppp-comp.h" +#endif + +/* + * This is an Ultrix kernel, we've got clists. + */ +#define CCOUNT(q) ((q)->c_cc) + +#define t_sc T_LINEP +#define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on que */ + +void pppattach __P((void)); +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 *ifp, struct mbuf *m0, + struct sockaddr *dst)); +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 void ppp_ccp_closed __P((struct ppp_softc *)); +static int ppp_ccp __P((struct ppp_softc *, struct mbuf *m, int rcvd)); +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 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_off > MMAXOFF) + +#define M_TRAILINGSPACE(m) \ + ((M_IS_CLUSTER(m) ? (u_int)(m)->m_clptr + M_CLUSTERSZ : MSIZE) \ + - ((m)->m_off + (m)->m_len)) + +#define M_OFFSTART(m) \ + (M_IS_CLUSTER(m) ? (u_int)(m)->m_clptr : MMINOFF) + +#define M_DATASIZE(m) \ + (M_IS_CLUSTER(m) ? M_CLUSTERSZ : 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. + */ +static u_short interactive_ports[8] = { + 0, 513, 0, 0, + 0, 21, 0, 23, +}; +#define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p)) + +/* + * Does c need to be escaped? + */ +#define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F))) + +#ifdef PPP_COMPRESS +/* + * List of compressors we know about. + */ + +extern struct compressor ppp_bsd_compress; + +struct compressor *ppp_compressors[] = { + &ppp_bsd_compress, + NULL +}; +#endif /* PPP_COMPRESS */ + +/* + * Called from boot code to establish ppp interfaces. + */ +void +pppattach() +{ + register struct ppp_softc *sc; + register int i = 0; + + for (sc = ppp_softc; i < NPPP; sc++) { + sc->sc_if.if_name = "ppp"; + sc->sc_if.if_unit = i++; + sc->sc_if.if_mtu = PPP_MTU; + sc->sc_if.if_flags = IFF_POINTOPOINT; + sc->sc_if.if_type = IFT_PPP; + sc->sc_if.if_ioctl = pppioctl; + 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; + if_attach(&sc->sc_if); +#if NBPFILTER > 0 + bpfattach(&sc->sc_bpf, &sc->sc_if, DLT_PPP, PPP_HDRLEN); +#endif + } +} + +/* + * Allocate a ppp interface unit and initialize it. + */ +struct ppp_softc * +pppalloc(pid) + pid_t pid; +{ + 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; + } + if (nppp >= NPPP) + 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; +#ifdef VJC + sl_compress_init(&sc->sc_comp); +#endif +#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_if.if_flags |= IFF_RUNNING; + + return sc; +} + +/* + * Deallocate a ppp unit. + */ +pppdealloc(sc) + struct ppp_softc *sc; +{ + struct mbuf *m; + + if_down(&sc->sc_if); + sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING); + sc->sc_devp = NULL; + sc->sc_xfer = 0; + for (;;) { + IF_DEQUEUE(&sc->sc_inq, m); + if (m == NULL) + break; + m_freem(m); + } + for (;;) { + IF_DEQUEUE(&sc->sc_fastq, m); + if (m == NULL) + break; + m_freem(m); + } +#ifdef PPP_COMPRESS + ppp_ccp_closed(sc); + sc->sc_xc_state = NULL; + sc->sc_rc_state = NULL; +#endif /* PPP_COMPRESS */ +} + +/* + * 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; +{ + register struct ppp_softc *sc; + int error, s, i; + struct proc *p = u.u_procp; + + if (!suser()) + return EPERM; + + 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; + } + + pppgetm(sc); + + sc->sc_ilen = 0; + bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); + sc->sc_asyncmap[0] = 0xffffffff; + sc->sc_asyncmap[3] = 0x60000000; + sc->sc_rasyncmap = 0; + sc->sc_devp = (void *) tp; + sc->sc_start = pppasyncstart; + + tp->t_sc = (caddr_t) sc; + ttyflush(tp, FREAD | FWRITE); + + return (0); +} + +/* + * Line specific close routine. + * Detach the tty from the ppp unit. + * Mimics part of ttyclose(). + */ +int +pppclose(tp, flag) + struct tty *tp; + int flag; +{ + register struct ppp_softc *sc; + struct mbuf *m; + int s; + + ttywflush(tp); + s = splimp(); /* paranoid; splnet probably ok */ + tp->t_line = 0; + sc = (struct ppp_softc *)tp->t_sc; + if (sc != NULL) { + tp->t_sc = NULL; + if (tp == (struct tty *) sc->sc_devp) { + m_freem(sc->sc_outm); + sc->sc_outm = NULL; + m_freem(sc->sc_m); + sc->sc_m = NULL; + pppdealloc(sc); + } + } + splx(s); + return 0; +} + +/* + * Line specific (tty) read routine. + */ +int +pppread(tp, uio, flag) + register struct tty *tp; + struct uio *uio; + int flag; +{ + register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; + struct mbuf *m, *m0; + register int s; + int error = 0; + + if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) + return 0; /* end of file */ + if (sc == NULL || tp != (struct tty *) sc->sc_devp) + return 0; + s = splimp(); + while (sc->sc_inq.ifq_head == NULL && tp->t_line == PPPDISC) { + if (tp->t_state & (TS_ASYNC | TS_NBIO)) { + splx(s); + return (EWOULDBLOCK); + } + sleep((caddr_t) &tp->t_rawq, TTIPRI); + } + if (tp->t_line != PPPDISC) { + splx(s); + return (-1); + } + + /* 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_READ, uio)) + break; + m_freem(m0); + return (error); +} + +/* + * Line specific (tty) write routine. + */ +int +pppwrite(tp, uio, flag) + register struct tty *tp; + struct uio *uio; + int flag; +{ + register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; + struct mbuf *m, *m0, **mp, *p; + struct sockaddr dst; + int len, error; + + if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) + return 0; /* wrote 0 bytes */ + if (tp->t_line != PPPDISC) + return (EINVAL); + if (sc == NULL || tp != (struct tty *) sc->sc_devp) + return EIO; + if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN || + uio->uio_resid < PPP_HDRLEN) + return (EMSGSIZE); + for (mp = &m0; uio->uio_resid; mp = &m->m_next) { + MGET(m, M_WAIT, MT_DATA); + if ((*mp = m) == NULL) { + m_freem(m0); + return (ENOBUFS); + } + if (uio->uio_resid >= CLBYTES / 2) { + MCLGET(m, p); + } else + m->m_len = MLEN; + len = MIN(m->m_len, uio->uio_resid); + if (error = uiomove(mtod(m, u_char *), len, UIO_WRITE, uio)) { + m_freem(m0); + return (error); + } + m->m_len = len; + } + dst.sa_family = AF_UNSPEC; + bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN); + m0->m_off += PPP_HDRLEN; + m0->m_len -= PPP_HDRLEN; + return (pppoutput(&sc->sc_if, m0, &dst)); +} + +/* + * 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) + struct tty *tp; + caddr_t data; + int cmd, flag; +{ + register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; + struct proc *p = u.u_procp; + int s, error, flags, mru, nb, npx; + struct ppp_option_data *odp; + struct compressor **cp; + struct npioctl *npi; + u_char ccp_option[CCP_MAX_OPTION_LENGTH]; + + if (sc == NULL || tp != (struct tty *) sc->sc_devp) + return -1; + + switch (cmd) { + case FIONREAD: + *(int *)data = sc->sc_inq.ifq_len; + break; + + case PPPIOCGUNIT: + *(int *)data = sc->sc_if.if_unit; + break; + + case PPPIOCGFLAGS: + *(u_int *)data = sc->sc_flags; + break; + + case PPPIOCSFLAGS: + if (!suser()) + return EPERM; + flags = *(int *)data & SC_MASK; + s = splimp(); + if (sc->sc_flags & SC_CCP_OPEN && !(flags & SC_CCP_OPEN)) + ppp_ccp_closed(sc); + sc->sc_flags = (sc->sc_flags & ~SC_MASK) | flags; + splx(s); + break; + + case PPPIOCSASYNCMAP: + if (!suser()) + return EPERM; + sc->sc_asyncmap[0] = *(u_int *)data; + break; + + case PPPIOCGASYNCMAP: + *(u_int *)data = sc->sc_asyncmap[0]; + break; + + case PPPIOCSRASYNCMAP: + if (!suser()) + return EPERM; + sc->sc_rasyncmap = *(u_int *)data; + break; + + case PPPIOCGRASYNCMAP: + *(u_int *)data = sc->sc_rasyncmap; + break; + + case PPPIOCSXASYNCMAP: + if (!suser()) + return EPERM; + 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 (!suser()) + return EPERM; + mru = *(int *)data; + if (mru >= PPP_MRU && mru <= PPP_MAXMRU) { + sc->sc_mru = mru; + pppgetm(sc); + } + break; + + case PPPIOCGMRU: + *(int *)data = sc->sc_mru; + break; + +#ifdef VJC + case PPPIOCSMAXCID: + if (!suser()) + return EPERM; + sl_compress_setup(&sc->sc_comp, *(int *)data); + break; +#endif + + case PPPIOCXFERUNIT: + if (!suser()) + return EPERM; + sc->sc_xfer = p->p_pid; + break; + +#ifdef PPP_COMPRESS + case PPPIOCSCOMPRESS: + if (!suser()) + return EPERM; + odp = (struct ppp_option_data *) data; + nb = odp->length; + if (nb > sizeof(ccp_option)) + nb = sizeof(ccp_option); + if (error = copyin(odp->ptr, ccp_option, nb)) + return (error); + if (ccp_option[1] < 2) /* preliminary check on the length byte */ + return (EINVAL); + for (cp = ppp_compressors; *cp != NULL; ++cp) + if ((*cp)->compress_proto == ccp_option[0]) { + /* + * Found a handler for the protocol - try to allocate + * a compressor or decompressor. + */ + error = 0; + s = splimp(); + if (odp->transmit) { + if (sc->sc_xc_state != NULL) + (*sc->sc_xcomp->comp_free)(sc->sc_xc_state); + sc->sc_xcomp = *cp; + sc->sc_xc_state = (*cp)->comp_alloc(ccp_option, nb); + if (sc->sc_xc_state == NULL) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: comp_alloc failed\n", + sc->sc_if.if_unit); + error = ENOBUFS; + } + sc->sc_flags &= ~SC_COMP_RUN; + } else { + if (sc->sc_rc_state != NULL) + (*sc->sc_rcomp->decomp_free)(sc->sc_rc_state); + sc->sc_rcomp = *cp; + sc->sc_rc_state = (*cp)->decomp_alloc(ccp_option, nb); + if (sc->sc_rc_state == NULL) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: decomp_alloc failed\n", + sc->sc_if.if_unit); + error = ENOBUFS; + } + 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 (!suser()) + return EPERM; + if (npi->mode != sc->sc_npmode[npx]) { + s = splimp(); + sc->sc_npmode[npx] = npi->mode; + if (npi->mode != NPMODE_QUEUE) + (*sc->sc_start)(sc); + splx(s); + } + } + break; + + default: + return (-1); + } + return (0); +} + +/* + * 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. + */ +static u_short +pppfcs(fcs, cp, len) + register u_short fcs; + register u_char *cp; + register int len; +{ + while (len--) + fcs = PPP_FCS(fcs, *cp++); + return (fcs); +} + +/* + * Queue a packet. Start transmission if not active. + * Packet is placed in Information field of PPP frame. + */ +int +pppoutput(ifp, m0, dst) + struct ifnet *ifp; + struct mbuf *m0; + struct sockaddr *dst; +{ + register struct ppp_softc *sc = &ppp_softc[ifp->if_unit]; + struct ppp_header *ph; + int protocol, address, control; + u_char *cp; + 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) { + error = ENETDOWN; /* sort of */ + goto bad; + } + + /* + * Compute PPP header. + */ + ifq = &ifp->if_snd; + switch (dst->sa_family) { +#ifdef INET + case AF_INET: + address = PPP_ALLSTATIONS; + control = PPP_UI; + protocol = PPP_IP; + 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 ((ip = mtod(m0, struct ip *))->ip_p == IPPROTO_TCP) { + register int p = ntohl(((int *)ip)[ip->ip_hl]); + if (INTERACTIVE(p & 0xffff) || INTERACTIVE(p >> 16)) + ifq = &sc->sc_fastq; + } + break; +#endif + case AF_UNSPEC: + 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); + error = EAFNOSUPPORT; + goto bad; + } + + /* + * 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. + */ + if (M_IS_CLUSTER(m0) || m0->m_off < MMINOFF + PPP_HDRLEN) { + struct mbuf *m; + + MGET(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + m_freem(m0); + return (ENOBUFS); + } + m->m_len = 0; + m->m_next = m0; + m0 = m; + } else + m0->m_off -= PPP_HDRLEN; + + cp = mtod(m0, u_char *); + *cp++ = address; + *cp++ = control; + *cp++ = protocol >> 8; + *cp++ = protocol & 0xff; + m0->m_len += PPP_HDRLEN; + + if (sc->sc_flags & SC_LOG_OUTPKT) { + printf("ppp%d output: ", ifp->if_unit); + pppdumpm(m0, -1); + } + +#if NBPFILTER > 0 + /* + * See if bpf wants to look at the packet. + */ + if (sc->sc_bpf) + bpf_mtap(sc->sc_bpf, m0); +#endif + + /* + * 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; + } + IF_ENQUEUE(ifq, m0); + + /* + * Tell the device to send it out. + */ + if (mode == NPMODE_PASS) + (*sc->sc_start)(sc); + + splx(s); + return (0); + +bad: + m_freem(m0); + return (error); +} + +/* + * Grab another packet off a queue and apply VJ compression, + * packet compression, address/control and/or protocol compression + * if enabled. + */ +struct mbuf * +ppp_dequeue(sc) + struct ppp_softc *sc; +{ + int s; + struct mbuf *m, *mp, **mpp; + u_char *cp; + int address, control, protocol; + struct ifqueue *ifq; + enum NPmode mode; + + s = splimp(); + + /* + * Scan through the send queues looking for a packet + * which can be sent: first the fast queue, then the normal queue. + */ + ifq = &sc->sc_fastq; + for (;;) { + mpp = &ifq->ifq_head; + mp = NULL; + while ((m = *mpp) != NULL) { + switch (PPP_PROTOCOL(mtod(m, u_char *))) { + case PPP_IP: + mode = sc->sc_npmode[NP_IP]; + break; + default: + mode = NPMODE_PASS; + } + if (mode == NPMODE_PASS) + break; + switch (mode) { + case NPMODE_DROP: + case NPMODE_ERROR: + *mpp = m->m_nextpkt; + m_freem(m); + break; + case NPMODE_QUEUE: + mpp = &m->m_nextpkt; + mp = m; + break; + } + } + if (m != NULL) + break; + + if (ifq == &sc->sc_if.if_snd) + break; + /* Finished the fast queue; do the normal queue. */ + ifq = &sc->sc_if.if_snd; + } + + if (m == NULL) { + splx(s); + return NULL; + } + + if ((*mpp = m->m_nextpkt) == NULL) + ifq->ifq_tail = mp; + m->m_nextpkt = NULL; + --ifq->ifq_len; + + splx(s); + + /* + * Extract the ppp header of the new packet. + * The ppp header will be in one mbuf. + */ + cp = mtod(m, u_char *); + address = PPP_ADDRESS(cp); + control = PPP_CONTROL(cp); + protocol = PPP_PROTOCOL(cp); + + switch (protocol) { +#ifdef VJC + case PPP_IP: + /* + * 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 */ + } + } + break; +#endif /* VJC */ + +#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; + 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 /* PPP_COMPRESS */ + + /* + * Compress the address/control and protocol, if possible. + */ + if (sc->sc_flags & SC_COMP_AC && address == PPP_ALLSTATIONS && + control == PPP_UI && protocol != PPP_ALLSTATIONS && + protocol != PPP_LCP) { + /* can compress address/control */ + m->m_off += 2; + m->m_len -= 2; + } + if (sc->sc_flags & SC_COMP_PROT && protocol < 0xFF) { + /* can compress protocol */ + if (mtod(m, u_char *) == cp) { + cp[2] = cp[1]; /* move address/control up */ + cp[1] = cp[0]; + } + ++m->m_off; + --m->m_len; + } + + return m; +} + +#ifdef PPP_COMPRESS +/* + * Handle a CCP packet. `rcvd' is 1 if the packet was received, + * 0 if it is about to be transmitted. + */ +static int +ppp_ccp(sc, m, rcvd) + struct ppp_softc *sc; + struct mbuf *m; + int rcvd; +{ + u_char *dp, *ep; + struct mbuf *mp; + int slen; + struct bsd_db *db; + + /* + * 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; + } + + 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; + } + + 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) + sc->sc_flags &= ~(SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN); + break; + + 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, sc->sc_flags & SC_DEBUG)) { + sc->sc_flags |= SC_COMP_RUN; + } + } 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, sc->sc_mru, + sc->sc_flags & SC_DEBUG)) { + sc->sc_flags |= SC_DECOMP_RUN; + sc->sc_flags &= ~(SC_DC_ERROR | SC_DC_FERROR); + } + } + } + break; + + 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); + sc->sc_flags &= ~SC_DC_ERROR; + } + } + } + break; + } +} + +/* + * CCP is down; free (de)compressor state if necessary. + */ +void +ppp_ccp_closed(sc) + struct ppp_softc *sc; +{ + 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_COMRPESS */ + +/* + * This gets called from pppoutput when a new packet is + * put on a queue. + */ +static +pppasyncstart(sc) + register struct ppp_softc *sc; +{ + register struct tty *tp = (struct tty *) sc->sc_devp; + + pppstart(tp); +} + +/* + * 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, s, ndone, done; + struct mbuf *m2; + + if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) { + /* sorry, I can't talk now */ + return; + } + if (sc == NULL || tp != (struct tty *) sc->sc_devp) { + (*tp->t_oproc)(tp); + return; + } + + for (;;) { + /* + * If there is more in the output queue, just send it now. + * We are being called in lieu of ttstart and must do what + * it would. + */ + if (CCOUNT(&tp->t_outq) != 0 && tp->t_oproc != NULL) { + (*tp->t_oproc)(tp); + if (CCOUNT(&tp->t_outq) > PPP_HIWAT) + return; + } + + /* + * See if we have an existing packet partly sent. + * If not, get a new packet and start sending it. + */ + m = sc->sc_outm; + if (m == NULL) { + /* + * Get another packet to be sent. + */ + m = ppp_dequeue(sc); + if (m == NULL) + return; + + /* + * The extra PPP_FLAG will start up a new packet, and thus + * will flush any accumulated garbage. We do this whenever + * the line may have been idle for some time. + */ + if (CCOUNT(&tp->t_outq) == 0) { + ++sc->sc_bytessent; + (void) putc(PPP_FLAG, &tp->t_outq); + } + + /* Calculate the FCS for the first mbuf's worth. */ + sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len); + } + + 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) { + 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 */ + } + /* + * 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--; + } + } + /* + * 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; + } + } + + if (!done) { + m->m_off += m->m_len - len; + m->m_len = len; + sc->sc_outm = m; + if (tp->t_oproc != NULL) + (*tp->t_oproc)(tp); + return; /* can't do any more at the moment */ + } + + /* 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++; + } +} + +/* + * Allocate enough mbuf to handle current MRU. + */ +static int +pppgetm(sc) + register struct ppp_softc *sc; +{ + struct mbuf *m, **mp, *p; + int len; + int s; + + s = splimp(); + mp = &sc->sc_m; + for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){ + if ((m = *mp) == NULL) { + MGET(m, M_DONTWAIT, MT_DATA); + if (m == NULL) + break; + *mp = m; + MCLGET(m, p); + } + len -= M_DATASIZE(m); + mp = &m->m_next; + } + splx(s); + return len <= 0; +} + +/* + * 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. The return value is 1 if the packet was put on + * sc->sc_inq, 0 otherwise. + */ +#define COMPTYPE(proto) ((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: \ + TYPE_UNCOMPRESSED_TCP) + +int +ppppktin(sc, m) + struct ppp_softc *sc; + struct mbuf *m; +{ + struct ifqueue *inq, *lock; + int s, ilen, xlen, proto, rv; + u_char *cp, adrs, ctrl; + struct mbuf *mp, *dmp, *pc; + u_char *iphdr; + u_int hlen; + + sc->sc_if.if_ipackets++; + rv = 0; + + cp = mtod(m, u_char *); + adrs = PPP_ADDRESS(cp); + ctrl = PPP_CONTROL(cp); + proto = PPP_PROTOCOL(cp); + +#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 (dmp != NULL) { + m_freem(m); + m = dmp; + cp = mtod(m, u_char *); + proto = PPP_PROTOCOL(cp); + + } else { + /* 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); + sc->sc_flags |= SC_VJ_RESET; + switch (rv) { + case DECOMP_OK: + /* no error, but no decompressed packet produced */ + m_freem(m); + return 0; + case DECOMP_ERROR: + sc->sc_flags |= SC_DC_ERROR; + break; + case DECOMP_FATALERROR: + sc->sc_flags |= SC_DC_FERROR; + break; + } + } + + } 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 we've missed a packet, we must toss subsequent compressed + * packets which don't have an explicit connection ID. + */ + if (sc->sc_flags & SC_VJ_RESET) { + sl_uncompress_tcp(NULL, 0, TYPE_ERROR, &sc->sc_comp); + sc->sc_flags &= ~SC_VJ_RESET; + } + + /* + * See if we have a VJ-compressed packet to uncompress. + */ + if (proto == PPP_VJC_COMP) { + 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_COMPRESSED_TCP, + &sc->sc_comp, &iphdr, &hlen); + + if (xlen <= 0) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: VJ uncompress failed on type comp\n", + sc->sc_if.if_unit); + goto bad; + } + + /* Copy the PPP and IP headers into a new mbuf. */ + MGET(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, pc); + 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_off += PPP_HDRLEN + xlen; + m->m_len -= PPP_HDRLEN + xlen; + if (m->m_len <= M_TRAILINGSPACE(mp)) { + bcopy(mtod(m, u_char *), mtod(mp, u_char *) + mp->m_len, m->m_len); + mp->m_len += m->m_len; + MFREE(m, mp->m_next); + } else + mp->m_next = m; + m = mp; + ilen += hlen - xlen; + + } else if (proto == PPP_VJC_UNCOMP) { + if (sc->sc_flags & SC_REJ_COMP_TCP) + goto bad; + + 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: VJ uncompress failed on type uncomp\n", + sc->sc_if.if_unit); + goto bad; + } + + proto = PPP_IP; + cp[3] = PPP_IP; + } +#endif /* VJC */ + + /* + * If the packet will fit in an ordinary mbuf, don't waste a + * whole cluster on it. + */ + if (ilen <= MLEN && M_IS_CLUSTER(m)) { + MGET(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; + } + } + +#if NBPFILTER > 0 + /* See if bpf wants to look at the packet. */ + if (sc->sc_bpf) + bpf_mtap(sc->sc_bpf, m); +#endif + + switch (proto) { +#ifdef INET + case PPP_IP: + /* + * IP packet - take off the ppp header and pass it up to IP. + */ + if ((sc->sc_if.if_flags & IFF_UP) == 0 + || sc->sc_npmode[NP_IP] != NPMODE_PASS) { + /* interface is down - drop the packet. */ + m_freem(m); + return 0; + } + m->m_off += PPP_HDRLEN; + m->m_len -= PPP_HDRLEN; + schednetisr(NETISR_IP); + inq = &ipintrq; + break; +#endif + + default: + /* + * Some other protocol - place on input queue for read(). + */ + inq = &sc->sc_inq; + rv = 1; + break; + } + + /* + * Put the packet on the appropriate input queue. + */ + s = splimp(); + lock = inq; + smp_lock(&lock->lk_ifqueue, LK_RETRY); + if (IF_QFULL(inq)) { + IF_DROP(inq); + /* XXX should we unlock here? */ + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: queue full\n", sc->sc_if.if_unit); + sc->sc_if.if_ierrors++; + m_freem(m); + rv = 0; + } else { + IF_ENQUEUEIF(inq, m, &sc->sc_if); + smp_unlock(&lock->lk_ifqueue); + } + + splx(s); + return rv; + + bad: + m_freem(m); + sc->sc_if.if_ierrors++; + return 0; +} + +/* + * 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; + + sc->sc_bytesrcvd++; + + c &= 0xff; + + if (c & 0x80) + sc->sc_flags |= SC_RCV_B7_1; + else + sc->sc_flags |= SC_RCV_B7_0; + if (paritytab[c >> 5] & (1 << (c & 0x1F))) + sc->sc_flags |= SC_RCV_ODDP; + else + sc->sc_flags |= SC_RCV_EVNP; + + if (sc->sc_flags & SC_LOG_RAWIN) + ppplogchar(sc, c); + + if (c == PPP_FLAG) { + ilen = sc->sc_ilen; + sc->sc_ilen = 0; + + 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) { + sc->sc_flags |= SC_VJ_RESET; + if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){ + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: bad fcs %x\n", sc->sc_if.if_unit, + sc->sc_fcs); + sc->sc_if.if_ierrors++; + } else + sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED); + return; + } + + if (ilen < PPP_HDRLEN + PPP_FCSLEN) { + if (ilen) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen); + sc->sc_if.if_ierrors++; + } + return; + } + + /* + * Remove FCS trailer. Somewhat painful... + */ + ilen -= 2; + if (--sc->sc_mc->m_len == 0) { + for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next) + ; + sc->sc_mc = m; + } + sc->sc_mc->m_len--; + + /* excise this mbuf chain */ + m = sc->sc_m; + sc->sc_m = sc->sc_mc->m_next; + sc->sc_mc->m_next = NULL; + + 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)) { + /* Put a placeholder byte in canq for ttselect()/ttnread(). */ + putc(0, &tp->t_canq); + ttwakeup(tp); + } + + pppgetm(sc); + return; + } + + if (sc->sc_flags & SC_FLUSH) { + if (sc->sc_flags & SC_LOG_FLUSH) + ppplogchar(sc, c); + return; + } + + if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) + return; + + if (sc->sc_flags & SC_ESCAPED) { + sc->sc_flags &= ~SC_ESCAPED; + c ^= PPP_TRANS; + } else if (c == PPP_ESCAPE) { + sc->sc_flags |= SC_ESCAPED; + return; + } + + /* + * Initialize buffer on first octet received. + * First octet could be address or protocol (when compressing + * address/control). + * Second octet is control. + * Third octet is first or second (when compressing protocol) + * octet of protocol. + * Fourth octet is second octet of protocol. + */ + if (sc->sc_ilen == 0) { + /* reset the first input mbuf */ + if (sc->sc_m == NULL) { + pppgetm(sc); + if (sc->sc_m == NULL) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit); + goto flush; + } + } + m = sc->sc_m; + m->m_len = 0; + m->m_off = M_OFFSTART(m); + 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) { + if (m->m_next == NULL) { + pppgetm(sc); + if (m->m_next == NULL) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit); + goto flush; + } + } + sc->sc_mc = m = m->m_next; + m->m_len = 0; + m->m_off = M_OFFSTART(m); + sc->sc_mp = mtod(m, char *); + } + + ++m->m_len; + *sc->sc_mp++ = c; + sc->sc_fcs = PPP_FCS(sc->sc_fcs, c); + return; + + flush: + if (!(sc->sc_flags & SC_FLUSH)) { + sc->sc_if.if_ierrors++; + sc->sc_flags |= SC_FLUSH; + if (sc->sc_flags & SC_LOG_FLUSH) + ppplogchar(sc, c); + } +} + +/* + * Process an ioctl request to interface. + */ +int +pppioctl(ifp, cmd, data) + register struct ifnet *ifp; + int cmd; + caddr_t data; +{ + struct proc *p = u.u_procp; + 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; + 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 (!suser()) + return EPERM; + sc->sc_if.if_mtu = ifr->ifr_mtu; + break; + + case SIOCGIFMTU: + ifr->ifr_mtu = sc->sc_if.if_mtu; + 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 */ +#ifdef PPP_COMPRESS + if (sc->sc_xc_state != NULL) + (*sc->sc_xcomp->comp_stat)(sc->sc_xc_state, &psp->c); + if (sc->sc_rc_state != NULL) + (*sc->sc_rcomp->decomp_stat)(sc->sc_rc_state, &psp->d); +#endif /* PPP_COMPRESS */ + break; + + default: + error = EINVAL; + } + splx(s); + return (error); +} + +#define MAX_DUMP_BYTES 128 + +static void +pppdumpm(m0, pktlen) + 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) { + int l = m->m_len; + u_char *rptr = mtod(m, u_char *); + + if (pktlen > 0) { + if (l > pktlen) + l = pktlen; + pktlen -= l; + } + while (l--) { + if (bp > buf + sizeof(buf) - 4) + goto done; + *bp++ = digits[*rptr >> 4]; /* convert byte to ascii hex */ + *bp++ = digits[*rptr++ & 0xf]; + } + + if (m->m_next) { + if (bp > buf + sizeof(buf) - 3) + goto done; + *bp++ = '|'; + } else + *bp++ = ' '; + } +done: + if (m && pktlen) + *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/ultrix/ppp_tty.c b/ultrix/ppp_tty.c new file mode 100644 index 0000000..d5e6fda --- /dev/null +++ b/ultrix/ppp_tty.c @@ -0,0 +1,918 @@ +/* + * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver. + * + * Copyright (c) 1989 Carnegie Mellon University. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by Carnegie Mellon University. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * 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. + * + * Drew D. Perkins + * Carnegie Mellon University + * 4910 Forbes Ave. + * Pittsburgh, PA 15213 + * (412) 268-8576 + * ddp@andrew.cmu.edu + * + * Based on: + * @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89 + * + * Copyright (c) 1987 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * 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. + * + * Serial Line interface + * + * Rick Adams + * Center for Seismic Studies + * 1300 N 17th Street, Suite 1450 + * Arlington, Virginia 22209 + * (703)276-7900 + * rick@seismo.ARPA + * seismo!rick + * + * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris). + * Converted to 4.3BSD Beta by Chris Torek. + * Other changes made at Berkeley, based in part on code by Kirk Smith. + * + * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com) + * Added VJ tcp header compression; more unified ioctls + * + * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au). + * Cleaned up a lot of the mbuf-related code to fix bugs that + * caused system crashes and packet corruption. Changed pppstart + * so that it doesn't just give up with a collision if the whole + * packet doesn't fit in the output ring buffer. + * + * Added priority queueing for interactive IP packets, following + * the model of if_sl.c, plus hooks for bpf. + * Paul Mackerras (paulus@cs.anu.edu.au). + * + * Ultrix port by Per Sundstrom , + * Robert Olsson and Paul Mackerras. + */ + +/* $Id: ppp_tty.c,v 1.1 1994/11/21 04:50:36 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 "../h/param.h" +#include "../h/user.h" +#include "../h/proc.h" +#include "../h/mbuf.h" +#include "../h/buf.h" +#include "../h/socket.h" +#include "../h/ioctl.h" +#include "../h/file.h" +#include "../h/tty.h" +#include "../h/kernel.h" +#include "../h/conf.h" +#include "../h/uio.h" +#include "../h/systm.h" + +#include "../net/net/if.h" + +#ifdef VJC +#include "../net/netinet/in.h" +#include "../net/netinet/in_systm.h" +#include "../net/netinet/ip.h" +#include "slcompress.h" +#endif + +#include "ppp_defs.h" +#include "if_ppp.h" +#include "if_pppvar.h" + +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 pppinput __P((int c, struct tty *tp)); +int pppstart __P((struct tty *tp)); + +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 pppgetm __P((struct ppp_softc *sc)); +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_off > MMAXOFF) + +#define M_TRAILINGSPACE(m) \ + ((M_IS_CLUSTER(m) ? (u_int)(m)->m_clptr + M_CLUSTERSZ : MSIZE) \ + - ((m)->m_off + (m)->m_len)) + +#define M_OFFSTART(m) \ + (M_IS_CLUSTER(m) ? (u_int)(m)->m_clptr : MMINOFF) + +#define M_DATASIZE(m) \ + (M_IS_CLUSTER(m) ? M_CLUSTERSZ : MLEN) + +/* + * Does c need to be escaped? + */ +#define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F))) + +/* + * Procedures for using an async tty interface for PPP. + */ + +/* + * This is an Ultrix kernel, we've got clists. + */ +#define CCOUNT(q) ((q)->c_cc) + +#define t_sc T_LINEP +#define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on que */ + +/* + * 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; +{ + register struct ppp_softc *sc; + int error, s, i; + struct proc *p = u.u_procp; + + if (!suser()) + return EPERM; + + 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; + } + + pppgetm(sc); + + 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; + sc->sc_ctlp = pppasyncctlp; + + tp->t_sc = (caddr_t) sc; + ttyflush(tp, FREAD | FWRITE); + + return (0); +} + +/* + * Line specific close routine. + * Detach the tty from the ppp unit. + * Mimics part of ttyclose(). + */ +int +pppclose(tp, flag) + struct tty *tp; + int flag; +{ + register struct ppp_softc *sc; + struct mbuf *m; + int s; + + ttywflush(tp); + s = splimp(); /* paranoid; splnet probably ok */ + tp->t_line = 0; + sc = (struct ppp_softc *)tp->t_sc; + if (sc != NULL) { + tp->t_sc = NULL; + if (tp == (struct tty *) sc->sc_devp) { + m_freem(sc->sc_outm); + sc->sc_outm = NULL; + m_freem(sc->sc_m); + sc->sc_m = NULL; + pppdealloc(sc); + } + } + splx(s); + return 0; +} + +/* + * Line specific (tty) read routine. + */ +int +pppread(tp, uio, flag) + register struct tty *tp; + struct uio *uio; + int flag; +{ + register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; + struct mbuf *m, *m0; + register int s; + int error = 0; + + if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) + return 0; /* end of file */ + if (sc == NULL || tp != (struct tty *) sc->sc_devp) + return 0; + s = splimp(); + while (sc->sc_inq.ifq_head == NULL && tp->t_line == PPPDISC) { + if (tp->t_state & (TS_ASYNC | TS_NBIO)) { + splx(s); + return (EWOULDBLOCK); + } + sleep((caddr_t) &tp->t_rawq, TTIPRI); + } + if (tp->t_line != PPPDISC) { + splx(s); + return (-1); + } + + /* 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_READ, uio)) + break; + m_freem(m0); + return (error); +} + +/* + * Line specific (tty) write routine. + */ +int +pppwrite(tp, uio, flag) + register struct tty *tp; + struct uio *uio; + int flag; +{ + register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; + struct mbuf *m, *m0, **mp, *p; + struct sockaddr dst; + int len, error; + + if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) + return 0; /* wrote 0 bytes */ + if (tp->t_line != PPPDISC) + return (EINVAL); + if (sc == NULL || tp != (struct tty *) sc->sc_devp) + return EIO; + if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN || + uio->uio_resid < PPP_HDRLEN) + return (EMSGSIZE); + for (mp = &m0; uio->uio_resid; mp = &m->m_next) { + MGET(m, M_WAIT, MT_DATA); + if ((*mp = m) == NULL) { + m_freem(m0); + return (ENOBUFS); + } + if (uio->uio_resid >= CLBYTES / 2) { + MCLGET(m, p); + } else + m->m_len = MLEN; + len = MIN(m->m_len, uio->uio_resid); + if (error = uiomove(mtod(m, u_char *), len, UIO_WRITE, uio)) { + m_freem(m0); + return (error); + } + m->m_len = len; + } + dst.sa_family = AF_UNSPEC; + *(u_int32_t *)dst.sa_data = *mtod(m0, u_int32_t *); + m0->m_off += PPP_HDRLEN; + m0->m_len -= PPP_HDRLEN; + return (pppoutput(&sc->sc_if, m0, &dst)); +} + +/* + * Line specific (tty) ioctl routine. + * 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) + struct tty *tp; + caddr_t data; + int cmd, flag; +{ + struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; + int error; + + if (sc == NULL || tp != (struct tty *) sc->sc_devp) + return -1; + + error = 0; + switch (cmd) { + case PPPIOCSASYNCMAP: + if (!suser()) + return EPERM; + sc->sc_asyncmap[0] = *(u_int *)data; + break; + + case PPPIOCGASYNCMAP: + *(u_int *)data = sc->sc_asyncmap[0]; + break; + + case PPPIOCSRASYNCMAP: + if (!suser()) + return EPERM; + sc->sc_rasyncmap = *(u_int *)data; + break; + + case PPPIOCGRASYNCMAP: + *(u_int *)data = sc->sc_rasyncmap; + break; + + case PPPIOCSXASYNCMAP: + if (!suser()) + return EPERM; + 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; + + default: + error = pppioctl(sc, cmd, data, flag); + if (error == 0 && cmd == PPPIOCSMRU) + pppgetm(sc); + } + + return error; +} + +/* + * 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. + */ +static u_short +pppfcs(fcs, cp, len) + register u_short fcs; + register u_char *cp; + register int len; +{ + while (len--) + fcs = PPP_FCS(fcs, *cp++); + return (fcs); +} + +/* + * This gets called from pppoutput when a new packet is + * put on a queue. + */ +static void +pppasyncstart(sc) + register struct ppp_softc *sc; +{ + register struct tty *tp = (struct tty *) sc->sc_devp; + + pppstart(tp); +} + +/* + * This gets called when a received packet is placed on + * the inq. + */ +static void +pppasyncctlp(sc) + struct ppp_softc *sc; +{ + struct tty *tp; + + /* Put a placeholder byte in canq for ttselect()/ttnread(). */ + tp = (struct tty *) sc->sc_devp; + putc(0, &tp->t_canq); + ttwakeup(tp); +} + +/* + * 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, s, ndone, done; + struct mbuf *m2; + + if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) { + /* sorry, I can't talk now */ + return; + } + if (sc == NULL || tp != (struct tty *) sc->sc_devp) { + (*tp->t_oproc)(tp); + return; + } + + for (;;) { + /* + * If there is more in the output queue, just send it now. + * We are being called in lieu of ttstart and must do what + * it would. + */ + if (CCOUNT(&tp->t_outq) != 0 && tp->t_oproc != NULL) { + (*tp->t_oproc)(tp); + if (CCOUNT(&tp->t_outq) > PPP_HIWAT) + return; + } + + /* + * See if we have an existing packet partly sent. + * If not, get a new packet and start sending it. + */ + m = sc->sc_outm; + if (m == NULL) { + /* + * Get another packet to be sent. + */ + m = ppp_dequeue(sc); + if (m == NULL) + return; + + /* + * The extra PPP_FLAG will start up a new packet, and thus + * will flush any accumulated garbage. We do this whenever + * the line may have been idle for some time. + */ + if (CCOUNT(&tp->t_outq) == 0) { + ++sc->sc_bytessent; + (void) putc(PPP_FLAG, &tp->t_outq); + } + + /* Calculate the FCS for the first mbuf's worth. */ + sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len); + } + + 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) { + 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 */ + } + /* + * 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--; + } + } + /* + * 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; + } + } + + if (!done) { + m->m_off += m->m_len - len; + m->m_len = len; + sc->sc_outm = m; + if (tp->t_oproc != NULL) + (*tp->t_oproc)(tp); + return; /* can't do any more at the moment */ + } + + /* 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++; + } +} + +/* + * Allocate enough mbuf to handle current MRU. + */ +static void +pppgetm(sc) + register struct ppp_softc *sc; +{ + struct mbuf *m, **mp, *p; + int len; + int s; + + s = splimp(); + mp = &sc->sc_m; + for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){ + if ((m = *mp) == NULL) { + MGET(m, M_DONTWAIT, MT_DATA); + if (m == NULL) + break; + *mp = m; + MCLGET(m, p); + } + len -= M_DATASIZE(m); + mp = &m->m_next; + } + splx(s); +} + +/* + * 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; + + sc->sc_bytesrcvd++; + + c &= 0xff; + + if (c & 0x80) + sc->sc_flags |= SC_RCV_B7_1; + else + sc->sc_flags |= SC_RCV_B7_0; + if (paritytab[c >> 5] & (1 << (c & 0x1F))) + sc->sc_flags |= SC_RCV_ODDP; + else + sc->sc_flags |= SC_RCV_EVNP; + + if (sc->sc_flags & SC_LOG_RAWIN) + ppplogchar(sc, c); + + if (c == PPP_FLAG) { + ilen = sc->sc_ilen; + sc->sc_ilen = 0; + + 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) { + sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */ + if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){ + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: bad fcs %x\n", sc->sc_if.if_unit, + sc->sc_fcs); + sc->sc_if.if_ierrors++; + } else + sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED); + return; + } + + if (ilen < PPP_HDRLEN + PPP_FCSLEN) { + if (ilen) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen); + sc->sc_if.if_ierrors++; + sc->sc_flags |= SC_PKTLOST; + } + return; + } + + /* + * Remove FCS trailer. Somewhat painful... + */ + ilen -= 2; + if (--sc->sc_mc->m_len == 0) { + for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next) + ; + sc->sc_mc = m; + } + sc->sc_mc->m_len--; + + /* excise this mbuf chain */ + m = sc->sc_m; + sc->sc_m = sc->sc_mc->m_next; + sc->sc_mc->m_next = NULL; + + ppppktin(sc, m, sc->sc_flags & SC_PKTLOST); + sc->sc_flags &= ~SC_PKTLOST; + + pppgetm(sc); + return; + } + + if (sc->sc_flags & SC_FLUSH) { + if (sc->sc_flags & SC_LOG_FLUSH) + ppplogchar(sc, c); + return; + } + + if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) + return; + + if (sc->sc_flags & SC_ESCAPED) { + sc->sc_flags &= ~SC_ESCAPED; + c ^= PPP_TRANS; + } else if (c == PPP_ESCAPE) { + sc->sc_flags |= SC_ESCAPED; + return; + } + + /* + * Initialize buffer on first octet received. + * First octet could be address or protocol (when compressing + * address/control). + * Second octet is control. + * Third octet is first or second (when compressing protocol) + * octet of protocol. + * Fourth octet is second octet of protocol. + */ + if (sc->sc_ilen == 0) { + /* reset the first input mbuf */ + if (sc->sc_m == NULL) { + pppgetm(sc); + if (sc->sc_m == NULL) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit); + goto flush; + } + } + m = sc->sc_m; + m->m_len = 0; + m->m_off = M_OFFSTART(m); + 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) { + if (m->m_next == NULL) { + pppgetm(sc); + if (m->m_next == NULL) { + if (sc->sc_flags & SC_DEBUG) + printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit); + goto flush; + } + } + sc->sc_mc = m = m->m_next; + m->m_len = 0; + m->m_off = M_OFFSTART(m); + sc->sc_mp = mtod(m, char *); + } + + ++m->m_len; + *sc->sc_mp++ = c; + sc->sc_fcs = PPP_FCS(sc->sc_fcs, c); + return; + + flush: + if (!(sc->sc_flags & SC_FLUSH)) { + sc->sc_if.if_ierrors++; + sc->sc_flags |= SC_FLUSH; + if (sc->sc_flags & SC_LOG_FLUSH) + ppplogchar(sc, c); + } +} + +#define MAX_DUMP_BYTES 128 + +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 */