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