blob: f1a52def1241a387c28ed6f5a045b839df8f994f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * PPP async serial channel driver for Linux.
3 *
4 * Copyright 1999 Paul Mackerras.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 * This driver provides the encapsulation and framing for sending
12 * and receiving PPP frames over async serial lines. It relies on
13 * the generic PPP layer to give it frames to send and to process
14 * received frames. It implements the PPP line discipline.
15 *
16 * Part of the code in this driver was inspired by the old async-only
17 * PPP driver, written by Michael Callahan and Al Longyear, and
18 * subsequently hacked by Paul Mackerras.
19 */
20
21#include <linux/module.h>
22#include <linux/kernel.h>
23#include <linux/skbuff.h>
24#include <linux/tty.h>
25#include <linux/netdevice.h>
26#include <linux/poll.h>
27#include <linux/crc-ccitt.h>
28#include <linux/ppp_defs.h>
29#include <linux/if_ppp.h>
30#include <linux/ppp_channel.h>
31#include <linux/spinlock.h>
32#include <linux/init.h>
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -080033#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <asm/uaccess.h>
Philippe De Muyter6722e782005-11-08 09:40:26 -080035#include <asm/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37#define PPP_VERSION "2.4.2"
38
39#define OBUFSIZE 256
40
41/* Structure for storing local state. */
42struct asyncppp {
43 struct tty_struct *tty;
44 unsigned int flags;
45 unsigned int state;
46 unsigned int rbits;
47 int mru;
48 spinlock_t xmit_lock;
49 spinlock_t recv_lock;
50 unsigned long xmit_flags;
51 u32 xaccm[8];
52 u32 raccm;
53 unsigned int bytes_sent;
54 unsigned int bytes_rcvd;
55
56 struct sk_buff *tpkt;
57 int tpkt_pos;
58 u16 tfcs;
59 unsigned char *optr;
60 unsigned char *olim;
61 unsigned long last_xmit;
62
63 struct sk_buff *rpkt;
64 int lcp_fcs;
65 struct sk_buff_head rqueue;
66
67 struct tasklet_struct tsk;
68
69 atomic_t refcnt;
70 struct semaphore dead_sem;
71 struct ppp_channel chan; /* interface to generic ppp layer */
72 unsigned char obuf[OBUFSIZE];
73};
74
75/* Bit numbers in xmit_flags */
76#define XMIT_WAKEUP 0
77#define XMIT_FULL 1
78#define XMIT_BUSY 2
79
80/* State bits */
81#define SC_TOSS 1
82#define SC_ESCAPE 2
83#define SC_PREV_ERROR 4
84
85/* Bits in rbits */
86#define SC_RCV_BITS (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
87
88static int flag_time = HZ;
89module_param(flag_time, int, 0);
90MODULE_PARM_DESC(flag_time, "ppp_async: interval between flagged packets (in clock ticks)");
91MODULE_LICENSE("GPL");
92MODULE_ALIAS_LDISC(N_PPP);
93
94/*
95 * Prototypes.
96 */
97static int ppp_async_encode(struct asyncppp *ap);
98static int ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb);
99static int ppp_async_push(struct asyncppp *ap);
100static void ppp_async_flush_output(struct asyncppp *ap);
101static void ppp_async_input(struct asyncppp *ap, const unsigned char *buf,
102 char *flags, int count);
103static int ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd,
104 unsigned long arg);
105static void ppp_async_process(unsigned long arg);
106
107static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,
108 int len, int inbound);
109
110static struct ppp_channel_ops async_ops = {
111 ppp_async_send,
112 ppp_async_ioctl
113};
114
115/*
116 * Routines implementing the PPP line discipline.
117 */
118
119/*
120 * We have a potential race on dereferencing tty->disc_data,
121 * because the tty layer provides no locking at all - thus one
122 * cpu could be running ppp_asynctty_receive while another
123 * calls ppp_asynctty_close, which zeroes tty->disc_data and
124 * frees the memory that ppp_asynctty_receive is using. The best
125 * way to fix this is to use a rwlock in the tty struct, but for now
126 * we use a single global rwlock for all ttys in ppp line discipline.
127 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400128 * FIXME: this is no longer true. The _close path for the ldisc is
129 * now guaranteed to be sane.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 */
131static DEFINE_RWLOCK(disc_data_lock);
132
133static struct asyncppp *ap_get(struct tty_struct *tty)
134{
135 struct asyncppp *ap;
136
137 read_lock(&disc_data_lock);
138 ap = tty->disc_data;
139 if (ap != NULL)
140 atomic_inc(&ap->refcnt);
141 read_unlock(&disc_data_lock);
142 return ap;
143}
144
145static void ap_put(struct asyncppp *ap)
146{
147 if (atomic_dec_and_test(&ap->refcnt))
148 up(&ap->dead_sem);
149}
150
151/*
152 * Called when a tty is put into PPP line discipline. Called in process
153 * context.
154 */
155static int
156ppp_asynctty_open(struct tty_struct *tty)
157{
158 struct asyncppp *ap;
159 int err;
160
Alan Coxf34d7a52008-04-30 00:54:13 -0700161 if (tty->ops->write == NULL)
162 return -EOPNOTSUPP;
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 err = -ENOMEM;
Yoann Padioleaudd00cc42007-07-19 01:49:03 -0700165 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
Joe Perchescd228d52007-11-12 18:07:31 -0800166 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 goto out;
168
169 /* initialize the asyncppp structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 ap->tty = tty;
171 ap->mru = PPP_MRU;
172 spin_lock_init(&ap->xmit_lock);
173 spin_lock_init(&ap->recv_lock);
174 ap->xaccm[0] = ~0U;
175 ap->xaccm[3] = 0x60000000U;
176 ap->raccm = ~0U;
177 ap->optr = ap->obuf;
178 ap->olim = ap->obuf;
179 ap->lcp_fcs = -1;
180
181 skb_queue_head_init(&ap->rqueue);
182 tasklet_init(&ap->tsk, ppp_async_process, (unsigned long) ap);
183
184 atomic_set(&ap->refcnt, 1);
185 init_MUTEX_LOCKED(&ap->dead_sem);
186
187 ap->chan.private = ap;
188 ap->chan.ops = &async_ops;
189 ap->chan.mtu = PPP_MRU;
190 err = ppp_register_channel(&ap->chan);
191 if (err)
192 goto out_free;
193
194 tty->disc_data = ap;
Alan Cox33f0f882006-01-09 20:54:13 -0800195 tty->receive_room = 65536;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 return 0;
197
198 out_free:
199 kfree(ap);
200 out:
201 return err;
202}
203
204/*
205 * Called when the tty is put into another line discipline
206 * or it hangs up. We have to wait for any cpu currently
207 * executing in any of the other ppp_asynctty_* routines to
208 * finish before we can call ppp_unregister_channel and free
209 * the asyncppp struct. This routine must be called from
210 * process context, not interrupt or softirq context.
211 */
212static void
213ppp_asynctty_close(struct tty_struct *tty)
214{
215 struct asyncppp *ap;
216
217 write_lock_irq(&disc_data_lock);
218 ap = tty->disc_data;
219 tty->disc_data = NULL;
220 write_unlock_irq(&disc_data_lock);
Joe Perchescd228d52007-11-12 18:07:31 -0800221 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 return;
223
224 /*
225 * We have now ensured that nobody can start using ap from now
226 * on, but we have to wait for all existing users to finish.
227 * Note that ppp_unregister_channel ensures that no calls to
228 * our channel ops (i.e. ppp_async_send/ioctl) are in progress
229 * by the time it returns.
230 */
231 if (!atomic_dec_and_test(&ap->refcnt))
232 down(&ap->dead_sem);
233 tasklet_kill(&ap->tsk);
234
235 ppp_unregister_channel(&ap->chan);
Joe Perchescd228d52007-11-12 18:07:31 -0800236 if (ap->rpkt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 kfree_skb(ap->rpkt);
238 skb_queue_purge(&ap->rqueue);
Joe Perchescd228d52007-11-12 18:07:31 -0800239 if (ap->tpkt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 kfree_skb(ap->tpkt);
241 kfree(ap);
242}
243
244/*
245 * Called on tty hangup in process context.
246 *
247 * Wait for I/O to driver to complete and unregister PPP channel.
248 * This is already done by the close routine, so just call that.
249 */
250static int ppp_asynctty_hangup(struct tty_struct *tty)
251{
252 ppp_asynctty_close(tty);
253 return 0;
254}
255
256/*
257 * Read does nothing - no data is ever available this way.
258 * Pppd reads and writes packets via /dev/ppp instead.
259 */
260static ssize_t
261ppp_asynctty_read(struct tty_struct *tty, struct file *file,
262 unsigned char __user *buf, size_t count)
263{
264 return -EAGAIN;
265}
266
267/*
268 * Write on the tty does nothing, the packets all come in
269 * from the ppp generic stuff.
270 */
271static ssize_t
272ppp_asynctty_write(struct tty_struct *tty, struct file *file,
273 const unsigned char *buf, size_t count)
274{
275 return -EAGAIN;
276}
277
278/*
279 * Called in process context only. May be re-entered by multiple
280 * ioctl calling threads.
281 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283static int
284ppp_asynctty_ioctl(struct tty_struct *tty, struct file *file,
285 unsigned int cmd, unsigned long arg)
286{
287 struct asyncppp *ap = ap_get(tty);
288 int err, val;
289 int __user *p = (int __user *)arg;
290
Joe Perchescd228d52007-11-12 18:07:31 -0800291 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return -ENXIO;
293 err = -EFAULT;
294 switch (cmd) {
295 case PPPIOCGCHAN:
296 err = -ENXIO;
Joe Perchescd228d52007-11-12 18:07:31 -0800297 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 break;
299 err = -EFAULT;
300 if (put_user(ppp_channel_index(&ap->chan), p))
301 break;
302 err = 0;
303 break;
304
305 case PPPIOCGUNIT:
306 err = -ENXIO;
Joe Perchescd228d52007-11-12 18:07:31 -0800307 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 break;
309 err = -EFAULT;
310 if (put_user(ppp_unit_number(&ap->chan), p))
311 break;
312 err = 0;
313 break;
314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 case TCFLSH:
316 /* flush our buffers and the serial port's buffer */
317 if (arg == TCIOFLUSH || arg == TCOFLUSH)
318 ppp_async_flush_output(ap);
Alan Coxd0127532007-11-07 01:27:34 -0800319 err = tty_perform_flush(tty, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 break;
321
322 case FIONREAD:
323 val = 0;
324 if (put_user(val, p))
325 break;
326 err = 0;
327 break;
328
329 default:
Alan Coxd0127532007-11-07 01:27:34 -0800330 /* Try the various mode ioctls */
331 err = tty_mode_ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 }
333
334 ap_put(ap);
335 return err;
336}
337
338/* No kernel lock - fine */
339static unsigned int
340ppp_asynctty_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
341{
342 return 0;
343}
344
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345/*
346 * This can now be called from hard interrupt level as well
347 * as soft interrupt level or mainline.
348 */
349static void
350ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
351 char *cflags, int count)
352{
353 struct asyncppp *ap = ap_get(tty);
354 unsigned long flags;
355
Joe Perchescd228d52007-11-12 18:07:31 -0800356 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return;
358 spin_lock_irqsave(&ap->recv_lock, flags);
359 ppp_async_input(ap, buf, cflags, count);
360 spin_unlock_irqrestore(&ap->recv_lock, flags);
David S. Millerb03efcf2005-07-08 14:57:23 -0700361 if (!skb_queue_empty(&ap->rqueue))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 tasklet_schedule(&ap->tsk);
363 ap_put(ap);
Alan Cox39c2e602008-04-30 00:54:18 -0700364 tty_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365}
366
367static void
368ppp_asynctty_wakeup(struct tty_struct *tty)
369{
370 struct asyncppp *ap = ap_get(tty);
371
372 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Joe Perchescd228d52007-11-12 18:07:31 -0800373 if (!ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 return;
375 set_bit(XMIT_WAKEUP, &ap->xmit_flags);
376 tasklet_schedule(&ap->tsk);
377 ap_put(ap);
378}
379
380
381static struct tty_ldisc ppp_ldisc = {
382 .owner = THIS_MODULE,
383 .magic = TTY_LDISC_MAGIC,
384 .name = "ppp",
385 .open = ppp_asynctty_open,
386 .close = ppp_asynctty_close,
387 .hangup = ppp_asynctty_hangup,
388 .read = ppp_asynctty_read,
389 .write = ppp_asynctty_write,
390 .ioctl = ppp_asynctty_ioctl,
391 .poll = ppp_asynctty_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 .receive_buf = ppp_asynctty_receive,
393 .write_wakeup = ppp_asynctty_wakeup,
394};
395
396static int __init
397ppp_async_init(void)
398{
399 int err;
400
401 err = tty_register_ldisc(N_PPP, &ppp_ldisc);
402 if (err != 0)
403 printk(KERN_ERR "PPP_async: error %d registering line disc.\n",
404 err);
405 return err;
406}
407
408/*
409 * The following routines provide the PPP channel interface.
410 */
411static int
412ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd, unsigned long arg)
413{
414 struct asyncppp *ap = chan->private;
415 void __user *argp = (void __user *)arg;
416 int __user *p = argp;
417 int err, val;
418 u32 accm[8];
419
420 err = -EFAULT;
421 switch (cmd) {
422 case PPPIOCGFLAGS:
423 val = ap->flags | ap->rbits;
424 if (put_user(val, p))
425 break;
426 err = 0;
427 break;
428 case PPPIOCSFLAGS:
429 if (get_user(val, p))
430 break;
431 ap->flags = val & ~SC_RCV_BITS;
432 spin_lock_irq(&ap->recv_lock);
433 ap->rbits = val & SC_RCV_BITS;
434 spin_unlock_irq(&ap->recv_lock);
435 err = 0;
436 break;
437
438 case PPPIOCGASYNCMAP:
439 if (put_user(ap->xaccm[0], (u32 __user *)argp))
440 break;
441 err = 0;
442 break;
443 case PPPIOCSASYNCMAP:
444 if (get_user(ap->xaccm[0], (u32 __user *)argp))
445 break;
446 err = 0;
447 break;
448
449 case PPPIOCGRASYNCMAP:
450 if (put_user(ap->raccm, (u32 __user *)argp))
451 break;
452 err = 0;
453 break;
454 case PPPIOCSRASYNCMAP:
455 if (get_user(ap->raccm, (u32 __user *)argp))
456 break;
457 err = 0;
458 break;
459
460 case PPPIOCGXASYNCMAP:
461 if (copy_to_user(argp, ap->xaccm, sizeof(ap->xaccm)))
462 break;
463 err = 0;
464 break;
465 case PPPIOCSXASYNCMAP:
466 if (copy_from_user(accm, argp, sizeof(accm)))
467 break;
468 accm[2] &= ~0x40000000U; /* can't escape 0x5e */
469 accm[3] |= 0x60000000U; /* must escape 0x7d, 0x7e */
470 memcpy(ap->xaccm, accm, sizeof(ap->xaccm));
471 err = 0;
472 break;
473
474 case PPPIOCGMRU:
475 if (put_user(ap->mru, p))
476 break;
477 err = 0;
478 break;
479 case PPPIOCSMRU:
480 if (get_user(val, p))
481 break;
482 if (val < PPP_MRU)
483 val = PPP_MRU;
484 ap->mru = val;
485 err = 0;
486 break;
487
488 default:
489 err = -ENOTTY;
490 }
491
492 return err;
493}
494
495/*
496 * This is called at softirq level to deliver received packets
497 * to the ppp_generic code, and to tell the ppp_generic code
498 * if we can accept more output now.
499 */
500static void ppp_async_process(unsigned long arg)
501{
502 struct asyncppp *ap = (struct asyncppp *) arg;
503 struct sk_buff *skb;
504
505 /* process received packets */
506 while ((skb = skb_dequeue(&ap->rqueue)) != NULL) {
507 if (skb->cb[0])
508 ppp_input_error(&ap->chan, 0);
509 ppp_input(&ap->chan, skb);
510 }
511
512 /* try to push more stuff out */
513 if (test_bit(XMIT_WAKEUP, &ap->xmit_flags) && ppp_async_push(ap))
514 ppp_output_wakeup(&ap->chan);
515}
516
517/*
518 * Procedures for encapsulation and framing.
519 */
520
521/*
522 * Procedure to encode the data for async serial transmission.
523 * Does octet stuffing (escaping), puts the address/control bytes
524 * on if A/C compression is disabled, and does protocol compression.
525 * Assumes ap->tpkt != 0 on entry.
526 * Returns 1 if we finished the current frame, 0 otherwise.
527 */
528
529#define PUT_BYTE(ap, buf, c, islcp) do { \
530 if ((islcp && c < 0x20) || (ap->xaccm[c >> 5] & (1 << (c & 0x1f)))) {\
531 *buf++ = PPP_ESCAPE; \
532 *buf++ = c ^ 0x20; \
533 } else \
534 *buf++ = c; \
535} while (0)
536
537static int
538ppp_async_encode(struct asyncppp *ap)
539{
540 int fcs, i, count, c, proto;
541 unsigned char *buf, *buflim;
542 unsigned char *data;
543 int islcp;
544
545 buf = ap->obuf;
546 ap->olim = buf;
547 ap->optr = buf;
548 i = ap->tpkt_pos;
549 data = ap->tpkt->data;
550 count = ap->tpkt->len;
551 fcs = ap->tfcs;
552 proto = (data[0] << 8) + data[1];
553
554 /*
555 * LCP packets with code values between 1 (configure-reqest)
556 * and 7 (code-reject) must be sent as though no options
557 * had been negotiated.
558 */
559 islcp = proto == PPP_LCP && 1 <= data[2] && data[2] <= 7;
560
561 if (i == 0) {
562 if (islcp)
563 async_lcp_peek(ap, data, count, 0);
564
565 /*
566 * Start of a new packet - insert the leading FLAG
567 * character if necessary.
568 */
569 if (islcp || flag_time == 0
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800570 || time_after_eq(jiffies, ap->last_xmit + flag_time))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 *buf++ = PPP_FLAG;
572 ap->last_xmit = jiffies;
573 fcs = PPP_INITFCS;
574
575 /*
576 * Put in the address/control bytes if necessary
577 */
578 if ((ap->flags & SC_COMP_AC) == 0 || islcp) {
579 PUT_BYTE(ap, buf, 0xff, islcp);
580 fcs = PPP_FCS(fcs, 0xff);
581 PUT_BYTE(ap, buf, 0x03, islcp);
582 fcs = PPP_FCS(fcs, 0x03);
583 }
584 }
585
586 /*
587 * Once we put in the last byte, we need to put in the FCS
588 * and closing flag, so make sure there is at least 7 bytes
589 * of free space in the output buffer.
590 */
591 buflim = ap->obuf + OBUFSIZE - 6;
592 while (i < count && buf < buflim) {
593 c = data[i++];
594 if (i == 1 && c == 0 && (ap->flags & SC_COMP_PROT))
595 continue; /* compress protocol field */
596 fcs = PPP_FCS(fcs, c);
597 PUT_BYTE(ap, buf, c, islcp);
598 }
599
600 if (i < count) {
601 /*
602 * Remember where we are up to in this packet.
603 */
604 ap->olim = buf;
605 ap->tpkt_pos = i;
606 ap->tfcs = fcs;
607 return 0;
608 }
609
610 /*
611 * We have finished the packet. Add the FCS and flag.
612 */
613 fcs = ~fcs;
614 c = fcs & 0xff;
615 PUT_BYTE(ap, buf, c, islcp);
616 c = (fcs >> 8) & 0xff;
617 PUT_BYTE(ap, buf, c, islcp);
618 *buf++ = PPP_FLAG;
619 ap->olim = buf;
620
621 kfree_skb(ap->tpkt);
622 ap->tpkt = NULL;
623 return 1;
624}
625
626/*
627 * Transmit-side routines.
628 */
629
630/*
631 * Send a packet to the peer over an async tty line.
632 * Returns 1 iff the packet was accepted.
633 * If the packet was not accepted, we will call ppp_output_wakeup
634 * at some later time.
635 */
636static int
637ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb)
638{
639 struct asyncppp *ap = chan->private;
640
641 ppp_async_push(ap);
642
643 if (test_and_set_bit(XMIT_FULL, &ap->xmit_flags))
644 return 0; /* already full */
645 ap->tpkt = skb;
646 ap->tpkt_pos = 0;
647
648 ppp_async_push(ap);
649 return 1;
650}
651
652/*
653 * Push as much data as possible out to the tty.
654 */
655static int
656ppp_async_push(struct asyncppp *ap)
657{
658 int avail, sent, done = 0;
659 struct tty_struct *tty = ap->tty;
660 int tty_stuffed = 0;
661
662 /*
663 * We can get called recursively here if the tty write
664 * function calls our wakeup function. This can happen
665 * for example on a pty with both the master and slave
666 * set to PPP line discipline.
667 * We use the XMIT_BUSY bit to detect this and get out,
668 * leaving the XMIT_WAKEUP bit set to tell the other
669 * instance that it may now be able to write more now.
670 */
671 if (test_and_set_bit(XMIT_BUSY, &ap->xmit_flags))
672 return 0;
673 spin_lock_bh(&ap->xmit_lock);
674 for (;;) {
675 if (test_and_clear_bit(XMIT_WAKEUP, &ap->xmit_flags))
676 tty_stuffed = 0;
677 if (!tty_stuffed && ap->optr < ap->olim) {
678 avail = ap->olim - ap->optr;
679 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700680 sent = tty->ops->write(tty, ap->optr, avail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 if (sent < 0)
682 goto flush; /* error, e.g. loss of CD */
683 ap->optr += sent;
684 if (sent < avail)
685 tty_stuffed = 1;
686 continue;
687 }
Joe Perchescd228d52007-11-12 18:07:31 -0800688 if (ap->optr >= ap->olim && ap->tpkt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 if (ppp_async_encode(ap)) {
690 /* finished processing ap->tpkt */
691 clear_bit(XMIT_FULL, &ap->xmit_flags);
692 done = 1;
693 }
694 continue;
695 }
696 /*
697 * We haven't made any progress this time around.
698 * Clear XMIT_BUSY to let other callers in, but
699 * after doing so we have to check if anyone set
700 * XMIT_WAKEUP since we last checked it. If they
701 * did, we should try again to set XMIT_BUSY and go
702 * around again in case XMIT_BUSY was still set when
703 * the other caller tried.
704 */
705 clear_bit(XMIT_BUSY, &ap->xmit_flags);
706 /* any more work to do? if not, exit the loop */
707 if (!(test_bit(XMIT_WAKEUP, &ap->xmit_flags)
Joe Perchescd228d52007-11-12 18:07:31 -0800708 || (!tty_stuffed && ap->tpkt)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 break;
710 /* more work to do, see if we can do it now */
711 if (test_and_set_bit(XMIT_BUSY, &ap->xmit_flags))
712 break;
713 }
714 spin_unlock_bh(&ap->xmit_lock);
715 return done;
716
717flush:
718 clear_bit(XMIT_BUSY, &ap->xmit_flags);
Joe Perchescd228d52007-11-12 18:07:31 -0800719 if (ap->tpkt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 kfree_skb(ap->tpkt);
721 ap->tpkt = NULL;
722 clear_bit(XMIT_FULL, &ap->xmit_flags);
723 done = 1;
724 }
725 ap->optr = ap->olim;
726 spin_unlock_bh(&ap->xmit_lock);
727 return done;
728}
729
730/*
731 * Flush output from our internal buffers.
732 * Called for the TCFLSH ioctl. Can be entered in parallel
733 * but this is covered by the xmit_lock.
734 */
735static void
736ppp_async_flush_output(struct asyncppp *ap)
737{
738 int done = 0;
739
740 spin_lock_bh(&ap->xmit_lock);
741 ap->optr = ap->olim;
742 if (ap->tpkt != NULL) {
743 kfree_skb(ap->tpkt);
744 ap->tpkt = NULL;
745 clear_bit(XMIT_FULL, &ap->xmit_flags);
746 done = 1;
747 }
748 spin_unlock_bh(&ap->xmit_lock);
749 if (done)
750 ppp_output_wakeup(&ap->chan);
751}
752
753/*
754 * Receive-side routines.
755 */
756
757/* see how many ordinary chars there are at the start of buf */
758static inline int
759scan_ordinary(struct asyncppp *ap, const unsigned char *buf, int count)
760{
761 int i, c;
762
763 for (i = 0; i < count; ++i) {
764 c = buf[i];
765 if (c == PPP_ESCAPE || c == PPP_FLAG
766 || (c < 0x20 && (ap->raccm & (1 << c)) != 0))
767 break;
768 }
769 return i;
770}
771
772/* called when a flag is seen - do end-of-packet processing */
773static void
774process_input_packet(struct asyncppp *ap)
775{
776 struct sk_buff *skb;
777 unsigned char *p;
778 unsigned int len, fcs, proto;
779
780 skb = ap->rpkt;
781 if (ap->state & (SC_TOSS | SC_ESCAPE))
782 goto err;
783
784 if (skb == NULL)
785 return; /* 0-length packet */
786
787 /* check the FCS */
788 p = skb->data;
789 len = skb->len;
790 if (len < 3)
791 goto err; /* too short */
792 fcs = PPP_INITFCS;
793 for (; len > 0; --len)
794 fcs = PPP_FCS(fcs, *p++);
795 if (fcs != PPP_GOODFCS)
796 goto err; /* bad FCS */
797 skb_trim(skb, skb->len - 2);
798
799 /* check for address/control and protocol compression */
800 p = skb->data;
Paul Mackerras7c5050e2007-04-19 13:05:52 -0700801 if (p[0] == PPP_ALLSTATIONS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 /* chop off address/control */
Paul Mackerras7c5050e2007-04-19 13:05:52 -0700803 if (p[1] != PPP_UI || skb->len < 3)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 goto err;
805 p = skb_pull(skb, 2);
806 }
807 proto = p[0];
808 if (proto & 1) {
809 /* protocol is compressed */
810 skb_push(skb, 1)[0] = 0;
811 } else {
812 if (skb->len < 2)
813 goto err;
814 proto = (proto << 8) + p[1];
815 if (proto == PPP_LCP)
816 async_lcp_peek(ap, p, skb->len, 1);
817 }
818
819 /* queue the frame to be processed */
820 skb->cb[0] = ap->state;
821 skb_queue_tail(&ap->rqueue, skb);
822 ap->rpkt = NULL;
823 ap->state = 0;
824 return;
825
826 err:
827 /* frame had an error, remember that, reset SC_TOSS & SC_ESCAPE */
828 ap->state = SC_PREV_ERROR;
Philippe De Muyter6722e782005-11-08 09:40:26 -0800829 if (skb) {
830 /* make skb appear as freshly allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 skb_trim(skb, 0);
Philippe De Muyter6722e782005-11-08 09:40:26 -0800832 skb_reserve(skb, - skb_headroom(skb));
833 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834}
835
836/* Called when the tty driver has data for us. Runs parallel with the
837 other ldisc functions but will not be re-entered */
838
839static void
840ppp_async_input(struct asyncppp *ap, const unsigned char *buf,
841 char *flags, int count)
842{
843 struct sk_buff *skb;
844 int c, i, j, n, s, f;
845 unsigned char *sp;
846
847 /* update bits used for 8-bit cleanness detection */
848 if (~ap->rbits & SC_RCV_BITS) {
849 s = 0;
850 for (i = 0; i < count; ++i) {
851 c = buf[i];
Joe Perchescd228d52007-11-12 18:07:31 -0800852 if (flags && flags[i] != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 continue;
854 s |= (c & 0x80)? SC_RCV_B7_1: SC_RCV_B7_0;
855 c = ((c >> 4) ^ c) & 0xf;
856 s |= (0x6996 & (1 << c))? SC_RCV_ODDP: SC_RCV_EVNP;
857 }
858 ap->rbits |= s;
859 }
860
861 while (count > 0) {
862 /* scan through and see how many chars we can do in bulk */
863 if ((ap->state & SC_ESCAPE) && buf[0] == PPP_ESCAPE)
864 n = 1;
865 else
866 n = scan_ordinary(ap, buf, count);
867
868 f = 0;
Joe Perchescd228d52007-11-12 18:07:31 -0800869 if (flags && (ap->state & SC_TOSS) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 /* check the flags to see if any char had an error */
871 for (j = 0; j < n; ++j)
872 if ((f = flags[j]) != 0)
873 break;
874 }
875 if (f != 0) {
876 /* start tossing */
877 ap->state |= SC_TOSS;
878
879 } else if (n > 0 && (ap->state & SC_TOSS) == 0) {
880 /* stuff the chars in the skb */
881 skb = ap->rpkt;
Joe Perchescd228d52007-11-12 18:07:31 -0800882 if (!skb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 skb = dev_alloc_skb(ap->mru + PPP_HDRLEN + 2);
Joe Perchescd228d52007-11-12 18:07:31 -0800884 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 goto nomem;
Philippe De Muyter6722e782005-11-08 09:40:26 -0800886 ap->rpkt = skb;
887 }
888 if (skb->len == 0) {
889 /* Try to get the payload 4-byte aligned.
890 * This should match the
891 * PPP_ALLSTATIONS/PPP_UI/compressed tests in
892 * process_input_packet, but we do not have
893 * enough chars here to test buf[1] and buf[2].
894 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (buf[0] != PPP_ALLSTATIONS)
896 skb_reserve(skb, 2 + (buf[0] & 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898 if (n > skb_tailroom(skb)) {
899 /* packet overflowed MRU */
900 ap->state |= SC_TOSS;
901 } else {
902 sp = skb_put(skb, n);
903 memcpy(sp, buf, n);
904 if (ap->state & SC_ESCAPE) {
905 sp[0] ^= 0x20;
906 ap->state &= ~SC_ESCAPE;
907 }
908 }
909 }
910
911 if (n >= count)
912 break;
913
914 c = buf[n];
915 if (flags != NULL && flags[n] != 0) {
916 ap->state |= SC_TOSS;
917 } else if (c == PPP_FLAG) {
918 process_input_packet(ap);
919 } else if (c == PPP_ESCAPE) {
920 ap->state |= SC_ESCAPE;
921 } else if (I_IXON(ap->tty)) {
922 if (c == START_CHAR(ap->tty))
923 start_tty(ap->tty);
924 else if (c == STOP_CHAR(ap->tty))
925 stop_tty(ap->tty);
926 }
927 /* otherwise it's a char in the recv ACCM */
928 ++n;
929
930 buf += n;
Joe Perchescd228d52007-11-12 18:07:31 -0800931 if (flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 flags += n;
933 count -= n;
934 }
935 return;
936
937 nomem:
938 printk(KERN_ERR "PPPasync: no memory (input pkt)\n");
939 ap->state |= SC_TOSS;
940}
941
942/*
943 * We look at LCP frames going past so that we can notice
944 * and react to the LCP configure-ack from the peer.
945 * In the situation where the peer has been sent a configure-ack
946 * already, LCP is up once it has sent its configure-ack
947 * so the immediately following packet can be sent with the
948 * configured LCP options. This allows us to process the following
949 * packet correctly without pppd needing to respond quickly.
950 *
951 * We only respond to the received configure-ack if we have just
952 * sent a configure-request, and the configure-ack contains the
953 * same data (this is checked using a 16-bit crc of the data).
954 */
955#define CONFREQ 1 /* LCP code field values */
956#define CONFACK 2
957#define LCP_MRU 1 /* LCP option numbers */
958#define LCP_ASYNCMAP 2
959
960static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,
961 int len, int inbound)
962{
963 int dlen, fcs, i, code;
964 u32 val;
965
966 data += 2; /* skip protocol bytes */
967 len -= 2;
968 if (len < 4) /* 4 = code, ID, length */
969 return;
970 code = data[0];
971 if (code != CONFACK && code != CONFREQ)
972 return;
973 dlen = (data[2] << 8) + data[3];
974 if (len < dlen)
975 return; /* packet got truncated or length is bogus */
976
977 if (code == (inbound? CONFACK: CONFREQ)) {
978 /*
979 * sent confreq or received confack:
980 * calculate the crc of the data from the ID field on.
981 */
982 fcs = PPP_INITFCS;
983 for (i = 1; i < dlen; ++i)
984 fcs = PPP_FCS(fcs, data[i]);
985
986 if (!inbound) {
987 /* outbound confreq - remember the crc for later */
988 ap->lcp_fcs = fcs;
989 return;
990 }
991
992 /* received confack, check the crc */
993 fcs ^= ap->lcp_fcs;
994 ap->lcp_fcs = -1;
995 if (fcs != 0)
996 return;
997 } else if (inbound)
998 return; /* not interested in received confreq */
999
1000 /* process the options in the confack */
1001 data += 4;
1002 dlen -= 4;
1003 /* data[0] is code, data[1] is length */
1004 while (dlen >= 2 && dlen >= data[1] && data[1] >= 2) {
1005 switch (data[0]) {
1006 case LCP_MRU:
1007 val = (data[2] << 8) + data[3];
1008 if (inbound)
1009 ap->mru = val;
1010 else
1011 ap->chan.mtu = val;
1012 break;
1013 case LCP_ASYNCMAP:
1014 val = (data[2] << 24) + (data[3] << 16)
1015 + (data[4] << 8) + data[5];
1016 if (inbound)
1017 ap->raccm = val;
1018 else
1019 ap->xaccm[0] = val;
1020 break;
1021 }
1022 dlen -= data[1];
1023 data += data[1];
1024 }
1025}
1026
1027static void __exit ppp_async_cleanup(void)
1028{
Alexey Dobriyan64ccd712005-06-23 00:10:33 -07001029 if (tty_unregister_ldisc(N_PPP) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 printk(KERN_ERR "failed to unregister PPP line discipline\n");
1031}
1032
1033module_init(ppp_async_init);
1034module_exit(ppp_async_cleanup);