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