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