netbsd-1.1/ppp_tty.c

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