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