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