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