ppp_tty.c

   1 /*
   2  * ppp_tty.c - Point-to-Point Protocol (PPP) driver for asynchronous
   3  *             tty devices.
   4  *
   5  * Copyright (c) 1989 Carnegie Mellon University.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms are permitted
   9  * provided that the above copyright notice and this paragraph are
  10  * duplicated in all such forms and that any documentation,
  11  * advertising materials, and other materials related to such
  12  * distribution and use acknowledge that the software was developed
  13  * by Carnegie Mellon University.  The name of the
  14  * University may not be used to endorse or promote products derived
  15  * from this software without specific prior written permission.
  16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19  *
  20  * Drew D. Perkins
  21  * Carnegie Mellon University
  22  * 4910 Forbes Ave.
  23  * Pittsburgh, PA 15213
  24  * (412) 268-8576
  25  * ddp@andrew.cmu.edu
  26  *
  27  * Based on:
  28  *      @(#)if_sl.c     7.6.1.2 (Berkeley) 2/15/89
  29  *
  30  * Copyright (c) 1987 Regents of the University of California.
  31  * All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms are permitted
  34  * provided that the above copyright notice and this paragraph are
  35  * duplicated in all such forms and that any documentation,
  36  * advertising materials, and other materials related to such
  37  * distribution and use acknowledge that the software was developed
  38  * by the University of California, Berkeley.  The name of the
  39  * University may not be used to endorse or promote products derived
  40  * from this software without specific prior written permission.
  41  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  42  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  43  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  44  *
  45  * Serial Line interface
  46  *
  47  * Rick Adams
  48  * Center for Seismic Studies
  49  * 1300 N 17th Street, Suite 1450
  50  * Arlington, Virginia 22209
  51  * (703)276-7900
  52  * rick@seismo.ARPA
  53  * seismo!rick
  54  *
  55  * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
  56  * Converted to 4.3BSD Beta by Chris Torek.
  57  * Other changes made at Berkeley, based in part on code by Kirk Smith.
  58  *
  59  * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
  60  * Added VJ tcp header compression; more unified ioctls
  61  *
  62  * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
  63  * Cleaned up a lot of the mbuf-related code to fix bugs that
  64  * caused system crashes and packet corruption.  Changed pppstart
  65  * so that it doesn't just give up with a collision if the whole
  66  * packet doesn't fit in the output ring buffer.
  67  *
  68  * Added priority queueing for interactive IP packets, following
  69  * the model of if_sl.c, plus hooks for bpf.
  70  * Paul Mackerras (paulus@cs.anu.edu.au).
  71  */
  72
  73 /* $Id: ppp_tty.c,v 1.1 1994/12/15 22:28:09 paulus Exp $ */
  74 /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
  75
  76 #include "ppp.h"
  77 #if NPPP > 0
  78
  79 #define VJC
  80 #define PPP_COMPRESS
  81
  82 #include <sys/param.h>
  83 #include <sys/systm.h>
  84 #include <sys/proc.h>
  85 #include <sys/mbuf.h>
  86 #include <sys/dkstat.h>
  87 #include <sys/socket.h>
  88 #include <sys/ioctl.h>
  89 #include <sys/file.h>
  90 #include <sys/tty.h>
  91 #include <sys/kernel.h>
  92 #include <sys/conf.h>
  93 #include <sys/vnode.h>
  94
  95 #include <net/if.h>
  96 #include <net/if_types.h>
  97
  98 #ifdef VJC
  99 #include <netinet/in.h>
 100 #include <netinet/in_systm.h>
 101 #include <netinet/ip.h>
 102 #include <net/pppcompress.h>
 103 #endif
 104
 105 #include <net/ppp_defs.h>
 106 #include <net/if_ppp.h>
 107 #include <net/if_pppvar.h>
 108
 109 void    pppasyncattach __P((void));
 110 int     pppopen __P((dev_t dev, struct tty *tp));
 111 int     pppclose __P((struct tty *tp, int flag));
 112 int     pppread __P((struct tty *tp, struct uio *uio, int flag));
 113 int     pppwrite __P((struct tty *tp, struct uio *uio, int flag));
 114 int     ppptioctl __P((struct tty *tp, int cmd, caddr_t data, int flag,
 115                        struct proc *));
 116 int     pppinput __P((int c, struct tty *tp));
 117 int     pppstart __P((struct tty *tp));
 118
 119 static u_short  pppfcs __P((u_short fcs, u_char *cp, int len));
 120 static void     pppasyncstart __P((struct ppp_softc *));
 121 static void     pppasyncctlp __P((struct ppp_softc *));
 122 static void     pppasyncrelinq __P((struct ppp_softc *));
 123 static void     ppp_timeout __P((void *));
 124 static void     pppgetm __P((struct ppp_softc *sc));
 125 static void     pppdumpb __P((u_char *b, int l));
 126 static void     ppplogchar __P((struct ppp_softc *, int));
 127
 128 /*
 129  * Some useful mbuf macros not in mbuf.h.
 130  */
 131 #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
 132
 133 #define M_DATASTART(m)  \
 134         (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
 135             (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
 136
 137 #define M_DATASIZE(m)   \
 138         (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
 139             (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
 140
 141 /*
 142  * Does c need to be escaped?
 143  */
 144 #define ESCAPE_P(c)     (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
 145
 146 /*
 147  * Procedures for using an async tty interface for PPP.
 148  */
 149
 150 /* This is a FreeBSD-2.0 kernel. */
 151 #define CCOUNT(q)       ((q)->c_cc)
 152 #define PPP_HIWAT       400     /* Don't start a new packet if HIWAT on que */
 153
 154 /*
 155  * Define the PPP line discipline.
 156  */
 157
 158 static struct linesw pppdisc = {
 159         pppopen, pppclose, pppread, pppwrite, ppptioctl,
 160         pppinput, pppstart, nullmodem
 161 };
 162
 163 void
 164 pppasyncattach()
 165 {
 166     linesw[PPPDISC] = pppdisc;
 167 }
 168
 169 TEXT_SET(pseudo_set, pppasyncattach);
 170
 171 /*
 172  * Line specific open routine for async tty devices.
 173  * Attach the given tty to the first available ppp unit.
 174  */
 175 /* ARGSUSED */
 176 int
 177 pppopen(dev, tp)
 178     dev_t dev;
 179     register struct tty *tp;
 180 {
 181     struct proc *p = curproc;           /* XXX */
 182     register struct ppp_softc *sc;
 183     int error, s, i;
 184
 185     if (error = suser(p->p_ucred, &p->p_acflag))
 186         return (error);
 187
 188     if (tp->t_line == PPPDISC) {
 189         sc = (struct ppp_softc *) tp->t_sc;
 190         if (sc != NULL && sc->sc_devp == (void *) tp)
 191             return (0);
 192     }
 193
 194     if ((sc = pppalloc(p->p_pid)) == NULL)
 195         return ENXIO;
 196
 197     if (sc->sc_relinq)
 198         (*sc->sc_relinq)(sc);   /* get previous owner to relinquish the unit */
 199
 200     s = splimp();
 201     sc->sc_ilen = 0;
 202     sc->sc_m = NULL;
 203     bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
 204     sc->sc_asyncmap[0] = 0xffffffff;
 205     sc->sc_asyncmap[3] = 0x60000000;
 206     sc->sc_rasyncmap = 0;
 207     sc->sc_devp = (void *) tp;
 208     sc->sc_start = pppasyncstart;
 209     sc->sc_ctlp = pppasyncctlp;
 210     sc->sc_relinq = pppasyncrelinq;
 211     sc->sc_outm = NULL;
 212     pppgetm(sc);
 213     sc->sc_if.if_flags |= IFF_RUNNING;
 214
 215     tp->t_sc = (caddr_t) sc;
 216     ttyflush(tp, FREAD | FWRITE);
 217     splx(s);
 218
 219     return (0);
 220 }
 221
 222 /*
 223  * Line specific close routine.
 224  * Detach the tty from the ppp unit.
 225  * Mimics part of ttyclose().
 226  */
 227 int
 228 pppclose(tp, flag)
 229     struct tty *tp;
 230     int flag;
 231 {
 232     register struct ppp_softc *sc;
 233     struct mbuf *m;
 234     int s;
 235
 236     ttywflush(tp);
 237     s = splimp();               /* paranoid; splnet probably ok */
 238     tp->t_line = 0;
 239     sc = (struct ppp_softc *) tp->t_sc;
 240     if (sc != NULL) {
 241         tp->t_sc = NULL;
 242         if (tp == (struct tty *) sc->sc_devp) {
 243             pppasyncrelinq(sc);
 244             pppdealloc(sc);
 245         }
 246     }
 247     splx(s);
 248     return 0;
 249 }
 250
 251 /*
 252  * Relinquish the interface unit to another device.
 253  */
 254 static void
 255 pppasyncrelinq(sc)
 256     struct ppp_softc *sc;
 257 {
 258     int s;
 259
 260     s = splimp();
 261     if (sc->sc_outm) {
 262         m_freem(sc->sc_outm);
 263         sc->sc_outm = NULL;
 264     }
 265     if (sc->sc_m) {
 266         m_freem(sc->sc_m);
 267         sc->sc_m = NULL;
 268     }
 269     if (sc->sc_flags & SC_TIMEOUT) {
 270         untimeout(ppp_timeout, (void *) sc);
 271         sc->sc_flags &= ~SC_TIMEOUT;
 272     }
 273     splx(s);
 274 }
 275
 276 /*
 277  * Line specific (tty) read routine.
 278  */
 279 int
 280 pppread(tp, uio, flag)
 281     register struct tty *tp;
 282     struct uio *uio;
 283     int flag;
 284 {
 285     register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 286     struct mbuf *m, *m0;
 287     register int s;
 288     int error = 0;
 289
 290     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
 291         return 0;               /* end of file */
 292     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 293         return 0;
 294     s = splimp();
 295     while (sc->sc_inq.ifq_head == NULL && tp->t_line == PPPDISC) {
 296         if (tp->t_state & TS_ASYNC || flag & IO_NDELAY) {
 297             splx(s);
 298             return (EWOULDBLOCK);
 299         }
 300         error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI|PCATCH, ttyin, 0);
 301         if (error) {
 302             splx(s);
 303             return error;
 304         }
 305     }
 306     if (tp->t_line != PPPDISC) {
 307         splx(s);
 308         return (-1);
 309     }
 310
 311     /* Pull place-holder byte out of canonical queue */
 312     getc(&tp->t_canq);
 313
 314     /* Get the packet from the input queue */
 315     IF_DEQUEUE(&sc->sc_inq, m0);
 316     splx(s);
 317
 318     for (m = m0; m && uio->uio_resid; m = m->m_next)
 319         if (error = uiomove(mtod(m, u_char *), m->m_len, uio))
 320             break;
 321     m_freem(m0);
 322     return (error);
 323 }
 324
 325 /*
 326  * Line specific (tty) write routine.
 327  */
 328 int
 329 pppwrite(tp, uio, flag)
 330     register struct tty *tp;
 331     struct uio *uio;
 332     int flag;
 333 {
 334     register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 335     struct mbuf *m, *m0, **mp;
 336     struct sockaddr dst;
 337     int len, error;
 338
 339     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
 340         return 0;               /* wrote 0 bytes */
 341     if (tp->t_line != PPPDISC)
 342         return (EINVAL);
 343     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 344         return EIO;
 345     if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN ||
 346         uio->uio_resid < PPP_HDRLEN)
 347         return (EMSGSIZE);
 348     for (mp = &m0; uio->uio_resid; mp = &m->m_next) {
 349         MGET(m, M_WAIT, MT_DATA);
 350         if ((*mp = m) == NULL) {
 351             m_freem(m0);
 352             return (ENOBUFS);
 353         }
 354         m->m_len = 0;
 355         if (uio->uio_resid >= MCLBYTES / 2)
 356             MCLGET(m, M_DONTWAIT);
 357         len = M_TRAILINGSPACE(m);
 358         if (len > uio->uio_resid)
 359             len = uio->uio_resid;
 360         if (error = uiomove(mtod(m, u_char *), len, uio)) {
 361             m_freem(m0);
 362             return (error);
 363         }
 364         m->m_len = len;
 365     }
 366     dst.sa_family = AF_UNSPEC;
 367     bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN);
 368     m0->m_data += PPP_HDRLEN;
 369     m0->m_len -= PPP_HDRLEN;
 370     return (pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0));
 371 }
 372
 373 /*
 374  * Line specific (tty) ioctl routine.
 375  * This discipline requires that tty device drivers call
 376  * the line specific l_ioctl routine from their ioctl routines.
 377  */
 378 /* ARGSUSED */
 379 int
 380 ppptioctl(tp, cmd, data, flag, p)
 381     struct tty *tp;
 382     caddr_t data;
 383     int cmd, flag;
 384     struct proc *p;
 385 {
 386     struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 387     int error, s;
 388
 389     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 390         return -1;
 391
 392     error = 0;
 393     switch (cmd) {
 394     case PPPIOCSASYNCMAP:
 395         if (error = suser(p->p_ucred, &p->p_acflag))
 396             break;
 397         sc->sc_asyncmap[0] = *(u_int *)data;
 398         break;
 399
 400     case PPPIOCGASYNCMAP:
 401         *(u_int *)data = sc->sc_asyncmap[0];
 402         break;
 403
 404     case PPPIOCSRASYNCMAP:
 405         if (error = suser(p->p_ucred, &p->p_acflag))
 406             break;
 407         sc->sc_rasyncmap = *(u_int *)data;
 408         break;
 409
 410     case PPPIOCGRASYNCMAP:
 411         *(u_int *)data = sc->sc_rasyncmap;
 412         break;
 413
 414     case PPPIOCSXASYNCMAP:
 415         if (error = suser(p->p_ucred, &p->p_acflag))
 416             break;
 417         s = spltty();
 418         bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
 419         sc->sc_asyncmap[1] = 0;             /* mustn't escape 0x20 - 0x3f */
 420         sc->sc_asyncmap[2] &= ~0x40000000;  /* mustn't escape 0x5e */
 421         sc->sc_asyncmap[3] |= 0x60000000;   /* must escape 0x7d, 0x7e */
 422         splx(s);
 423         break;
 424
 425     case PPPIOCGXASYNCMAP:
 426         bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
 427         break;
 428
 429     default:
 430         error = pppioctl(sc, cmd, data, flag, p);
 431         if (error == 0 && cmd == PPPIOCSMRU)
 432             pppgetm(sc);
 433     }
 434
 435     return error;
 436 }
 437
 438 /*
 439  * FCS lookup table as calculated by genfcstab.
 440  */
 441 static u_short fcstab[256] = {
 442         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 443         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 444         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 445         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 446         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 447         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 448         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 449         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 450         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 451         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 452         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 453         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 454         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 455         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 456         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 457         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 458         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 459         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 460         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 461         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 462         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 463         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 464         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 465         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 466         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 467         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 468         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 469         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 470         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 471         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 472         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 473         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 474 };
 475
 476 /*
 477  * Calculate a new FCS given the current FCS and the new data.
 478  */
 479 static u_short
 480 pppfcs(fcs, cp, len)
 481     register u_short fcs;
 482     register u_char *cp;
 483     register int len;
 484 {
 485     while (len--)
 486         fcs = PPP_FCS(fcs, *cp++);
 487     return (fcs);
 488 }
 489
 490 /*
 491  * This gets called from pppoutput when a new packet is
 492  * put on a queue.
 493  */
 494 static void
 495 pppasyncstart(sc)
 496     register struct ppp_softc *sc;
 497 {
 498     register struct tty *tp = (struct tty *) sc->sc_devp;
 499     int s;
 500
 501     s = splimp();
 502     pppstart(tp);
 503     splx(s);
 504 }
 505
 506 /*
 507  * This gets called when a received packet is placed on
 508  * the inq.
 509  */
 510 static void
 511 pppasyncctlp(sc)
 512     struct ppp_softc *sc;
 513 {
 514     struct tty *tp;
 515
 516     /* Put a placeholder byte in canq for ttselect()/ttnread(). */
 517     tp = (struct tty *) sc->sc_devp;
 518     putc(0, &tp->t_canq);
 519     ttwakeup(tp);
 520 }
 521
 522 /*
 523  * Start output on async tty interface.  Get another datagram
 524  * to send from the interface queue and start sending it.
 525  */
 526 int
 527 pppstart(tp)
 528     register struct tty *tp;
 529 {
 530     register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 531     register struct mbuf *m;
 532     register int len;
 533     register u_char *start, *stop, *cp;
 534     int n, s, ndone, done, idle;
 535     struct mbuf *m2;
 536
 537     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0
 538         || sc == NULL || tp != (struct tty *) sc->sc_devp) {
 539         if (tp->t_oproc != NULL)
 540             (*tp->t_oproc)(tp);
 541         return 0;
 542     }
 543
 544     idle = 0;
 545     while (CCOUNT(&tp->t_outq) < PPP_HIWAT) {
 546         /*
 547          * See if we have an existing packet partly sent.
 548          * If not, get a new packet and start sending it.
 549          */
 550         m = sc->sc_outm;
 551         if (m == NULL) {
 552             /*
 553              * Get another packet to be sent.
 554              */
 555             m = ppp_dequeue(sc);
 556             if (m == NULL) {
 557                 idle = 1;
 558                 break;
 559             }
 560
 561             /*
 562              * The extra PPP_FLAG will start up a new packet, and thus
 563              * will flush any accumulated garbage.  We do this whenever
 564              * the line may have been idle for some time.
 565              */
 566             if (CCOUNT(&tp->t_outq) == 0) {
 567                 ++sc->sc_bytessent;
 568                 (void) putc(PPP_FLAG, &tp->t_outq);
 569             }
 570
 571             /* Calculate the FCS for the first mbuf's worth. */
 572             sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
 573         }
 574
 575         for (;;) {
 576             start = mtod(m, u_char *);
 577             len = m->m_len;
 578             stop = start + len;
 579             while (len > 0) {
 580                 /*
 581                  * Find out how many bytes in the string we can
 582                  * handle without doing something special.
 583                  */
 584                 for (cp = start; cp < stop; cp++)
 585                     if (ESCAPE_P(*cp))
 586                         break;
 587                 n = cp - start;
 588                 if (n) {
 589                     /* NetBSD (0.9 or later), 4.3-Reno or similar. */
 590                     ndone = n - b_to_q(start, n, &tp->t_outq);
 591                     len -= ndone;
 592                     start += ndone;
 593                     sc->sc_bytessent += ndone;
 594
 595                     if (ndone < n)
 596                         break;  /* packet doesn't fit */
 597                 }
 598                 /*
 599                  * If there are characters left in the mbuf,
 600                  * the first one must be special..
 601                  * Put it out in a different form.
 602                  */
 603                 if (len) {
 604                     if (putc(PPP_ESCAPE, &tp->t_outq))
 605                         break;
 606                     if (putc(*start ^ PPP_TRANS, &tp->t_outq)) {
 607                         (void) unputc(&tp->t_outq);
 608                         break;
 609                     }
 610                     sc->sc_bytessent += 2;
 611                     start++;
 612                     len--;
 613                 }
 614             }
 615
 616             /*
 617              * If we didn't empty this mbuf, remember where we're up to.
 618              * If we emptied the last mbuf, try to add the FCS and closing
 619              * flag, and if we can't, leave sc_outm pointing to m, but with
 620              * m->m_len == 0, to remind us to output the FCS and flag later.
 621              */
 622             done = len == 0;
 623             if (done && m->m_next == NULL) {
 624                 u_char *p, *q;
 625                 int c;
 626                 u_char endseq[8];
 627
 628                 /*
 629                  * We may have to escape the bytes in the FCS.
 630                  */
 631                 p = endseq;
 632                 c = ~sc->sc_outfcs & 0xFF;
 633                 if (ESCAPE_P(c)) {
 634                     *p++ = PPP_ESCAPE;
 635                     *p++ = c ^ PPP_TRANS;
 636                 } else
 637                     *p++ = c;
 638                 c = (~sc->sc_outfcs >> 8) & 0xFF;
 639                 if (ESCAPE_P(c)) {
 640                     *p++ = PPP_ESCAPE;
 641                     *p++ = c ^ PPP_TRANS;
 642                 } else
 643                     *p++ = c;
 644                 *p++ = PPP_FLAG;
 645
 646                 /*
 647                  * Try to output the FCS and flag.  If the bytes
 648                  * don't all fit, back out.
 649                  */
 650                 for (q = endseq; q < p; ++q)
 651                     if (putc(*q, &tp->t_outq)) {
 652                         done = 0;
 653                         for (; q > endseq; --q)
 654                             unputc(&tp->t_outq);
 655                         break;
 656                     }
 657                 sc->sc_bytessent += q - endseq;
 658             }
 659
 660             if (!done) {
 661                 /* remember where we got to */
 662                 m->m_data = start;
 663                 m->m_len = len;
 664                 break;
 665             }
 666
 667             /* Finished with this mbuf; free it and move on. */
 668             MFREE(m, m2);
 669             m = m2;
 670             if (m == NULL) {
 671                 /* Finished a packet */
 672                 sc->sc_if.if_opackets++;
 673                 sc->sc_if.if_obytes = sc->sc_bytessent;
 674                 break;
 675             }
 676             sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
 677         }
 678
 679         /*
 680          * Here we have either finished a packet (m == NULL)
 681          * or filled up the output queue (m != NULL).
 682          */
 683         sc->sc_outm = m;
 684         if (m)
 685             break;
 686     }
 687
 688     /*
 689      * If there is stuff in the output queue, send it now.
 690      * We are being called in lieu of ttstart and must do what it would.
 691      */
 692     if (tp->t_oproc != NULL)
 693         (*tp->t_oproc)(tp);
 694
 695     /*
 696      * This timeout is needed for operation on a pseudo-tty,
 697      * because the pty code doesn't call pppstart after it has
 698      * drained the t_outq.
 699      */
 700     if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
 701         timeout(ppp_timeout, (void *) sc, 1);
 702         sc->sc_flags |= SC_TIMEOUT;
 703     }
 704
 705     return 0;
 706 }
 707
 708 /*
 709  * Timeout routine - try to start some more output.
 710  */
 711 static void
 712 ppp_timeout(x)
 713     void *x;
 714 {
 715     struct ppp_softc *sc = (struct ppp_softc *) x;
 716     struct tty *tp = (struct tty *) sc->sc_devp;
 717     int s;
 718
 719     s = splimp();
 720     sc->sc_flags &= ~SC_TIMEOUT;
 721     pppstart(tp);
 722     splx(s);
 723 }
 724
 725 /*
 726  * Allocate enough mbuf to handle current MRU.
 727  */
 728 static void
 729 pppgetm(sc)
 730     register struct ppp_softc *sc;
 731 {
 732     struct mbuf *m, **mp;
 733     int len;
 734     int s;
 735
 736     s = splimp();
 737     mp = &sc->sc_m;
 738     for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
 739         if ((m = *mp) == NULL) {
 740             MGETHDR(m, M_DONTWAIT, MT_DATA);
 741             if (m == NULL)
 742                 break;
 743             *mp = m;
 744             MCLGET(m, M_DONTWAIT);
 745         }
 746         len -= M_DATASIZE(m);
 747         mp = &m->m_next;
 748     }
 749     splx(s);
 750 }
 751
 752 /*
 753  * tty interface receiver interrupt.
 754  */
 755 static unsigned paritytab[8] = {
 756     0x96696996, 0x69969669, 0x69969669, 0x96696996,
 757     0x69969669, 0x96696996, 0x96696996, 0x69969669
 758 };
 759
 760 int
 761 pppinput(c, tp)
 762     int c;
 763     register struct tty *tp;
 764 {
 765     register struct ppp_softc *sc;
 766     struct mbuf *m;
 767     int ilen, s;
 768
 769     sc = (struct ppp_softc *) tp->t_sc;
 770     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 771         return 0;
 772
 773     s = spltty();
 774     ++tk_nin;
 775     ++sc->sc_bytesrcvd;
 776
 777     if (c & TTY_FE) {
 778         /* framing error or overrun on this char - abort packet */
 779         if (sc->sc_flags & SC_DEBUG)
 780             printf("ppp%d: bad char %x\n", sc->sc_if.if_unit, c);
 781         goto flush;
 782     }
 783
 784     c &= 0xff;
 785
 786     if (c & 0x80)
 787         sc->sc_flags |= SC_RCV_B7_1;
 788     else
 789         sc->sc_flags |= SC_RCV_B7_0;
 790     if (paritytab[c >> 5] & (1 << (c & 0x1F)))
 791         sc->sc_flags |= SC_RCV_ODDP;
 792     else
 793         sc->sc_flags |= SC_RCV_EVNP;
 794
 795     if (sc->sc_flags & SC_LOG_RAWIN)
 796         ppplogchar(sc, c);
 797
 798     if (c == PPP_FLAG) {
 799         ilen = sc->sc_ilen;
 800         sc->sc_ilen = 0;
 801         sc->sc_if.if_ibytes = sc->sc_bytesrcvd;
 802
 803         if (sc->sc_rawin_count > 0)
 804             ppplogchar(sc, -1);
 805
 806         /*
 807          * If SC_ESCAPED is set, then we've seen the packet
 808          * abort sequence "}~".
 809          */
 810         if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
 811             || ilen > 0 && sc->sc_fcs != PPP_GOODFCS) {
 812             sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */
 813             if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
 814                 if (sc->sc_flags & SC_DEBUG)
 815                     printf("ppp%d: bad fcs %x\n", sc->sc_if.if_unit,
 816                            sc->sc_fcs);
 817                 sc->sc_if.if_ierrors++;
 818             } else
 819                 sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
 820             splx(s);
 821             return 0;
 822         }
 823
 824         if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
 825             if (ilen) {
 826                 if (sc->sc_flags & SC_DEBUG)
 827                     printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen);
 828                 sc->sc_if.if_ierrors++;
 829                 sc->sc_flags |= SC_PKTLOST;
 830             }
 831             splx(s);
 832             return 0;
 833         }
 834
 835         /*
 836          * Remove FCS trailer.  Somewhat painful...
 837          */
 838         ilen -= 2;
 839         if (--sc->sc_mc->m_len == 0) {
 840             for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
 841                 ;
 842             sc->sc_mc = m;
 843         }
 844         sc->sc_mc->m_len--;
 845
 846         /* excise this mbuf chain */
 847         m = sc->sc_m;
 848         sc->sc_m = sc->sc_mc->m_next;
 849         sc->sc_mc->m_next = NULL;
 850
 851         ppppktin(sc, m, sc->sc_flags & SC_PKTLOST);
 852         sc->sc_flags &= ~SC_PKTLOST;
 853
 854         pppgetm(sc);
 855         splx(s);
 856         return 0;
 857     }
 858
 859     if (sc->sc_flags & SC_FLUSH) {
 860         if (sc->sc_flags & SC_LOG_FLUSH)
 861             ppplogchar(sc, c);
 862         splx(s);
 863         return 0;
 864     }
 865
 866     if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) {
 867         splx(s);
 868         return 0;
 869     }
 870
 871     if (sc->sc_flags & SC_ESCAPED) {
 872         sc->sc_flags &= ~SC_ESCAPED;
 873         c ^= PPP_TRANS;
 874     } else if (c == PPP_ESCAPE) {
 875         sc->sc_flags |= SC_ESCAPED;
 876         splx(s);
 877         return 0;
 878     }
 879
 880     /*
 881      * Initialize buffer on first octet received.
 882      * First octet could be address or protocol (when compressing
 883      * address/control).
 884      * Second octet is control.
 885      * Third octet is first or second (when compressing protocol)
 886      * octet of protocol.
 887      * Fourth octet is second octet of protocol.
 888      */
 889     if (sc->sc_ilen == 0) {
 890         /* reset the first input mbuf */
 891         if (sc->sc_m == NULL) {
 892             pppgetm(sc);
 893             if (sc->sc_m == NULL) {
 894                 if (sc->sc_flags & SC_DEBUG)
 895                     printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit);
 896                 goto flush;
 897             }
 898         }
 899         m = sc->sc_m;
 900         m->m_len = 0;
 901         m->m_data = M_DATASTART(sc->sc_m);
 902         sc->sc_mc = m;
 903         sc->sc_mp = mtod(m, char *);
 904         sc->sc_fcs = PPP_INITFCS;
 905         if (c != PPP_ALLSTATIONS) {
 906             if (sc->sc_flags & SC_REJ_COMP_AC) {
 907                 if (sc->sc_flags & SC_DEBUG)
 908                     printf("ppp%d: garbage received: 0x%x (need 0xFF)\n",
 909                            sc->sc_if.if_unit, c);
 910                 goto flush;
 911             }
 912             *sc->sc_mp++ = PPP_ALLSTATIONS;
 913             *sc->sc_mp++ = PPP_UI;
 914             sc->sc_ilen += 2;
 915             m->m_len += 2;
 916         }
 917     }
 918     if (sc->sc_ilen == 1 && c != PPP_UI) {
 919         if (sc->sc_flags & SC_DEBUG)
 920             printf("ppp%d: missing UI (0x3), got 0x%x\n",
 921                    sc->sc_if.if_unit, c);
 922         goto flush;
 923     }
 924     if (sc->sc_ilen == 2 && (c & 1) == 1) {
 925         /* a compressed protocol */
 926         *sc->sc_mp++ = 0;
 927         sc->sc_ilen++;
 928         sc->sc_mc->m_len++;
 929     }
 930     if (sc->sc_ilen == 3 && (c & 1) == 0) {
 931         if (sc->sc_flags & SC_DEBUG)
 932             printf("ppp%d: bad protocol %x\n", sc->sc_if.if_unit,
 933                    (sc->sc_mp[-1] << 8) + c);
 934         goto flush;
 935     }
 936
 937     /* packet beyond configured mru? */
 938     if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
 939         if (sc->sc_flags & SC_DEBUG)
 940             printf("ppp%d: packet too big\n", sc->sc_if.if_unit);
 941         goto flush;
 942     }
 943
 944     /* is this mbuf full? */
 945     m = sc->sc_mc;
 946     if (M_TRAILINGSPACE(m) <= 0) {
 947         if (m->m_next == NULL) {
 948             pppgetm(sc);
 949             if (m->m_next == NULL) {
 950                 if (sc->sc_flags & SC_DEBUG)
 951                     printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit);
 952                 goto flush;
 953             }
 954         }
 955         sc->sc_mc = m = m->m_next;
 956         m->m_len = 0;
 957         m->m_data = M_DATASTART(m);
 958         sc->sc_mp = mtod(m, char *);
 959     }
 960
 961     ++m->m_len;
 962     *sc->sc_mp++ = c;
 963     sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
 964     splx(s);
 965     return 0;
 966
 967  flush:
 968     if (!(sc->sc_flags & SC_FLUSH)) {
 969         sc->sc_if.if_ierrors++;
 970         sc->sc_flags |= SC_FLUSH;
 971         if (sc->sc_flags & SC_LOG_FLUSH)
 972             ppplogchar(sc, c);
 973     }
 974     splx(s);
 975     return 0;
 976 }
 977
 978 #define MAX_DUMP_BYTES  128
 979
 980 static void
 981 ppplogchar(sc, c)
 982     struct ppp_softc *sc;
 983     int c;
 984 {
 985     if (c >= 0)
 986         sc->sc_rawin[sc->sc_rawin_count++] = c;
 987     if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
 988         || c < 0 && sc->sc_rawin_count > 0) {
 989         printf("ppp%d input: ", sc->sc_if.if_unit);
 990         pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
 991         sc->sc_rawin_count = 0;
 992     }
 993 }
 994
 995 static void
 996 pppdumpb(b, l)
 997     u_char *b;
 998     int l;
 999 {
1000     char buf[3*MAX_DUMP_BYTES+4];
1001     char *bp = buf;
1002     static char digits[] = "0123456789abcdef";
1003
1004     while (l--) {
1005         if (bp >= buf + sizeof(buf) - 3) {
1006             *bp++ = '>';
1007             break;
1008         }
1009         *bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
1010         *bp++ = digits[*b++ & 0xf];
1011         *bp++ = ' ';
1012     }
1013
1014     *bp = 0;
1015     printf("%s\n", buf);
1016 }
1017
1018 #endif  /* NPPP > 0 */