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