NeXT/ppp_tty.c

   1 /*      $ID: ppp_tty.c,v 1.4 1994/12/13 03:42:17 paulus Exp paulus $    */
   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  * Rewritten for NextStep's funky kernel functions, I/O threads,
  75  * and netbufs (instead of real mbufs).  Also, ifnets don't install
  76  * into the kernel under NS as they do under BSD.  We have tried to
  77  * make the code remain as similar to the NetBSD version without
  78  * incurring too much hassle.  This code is the merge of
  79  * Philip Prindeville's <philipp@res.enst.fr>/Pete French's <pete@ohm.york.ac.uk>
  80  * and Stephen Perkins'  <perkins@cps.msu.edu> independent ports.
  81  *
  82  */
  83
  84 /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
  85 /* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:59 cgd Exp */
  86
  87 /* #include "ppp.h" */
  88 #if NUM_PPP > 0
  89
  90 #define KERNEL 1
  91 #define KERNEL_FEATURES 1
  92 #define INET 1
  93
  94 #if NS_TARGET >= 40
  95 #if NS_TARGET >= 41
  96 #include <kernserv/lock.h>
  97 #else
  98 #include <kern/lock.h>
  99 #endif /* NS_TARGET */
 100 #endif /* NS_TARGET */
 101
 102 #include <sys/param.h>
 103 #if NS_TARGET >= 41
 104 typedef simple_lock_data_t lock_data_t;         /* XXX */
 105 #endif /* NS_TARGET */
 106 #include <sys/proc.h>
 107 #include <sys/user.h>
 108 #include "netbuf.h"
 109 #include <sys/socket.h>
 110 #include <sys/ioctl.h>
 111 #include <sys/file.h>
 112 #include <sys/tty.h>
 113 #include <sys/conf.h>
 114 #include <sys/dk.h>
 115 #include <sys/uio.h>
 116 #include <sys/errno.h>
 117 #if !(NS_TARGET >= 40)
 118 /*  XXX what happened to this header file? */
 119 #include <machine/param.h>
 120 #endif
 121
 122 #include <kernserv/prototypes.h>
 123 /* NeXT broke spl.h in 3.2/m68k. Thanks EPS! */
 124
 125 #if defined(m68k)
 126 #import "spl.h"
 127 #else
 128 #include <driverkit/generalFuncs.h>
 129 #import <kernserv/machine/spl.h>
 130 #endif
 131
 132 #include <kernserv/kern_server_types.h>
 133
 134 #include <net/if.h>
 135 #include <net/route.h>
 136
 137 #ifdef VJC
 138 #include <netinet/in.h>
 139 #include <netinet/in_systm.h>
 140 #include <netinet/ip.h>
 141 #endif
 142
 143 #include <net/ppp_defs.h>
 144 #ifdef VJC
 145 #include <net/vjcompress.h>
 146 #endif
 147 #include <net/if_ppp.h>
 148 #include "if_pppvar.h"
 149
 150 #include "inlines.h"
 151
 152 int     pppopen __P((dev_t dev, struct tty *tp));
 153 void    pppclose __P((struct tty *tp));
 154 int     pppread __P((struct tty *tp, struct uio *uio));
 155 int     pppwrite __P((struct tty *tp, struct uio *uio));
 156 int     ppptioctl __P((struct tty *tp, int cmd, void *data, int flag));
 157 void    pppinput __P((int c, struct tty *tp));
 158 void    pppstart __P((struct tty *tp));
 159
 160 /*
 161  * Must return an actual netbuf_t since other protocols
 162  * use this to get our buffers.
 163  */
 164 netbuf_t        pppgetbuf __P((netif_t));
 165
 166 /*
 167  * Must accept an actual netbuf_t since others use this
 168  * Procedure to access our output routine.
 169  */
 170 int             pppoutput __P((netif_t ifp, netbuf_t m, void *arg));
 171
 172 static u_int16_t pppfcs __P((u_int16_t fcs, u_char *cp, int len));
 173 static void     pppasyncstart __P((struct ppp_softc *));
 174 static void     pppasyncctlp __P((struct ppp_softc *));
 175 static void     pppasyncrelinq __P((struct ppp_softc *));
 176 static int      ppp_timeout __P((void *));
 177 void            pppgetm __P((struct ppp_softc *sc));
 178 static void     pppdumpb __P((u_char *b, int l));
 179 void            ppplogchar __P((struct ppp_softc *, int));
 180
 181 extern kern_server_t instance;
 182
 183 /*
 184  * Does c need to be escaped?
 185  */
 186 #define ESCAPE_P(c)     (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
 187
 188 #define CCOUNT(q)       ((q)->c_cc)
 189
 190 #define PPP_HIWAT       400     /* Don't start a new packet if HIWAT on que */
 191
 192 #include "linedisc.h"
 193
 194
 195 extern int ttymodem(struct tty*, int);
 196 extern int ttselect(struct tty *tp, int rw);
 197
 198
 199 static NETBUF_T
 200 pppgetinbuf(netif_t ifp)
 201 {
 202     register struct ppp_softc *sc = &ppp_softc[if_unit(ifp)];
 203     NETBUF_T nb;
 204     int len = MAX(sc->sc_mru, PPP_MTU) + sizeof (struct ifnet *) +
 205 #ifdef VJC
 206               VJ_HDRLEN +
 207 #endif
 208               PPP_HDRLEN + PPP_FCSLEN;
 209     nb =  NB_ALLOC(len);
 210     if (nb != NULL)
 211       {
 212 #ifdef VJC
 213         NB_SHRINK_TOP(nb, VJ_HDRLEN + PPP_HDRLEN);
 214 #else
 215         NB_SHRINK_TOP(nb, PPP_HDRLEN);
 216 #endif
 217       }
 218
 219     return nb;
 220 }
 221
 222 /*
 223  * I was a bit worried about reentrancy here.  +++SJP
 224  */
 225
 226 void
 227 pppfillfreeq(void *arg)
 228 {
 229     struct ppp_softc *sc = (struct ppp_softc *)arg;
 230     NETBUF_T nb;
 231     volatile static int in = 0;
 232
 233     if (in)
 234       return;
 235     in = 1;
 236
 237     while(!nbq_high(&sc->sc_freeq)) {
 238         nb = pppgetinbuf(sc->sc_if);
 239         if (! nb) break;
 240         nbq_enqueue(&sc->sc_freeq, nb);
 241     }
 242
 243     in = 0;
 244 }
 245
 246 /*
 247  * Line specific open routine for async tty devices.
 248  * Attach the given tty to the first available ppp unit.
 249  */
 250 /* ARGSUSED */
 251 int
 252 pppopen(dev, tp)
 253     dev_t dev;
 254     register struct tty *tp;
 255 {
 256     struct proc *p = curproc;           /* XXX */
 257     register struct ppp_softc *sc;
 258     int s;
 259
 260     if (! suser())
 261         return EPERM;
 262
 263     if (tp->t_line == PPPDISC) {
 264         sc = (struct ppp_softc *) tp->t_sc;
 265         if (sc != NULL && sc->sc_devp == (void *) tp)
 266             return (0);
 267     }
 268
 269     if ((sc = pppalloc(p->p_pid)) == NULL)
 270         return ENXIO;
 271
 272     if (sc->sc_relinq)
 273         (*sc->sc_relinq)(sc);   /* get previous owner to relinquish the unit */
 274
 275     pppfillfreeq((void *) sc);   /* fill the free queue - we may block */
 276
 277     s = splimp();
 278     sc->sc_ilen = 0;
 279     sc->sc_m = NULL;
 280     bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
 281     sc->sc_asyncmap[0] = 0xffffffff;
 282     sc->sc_asyncmap[3] = 0x60000000;    /* 0x7D and 0x7E */
 283     sc->sc_rasyncmap = 0;
 284     sc->sc_devp = (void *) tp;
 285     sc->sc_start = pppasyncstart;
 286     sc->sc_ctlp = pppasyncctlp;
 287     sc->sc_relinq = pppasyncrelinq;
 288     sc->sc_outm = NULL;
 289     pppgetm(sc);
 290     if_flags_set(sc->sc_if, if_flags(sc->sc_if) | IFF_RUNNING);
 291
 292     tp->t_sc = (caddr_t) sc;
 293     ttyflush(tp, FREAD | FWRITE);
 294     splx(s);
 295
 296     return (0);
 297 }
 298
 299 /*
 300  * Line specific close routine.
 301  * Detach the tty from the ppp unit.
 302  * Mimics part of ttyclose().
 303  */
 304 void
 305 pppclose(tp)
 306     struct tty *tp;
 307 {
 308     register struct ppp_softc *sc;
 309     int s;
 310
 311     ttywflush(tp);
 312     s = splimp();               /* paranoid; splnet probably ok */
 313     tp->t_line = 0;
 314     sc = (struct ppp_softc *) tp->t_sc;
 315     if (sc != NULL) {
 316         tp->t_sc = NULL;
 317         if (tp == (struct tty *) sc->sc_devp) {
 318             pppasyncrelinq(sc);
 319             pppdealloc(sc);
 320         }
 321     }
 322     splx(s);
 323     return;
 324 }
 325
 326 /*
 327  * Relinquish the interface unit to another device.
 328  */
 329 static void
 330 pppasyncrelinq(sc)
 331     struct ppp_softc *sc;
 332 {
 333     int s;
 334
 335     s = splimp();
 336     if (sc->sc_outm) {
 337         NB_FREE(sc->sc_outm);
 338         sc->sc_outm = NULL;
 339     }
 340     if (sc->sc_m) {
 341         NB_FREE(sc->sc_m);
 342         sc->sc_m = NULL;
 343     }
 344     if (sc->sc_flags & SC_TIMEOUT) {
 345         ns_untimeout(ppp_timeout, (void *) sc);
 346         sc->sc_flags &= ~SC_TIMEOUT;
 347     }
 348     splx(s);
 349 }
 350
 351 /*
 352  * Line specific (tty) read routine.
 353  */
 354 int
 355 pppread(tp, uio)
 356     register struct tty *tp;
 357     struct uio *uio;
 358 {
 359     register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 360     NETBUF_T m;
 361     register int s;
 362     int error = 0;
 363     struct nty *np = ttynty(tp);
 364
 365 #ifdef NEW_CLOCAL
 366     if ((tp->t_state & TS_CARR_ON) == 0 && (np->t_pflags & TP_CLOCAL) == 0)
 367         return 0;               /* end of file */
 368
 369 #else
 370
 371     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_flags & CLOCAL) == 0)
 372         return 0;               /* end of file */
 373
 374 #endif /* NEW_CLOCAL */
 375
 376     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 377         return 0;
 378     s = splimp();
 379     while (nbq_empty(&sc->sc_inq) && tp->t_line == PPPDISC) {
 380         if (tp->t_state & (TS_ASYNC | TS_NBIO)) {
 381             splx(s);
 382             return (EWOULDBLOCK);
 383         }
 384         sleep((caddr_t)&tp->t_rawq, TTIPRI);
 385     }
 386     if (tp->t_line != PPPDISC) {
 387         splx(s);
 388         return (-1);
 389     }
 390
 391     /* Pull place-holder byte out of canonical queue */
 392     getc(&tp->t_canq);
 393
 394     /* Get the packet from the input queue */
 395     m = nbq_dequeue(&sc->sc_inq);
 396     splx(s);
 397     if (nbuf == NULL){
 398       if (sc->sc_flags & SC_DEBUG)
 399         IOLogDbg("Read didn't get a buffer at %s %d\n", __FILE__, __LINE__);
 400       return -1;
 401     }
 402     error = uiomove(NB_MAP(m), NB_SIZE(m), UIO_READ, uio);
 403     NB_FREE(m);
 404     return (error);
 405 }
 406
 407 /*
 408  * Line specific (tty) write routine.
 409  */
 410 int
 411 pppwrite(tp, uio)
 412     register struct tty *tp;
 413     struct uio *uio;
 414 {
 415     register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 416     NETBUF_T m;
 417     struct sockaddr dst;
 418     int len, error;
 419     struct nty *np = ttynty(tp);
 420
 421 #ifdef NEW_CLOCAL
 422
 423     if ((tp->t_state & TS_CARR_ON) == 0 && (np->t_pflags & TP_CLOCAL) == 0)
 424         return 0;               /* wrote 0 bytes */
 425
 426 #else
 427
 428     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_flags & CLOCAL) == 0)
 429         return 0;               /* wrote 0 bytes */
 430
 431 #endif /* NEW_CLOCAL */
 432
 433     if (tp->t_line != PPPDISC)
 434         return (EINVAL);
 435     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 436         return EIO;
 437     if (uio->uio_resid > if_mtu(sc->sc_if) + PPP_HDRLEN ||
 438       uio->uio_resid < PPP_HDRLEN)
 439         return (EMSGSIZE);
 440     m = nb_TO_NB(pppgetbuf(sc->sc_if));
 441
 442     if (m == NULL){
 443       if (sc->sc_flags & SC_DEBUG)
 444         IOLogDbg("No buffers available for user level write()\n");
 445       return(ENOBUFS);
 446     }
 447     NB_GROW_TOP(m, PPP_HDRLEN);
 448     len = uio->uio_resid;
 449     if (error = uiomove(NB_MAP(m), NB_SIZE(m), UIO_WRITE, uio)) {
 450         NB_FREE(m);
 451         return error;
 452     }
 453     NB_SHRINK_BOT(m, NB_SIZE(m) - len);
 454     dst.sa_family = AF_UNSPEC;
 455     bcopy(mtod(m, u_char *), dst.sa_data, PPP_HDRLEN);
 456
 457     NB_SHRINK_TOP(m, PPP_HDRLEN);
 458     return (pppoutput(sc->sc_if, NB_TO_nb(m), &dst));
 459 }
 460
 461 /*
 462  * Line specific (tty) ioctl routine.
 463  * This discipline requires that tty device drivers call
 464  * the line specific l_ioctl routine from their ioctl routines.
 465  */
 466 /* ARGSUSED */
 467 int
 468 ppptioctl(tp, cmd, data, flag)
 469     struct tty *tp;
 470     void *data;
 471     int cmd, flag;
 472 {
 473     struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 474     int error, s;
 475
 476     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 477         return -1;
 478
 479     error = 0;
 480     switch (cmd) {
 481     case PPPIOCSASYNCMAP:
 482         if (! suser())
 483             return EPERM;
 484
 485         sc->sc_asyncmap[0] = *(u_int *)data;
 486         break;
 487
 488     case PPPIOCGASYNCMAP:
 489         *(u_int *)data = sc->sc_asyncmap[0];
 490         break;
 491
 492     case PPPIOCSRASYNCMAP:
 493         if (! suser())
 494             return EPERM;
 495         sc->sc_rasyncmap = *(u_int *)data;
 496         break;
 497
 498     case PPPIOCGRASYNCMAP:
 499         *(u_int *)data = sc->sc_rasyncmap;
 500         break;
 501
 502     case PPPIOCSXASYNCMAP:
 503         if (! suser())
 504             return EPERM;
 505         s = spltty();
 506         bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
 507         sc->sc_asyncmap[1] = 0;                 /* mustn't escape 0x20 - 0x3f */
 508         sc->sc_asyncmap[2] &= ~0x40000000;      /* mustn't escape 0x5e */
 509         sc->sc_asyncmap[3] |= 0x60000000;       /* must escape 0x7d, 0x7e */
 510         splx(s);
 511         break;
 512
 513     case PPPIOCGXASYNCMAP:
 514         bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
 515         break;
 516
 517     default:
 518         error = pppioctl(sc, cmd, data, flag);
 519         if (error == 0 && cmd == PPPIOCSMRU)
 520             pppgetm(sc);
 521     }
 522
 523 #ifdef  i386
 524     if (! error && (cmd & IOC_OUT)) {
 525         struct uthread *_u = uthread_from_thread(current_thread());
 526
 527         /* third arg is destination in ioctl() call... */
 528         copyout(data, (caddr_t) _u->uu_arg[2], (cmd >> 16) & IOCPARM_MASK);
 529     }
 530 #endif
 531
 532     return error;
 533 }
 534
 535 /*
 536  * FCS lookup table as calculated by genfcstab.
 537  */
 538 static const u_int16_t fcstab[256] = {
 539         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 540         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 541         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 542         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 543         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 544         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 545         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 546         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 547         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 548         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 549         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 550         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 551         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 552         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 553         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 554         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 555         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 556         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 557         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 558         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 559         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 560         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 561         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 562         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 563         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 564         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 565         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 566         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 567         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 568         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 569         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 570         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 571 };
 572
 573 /*
 574  * Calculate a new FCS given the current FCS and the new data.
 575  */
 576 static u_int16_t
 577 pppfcs(fcs, cp, len)
 578     register u_int16_t fcs;
 579     register u_char *cp;
 580     register int len;
 581 {
 582     while (len--)
 583         fcs = PPP_FCS(fcs, *cp++);
 584     return (fcs);
 585 }
 586
 587 /*
 588  * This gets called from pppoutput when a new packet is
 589  * put on a queue.
 590  */
 591 static void
 592 pppasyncstart(sc)
 593     register struct ppp_softc *sc;
 594 {
 595     register struct tty *tp = (struct tty *) sc->sc_devp;
 596     int s;
 597
 598     s = splimp();
 599     pppstart(tp);
 600     splx(s);
 601 }
 602
 603 /*
 604  * This gets called when a received packet is placed on
 605  * the inq.
 606  */
 607 static void
 608 pppasyncctlp(sc)
 609     struct ppp_softc *sc;
 610 {
 611     struct tty *tp;
 612
 613     /* Put a placeholder byte in canq for ttselect()/ttnread(). */
 614     tp = (struct tty *) sc->sc_devp;
 615     putc(0, &tp->t_canq);
 616     ttwakeup(tp);
 617 }
 618
 619 /*
 620  * Start output on async tty interface.  Get another datagram
 621  * to send from the interface queue and start sending it.
 622  */
 623 void
 624 pppstart(tp)
 625     register struct tty *tp;
 626 {
 627     register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 628     register NETBUF_T m;
 629     register int len;
 630     register u_char *start, *stop, *cp;
 631     int n, ndone, done, idle;
 632     struct nty *np = ttynty(tp);
 633
 634 #ifdef NEW_CLOCAL
 635
 636     if ((tp->t_state & TS_CARR_ON) == 0 && (np->t_pflags & TP_CLOCAL) == 0
 637
 638 #else
 639
 640     if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_flags & CLOCAL) == 0
 641
 642 #endif /* NEW_CLOCAL */
 643
 644         || sc == NULL || tp != (struct tty *) sc->sc_devp) {
 645         if (tp->t_oproc != NULL)
 646             (*tp->t_oproc)(tp);
 647         return;
 648     }
 649
 650     idle = 0;
 651 #ifdef  OLD_MUX
 652     while (CCOUNT(&tp->t_outq) == 0) {
 653 #else
 654     while (CCOUNT(&tp->t_outq) < PPP_HIWAT) {
 655 #endif
 656         /*
 657          * See if we have an existing packet partly sent.
 658          * If not, get a new packet and start sending it.
 659          */
 660         m = sc->sc_outm;
 661         if (m == NULL) {
 662             /*
 663              * Get another packet to be sent.
 664              */
 665             m = ppp_dequeue(sc);
 666             if (m == NULL) {
 667                 idle = 1;
 668                 break;
 669             }
 670
 671             /*
 672              * The extra PPP_FLAG will start up a new packet, and thus
 673              * will flush any accumulated garbage.  We do this whenever
 674              * the line may have been idle for some time.
 675              */
 676             if (CCOUNT(&tp->t_outq) == 0) {
 677                 ++sc->sc_bytessent;
 678                 (void) putc(PPP_FLAG, &tp->t_outq);
 679             }
 680
 681             /* Calculate the FCS for the first netbuf's worth. */
 682             sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), NB_SIZE(m));
 683             sc->sc_outfcs ^= 0xffff;
 684
 685             cp = mtod(m, u_char *) + NB_SIZE(m);
 686             NB_GROW_BOT(m, PPP_FCSLEN);
 687             *cp++ = sc->sc_outfcs & 0xFF;
 688             *cp++ = (sc->sc_outfcs >> 8) & 0xFF;
 689         }
 690
 691         start = mtod(m, u_char *);
 692         len = NB_SIZE(m);
 693         stop = start + len;
 694         while (len > 0) {
 695             /*
 696              * Find out how many bytes in the string we can
 697              * handle without doing something special.
 698              */
 699             for (cp = start; cp < stop; cp++)
 700                 if (ESCAPE_P(*cp))
 701                     break;
 702
 703             n = cp - start;
 704
 705             if (n) {
 706                 /*
 707                  * b_to_q returns the number of characters
 708                  * _not_ sent
 709                  *
 710                  * NetBSD (0.9 or later), 4.3-Reno or similar.
 711                  */
 712                 ndone = n - b_to_q(start, n, &tp->t_outq);
 713                 len -= ndone;
 714                 start += ndone;
 715                 sc->sc_bytessent += ndone;
 716
 717                 if (ndone < n)
 718                     break;      /* packet doesn't fit */
 719
 720             }
 721
 722             /*
 723              * If there are characters left in the netbuf,
 724              * the first one must be special..
 725              * Put it out in a different form.
 726              */
 727             if (len) {
 728                 if (putc(PPP_ESCAPE, &tp->t_outq))
 729                     break;
 730                 if (putc(*start ^ PPP_TRANS, &tp->t_outq)) {
 731                     (void) unputc(&tp->t_outq);
 732                     break;
 733                 }
 734                 sc->sc_bytessent += 2;
 735                 start++;
 736                 len--;
 737             }
 738         }
 739         /*
 740          * If we didn't empty this netbuf, remember where we're up to.
 741          */
 742         done = len == 0;
 743
 744         if (!done) {
 745             /* remember where we got to */
 746             NB_SHRINK_TOP(m, start - mtod(m, u_char *));
 747             break;      /* can't do any more at the moment */
 748         }
 749
 750         /*
 751          * Output trailing PPP flag and finish packet.
 752          * We make the length zero in case the flag
 753          * cannot be output immediately.
 754          */
 755         NB_SHRINK_TOP(m, NB_SIZE(m));
 756         if (putc(PPP_FLAG, &tp->t_outq))
 757             break;
 758         sc->sc_bytessent++;
 759
 760
 761         /* Finished with this netbuf; free it and move on. */
 762         NB_FREE(m);
 763         m = NULL;
 764         incr_cnt(sc->sc_if, if_opackets);
 765
 766         sc->sc_outm = m;
 767     }
 768
 769     /*
 770      * If there is stuff in the output queue, send it now.
 771      * We are being called in lieu of ttstart and must do what it would.
 772      */
 773     if (tp->t_oproc != NULL)
 774         (*tp->t_oproc)(tp);
 775
 776     /*
 777      * This timeout is needed for operation on a pseudo-tty,
 778      * because the pty code doesn't call pppstart after it has
 779      * drained the t_outq.
 780      */
 781     if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
 782 #if NS_TARGET >= 40
 783         timeout(ppp_timeout, (void *) sc, 1);
 784 #else
 785         ns_timeout(ppp_timeout, (void *) sc, 1 * (1000000000L / HZ), CALLOUT_PRI_SOFTINT0);
 786 #endif /*NS_TARGET */
 787         sc->sc_flags |= SC_TIMEOUT;
 788     }
 789
 790     return;
 791 }
 792
 793 /*
 794  * Timeout routine - try to start some more output.
 795  */
 796 static int
 797 ppp_timeout(x)
 798     void *x;
 799 {
 800     struct ppp_softc *sc = (struct ppp_softc *) x;
 801     struct tty *tp = (struct tty *) sc->sc_devp;
 802     int s;
 803
 804     s = splimp();
 805     sc->sc_flags &= ~SC_TIMEOUT;
 806     pppstart(tp);
 807     splx(s);
 808     return 0;
 809 }
 810
 811 /*
 812  * Allocate enough netbuf to handle current MRU.
 813  *
 814  * Warning Will Robinson:  pppgetm() can get called at interrupt-level!
 815  */
 816 void
 817 pppgetm(sc)
 818     register struct ppp_softc *sc;
 819 {
 820     int s;
 821
 822     s = splimp();
 823     /*
 824      * When the MRU is being changed, we could conceivably end up
 825      * nuking a packet being received, but I doubt it, since the
 826      * hand-shake is lock-step (ie. single packet).
 827      */
 828     if (sc->sc_m != NULL)
 829         NB_FREE(sc->sc_m);
 830     sc->sc_m = nbq_dequeue(&sc->sc_freeq);
 831     splx(s);
 832 }
 833
 834 /*
 835  * 4.3 says this is an unused function.  However,
 836  * it appears to be returning a NULL terminated string
 837  * of several characters.  My guess is that the serial
 838  * driver is doing a little buffering so that we don't
 839  * get burdend with interrupts.
 840  *
 841  * This function gets called when you use the NeXT
 842  * supplied serial drivers.  It does not get called
 843  * with the MuX driver.
 844  *
 845  * In order to expedite the work done here, we
 846  * handle most things here that don't require
 847  * processing of a PPP_FLAG.
 848  *
 849  */
 850
 851 void
 852 ppprend(cp, n, tp)
 853     unsigned char *cp;
 854     int n;
 855     struct tty *tp;
 856 {
 857
 858 #ifndef OPTIMIZE_PPPREND
 859 #warning PPPREND Not optimized!!!
 860   while (n--) pppinput((u_char) *cp++, tp);
 861 #else
 862
 863
 864   register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
 865   register int ret;
 866
 867   if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 868     {
 869       printf("Warning, bad softc structure at %s %d\n", __FILE__, __LINE__);
 870       return;
 871     }
 872
 873   /*
 874    * We can handle FLUSHs, ESCAPES, and non PPP_FLAG characters
 875    */
 876
 877   while (n)
 878     {
 879       if (sc->sc_flags & SC_FLUSH)
 880         {
 881           do
 882             {
 883               if (*(cp++) == PPP_FLAG)
 884                 {
 885                   pppinput(PPP_FLAG, tp);
 886                   --n;
 887                   break;
 888                 }
 889               else if (sc->sc_flags & SC_LOG_FLUSH)
 890                 ppplogchar(sc, *cp);
 891             }
 892           while(--n);
 893         }
 894       else if (sc->sc_ilen > 3 &&
 895                (NB_SIZE(sc->sc_m) - sc->sc_ilen) > n &&
 896                *cp != PPP_FLAG &&
 897                *cp != PPP_ESCAPE)        /* Dont really handle escapes properly...should */
 898         {
 899           unsigned char* cp1 = cp;
 900           if (sc->sc_flags & SC_ESCAPED)
 901             {
 902               sc->sc_flags &= ~SC_ESCAPED;
 903               *cp ^= PPP_TRANS;
 904             }
 905
 906           do
 907             {
 908               sc->sc_fcs = PPP_FCS(sc->sc_fcs, *(cp++));
 909               if (sc->sc_flags & SC_LOG_RAWIN)
 910                 ppplogchar(sc, *cp);
 911
 912             } while(--n && *cp != PPP_FLAG && *cp != PPP_ESCAPE);
 913
 914
 915           bcopy(cp1, sc->sc_mp, (cp-cp1));
 916
 917           sc->sc_bytesrcvd += (cp - cp1);
 918           sc->sc_ilen += (cp-cp1);
 919           sc->sc_mp += (cp-cp1);
 920
 921         }
 922       else
 923         {
 924           --n;
 925           pppinput(*(cp++), tp);
 926         }
 927     }
 928
 929 #endif /* OPTIMIZE_PPPREND */
 930 }
 931
 932 /*
 933  * tty interface receiver interrupt.
 934  */
 935 static const unsigned paritytab[8] = {
 936     0x96696996, 0x69969669, 0x69969669, 0x96696996,
 937     0x69969669, 0x96696996, 0x96696996, 0x69969669
 938 };
 939
 940 void
 941 pppinput(c, tp)
 942     int c;
 943     register struct tty *tp;
 944 {
 945     register struct ppp_softc *sc;
 946     NETBUF_T m;
 947     int ilen, s;
 948
 949     sc = (struct ppp_softc *) tp->t_sc;
 950     if (sc == NULL || tp != (struct tty *) sc->sc_devp)
 951         return;
 952
 953     ++tk_nin;
 954     ++sc->sc_bytesrcvd;
 955
 956     if (c & TTY_FE) {
 957         /* framing error or overrun on this char - abort packet */
 958         IOLogDbg("ppp%d: bad char 0x%x\n", if_unit(sc->sc_if), c);
 959         goto flush;
 960     }
 961
 962     c &= 0xff;
 963
 964     if (c & 0x80)
 965         sc->sc_flags |= SC_RCV_B7_1;
 966     else
 967         sc->sc_flags |= SC_RCV_B7_0;
 968     if (paritytab[c >> 5] & (1 << (c & 0x1F)))
 969         sc->sc_flags |= SC_RCV_ODDP;
 970     else
 971         sc->sc_flags |= SC_RCV_EVNP;
 972
 973     if (sc->sc_flags & SC_LOG_RAWIN)
 974         ppplogchar(sc, c);
 975
 976     if (c == PPP_FLAG) {
 977
 978       if (sc->sc_ilen == 0)
 979         return;
 980
 981         ilen = sc->sc_ilen;
 982         sc->sc_ilen = 0;
 983
 984         if (sc->sc_rawin_count > 0)
 985             ppplogchar(sc, -1);
 986
 987         /*
 988          * From the RFC:
 989          *  Each Control Escape octet is also
 990          *  removed, and the following octet is exclusive-or'd with hexadecimal
 991          *  0x20, unless it is the Flag Sequence (which aborts a frame).
 992          *
 993          * So, if SC_ESCAPED is set, then we've seen the packet
 994          * abort sequence "}~".
 995          */
 996         if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) ||
 997             ((ilen > 0) && (sc->sc_fcs != PPP_GOODFCS)))
 998           {
 999             sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */
1000             if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0)
1001               {
1002                 IOLog("ppp%d: bad fcs 0x%04x\n", if_unit(sc->sc_if), sc->sc_fcs);
1003                 incr_cnt(sc->sc_if, if_ierrors);
1004               }
1005             else
1006               {
1007                 IOLog("ppp%d: bad packet flushed...\n", if_unit(sc->sc_if));
1008                 sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
1009               }
1010             return;
1011           }
1012
1013         if (ilen < (PPP_HDRLEN + PPP_FCSLEN))
1014           {
1015             if (ilen)
1016               {
1017                 IOLogDbg("ppp%d: too short (%d)\n", if_unit(sc->sc_if), ilen);
1018                 incr_cnt(sc->sc_if, if_ierrors);
1019                 sc->sc_flags |= SC_PKTLOST;
1020               }
1021             return;
1022           }
1023
1024         /*
1025          * Remove FCS trailer.  Set packet length...
1026          */
1027         ilen -= PPP_FCSLEN;
1028         NB_SHRINK_BOT(sc->sc_m, NB_SIZE(sc->sc_m) - ilen);
1029
1030         /* excise this netbuf */
1031         m = sc->sc_m;
1032         sc->sc_m = NULL;
1033
1034         ppppktin(sc, m, sc->sc_flags & SC_PKTLOST);
1035         sc->sc_flags &= ~SC_PKTLOST;
1036
1037         pppgetm(sc);
1038         return;
1039     }
1040
1041     if (sc->sc_flags & SC_FLUSH) {
1042         if (sc->sc_flags & SC_LOG_FLUSH)
1043             ppplogchar(sc, c);
1044         return;
1045     }
1046
1047 /*
1048  * From the RFC:
1049  *  On reception, prior to FCS computation, each octet with value less
1050  *  than hexadecimal 0x20 is checked.  If it is flagged in the receiving
1051  *  ACCM, it is simply removed (it may have been inserted by intervening
1052  *  data communications equipment).  Each Control Escape octet is also
1053  *  removed, and the following octet is exclusive-or'd with hexadecimal
1054  *  0x20, unless it is the Flag Sequence (which aborts a frame).
1055  */
1056     if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) {
1057         return;
1058     }
1059
1060     if (sc->sc_flags & SC_ESCAPED) {
1061         sc->sc_flags &= ~SC_ESCAPED;
1062         c ^= PPP_TRANS;
1063     } else if (c == PPP_ESCAPE) {
1064         sc->sc_flags |= SC_ESCAPED;
1065         return;
1066     }
1067
1068     /*
1069      * Initialize buffer on first octet received.
1070      * First octet could be address or protocol (when compressing
1071      * address/control).
1072      * Second octet is control.
1073      * Third octet is first or second (when compressing protocol)
1074      * octet of protocol.
1075      * Fourth octet is second octet of protocol.
1076      */
1077     if (sc->sc_ilen == 0) {
1078
1079         /* reset the input netbuf */
1080         if (sc->sc_m == NULL) {
1081             pppgetm(sc);
1082             if (sc->sc_m == NULL) {
1083                 /*
1084                  * We schedule a call here as pppindrain will
1085                  * not get scheduled and we need the free buffers
1086                  */
1087                 IOLog("ppp%d: no input netbufs!\n", if_unit(sc->sc_if));
1088                 (void)pppsched(pppfillfreeq, sc);
1089                 goto flush;
1090             }
1091         }
1092         m = sc->sc_m;
1093         sc->sc_mp = mtod(m, char *);
1094         sc->sc_fcs = PPP_INITFCS;
1095
1096         if (c != PPP_ALLSTATIONS) {
1097             if (sc->sc_flags & SC_REJ_COMP_AC) {
1098                 IOLogDbg("ppp%d: garbage received: 0x%02x (need 0x%02x)\n",
1099                            if_unit(sc->sc_if), c, PPP_ALLSTATIONS);
1100                 goto flush;
1101             }
1102             *sc->sc_mp++ = PPP_ALLSTATIONS;
1103             *sc->sc_mp++ = PPP_UI;
1104             sc->sc_ilen += 2;
1105         }
1106     }
1107
1108
1109     if (sc->sc_ilen == 1 && c != PPP_UI) {
1110         IOLogDbg("ppp%d: missing UI (0x%02x), got 0x%02x\n",
1111                    if_unit(sc->sc_if), PPP_UI, c);
1112         goto flush;
1113     }
1114
1115     if (sc->sc_ilen == 2 && (c & 1) == 1) {
1116         /* a compressed protocol */
1117         *sc->sc_mp++ = 0;
1118         sc->sc_ilen++;
1119     }
1120
1121     if (sc->sc_ilen == 3 && (c & 1) == 0) {
1122         IOLogDbg("ppp%d: bad protocol %x\n", if_unit(sc->sc_if),
1123                    (sc->sc_mp[-1] << 8) + c);
1124         goto flush;
1125     }
1126
1127     /* packet beyond configured mru? */
1128     if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
1129         IOLogDbg("ppp%d: packet too big (%d bytes)\n", if_unit(sc->sc_if),
1130                 sc->sc_ilen);
1131         goto flush;
1132     }
1133
1134     /* ilen was incremented above... */
1135     *sc->sc_mp++ = c;
1136     sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
1137     return;
1138
1139  flush:
1140     if (!(sc->sc_flags & SC_FLUSH)) {
1141         incr_cnt(sc->sc_if, if_ierrors);
1142         sc->sc_flags |= SC_FLUSH;
1143         if (sc->sc_flags & SC_LOG_FLUSH)
1144             ppplogchar(sc, c);
1145     }
1146     return;
1147 }
1148
1149 int
1150 install_ppp_ld(void)
1151 {
1152     return tty_ld_install(PPPDISC, NORMAL_LDISC, pppopen,
1153                           pppclose, pppread, pppwrite, ppptioctl,
1154                           pppinput, ppprend, pppstart, ttymodem,
1155                           ttselect);
1156 }
1157
1158 #define MAX_DUMP_BYTES  128
1159
1160 void
1161 ppplogchar(sc, c)
1162     struct ppp_softc *sc;
1163     int c;
1164 {
1165     if (c >= 0)
1166         sc->sc_rawin[sc->sc_rawin_count++] = c;
1167     if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
1168         || c < 0 && sc->sc_rawin_count > 0) {
1169         IOLog("ppp%d input:\n", if_unit(sc->sc_if));
1170         pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
1171         sc->sc_rawin_count = 0;
1172     }
1173 }
1174
1175 static void
1176 pppdumpb(b, l)
1177     u_char *b;
1178     int l;
1179 {
1180     char buf[3*MAX_DUMP_BYTES+4];
1181     char *bp = buf;
1182     static char digits[] = "0123456789abcdef";
1183
1184     while (l--) {
1185         if (bp >= buf + sizeof(buf) - 3) {
1186             *bp++ = '>';
1187             break;
1188         }
1189         *bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
1190         *bp++ = digits[*b++ & 0xf];
1191         *bp++ = ' ';
1192     }
1193
1194     *bp = 0;
1195     IOLog("%s\n", buf);
1196 }
1197 #endif  /* NUM_PPP > 0 */