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