netbsd-1.1/ppp_tty.c

   1 /*      $Id: ppp_tty.c,v 1.1 1995/12/11 05:17:10 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
  96 #include <net/if.h>
  97 #include <net/if_types.h>
  98
  99 #ifdef VJC
 100 #include <netinet/in.h>
 101 #include <netinet/in_systm.h>
 102 #include <netinet/ip.h>
 103 #include <net/slcompress.h>
 104 #endif
 105
 106 #include <net/ppp_defs.h>
 107 #include <net/if_ppp.h>
 108 #include <net/if_pppvar.h>
 109
 110 int     pppopen __P((dev_t dev, struct tty *tp));
 111 int     pppclose __P((struct tty *tp, int flag));
 112 int     pppread __P((struct tty *tp, struct uio *uio, int flag));
 113 int     pppwrite __P((struct tty *tp, struct uio *uio, int flag));
 114 int     ppptioctl __P((struct tty *tp, u_long cmd, caddr_t data, int flag,
 115                        struct proc *));
 116 int     pppinput __P((int c, struct tty *tp));
 117 int     pppstart __P((struct tty *tp));
 118
 119 static u_int16_t pppfcs __P((u_int16_t fcs, u_char *cp, int len));
 120 static void     pppasyncstart __P((struct ppp_softc *));
 121 static void     pppasyncctlp __P((struct ppp_softc *));
 122 static void     pppasyncrelinq __P((struct ppp_softc *));
 123 static void     ppp_timeout __P((void *));
 124 static void     pppgetm __P((struct ppp_softc *sc));
 125 static void     pppdumpb __P((u_char *b, int l));
 126 static void     ppplogchar __P((struct ppp_softc *, int));
 127
 128 /*
 129  * Some useful mbuf macros not in mbuf.h.
 130  */
 131 #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
 132
 133 #define M_DATASTART(m)  \
 134         (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
 135             (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
 136
 137 #define M_DATASIZE(m)   \
 138         (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
 139             (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
 140
 141 /*
 142  * Does c need to be escaped?
 143  */
 144 #define ESCAPE_P(c)     (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
 145
 146 /*
 147  * Procedures for using an async tty interface for PPP.
 148  */
 149
 150 /* This is a NetBSD-1.0 or later kernel. */
 151 #define CCOUNT(q)       ((q)->c_cc)
 152
 153 #define PPP_HIWAT       400     /* Don't start a new packet if HIWAT on que */
 154
 155 /*
 156  * Line specific open routine for async tty devices.
 157  * Attach the given tty to the first available ppp unit.
 158  * Called from device open routine or ttioctl.
 159  */
 160 /* ARGSUSED */
 161 int
 162 pppopen(dev, tp)
 163     dev_t dev;
 164     register struct tty *tp;
 165 {
 166     struct proc *p = curproc;           /* XXX */
 167     register struct ppp_softc *sc;
 168     int error, s, i;
 169
 170     if (error = suser(p->p_ucred, &p->p_acflag))
 171         return (error);
 172
 173     s = spltty();
 174
 175     if (tp->t_line == PPPDISC) {
 176         sc = (struct ppp_softc *) tp->t_sc;
 177         if (sc != NULL && sc->sc_devp == (void *) tp) {
 178             splx(s);
 179             return (0);
 180         }
 181     }
 182
 183     if ((sc = pppalloc(p->p_pid)) == NULL) {
 184         splx(s);
 185         return ENXIO;
 186     }
 187
 188     if (sc->sc_relinq)
 189         (*sc->sc_relinq)(sc);   /* get previous owner to relinquish the unit */
 190
 191     sc->sc_ilen = 0;
 192     sc->sc_m = NULL;
 193     bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
 194     sc->sc_asyncmap[0] = 0xffffffff;
 195     sc->sc_asyncmap[3] = 0x60000000;
 196     sc->sc_rasyncmap = 0;
 197     sc->sc_devp = (void *) tp;
 198     sc->sc_start = pppasyncstart;
 199     sc->sc_ctlp = pppasyncctlp;
 200     sc->sc_relinq = pppasyncrelinq;
 201     sc->sc_outm = NULL;
 202     pppgetm(sc);
 203     sc->sc_if.if_flags |= IFF_RUNNING;
 204     sc->sc_if.if_baudrate = tp->t_ospeed;
 205
 206     tp->t_sc = (caddr_t) sc;
 207     ttyflush(tp, FREAD | FWRITE);
 208
 209     splx(s);
 210     return (0);
 211 }
 212
 213 /*
 214  * Line specific close routine, called from device close routine
 215  * and from ttioctl.
 216  * Detach the tty from the ppp unit.
 217  * Mimics part of ttyclose().
 218  */
 219 int
 220 pppclose(tp, flag)
 221     struct tty *tp;
 222     int flag;
 223 {
 224     register struct ppp_softc *sc;
 225     struct mbuf *m;
 226     int s;
 227
 228     s = spltty();
 229     ttyflush(tp, FREAD|FWRITE);
 230     tp->t_line = 0;
 231     sc = (struct ppp_softc *) tp->t_sc;
 232     if (sc != NULL) {
 233         tp->t_sc = NULL;
 234         if (tp == (struct tty *) sc->sc_devp) {
 235             pppasyncrelinq(sc);
 236             pppdealloc(sc);
 237         }
 238     }
 239     splx(s);
 240     return 0;
 241 }
 242
 243 /*
 244  * Relinquish the interface unit to another device.
 245  */
 246 static void
 247 pppasyncrelinq(sc)
 248     struct ppp_softc *sc;
 249 {
 250     int s;
 251
 252     s = spltty();
 253     if (sc->sc_outm) {
 254         m_freem(sc->sc_outm);
 255         sc->sc_outm = NULL;
 256     }
 257     if (sc->sc_m) {
 258         m_freem(sc->sc_m);
 259         sc->sc_m = NULL;
 260     }
 261     if (sc->sc_flags & SC_TIMEOUT) {
 262         untimeout(ppp_timeout, (void *) sc);
 263         sc->sc_flags &= ~SC_TIMEOUT;
 264     }
 265     splx(s);
 266 }
 267
 268 /*
 269  * Line specific (tty) read routine.
 270  */
 271 int
 272 pppread(tp, uio, flag)
 273     register struct tty *tp;
 274     struct uio *uio;
 275     int flag;
 276 {
 277     register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 278     struct mbuf *m, *m0;
 279     register int s;
 280     int error = 0;
 281
 282     if (sc == NULL)
 283         return 0;
 284     /*
 285      * Loop waiting for input, checking that nothing disasterous
 286      * happens in the meantime.
 287      */
 288     s = spltty();
 289     for (;;) {
 290         if (tp != (struct tty *) sc->sc_devp || tp->t_line != PPPDISC) {
 291             splx(s);
 292             return 0;
 293         }
 294         if (sc->sc_inq.ifq_head != NULL)
 295             break;
 296         if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0
 297             && (tp->t_state & TS_ISOPEN)) {
 298             splx(s);
 299             return 0;           /* end of file */
 300         }
 301         if (tp->t_state & TS_ASYNC || flag & IO_NDELAY) {
 302             splx(s);
 303             return (EWOULDBLOCK);
 304         }
 305         error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI|PCATCH, ttyin, 0);
 306         if (error) {
 307             splx(s);
 308             return error;
 309         }
 310     }
 311
 312     /* Pull place-holder byte out of canonical queue */
 313     getc(&tp->t_canq);
 314
 315     /* Get the packet from the input queue */
 316     IF_DEQUEUE(&sc->sc_inq, m0);
 317     splx(s);
 318
 319     for (m = m0; m && uio->uio_resid; m = m->m_next)
 320         if (error = uiomove(mtod(m, u_char *), m->m_len, uio))
 321             break;
 322     m_freem(m0);
 323     return (error);
 324 }
 325
 326 /*
 327  * Line specific (tty) write routine.
 328  */
 329 int
 330 pppwrite(tp, uio, flag)
 331     register struct tty *tp;
 332     struct uio *uio;
 333     int flag;
 334 {
 335     register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 336     struct mbuf *m, *m0, **mp;
 337     struct sockaddr dst;
 338     int len, error;
 339
 340     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
 341         return 0;               /* wrote 0 bytes */
 342     if (tp->t_line != PPPDISC)
 343         return (EINVAL);
 344     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 345         return EIO;
 346     if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN ||
 347         uio->uio_resid < PPP_HDRLEN)
 348         return (EMSGSIZE);
 349     for (mp = &m0; uio->uio_resid; mp = &m->m_next) {
 350         MGET(m, M_WAIT, MT_DATA);
 351         if ((*mp = m) == NULL) {
 352             m_freem(m0);
 353             return (ENOBUFS);
 354         }
 355         m->m_len = 0;
 356         if (uio->uio_resid >= MCLBYTES / 2)
 357             MCLGET(m, M_DONTWAIT);
 358         len = M_TRAILINGSPACE(m);
 359         if (len > uio->uio_resid)
 360             len = uio->uio_resid;
 361         if (error = uiomove(mtod(m, u_char *), len, uio)) {
 362             m_freem(m0);
 363             return (error);
 364         }
 365         m->m_len = len;
 366     }
 367     dst.sa_family = AF_UNSPEC;
 368     bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN);
 369     m0->m_data += PPP_HDRLEN;
 370     m0->m_len -= PPP_HDRLEN;
 371     return (pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0));
 372 }
 373
 374 /*
 375  * Line specific (tty) ioctl routine.
 376  * This discipline requires that tty device drivers call
 377  * the line specific l_ioctl routine from their ioctl routines.
 378  */
 379 /* ARGSUSED */
 380 int
 381 ppptioctl(tp, cmd, data, flag, p)
 382     struct tty *tp;
 383     u_long cmd;
 384     caddr_t data;
 385     int flag;
 386     struct proc *p;
 387 {
 388     struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 389     int error, s;
 390
 391     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 392         return -1;
 393
 394     error = 0;
 395     switch (cmd) {
 396     case PPPIOCSASYNCMAP:
 397         if (error = suser(p->p_ucred, &p->p_acflag))
 398             break;
 399         sc->sc_asyncmap[0] = *(u_int *)data;
 400         break;
 401
 402     case PPPIOCGASYNCMAP:
 403         *(u_int *)data = sc->sc_asyncmap[0];
 404         break;
 405
 406     case PPPIOCSRASYNCMAP:
 407         if (error = suser(p->p_ucred, &p->p_acflag))
 408             break;
 409         sc->sc_rasyncmap = *(u_int *)data;
 410         break;
 411
 412     case PPPIOCGRASYNCMAP:
 413         *(u_int *)data = sc->sc_rasyncmap;
 414         break;
 415
 416     case PPPIOCSXASYNCMAP:
 417         if (error = suser(p->p_ucred, &p->p_acflag))
 418             break;
 419         s = spltty();
 420         bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
 421         sc->sc_asyncmap[1] = 0;             /* mustn't escape 0x20 - 0x3f */
 422         sc->sc_asyncmap[2] &= ~0x40000000;  /* mustn't escape 0x5e */
 423         sc->sc_asyncmap[3] |= 0x60000000;   /* must escape 0x7d, 0x7e */
 424         splx(s);
 425         break;
 426
 427     case PPPIOCGXASYNCMAP:
 428         bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
 429         break;
 430
 431     default:
 432         error = pppioctl(sc, cmd, data, flag, p);
 433         if (error == 0 && cmd == PPPIOCSMRU)
 434             pppgetm(sc);
 435     }
 436
 437     return error;
 438 }
 439
 440 /*
 441  * FCS lookup table as calculated by genfcstab.
 442  */
 443 static u_int16_t fcstab[256] = {
 444         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 445         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 446         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 447         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 448         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 449         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 450         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 451         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 452         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 453         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 454         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 455         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 456         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 457         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 458         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 459         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 460         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 461         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 462         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 463         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 464         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 465         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 466         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 467         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 468         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 469         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 470         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 471         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 472         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 473         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 474         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 475         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 476 };
 477
 478 /*
 479  * Calculate a new FCS given the current FCS and the new data.
 480  */
 481 static u_int16_t
 482 pppfcs(fcs, cp, len)
 483     register u_int16_t fcs;
 484     register u_char *cp;
 485     register int len;
 486 {
 487     while (len--)
 488         fcs = PPP_FCS(fcs, *cp++);
 489     return (fcs);
 490 }
 491
 492 /*
 493  * This gets called from pppoutput when a new packet is
 494  * put on a queue, at splsoftnet.
 495  */
 496 static void
 497 pppasyncstart(sc)
 498     register struct ppp_softc *sc;
 499 {
 500     register struct tty *tp = (struct tty *) sc->sc_devp;
 501     int s;
 502
 503     s = spltty();
 504     pppstart(tp);
 505     splx(s);
 506 }
 507
 508 /*
 509  * This gets called when a received packet is placed on
 510  * the inq, at splsoftnet.
 511  */
 512 static void
 513 pppasyncctlp(sc)
 514     struct ppp_softc *sc;
 515 {
 516     struct tty *tp;
 517     int s;
 518
 519     /* Put a placeholder byte in canq for ttselect()/ttnread(). */
 520     s = spltty();
 521     tp = (struct tty *) sc->sc_devp;
 522     putc(0, &tp->t_canq);
 523     ttwakeup(tp);
 524     splx(s);
 525 }
 526
 527 /*
 528  * Start output on async tty interface.  Get another datagram
 529  * to send from the interface queue and start sending it.
 530  * Called at spltty or higher.
 531  */
 532 int
 533 pppstart(tp)
 534     register struct tty *tp;
 535 {
 536     register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 537     register struct mbuf *m;
 538     register int len;
 539     register u_char *start, *stop, *cp;
 540     int n, s, ndone, done, idle;
 541     struct mbuf *m2;
 542
 543     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0
 544         || sc == NULL || tp != (struct tty *) sc->sc_devp) {
 545         if (tp->t_oproc != NULL)
 546             (*tp->t_oproc)(tp);
 547         return 0;
 548     }
 549
 550     idle = 0;
 551     while (CCOUNT(&tp->t_outq) < PPP_HIWAT) {
 552         /*
 553          * See if we have an existing packet partly sent.
 554          * If not, get a new packet and start sending it.
 555          */
 556         m = sc->sc_outm;
 557         if (m == NULL) {
 558             /*
 559              * Get another packet to be sent.
 560              */
 561             m = ppp_dequeue(sc);
 562             if (m == NULL) {
 563                 idle = 1;
 564                 break;
 565             }
 566
 567             /*
 568              * The extra PPP_FLAG will start up a new packet, and thus
 569              * will flush any accumulated garbage.  We do this whenever
 570              * the line may have been idle for some time.
 571              */
 572             if (CCOUNT(&tp->t_outq) == 0) {
 573                 ++sc->sc_bytessent;
 574                 (void) putc(PPP_FLAG, &tp->t_outq);
 575             }
 576
 577             /* Calculate the FCS for the first mbuf's worth. */
 578             sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
 579             sc->sc_if.if_lastchange = time;
 580         }
 581
 582         for (;;) {
 583             start = mtod(m, u_char *);
 584             len = m->m_len;
 585             stop = start + len;
 586             while (len > 0) {
 587                 /*
 588                  * Find out how many bytes in the string we can
 589                  * handle without doing something special.
 590                  */
 591                 for (cp = start; cp < stop; cp++)
 592                     if (ESCAPE_P(*cp))
 593                         break;
 594                 n = cp - start;
 595                 if (n) {
 596                     /* NetBSD (0.9 or later), 4.3-Reno or similar. */
 597                     ndone = n - b_to_q(start, n, &tp->t_outq);
 598                     len -= ndone;
 599                     start += ndone;
 600                     sc->sc_bytessent += ndone;
 601
 602                     if (ndone < n)
 603                         break;  /* packet doesn't fit */
 604                 }
 605                 /*
 606                  * If there are characters left in the mbuf,
 607                  * the first one must be special..
 608                  * Put it out in a different form.
 609                  */
 610                 if (len) {
 611                     if (putc(PPP_ESCAPE, &tp->t_outq))
 612                         break;
 613                     if (putc(*start ^ PPP_TRANS, &tp->t_outq)) {
 614                         (void) unputc(&tp->t_outq);
 615                         break;
 616                     }
 617                     sc->sc_bytessent += 2;
 618                     start++;
 619                     len--;
 620                 }
 621             }
 622
 623             /*
 624              * If we didn't empty this mbuf, remember where we're up to.
 625              * If we emptied the last mbuf, try to add the FCS and closing
 626              * flag, and if we can't, leave sc_outm pointing to m, but with
 627              * m->m_len == 0, to remind us to output the FCS and flag later.
 628              */
 629             done = len == 0;
 630             if (done && m->m_next == NULL) {
 631                 u_char *p, *q;
 632                 int c;
 633                 u_char endseq[8];
 634
 635                 /*
 636                  * We may have to escape the bytes in the FCS.
 637                  */
 638                 p = endseq;
 639                 c = ~sc->sc_outfcs & 0xFF;
 640                 if (ESCAPE_P(c)) {
 641                     *p++ = PPP_ESCAPE;
 642                     *p++ = c ^ PPP_TRANS;
 643                 } else
 644                     *p++ = c;
 645                 c = (~sc->sc_outfcs >> 8) & 0xFF;
 646                 if (ESCAPE_P(c)) {
 647                     *p++ = PPP_ESCAPE;
 648                     *p++ = c ^ PPP_TRANS;
 649                 } else
 650                     *p++ = c;
 651                 *p++ = PPP_FLAG;
 652
 653                 /*
 654                  * Try to output the FCS and flag.  If the bytes
 655                  * don't all fit, back out.
 656                  */
 657                 for (q = endseq; q < p; ++q)
 658                     if (putc(*q, &tp->t_outq)) {
 659                         done = 0;
 660                         for (; q > endseq; --q)
 661                             unputc(&tp->t_outq);
 662                         break;
 663                     }
 664                 sc->sc_bytessent += q - endseq;
 665             }
 666
 667             if (!done) {
 668                 /* remember where we got to */
 669                 m->m_data = start;
 670                 m->m_len = len;
 671                 break;
 672             }
 673
 674             /* Finished with this mbuf; free it and move on. */
 675             MFREE(m, m2);
 676             m = m2;
 677             if (m == NULL) {
 678                 /* Finished a packet */
 679                 sc->sc_if.if_opackets++;
 680                 sc->sc_if.if_obytes = sc->sc_bytessent;
 681                 break;
 682             }
 683             sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
 684         }
 685
 686         /*
 687          * Here we have either finished a packet (m == NULL)
 688          * or filled up the output queue (m != NULL).
 689          */
 690         sc->sc_outm = m;
 691         if (m)
 692             break;
 693     }
 694
 695     /*
 696      * If there is stuff in the output queue, send it now.
 697      * We are being called in lieu of ttstart and must do what it would.
 698      */
 699     if (tp->t_oproc != NULL)
 700         (*tp->t_oproc)(tp);
 701
 702     /*
 703      * This timeout is needed for operation on a pseudo-tty,
 704      * because the pty code doesn't call pppstart after it has
 705      * drained the t_outq.
 706      */
 707     if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
 708         timeout(ppp_timeout, (void *) sc, 1);
 709         sc->sc_flags |= SC_TIMEOUT;
 710     }
 711
 712     return 0;
 713 }
 714
 715 /*
 716  * Timeout routine - try to start some more output.
 717  */
 718 static void
 719 ppp_timeout(x)
 720     void *x;
 721 {
 722     struct ppp_softc *sc = (struct ppp_softc *) x;
 723     struct tty *tp = (struct tty *) sc->sc_devp;
 724     int s;
 725
 726     s = spltty();
 727     sc->sc_flags &= ~SC_TIMEOUT;
 728     pppstart(tp);
 729     splx(s);
 730 }
 731
 732 /*
 733  * Allocate enough mbuf to handle current MRU.
 734  */
 735 static void
 736 pppgetm(sc)
 737     register struct ppp_softc *sc;
 738 {
 739     struct mbuf *m, **mp;
 740     int len;
 741     int s;
 742
 743     s = spltty();
 744     mp = &sc->sc_m;
 745     for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
 746         if ((m = *mp) == NULL) {
 747             MGETHDR(m, M_DONTWAIT, MT_DATA);
 748             if (m == NULL)
 749                 break;
 750             *mp = m;
 751             MCLGET(m, M_DONTWAIT);
 752         }
 753         len -= M_DATASIZE(m);
 754         mp = &m->m_next;
 755     }
 756     splx(s);
 757 }
 758
 759 /*
 760  * tty interface receiver interrupt.
 761  */
 762 static unsigned paritytab[8] = {
 763     0x96696996, 0x69969669, 0x69969669, 0x96696996,
 764     0x69969669, 0x96696996, 0x96696996, 0x69969669
 765 };
 766
 767 int
 768 pppinput(c, tp)
 769     int c;
 770     register struct tty *tp;
 771 {
 772     register struct ppp_softc *sc;
 773     struct mbuf *m;
 774     int ilen, s;
 775
 776     sc = (struct ppp_softc *) tp->t_sc;
 777     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 778         return 0;
 779
 780     s = spltty();               /* should be unnecessary */
 781     ++tk_nin;
 782     ++sc->sc_bytesrcvd;
 783
 784     if (c & TTY_FE) {
 785         /* framing error or overrun on this char - abort packet */
 786         if (sc->sc_flags & SC_DEBUG)
 787             printf("ppp%d: bad char %x\n", sc->sc_if.if_unit, c);
 788         goto flush;
 789     }
 790
 791     c &= 0xff;
 792
 793     /*
 794      * Handle software flow control of output.
 795      */
 796     if (tp->t_iflag & IXON) {
 797         if (c == tp->t_cc[VSTOP] && tp->t_cc[VSTOP] != _POSIX_VDISABLE) {
 798             if ((tp->t_state & TS_TTSTOP) == 0) {
 799                 tp->t_state |= TS_TTSTOP;
 800                 (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
 801             }
 802             return 0;
 803         }
 804         if (c == tp->t_cc[VSTART] && tp->t_cc[VSTART] != _POSIX_VDISABLE) {
 805             tp->t_state &= ~TS_TTSTOP;
 806             if (tp->t_oproc != NULL)
 807                 (*tp->t_oproc)(tp);
 808             return 0;
 809         }
 810     }
 811
 812     if (c & 0x80)
 813         sc->sc_flags |= SC_RCV_B7_1;
 814     else
 815         sc->sc_flags |= SC_RCV_B7_0;
 816     if (paritytab[c >> 5] & (1 << (c & 0x1F)))
 817         sc->sc_flags |= SC_RCV_ODDP;
 818     else
 819         sc->sc_flags |= SC_RCV_EVNP;
 820
 821     if (sc->sc_flags & SC_LOG_RAWIN)
 822         ppplogchar(sc, c);
 823
 824     if (c == PPP_FLAG) {
 825         ilen = sc->sc_ilen;
 826         sc->sc_ilen = 0;
 827         sc->sc_if.if_ibytes = sc->sc_bytesrcvd;
 828
 829         if (sc->sc_rawin_count > 0)
 830             ppplogchar(sc, -1);
 831
 832         /*
 833          * If SC_ESCAPED is set, then we've seen the packet
 834          * abort sequence "}~".
 835          */
 836         if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
 837             || ilen > 0 && sc->sc_fcs != PPP_GOODFCS) {
 838             sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */
 839             if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
 840                 if (sc->sc_flags & SC_DEBUG)
 841                     printf("ppp%d: bad fcs %x\n", sc->sc_if.if_unit,
 842                            sc->sc_fcs);
 843                 sc->sc_if.if_ierrors++;
 844             } else
 845                 sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
 846             splx(s);
 847             return 0;
 848         }
 849
 850         if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
 851             if (ilen) {
 852                 if (sc->sc_flags & SC_DEBUG)
 853                     printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen);
 854                 sc->sc_if.if_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_flags |= SC_FLUSH;
 997         if (sc->sc_flags & SC_LOG_FLUSH)
 998             ppplogchar(sc, c);
 999     }
1000     splx(s);
1001     return 0;
1002 }
1003
1004 #define MAX_DUMP_BYTES  128
1005
1006 static void
1007 ppplogchar(sc, c)
1008     struct ppp_softc *sc;
1009     int c;
1010 {
1011     if (c >= 0)
1012         sc->sc_rawin[sc->sc_rawin_count++] = c;
1013     if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
1014         || c < 0 && sc->sc_rawin_count > 0) {
1015         printf("ppp%d input: ", sc->sc_if.if_unit);
1016         pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
1017         sc->sc_rawin_count = 0;
1018     }
1019 }
1020
1021 static void
1022 pppdumpb(b, l)
1023     u_char *b;
1024     int l;
1025 {
1026     char buf[3*MAX_DUMP_BYTES+4];
1027     char *bp = buf;
1028     static char digits[] = "0123456789abcdef";
1029
1030     while (l--) {
1031         if (bp >= buf + sizeof(buf) - 3) {
1032             *bp++ = '>';
1033             break;
1034         }
1035         *bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
1036         *bp++ = digits[*b++ & 0xf];
1037         *bp++ = ' ';
1038     }
1039
1040     *bp = 0;
1041     printf("%s\n", buf);
1042 }
1043
1044 #endif  /* NPPP > 0 */