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