3 * Michael Callahan <callahan@maths.ox.ac.uk>
4 * Al Longyear <longyear@netcom.com>
5 * Extensively rewritten by Paul Mackerras <paulus@cs.anu.edu.au>
7 * ==FILEVERSION 990910==
10 * If you modify this file at all, please set the number above to the
11 * date of the modification as YYMMDD (year month day).
12 * ppp.c is shipped with a PPP distribution as well as with the kernel;
13 * if everyone increases the FILEVERSION number above, then scripts
14 * can do the right thing when deciding whether to install a new ppp.c
15 * file. Don't change the format of that line otherwise, so the
16 * installation script can recognize it.
24 RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
25 Multi-protocol Datagrams over Point-to-Point Links
31 Flags for this module (any combination is acceptable for testing.):
33 OPTIMIZE_FLAG_TIME - Number of jiffies to force sending of leading flag
34 character. This is normally set to ((HZ * 3) / 2).
35 This is 1.5 seconds. If zero then the leading
38 CHECK_CHARACTERS - Enable the checking on all received characters for
39 8 data bits, no parity. This adds a small amount of
40 processing for each received character.
43 #define OPTIMIZE_FLAG_TIME ((HZ * 3)/2)
44 #define CHECK_CHARACTERS 1
46 #define PPP_MAX_RCV_QLEN 32 /* max # frames we queue up for pppd */
48 /* $Id: ppp.c,v 1.33 1999/12/23 01:48:45 paulus Exp $ */
50 #include <linux/version.h>
51 #include <linux/config.h>
52 #include <linux/module.h>
53 #include <linux/kernel.h>
54 #include <linux/sched.h>
55 #include <linux/types.h>
56 #include <linux/fcntl.h>
57 #include <linux/interrupt.h>
58 #include <linux/ptrace.h>
60 /* a macro to generate linux version number codes */
61 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
63 #if LINUX_VERSION_CODE < VERSION(2,1,14)
64 #include <linux/ioport.h>
67 #if LINUX_VERSION_CODE >= VERSION(2,1,23)
68 #include <linux/poll.h>
72 #include <linux/malloc.h>
73 #include <linux/tty.h>
74 #include <linux/errno.h>
75 #include <linux/sched.h> /* to get the struct task_struct */
76 #include <linux/string.h> /* used in new tty drivers */
77 #include <linux/signal.h> /* used in new tty drivers */
78 #include <asm/system.h>
79 #include <asm/bitops.h>
81 #include <linux/if_ether.h>
82 #include <linux/netdevice.h>
83 #include <linux/skbuff.h>
84 #include <linux/inet.h>
85 #include <linux/ioctl.h>
87 #include <linux/tcp.h>
88 #include <linux/if_arp.h>
89 #include <net/slhc_vj.h>
91 #define fcstab ppp_crc16_table /* Name of the table in the kernel */
92 #include <linux/ppp_defs.h>
94 #include <linux/socket.h>
95 #include <linux/if_ppp.h>
96 #include <linux/if_pppvar.h>
97 #include <linux/ppp-comp.h>
100 #include <linux/kmod.h>
102 #ifdef CONFIG_KERNELD
103 #include <linux/kerneld.h>
107 #define PPP_VERSION "2.3.11"
109 #if LINUX_VERSION_CODE >= VERSION(2,1,4)
111 #if LINUX_VERSION_CODE >= VERSION(2,1,5)
112 #include <asm/uaccess.h>
114 #include <asm/segment.h>
117 #define GET_USER get_user
118 #define PUT_USER put_user
119 #define COPY_FROM_USER copy_from_user
120 #define COPY_TO_USER copy_to_user
122 #else /* 2.0.x and 2.1.x before 2.1.4 */
124 #define GET_USER(val, src) \
125 (verify_area(VERIFY_READ, src, sizeof(*src))? -EFAULT: \
126 ((val) = get_user(src), 0))
127 #define PUT_USER(val, dst) \
128 (verify_area(VERIFY_WRITE, dst, sizeof(*dst))? -EFAULT: \
129 (put_user(val, dst), 0))
130 #define COPY_FROM_USER(dst, src, size) \
131 (verify_area(VERIFY_READ, src, size)? -EFAULT: \
132 (memcpy_fromfs(dst, src, size), 0))
133 #define COPY_TO_USER(dst, src, size) \
134 (verify_area(VERIFY_WRITE, dst, size)? -EFAULT: \
135 (memcpy_tofs(dst, src, size), 0))
139 #if LINUX_VERSION_CODE < VERSION(2,1,37)
140 #define test_and_set_bit(nr, addr) set_bit(nr, addr)
143 #if LINUX_VERSION_CODE < VERSION(2,1,25)
144 #define net_device_stats enet_statistics
147 #if LINUX_VERSION_CODE < VERSION(2,1,57)
148 #define signal_pending(tsk) ((tsk)->signal & ~(tsk)->blocked)
151 #if LINUX_VERSION_CODE < VERSION(2,1,60)
152 typedef int rw_ret_t;
153 typedef unsigned int rw_count_t;
155 typedef ssize_t rw_ret_t;
156 typedef size_t rw_count_t;
159 #if LINUX_VERSION_CODE < VERSION(2,1,86)
160 #define KFREE_SKB(s) dev_kfree_skb((s), FREE_WRITE)
162 #define KFREE_SKB(s) kfree_skb(s)
165 #if LINUX_VERSION_CODE < VERSION(2,1,15)
166 #define LIBERATE_SKB(s) ((s)->free = 1)
168 #define LIBERATE_SKB(s) do { } while (0)
171 #if LINUX_VERSION_CODE < VERSION(2,1,95)
172 #define SUSER() suser()
174 #define SUSER() capable(CAP_NET_ADMIN)
177 #if LINUX_VERSION_CODE < VERSION(2,2,0)
185 static int ppp_register_compressor (struct compressor *cp);
186 static void ppp_unregister_compressor (struct compressor *cp);
188 static void ppp_async_init(struct ppp *ppp);
189 static void ppp_async_release(struct ppp *ppp);
190 static int ppp_tty_sync_push(struct ppp *ppp);
191 static int ppp_tty_push(struct ppp *ppp);
192 static int ppp_async_encode(struct ppp *ppp);
193 static int ppp_async_send(struct ppp *, struct sk_buff *);
194 static int ppp_sync_send(struct ppp *, struct sk_buff *);
195 static void ppp_tty_flush_output(struct ppp *);
197 static int ppp_ioctl(struct ppp *, unsigned int, unsigned long);
198 static int ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp);
199 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd);
200 static void ppp_ccp_closed(struct ppp *ppp);
201 static int ppp_receive_frame(struct ppp *, struct sk_buff *);
202 static void ppp_receive_error(struct ppp *ppp);
203 static void ppp_output_wakeup(struct ppp *ppp);
204 static void ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb);
205 static void ppp_send_frame(struct ppp *ppp, struct sk_buff *skb);
206 static void ppp_send_frames(struct ppp *ppp);
207 static struct sk_buff *ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb);
209 static struct ppp *ppp_find (int pid_value);
210 static struct ppp *ppp_alloc (void);
211 static void ppp_generic_init(struct ppp *ppp);
212 static void ppp_release(struct ppp *ppp);
213 static void ppp_print_buffer (const char *, const __u8 *, int);
214 static struct compressor *find_compressor (int type);
216 #ifndef OPTIMIZE_FLAG_TIME
217 #define OPTIMIZE_FLAG_TIME 0
221 * Parameters which may be changed via insmod.
224 static int flag_time = OPTIMIZE_FLAG_TIME;
225 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
226 MODULE_PARM(flag_time, "i");
229 #define CHECK_PPP_MAGIC(ppp) do { \
230 if (ppp->magic != PPP_MAGIC) { \
231 printk(ppp_magic_warn, ppp, __FILE__, __LINE__); \
234 #define CHECK_PPP(a) do { \
235 CHECK_PPP_MAGIC(ppp); \
237 printk(ppp_warning, __LINE__); \
241 #define CHECK_PPP_VOID() do { \
242 CHECK_PPP_MAGIC(ppp); \
244 printk(ppp_warning, __LINE__); \
249 #define tty2ppp(tty) ((struct ppp *) ((tty)->disc_data))
250 #define dev2ppp(dev) ((struct ppp *) ((dev)->priv))
251 #define ppp2tty(ppp) ((ppp)->tty)
252 #define ppp2dev(ppp) (&(ppp)->dev)
254 static struct ppp *ppp_list = NULL;
255 static struct ppp *ppp_last = NULL;
257 /* Define these strings only once for all macro invocations */
258 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
259 static char ppp_magic_warn[] = KERN_WARNING "bad magic for ppp %p at %s:%d\n";
261 static char szVersion[] = PPP_VERSION;
263 #if LINUX_VERSION_CODE < VERSION(2,1,18)
264 static struct symbol_table ppp_syms = {
265 #include <linux/symtab_begin.h>
266 X(ppp_register_compressor),
267 X(ppp_unregister_compressor),
268 #include <linux/symtab_end.h>
271 EXPORT_SYMBOL(ppp_register_compressor);
272 EXPORT_SYMBOL(ppp_unregister_compressor);
275 /*************************************************************
276 * LINE DISCIPLINE SUPPORT
277 * The following code implements the PPP line discipline
278 * and supports using PPP on an async serial line.
279 *************************************************************/
281 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
282 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
283 ppp->recv_async_map & (1 << (c)))
289 static rw_ret_t ppp_tty_read(struct tty_struct *, struct file *, __u8 *,
291 static rw_ret_t ppp_tty_write(struct tty_struct *, struct file *, const __u8 *,
293 static int ppp_tty_ioctl(struct tty_struct *, struct file *, unsigned int,
295 #if LINUX_VERSION_CODE < VERSION(2,1,23)
296 static int ppp_tty_select(struct tty_struct *tty, struct inode *inode,
297 struct file *filp, int sel_type, select_table * wait);
299 static unsigned int ppp_tty_poll(struct tty_struct *tty, struct file *filp,
302 static int ppp_tty_open (struct tty_struct *);
303 static void ppp_tty_close (struct tty_struct *);
304 static int ppp_tty_room (struct tty_struct *tty);
305 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
306 char *fp, int count);
307 static void ppp_tty_wakeup (struct tty_struct *tty);
309 __u16 ppp_crc16_table[256] =
311 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
312 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
313 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
314 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
315 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
316 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
317 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
318 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
319 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
320 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
321 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
322 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
323 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
324 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
325 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
326 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
327 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
328 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
329 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
330 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
331 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
332 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
333 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
334 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
335 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
336 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
337 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
338 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
339 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
340 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
341 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
342 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
344 #if LINUX_VERSION_CODE >= VERSION(2,1,18)
345 EXPORT_SYMBOL(ppp_crc16_table);
348 #ifdef CHECK_CHARACTERS
349 static __u32 paritytab[8] =
351 0x96696996, 0x69969669, 0x69969669, 0x96696996,
352 0x69969669, 0x96696996, 0x96696996, 0x69969669
357 * This procedure is called at initialization time to register
358 * the PPP line discipline.
363 static struct tty_ldisc ppp_ldisc;
367 "PPP: version %s (demand dialling)"
370 #ifndef MODULE /* slhc module logic has its own copyright announcement */
372 "TCP compression code copyright 1989 Regents of the "
373 "University of California\n");
377 * Register the tty discipline
379 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
380 ppp_ldisc.magic = TTY_LDISC_MAGIC;
381 #if LINUX_VERSION_CODE >= VERSION(2,1,28)
382 ppp_ldisc.name = "ppp";
384 ppp_ldisc.open = ppp_tty_open;
385 ppp_ldisc.close = ppp_tty_close;
386 ppp_ldisc.read = ppp_tty_read;
387 ppp_ldisc.write = ppp_tty_write;
388 ppp_ldisc.ioctl = ppp_tty_ioctl;
389 #if LINUX_VERSION_CODE < VERSION(2,1,23)
390 ppp_ldisc.select = ppp_tty_select;
392 ppp_ldisc.poll = ppp_tty_poll;
394 ppp_ldisc.receive_room = ppp_tty_room;
395 ppp_ldisc.receive_buf = ppp_tty_receive;
396 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
398 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
400 printk(KERN_INFO "PPP line discipline registered.\n");
402 printk(KERN_ERR "error registering line discipline: %d\n",
410 * Called at boot time if the PPP driver is compiled into the kernel.
413 ppp_init(struct device *dev)
415 static int first_time = 1;
420 answer = ppp_first_time();
421 #if LINUX_VERSION_CODE < VERSION(2,1,18)
423 (void) register_symtab(&ppp_syms);
433 * Initialize the async-specific parts of the ppp structure.
436 ppp_async_init(struct ppp *ppp)
440 ppp->tty_pushing = 0;
442 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
443 ppp->xmit_async_map[0] = 0xffffffff;
444 ppp->xmit_async_map[3] = 0x60000000;
445 ppp->recv_async_map = 0xffffffff;
448 ppp->tfcs = PPP_INITFCS;
449 ppp->optr = ppp->obuf;
450 ppp->olim = ppp->obuf;
453 ppp->rfcs = PPP_INITFCS;
456 ppp->backup_tty = NULL;
463 * Clean up the async-specific parts of the ppp structure.
466 ppp_async_release(struct ppp *ppp)
470 if ((skb = ppp->rpkt) != NULL)
473 if ((skb = ppp->tpkt) != NULL)
481 * Called when the tty discipline is switched to PPP.
485 ppp_tty_open (struct tty_struct *tty)
490 * Allocate a ppp structure to use.
492 tty->disc_data = NULL;
493 ppp = ppp_find(current->pid);
496 * If we are taking over a ppp unit which is currently
497 * connected to a loopback pty, there's not much to do.
504 printk(KERN_ERR "ppp_alloc failed\n");
509 * Initialize the control block
511 ppp_generic_init(ppp);
517 tty->disc_data = ppp;
521 * Flush any pending characters in the driver
523 if (tty->driver.flush_buffer)
524 tty->driver.flush_buffer (tty);
532 * Called when the line discipline is changed to something
533 * else, the tty is closed, or the tty detects a hangup.
537 ppp_tty_close (struct tty_struct *tty)
539 struct ppp *ppp = tty2ppp(tty);
543 tty->disc_data = NULL;
544 if (ppp->magic != PPP_MAGIC) {
545 printk(KERN_WARNING "ppp_tty_close: bogus\n");
549 printk(KERN_WARNING "ppp_tty_close: not inuse\n");
550 ppp->tty = ppp->backup_tty = 0;
553 if (tty == ppp->backup_tty)
557 if (ppp->backup_tty) {
558 ppp->tty = ppp->backup_tty;
559 if (ppp_tty_push(ppp))
560 ppp_output_wakeup(ppp);
561 wake_up_interruptible(&ppp->read_wait);
565 if (ppp->flags & SC_DEBUG)
566 printk(KERN_INFO "ppp: channel %s closing.\n",
569 ppp_async_release(ppp);
576 * Read a PPP frame from the rcv_q list,
577 * waiting if necessary
580 ppp_tty_read(struct tty_struct *tty, struct file *file, __u8 * buf,
583 struct ppp *ppp = tty2ppp (tty);
588 * Validate the pointers
595 * Before we attempt to write the frame to the user, ensure that the
596 * user has access to the pages for the total buffer length.
598 err = verify_area(VERIFY_WRITE, buf, nr);
603 * Wait for a frame to arrive if necessary.
604 * We increment the module use count so that the module
605 * can't go away while we're sleeping.
612 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
616 skb = skb_dequeue(&ppp->rcv_q);
621 * If no frame is available, return -EAGAIN or wait.
624 if (file->f_flags & O_NONBLOCK)
627 interruptible_sleep_on(&ppp->read_wait);
629 if (signal_pending(current))
637 * Ensure that the frame will fit within the caller's buffer.
638 * If not, just discard the frame.
642 if (ppp->flags & SC_DEBUG)
644 "ppp: read of %lu bytes too small for %ld "
645 "frame\n", (unsigned long) nr, (long) len);
646 ppp->stats.ppp_ierrors++;
652 * Copy the received data from the buffer to the caller's area.
655 if (COPY_TO_USER(buf, skb->data, len))
664 * Writing to a tty in ppp line discipline sends a PPP frame.
665 * Used by pppd to send control packets (LCP, etc.).
668 ppp_tty_write(struct tty_struct *tty, struct file *file, const __u8 * data,
671 struct ppp *ppp = tty2ppp (tty);
676 * Verify the pointers.
681 if (ppp->magic != PPP_MAGIC)
687 * Ensure that the caller does not wish to send too much.
689 if (count > PPP_MTU + PPP_HDRLEN) {
690 if (ppp->flags & SC_DEBUG)
692 "ppp_tty_write: truncating user packet "
693 "from %lu to mtu %d\n", (unsigned long) count,
694 PPP_MTU + PPP_HDRLEN);
695 count = PPP_MTU + PPP_HDRLEN;
699 * Allocate a buffer for the data and fetch it from the user space.
701 skb = alloc_skb(count, GFP_KERNEL);
703 printk(KERN_ERR "ppp_tty_write: no memory\n");
707 new_data = skb_put(skb, count);
710 * Retrieve the user's buffer
712 if (COPY_FROM_USER(new_data, data, count)) {
720 ppp_send_ctrl(ppp, skb);
722 return (rw_ret_t) count;
726 * Process the IOCTL call for the tty device.
727 * Only the ioctls that relate to using ppp on async serial lines
728 * are processed here; the rest are handled by ppp_ioctl.
731 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
732 unsigned int param2, unsigned long param3)
734 struct ppp *ppp = tty2ppp (tty);
735 register int temp_i = 0;
739 * Verify the status of the PPP device.
741 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
745 * The user must have an euid of root to do these requests.
751 case PPPIOCGASYNCMAP:
753 * Retrieve the transmit async map
755 if (PUT_USER(ppp->xmit_async_map[0], (int *) param3))
760 case PPPIOCSASYNCMAP:
762 * Set the transmit async map
764 if (GET_USER(temp_i, (int *) param3))
766 ppp->xmit_async_map[0] = temp_i;
767 if (ppp->flags & SC_DEBUG)
769 "ppp_tty_ioctl: set xmit asyncmap %x\n",
770 ppp->xmit_async_map[0]);
774 case PPPIOCSRASYNCMAP:
776 * Set the receive async map
778 if (GET_USER(temp_i, (int *) param3))
780 ppp->recv_async_map = temp_i;
781 if (ppp->flags & SC_DEBUG)
783 "ppp_tty_ioctl: set rcv asyncmap %x\n",
784 ppp->recv_async_map);
788 case PPPIOCGXASYNCMAP:
790 * Get the map of characters to be escaped on transmission.
792 if (COPY_TO_USER((void *) param3, ppp->xmit_async_map,
793 sizeof (ppp->xmit_async_map)))
798 case PPPIOCSXASYNCMAP:
800 * Set the map of characters to be escaped on transmission.
805 if (COPY_FROM_USER(temp_tbl, (void *) param3,
809 temp_tbl[1] = 0x00000000;
810 temp_tbl[2] &= ~0x40000000;
811 temp_tbl[3] |= 0x60000000;
813 memcpy(ppp->xmit_async_map, temp_tbl,
814 sizeof (ppp->xmit_async_map));
816 if (ppp->flags & SC_DEBUG)
818 "ppp_tty_ioctl: set xasyncmap\n");
825 * Set up this PPP unit to be used next time this
826 * process sets a tty to PPP line discipline.
828 ppp->backup_tty = tty;
829 ppp->sc_xfer = current->pid;
836 * Allow users to read, but not set, the serial port parameters
838 error = n_tty_ioctl (tty, file, param2, param3);
843 * Flush our buffers, then call the generic code to
844 * flush the serial port's buffer.
846 if (param3 == TCIFLUSH || param3 == TCIOFLUSH) {
848 while ((skb = skb_dequeue(&ppp->rcv_q)) != NULL)
851 if (param3 == TCIOFLUSH || param3 == TCOFLUSH)
852 ppp_tty_flush_output(ppp);
853 error = n_tty_ioctl (tty, file, param2, param3);
858 * Returns how many bytes are available for a read().
867 skb = skb_peek(&ppp->rcv_q);
870 restore_flags(flags);
871 if (PUT_USER(count, (int *) param3))
879 * All other ioctl() events will come here.
881 error = ppp_ioctl(ppp, param2, param3);
890 * Process the select() or poll() statement for the PPP device.
893 #if LINUX_VERSION_CODE < VERSION(2,1,23)
895 ppp_tty_select(struct tty_struct *tty, struct inode *inode,
896 struct file *filp, int sel_type, select_table * wait)
898 struct ppp *ppp = tty2ppp(tty);
902 * Verify the status of the PPP device.
904 if (!ppp || tty != ppp->tty)
911 /* The fd is readable if the receive queue isn't empty. */
912 if (skb_peek(&ppp->rcv_q) != NULL)
916 /* Check for exceptions or read errors. */
917 /* Is this a pty link and the remote disconnected? */
918 if (tty->flags & (1 << TTY_OTHER_CLOSED))
921 /* Is this a local link and the modem disconnected? */
922 if (tty_hung_up_p (filp))
925 select_wait(&ppp->read_wait, wait);
930 /* The fd is always writable. */
936 #else /* 2.1.23 or later */
939 ppp_tty_poll(struct tty_struct *tty, struct file *filp, poll_table * wait)
941 struct ppp *ppp = tty2ppp(tty);
942 unsigned int mask = 0;
944 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
947 poll_wait(filp, &ppp->read_wait, wait);
949 if (skb_peek(&ppp->rcv_q) != NULL)
950 mask |= POLLIN | POLLRDNORM;
951 if (tty->flags & (1 << TTY_OTHER_CLOSED)
952 || tty_hung_up_p(filp))
954 mask |= POLLOUT | POLLWRNORM;
958 #endif /* >= 2.1.23 */
961 * This function is called by the tty driver when the transmit buffer has
962 * additional space. It is used by the ppp code to continue to transmit
963 * the current buffer should the buffer have been partially sent.
966 ppp_tty_wakeup (struct tty_struct *tty)
968 struct ppp *ppp = tty2ppp (tty);
970 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
977 if (ppp_tty_push(ppp))
978 ppp_output_wakeup(ppp);
982 * Send a packet to the peer over a synchronous tty line.
983 * All encoding and FCS are handled by hardware.
984 * Addr/Ctrl and Protocol field compression implemented.
985 * Returns -1 iff the packet could not be accepted at present,
986 * 0 if the packet was accepted but we can't accept another yet, or
987 * 1 if we can accept another packet immediately.
988 * If this procedure returns 0, ppp_output_wakeup will be called
992 ppp_sync_send(struct ppp *ppp, struct sk_buff *skb)
999 if (ppp->tpkt != NULL)
1003 data = ppp->tpkt->data;
1006 * LCP packets with code values between 1 (configure-reqest)
1007 * and 7 (code-reject) must be sent as though no options
1008 * had been negotiated.
1010 islcp = PPP_PROTOCOL(data) == PPP_LCP
1011 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
1013 /* only reset idle time for data packets */
1014 if (PPP_PROTOCOL(data) < 0x8000)
1015 ppp->last_xmit = jiffies;
1016 ++ppp->stats.ppp_opackets;
1017 ppp->stats.ppp_ooctects += ppp->tpkt->len;
1019 if ( !(data[2]) && (ppp->flags & SC_COMP_PROT) ) {
1020 /* compress protocol field */
1023 skb_pull(ppp->tpkt,1);
1024 data = ppp->tpkt->data;
1028 * Do address/control compression
1030 if ((ppp->flags & SC_COMP_AC) && !islcp
1031 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1032 && PPP_CONTROL(data) == PPP_UI) {
1033 /* strip addr and control field */
1034 skb_pull(ppp->tpkt,2);
1037 return ppp_tty_sync_push(ppp);
1041 * Push a synchronous frame out to the tty.
1042 * Returns 1 if frame accepted (or discarded), 0 otherwise.
1045 ppp_tty_sync_push(struct ppp *ppp)
1048 struct tty_struct *tty = ppp2tty(ppp);
1049 unsigned long flags;
1053 if (ppp->tpkt == NULL)
1056 /* prevent reentrancy with tty_pushing flag */
1059 if (ppp->tty_pushing) {
1060 /* record wakeup attempt so we don't lose */
1061 /* a wakeup call while doing push processing */
1063 restore_flags(flags);
1066 ppp->tty_pushing = 1;
1067 restore_flags(flags);
1069 if (tty == NULL || tty->disc_data != (void *) ppp)
1075 /* Note: Sync driver accepts complete frame or nothing */
1076 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1077 sent = tty->driver.write(tty, 0, ppp->tpkt->data, ppp->tpkt->len);
1079 /* write error (possible loss of CD) */
1080 /* record error and discard current packet */
1081 ppp->stats.ppp_oerrors++;
1084 ppp->stats.ppp_obytes += sent;
1085 if (sent < ppp->tpkt->len) {
1086 /* driver unable to accept frame just yet */
1090 /* wake up called while processing */
1091 /* try to send the frame again */
1092 restore_flags(flags);
1095 /* wait for wakeup callback to try send again */
1096 ppp->tty_pushing = 0;
1097 restore_flags(flags);
1103 /* done with current packet (sent or discarded) */
1104 KFREE_SKB(ppp->tpkt);
1106 ppp->tty_pushing = 0;
1111 * Send a packet to the peer over an async tty line.
1112 * Returns -1 iff the packet could not be accepted at present,
1113 * 0 if the packet was accepted but we can't accept another yet, or
1114 * 1 if we can accept another packet immediately.
1115 * If this procedure returns 0, ppp_output_wakeup will be called
1119 ppp_async_send(struct ppp *ppp, struct sk_buff *skb)
1125 if (ppp->tpkt != NULL)
1130 return ppp_tty_push(ppp);
1134 * Push as much data as possible out to the tty.
1135 * Returns 1 if we finished encoding the current frame, 0 otherwise.
1138 ppp_tty_push(struct ppp *ppp)
1140 int avail, sent, done = 0;
1141 struct tty_struct *tty = ppp2tty(ppp);
1143 if (ppp->flags & SC_SYNC)
1144 return ppp_tty_sync_push(ppp);
1147 if (ppp->tty_pushing) {
1151 if (tty == NULL || tty->disc_data != (void *) ppp)
1153 while (ppp->optr < ppp->olim || ppp->tpkt != 0) {
1154 ppp->tty_pushing = 1;
1157 avail = ppp->olim - ppp->optr;
1159 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1160 sent = tty->driver.write(tty, 0, ppp->optr, avail);
1162 goto flush; /* error, e.g. loss of CD */
1163 ppp->stats.ppp_obytes += sent;
1167 ppp->tty_pushing = 0;
1175 done = ppp_async_encode(ppp);
1177 ppp->tty_pushing = 0;
1182 ppp->tty_pushing = 1;
1184 ppp->stats.ppp_oerrors++;
1185 if (ppp->tpkt != 0) {
1186 KFREE_SKB(ppp->tpkt);
1190 ppp->optr = ppp->olim;
1192 ppp->tty_pushing = 0;
1197 * Procedure to encode the data for async serial transmission.
1198 * Does octet stuffing (escaping) and address/control
1199 * and protocol compression.
1200 * Assumes ppp->opkt != 0 on entry.
1201 * Returns 1 if we finished the current frame, 0 otherwise.
1204 ppp_async_encode(struct ppp *ppp)
1206 int fcs, i, count, c;
1207 unsigned char *buf, *buflim;
1208 unsigned char *data;
1217 data = ppp->tpkt->data;
1218 count = ppp->tpkt->len;
1222 * LCP packets with code values between 1 (configure-reqest)
1223 * and 7 (code-reject) must be sent as though no options
1224 * had been negotiated.
1226 islcp = PPP_PROTOCOL(data) == PPP_LCP
1227 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
1231 * Start of a new packet - insert the leading FLAG
1232 * character if necessary.
1234 if (islcp || flag_time == 0
1235 || jiffies - ppp->last_xmit >= flag_time)
1237 /* only reset idle time for data packets */
1238 if (PPP_PROTOCOL(data) < 0x8000)
1239 ppp->last_xmit = jiffies;
1241 ++ppp->stats.ppp_opackets;
1242 ppp->stats.ppp_ooctects += count;
1245 * Do address/control compression
1247 if ((ppp->flags & SC_COMP_AC) != 0 && !islcp
1248 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1249 && PPP_CONTROL(data) == PPP_UI)
1254 * Once we put in the last byte, we need to put in the FCS
1255 * and closing flag, so make sure there is at least 7 bytes
1256 * of free space in the output buffer.
1258 buflim = buf + OBUFSIZE - 6;
1259 while (i < count && buf < buflim) {
1261 if (i == 3 && c == 0 && (ppp->flags & SC_COMP_PROT))
1262 continue; /* compress protocol field */
1263 fcs = PPP_FCS(fcs, c);
1264 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1265 *buf++ = PPP_ESCAPE;
1273 * We have finished the packet. Add the FCS and flag.
1277 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1278 *buf++ = PPP_ESCAPE;
1282 c = (fcs >> 8) & 0xff;
1283 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1284 *buf++ = PPP_ESCAPE;
1291 KFREE_SKB(ppp->tpkt);
1297 * Remember where we are up to in this packet.
1306 * Flush output from our internal buffers.
1307 * Called for the TCFLSH ioctl.
1310 ppp_tty_flush_output(struct ppp *ppp)
1312 struct sk_buff *skb;
1315 while ((skb = skb_dequeue(&ppp->xmt_q)) != NULL)
1317 ppp->tty_pushing = 1;
1319 ppp->optr = ppp->olim;
1320 if (ppp->tpkt != NULL) {
1321 KFREE_SKB(ppp->tpkt);
1326 ppp->tty_pushing = 0;
1328 ppp_output_wakeup(ppp);
1332 * Callback function from tty driver. Return the amount of space left
1333 * in the receiver's buffer to decide if remote transmitter is to be
1337 ppp_tty_room (struct tty_struct *tty)
1339 return 65536; /* We can handle an infinite amount of data. :-) */
1343 * Callback function when data is available at the tty driver.
1346 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1347 char *flags, int count)
1349 register struct ppp *ppp = tty2ppp (tty);
1350 struct sk_buff *skb;
1357 * This can happen if stuff comes in on the backup tty.
1359 if (ppp == 0 || tty != ppp->tty)
1362 * Verify the table pointer and ensure that the line is
1363 * still in PPP discipline.
1365 if (ppp->magic != PPP_MAGIC) {
1366 if (ppp->flags & SC_DEBUG)
1368 "PPP: tty_receive called but couldn't find "
1373 * Print the buffer if desired
1375 if (ppp->flags & SC_LOG_RAWIN)
1376 ppp_print_buffer ("receive buffer", data, count);
1378 ppp->stats.ppp_ibytes += count;
1381 if ( ppp->flags & SC_SYNC ) {
1382 /* synchronous mode */
1384 if (ppp->toss==0xE0) {
1385 /* this is the 1st frame, reset vj comp */
1386 ppp_receive_error(ppp);
1391 * Allocate an skbuff for frame.
1392 * The 128 is room for VJ header expansion.
1396 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1399 if (ppp->flags & SC_DEBUG)
1400 printk(KERN_DEBUG "couldn't "
1401 "alloc skb for recv\n");
1405 * Decompress A/C and protocol compression here.
1407 p = skb_put(skb, 2);
1408 p[0] = PPP_ALLSTATIONS;
1410 if (*data == PPP_ALLSTATIONS) {
1414 if ((*data & 1) != 0) {
1415 p = skb_put(skb, 1);
1419 /* copy frame to socket buffer */
1420 p = skb_put(skb, count);
1421 memcpy(p,data,count);
1424 * Check if we've overflowed the MRU
1426 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1427 || skb_tailroom(skb) <= 0) {
1428 ++ppp->estats.rx_length_errors;
1429 if (ppp->flags & SC_DEBUG)
1430 printk(KERN_DEBUG "rcv frame too long: "
1431 "len=%d mru=%d hroom=%d troom=%d\n",
1432 skb->len, ppp->mru, skb_headroom(skb),
1435 if (!ppp_receive_frame(ppp, skb)) {
1437 ppp_receive_error(ppp);
1441 /* Reset for the next frame */
1448 while (count-- > 0) {
1450 * Collect the character and error condition for the character.
1451 * Set the toss flag for the first character error.
1461 ++ppp->estats.rx_fifo_errors;
1465 ++ppp->estats.rx_frame_errors;
1473 * Set the flags for d7 being 0/1 and parity being
1474 * even/odd so that the normal processing would have
1475 * all flags set at the end of the session. A
1476 * missing flag bit indicates an error condition.
1479 #ifdef CHECK_CHARACTERS
1481 ppp->flags |= SC_RCV_B7_1;
1483 ppp->flags |= SC_RCV_B7_0;
1485 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1486 ppp->flags |= SC_RCV_ODDP;
1488 ppp->flags |= SC_RCV_EVNP;
1491 if (chr == PPP_FLAG) {
1493 * FLAG. This is the end of the block. If the block
1494 * ends with ESC FLAG, then the block is to be ignored.
1499 * Process the frame if it was received correctly.
1500 * If there was an error, let the VJ decompressor know.
1501 * There are 4 cases here:
1502 * skb != NULL, toss != 0: error in frame
1503 * skb != NULL, toss == 0: frame ok
1504 * skb == NULL, toss != 0: very first frame,
1505 * error on 1st char, or alloc_skb failed
1506 * skb == NULL, toss == 0: empty frame (~~)
1508 if (ppp->toss || !ppp_receive_frame(ppp, skb)) {
1509 if (ppp->toss && (ppp->flags & SC_DEBUG))
1511 "ppp: tossing frame (%x)\n",
1515 if (!(ppp->toss == 0xE0 || ppp->toss == 0x80))
1516 ++ppp->stats.ppp_ierrors;
1517 ppp_receive_error(ppp);
1520 * Reset for the next frame.
1523 ppp->rfcs = PPP_INITFCS;
1529 /* If we're tossing, look no further. */
1533 /* If this is a control char to be ignored, do so */
1534 if (in_rmap(ppp, chr))
1538 * Modify the next character if preceded by escape.
1539 * The escape character (0x7d) could be an escaped
1540 * 0x5d, if it follows an escape :-)
1545 } else if (chr == PPP_ESCAPE) {
1546 ppp->escape = PPP_TRANS;
1551 * Allocate an skbuff on the first character received.
1552 * The 128 is room for VJ header expansion and FCS.
1555 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1557 if (ppp->flags & SC_DEBUG)
1558 printk(KERN_DEBUG "couldn't "
1559 "alloc skb for recv\n");
1567 * Decompress A/C and protocol compression here.
1569 if (skb->len == 0 && chr != PPP_ALLSTATIONS) {
1570 p = skb_put(skb, 2);
1571 p[0] = PPP_ALLSTATIONS;
1574 if (skb->len == 2 && (chr & 1) != 0) {
1575 p = skb_put(skb, 1);
1580 * Check if we've overflowed the MRU
1582 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1583 || skb_tailroom(skb) <= 0) {
1584 ++ppp->estats.rx_length_errors;
1586 if (ppp->flags & SC_DEBUG)
1587 printk(KERN_DEBUG "rcv frame too long: "
1588 "len=%d mru=%d hroom=%d troom=%d\n",
1589 skb->len, ppp->mru, skb_headroom(skb),
1595 * Store the character and update the FCS.
1597 p = skb_put(skb, 1);
1599 ppp->rfcs = PPP_FCS(ppp->rfcs, chr);
1604 /*************************************************************
1605 * PPP NETWORK INTERFACE SUPPORT
1606 * The following code implements the PPP network
1607 * interface device and handles those parts of
1608 * the PPP processing which are independent of the
1609 * type of hardware link being used, including
1610 * VJ and packet compression.
1611 *************************************************************/
1614 * Network device driver callback routines
1617 static int ppp_init_dev(struct device *dev);
1618 static int ppp_dev_open(struct device *);
1619 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
1620 static int ppp_dev_close(struct device *);
1621 static int ppp_dev_xmit(struct sk_buff *, struct device *);
1622 static struct net_device_stats *ppp_dev_stats (struct device *);
1624 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1625 static int ppp_dev_header(struct sk_buff *, struct device *, __u16,
1626 void *, void *, unsigned int);
1627 static int ppp_dev_rebuild(void *eth, struct device *dev,
1628 unsigned long raddr, struct sk_buff *skb);
1632 * Information for the protocol decoder
1635 typedef int (*pfn_proto) (struct ppp *, struct sk_buff *);
1637 typedef struct ppp_proto_struct {
1642 static int rcv_proto_ip (struct ppp *, struct sk_buff *);
1643 static int rcv_proto_ipv6 (struct ppp *, struct sk_buff *);
1644 static int rcv_proto_ipx (struct ppp *, struct sk_buff *);
1645 static int rcv_proto_at (struct ppp *, struct sk_buff *);
1646 static int rcv_proto_vjc_comp (struct ppp *, struct sk_buff *);
1647 static int rcv_proto_vjc_uncomp (struct ppp *, struct sk_buff *);
1648 static int rcv_proto_ccp (struct ppp *, struct sk_buff *);
1649 static int rcv_proto_unknown (struct ppp *, struct sk_buff *);
1652 ppp_proto_type proto_list[] = {
1653 { PPP_IP, rcv_proto_ip },
1654 { PPP_IPV6, rcv_proto_ipv6 },
1655 { PPP_IPX, rcv_proto_ipx },
1656 { PPP_AT, rcv_proto_at },
1657 { PPP_VJC_COMP, rcv_proto_vjc_comp },
1658 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
1659 { PPP_CCP, rcv_proto_ccp },
1660 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
1664 * Called when the PPP network interface device is actually created.
1667 ppp_init_dev (struct device *dev)
1669 dev->hard_header_len = PPP_HDRLEN;
1670 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1671 dev->hard_header = ppp_dev_header;
1672 dev->rebuild_header = ppp_dev_rebuild;
1677 dev->hard_start_xmit = ppp_dev_xmit;
1678 dev->open = ppp_dev_open;
1679 dev->stop = ppp_dev_close;
1680 dev->get_stats = ppp_dev_stats;
1681 dev->do_ioctl = ppp_dev_ioctl;
1683 dev->tx_queue_len = 10;
1684 dev->type = ARPHRD_PPP;
1686 #if LINUX_VERSION_CODE < VERSION(2,1,20)
1690 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
1691 skb_queue_head_init (&dev->buffs[indx]);
1694 dev_init_buffers(dev);
1697 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
1703 * Callback from the network layer when the device goes up.
1707 ppp_dev_open (struct device *dev)
1709 struct ppp *ppp = dev2ppp(dev);
1711 if (!ppp->inuse || ppp2tty(ppp) == NULL) {
1712 printk(KERN_ERR "ppp: %s not active\n", dev->name);
1722 * Callback from the network layer when the ppp device goes down.
1726 ppp_dev_close (struct device *dev)
1728 struct ppp *ppp = dev2ppp (dev);
1730 CHECK_PPP_MAGIC(ppp);
1738 get_vj_stats(struct vjstat *vj, struct slcompress *slc)
1740 vj->vjs_packets = slc->sls_o_compressed + slc->sls_o_uncompressed;
1741 vj->vjs_compressed = slc->sls_o_compressed;
1742 vj->vjs_searches = slc->sls_o_searches;
1743 vj->vjs_misses = slc->sls_o_misses;
1744 vj->vjs_errorin = slc->sls_i_error;
1745 vj->vjs_tossed = slc->sls_i_tossed;
1746 vj->vjs_uncompressedin = slc->sls_i_uncompressed;
1747 vj->vjs_compressedin = slc->sls_i_compressed;
1751 * Callback from the network layer to process the sockioctl functions.
1754 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
1756 struct ppp *ppp = dev2ppp(dev);
1759 struct ppp_stats stats;
1760 struct ppp_comp_stats cstats;
1764 CHECK_PPP_MAGIC(ppp);
1766 memset(&u, 0, sizeof(u));
1769 u.stats.p = ppp->stats;
1770 if (ppp->slcomp != NULL)
1771 get_vj_stats(&u.stats.vj, ppp->slcomp);
1772 nb = sizeof(u.stats);
1775 case SIOCGPPPCSTATS:
1776 if (ppp->sc_xc_state != NULL)
1777 (*ppp->sc_xcomp->comp_stat)
1778 (ppp->sc_xc_state, &u.cstats.c);
1779 if (ppp->sc_rc_state != NULL)
1780 (*ppp->sc_rcomp->decomp_stat)
1781 (ppp->sc_rc_state, &u.cstats.d);
1782 nb = sizeof(u.cstats);
1786 strcpy(u.vers, szVersion);
1787 nb = strlen(u.vers) + 1;
1794 if (COPY_TO_USER((void *) ifr->ifr_ifru.ifru_data, &u, nb))
1800 * Process the generic PPP ioctls, i.e. those which are not specific
1801 * to any particular type of hardware link.
1804 ppp_ioctl(struct ppp *ppp, unsigned int param2, unsigned long param3)
1806 register int temp_i = 0, oldflags;
1807 int error = -EFAULT;
1808 unsigned long flags;
1809 struct ppp_idle cur_ddinfo;
1815 * The user must have an euid of root to do these requests.
1825 if (GET_USER(temp_i, (int *) param3))
1827 if (temp_i < PPP_MRU)
1830 if (ppp->flags & SC_DEBUG)
1832 "ppp_ioctl: set mru to %x\n", temp_i);
1838 * Fetch the current flags
1840 temp_i = ppp->flags & SC_MASK;
1841 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
1842 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
1843 SC_RCV_ODDP | SC_RCV_EVNP;
1845 if (PUT_USER(temp_i, (int *) param3))
1852 * Set the flags for the various options
1854 if (GET_USER(temp_i, (int *) param3))
1857 if (ppp->flags & ~temp_i & SC_CCP_OPEN)
1858 ppp_ccp_closed(ppp);
1862 oldflags = ppp->flags;
1863 temp_i = (temp_i & SC_MASK) | (oldflags & ~SC_MASK);
1864 ppp->flags = temp_i;
1865 restore_flags(flags);
1867 if ((oldflags | temp_i) & SC_DEBUG)
1869 "ppp_ioctl: set flags to %x\n", temp_i);
1873 case PPPIOCSCOMPRESS:
1875 * Set the compression mode
1877 error = ppp_set_compression
1878 (ppp, (struct ppp_option_data *) param3);
1883 * Obtain the unit number for this device.
1885 if (PUT_USER(ppp->line, (int *) param3))
1887 if (ppp->flags & SC_DEBUG)
1889 "ppp_ioctl: get unit: %d\n", ppp->line);
1895 * Set the debug level
1897 if (GET_USER(temp_i, (int *) param3))
1899 temp_i = (temp_i & 0x1F) << 16;
1901 if ((ppp->flags | temp_i) & SC_DEBUG)
1903 "ppp_ioctl: set dbg flags to %x\n", temp_i);
1907 ppp->flags = (ppp->flags & ~0x1F0000) | temp_i;
1908 restore_flags(flags);
1914 * Get the debug level
1916 temp_i = (ppp->flags >> 16) & 0x1F;
1917 if (PUT_USER(temp_i, (int *) param3))
1924 * Get the times since the last send/receive frame operation
1926 /* change absolute times to relative times. */
1927 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
1928 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
1929 if (COPY_TO_USER((void *) param3, &cur_ddinfo,
1930 sizeof (cur_ddinfo)))
1937 * Set the maximum VJ header compression slot number.
1939 if (GET_USER(temp_i, (int *) param3))
1942 if (temp_i < 2 || temp_i > 255)
1945 if (ppp->flags & SC_DEBUG)
1946 printk(KERN_INFO "ppp_ioctl: set maxcid to %d\n",
1948 if (ppp->slcomp != NULL)
1949 slhc_free(ppp->slcomp);
1950 ppp->slcomp = slhc_init(16, temp_i);
1953 if (ppp->slcomp == NULL) {
1954 printk(KERN_ERR "ppp: no memory for VJ compression\n");
1962 if (COPY_FROM_USER(&npi, (void *) param3, sizeof(npi)))
1965 switch (npi.protocol) {
1967 npi.protocol = NP_IPV6;
1970 npi.protocol = NP_IP;
1973 npi.protocol = NP_IPX;
1976 npi.protocol = NP_AT;
1979 if (ppp->flags & SC_DEBUG)
1980 printk(KERN_DEBUG "pppioc[gs]npmode: "
1981 "invalid proto %d\n", npi.protocol);
1986 if (param2 == PPPIOCGNPMODE) {
1987 npi.mode = ppp->sc_npmode[npi.protocol];
1988 if (COPY_TO_USER((void *) param3, &npi, sizeof(npi)))
1991 ppp->sc_npmode[npi.protocol] = npi.mode;
1992 if (ppp->flags & SC_DEBUG)
1993 printk(KERN_DEBUG "ppp: set np %d to %d\n",
1994 npi.protocol, npi.mode);
2002 * All other ioctl() events will come here.
2004 if (ppp->flags & SC_DEBUG)
2006 "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
2009 error = -ENOIOCTLCMD;
2017 * Process the set-compression ioctl.
2020 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
2022 struct compressor *cp;
2024 unsigned long flags;
2026 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
2027 struct ppp_option_data data;
2030 * Fetch the compression parameters
2033 if (COPY_FROM_USER(&data, odp, sizeof (data)))
2038 if ((unsigned) nb >= CCP_MAX_OPTION_LENGTH)
2039 nb = CCP_MAX_OPTION_LENGTH;
2041 if (COPY_FROM_USER(ccp_option, ptr, nb))
2045 if (ccp_option[1] < 2) /* preliminary check on the length byte */
2050 ppp->flags &= ~(data.transmit? SC_COMP_RUN: SC_DECOMP_RUN);
2051 restore_flags(flags);
2053 cp = find_compressor (ccp_option[0]);
2054 #if defined(CONFIG_KMOD) || defined(CONFIG_KERNELD)
2057 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
2058 request_module(modname);
2059 cp = find_compressor(ccp_option[0]);
2061 #endif /* CONFIG_KMOD */
2064 if (ppp->flags & SC_DEBUG)
2066 "%s: no compressor for [%x %x %x], %x\n",
2067 ppp->name, ccp_option[0], ccp_option[1],
2069 goto out; /* compressor not loaded */
2073 * Found a handler for the protocol - try to allocate
2074 * a compressor or decompressor.
2077 if (data.transmit) {
2078 if (ppp->sc_xc_state != NULL)
2079 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2080 ppp->sc_xc_state = NULL;
2083 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2084 if (ppp->sc_xc_state == NULL) {
2085 if (ppp->flags & SC_DEBUG)
2086 printk(KERN_DEBUG "%s: comp_alloc failed\n",
2091 if (ppp->sc_rc_state != NULL)
2092 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2093 ppp->sc_rc_state = NULL;
2096 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2097 if (ppp->sc_rc_state == NULL) {
2098 if (ppp->flags & SC_DEBUG)
2099 printk(KERN_DEBUG "%s: decomp_alloc failed\n",
2109 * Handle a CCP packet.
2111 * The CCP packet is passed along to the pppd process just like any
2112 * other PPP frame. The difference is that some processing needs to be
2113 * immediate or the compressors will become confused on the peer.
2116 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd)
2118 int slen = CCP_LENGTH(dp);
2119 __u8 *opt = dp + CCP_HDRLEN;
2120 int opt_len = slen - CCP_HDRLEN;
2121 unsigned long flags;
2126 if (ppp->flags & SC_DEBUG)
2127 printk(KERN_DEBUG "ppp_proto_ccp rcvd=%d code=%x flags=%x\n",
2128 rcvd, CCP_CODE(dp), ppp->flags);
2130 switch (CCP_CODE(dp)) {
2135 * CCP must be going down - disable compression
2137 if (ppp->flags & SC_CCP_UP) {
2139 ppp->flags &= ~(SC_CCP_UP |
2146 if ((ppp->flags & SC_CCP_OPEN) == 0)
2148 if (ppp->flags & SC_CCP_UP)
2150 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
2152 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
2156 * we're agreeing to send compressed packets.
2158 if (ppp->sc_xc_state == NULL)
2161 if ((*ppp->sc_xcomp->comp_init)
2164 ppp->line, 0, ppp->flags & SC_DEBUG)) {
2165 if (ppp->flags & SC_DEBUG)
2166 printk(KERN_DEBUG "%s: comp running\n",
2169 ppp->flags |= SC_COMP_RUN;
2175 * peer is agreeing to send compressed packets.
2177 if (ppp->sc_rc_state == NULL)
2180 if ((*ppp->sc_rcomp->decomp_init)
2183 ppp->line, 0, ppp->mru, ppp->flags & SC_DEBUG)) {
2184 if (ppp->flags & SC_DEBUG)
2185 printk(KERN_DEBUG "%s: decomp running\n",
2188 ppp->flags |= SC_DECOMP_RUN;
2189 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
2195 * CCP Reset-ack resets compressors and decompressors
2196 * as it passes through.
2198 if ((ppp->flags & SC_CCP_UP) == 0)
2202 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
2203 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
2204 if (ppp->flags & SC_DEBUG)
2205 printk(KERN_DEBUG "%s: comp reset\n",
2209 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
2210 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
2211 if (ppp->flags & SC_DEBUG)
2212 printk(KERN_DEBUG "%s: decomp reset\n",
2215 ppp->flags &= ~SC_DC_ERROR;
2220 restore_flags(flags);
2224 * CCP is down; free (de)compressor state if necessary.
2228 ppp_ccp_closed(struct ppp *ppp)
2230 unsigned long flags;
2234 ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
2235 restore_flags(flags);
2236 if (ppp->flags & SC_DEBUG)
2237 printk(KERN_DEBUG "%s: ccp closed\n", ppp->name);
2238 if (ppp->sc_xc_state) {
2239 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
2240 ppp->sc_xc_state = NULL;
2243 if (ppp->sc_rc_state) {
2244 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
2245 ppp->sc_rc_state = NULL;
2249 /*************************************************************
2250 * RECEIVE-SIDE ROUTINES
2251 *************************************************************/
2254 * On entry, a received frame is in skb.
2255 * Check it and dispose as appropriate.
2258 ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb)
2264 struct sk_buff *new_skb;
2265 ppp_proto_type *proto_ptr;
2268 * An empty frame is ignored. This occurs if the FLAG sequence
2269 * precedes and follows each frame.
2273 if (skb->len == 0) {
2281 * Generate an error if the frame is too small.
2283 if (count < PPP_HDRLEN + 2) {
2284 if (ppp->flags & SC_DEBUG)
2286 "ppp: got runt ppp frame, %d chars\n", count);
2287 ++ppp->estats.rx_length_errors;
2291 if ( !(ppp->flags & SC_SYNC) ) {
2293 * Verify the FCS of the frame and discard the FCS characters
2294 * from the end of the buffer.
2296 if (ppp->rfcs != PPP_GOODFCS) {
2297 if (ppp->flags & SC_DEBUG) {
2299 "ppp: frame with bad fcs, length = %d\n",
2301 ppp_print_buffer("bad frame", data, count);
2303 ++ppp->estats.rx_crc_errors;
2306 count -= 2; /* ignore the fcs characters */
2307 skb_trim(skb, count);
2311 * Process the active decompressor.
2313 if (ppp->sc_rc_state != NULL &&
2314 (ppp->flags & SC_DECOMP_RUN) &&
2315 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
2316 if (PPP_PROTOCOL(data) == PPP_COMP) {
2318 * If the frame is compressed then decompress it.
2320 new_skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
2321 if (new_skb == NULL) {
2322 printk(KERN_ERR "ppp_recv_frame: no memory\n");
2323 new_count = DECOMP_ERROR;
2325 LIBERATE_SKB(new_skb);
2326 new_count = (*ppp->sc_rcomp->decompress)
2327 (ppp->sc_rc_state, data, count,
2328 new_skb->data, ppp->mru + PPP_HDRLEN);
2330 if (new_count > 0) {
2331 /* Frame was decompressed OK */
2335 data = skb_put(skb, count);
2339 * On a decompression error, we pass the
2340 * compressed frame up to pppd as an
2343 if (ppp->flags & SC_DEBUG)
2344 printk(KERN_INFO "%s: decomp err %d\n",
2345 ppp->name, new_count);
2348 if (ppp->slcomp != 0)
2349 slhc_toss(ppp->slcomp);
2350 ++ppp->stats.ppp_ierrors;
2351 if (new_count == DECOMP_FATALERROR) {
2352 ppp->flags |= SC_DC_FERROR;
2354 ppp->flags |= SC_DC_ERROR;
2361 * The frame is not compressed. Pass it to the
2362 * decompression code so it can update its
2363 * dictionary if necessary.
2365 (*ppp->sc_rcomp->incomp)(ppp->sc_rc_state,
2369 else if (PPP_PROTOCOL(data) == PPP_COMP && (ppp->flags & SC_DEBUG))
2370 printk(KERN_INFO "%s: not decomp, rc_state=%p flags=%x\n",
2371 ppp->name, ppp->sc_rc_state, ppp->flags);
2374 * Count the frame and print it
2376 ++ppp->stats.ppp_ipackets;
2377 ppp->stats.ppp_ioctects += count;
2378 if (ppp->flags & SC_LOG_INPKT)
2379 ppp_print_buffer ("receive frame", data, count);
2382 * Find the procedure to handle this protocol.
2383 * The last one is marked as protocol 0 which is the 'catch-all'
2384 * to feed it to the pppd daemon.
2386 proto = PPP_PROTOCOL(data);
2387 proto_ptr = proto_list;
2388 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
2392 * Update the appropriate statistic counter.
2394 if (!(*proto_ptr->func)(ppp, skb)) {
2396 ++ppp->stats.ppp_discards;
2403 * An input error has been detected, so we need to inform
2404 * the VJ decompressor.
2407 ppp_receive_error(struct ppp *ppp)
2411 if (ppp->slcomp != 0)
2412 slhc_toss(ppp->slcomp);
2416 * Put the input frame into the networking system for the indicated protocol
2419 ppp_rcv_rx(struct ppp *ppp, __u16 proto, struct sk_buff *skb)
2423 * Fill in a few fields of the skb and give it to netif_rx().
2425 skb->dev = ppp2dev(ppp); /* We are the device */
2426 skb->protocol = htons(proto);
2427 skb_pull(skb, PPP_HDRLEN); /* pull off ppp header */
2428 skb->mac.raw = skb->data;
2429 ppp->last_recv = jiffies;
2435 * Process the receipt of an IP frame
2438 rcv_proto_ip(struct ppp *ppp, struct sk_buff *skb)
2441 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2442 && ppp->sc_npmode[NP_IP] == NPMODE_PASS)
2443 return ppp_rcv_rx(ppp, ETH_P_IP, skb);
2448 * Process the receipt of an IPv6 frame
2451 rcv_proto_ipv6(struct ppp *ppp, struct sk_buff *skb)
2454 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2455 && ppp->sc_npmode[NP_IPV6] == NPMODE_PASS)
2456 return ppp_rcv_rx(ppp, ETH_P_IPV6, skb);
2461 * Process the receipt of an IPX frame
2464 rcv_proto_ipx(struct ppp *ppp, struct sk_buff *skb)
2467 if (((ppp2dev(ppp)->flags & IFF_UP) != 0) && (skb->len > 0)
2468 && ppp->sc_npmode[NP_IPX] == NPMODE_PASS)
2469 return ppp_rcv_rx(ppp, ETH_P_IPX, skb);
2474 * Process the receipt of an Appletalk frame
2477 rcv_proto_at(struct ppp *ppp, struct sk_buff *skb)
2480 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2481 && ppp->sc_npmode[NP_AT] == NPMODE_PASS)
2482 return ppp_rcv_rx(ppp, ETH_P_PPPTALK, skb);
2487 * Process the receipt of an VJ Compressed frame
2490 rcv_proto_vjc_comp(struct ppp *ppp, struct sk_buff *skb)
2495 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2497 new_count = slhc_uncompress(ppp->slcomp, skb->data + PPP_HDRLEN,
2498 skb->len - PPP_HDRLEN);
2499 if (new_count <= 0) {
2500 if (ppp->flags & SC_DEBUG)
2502 "ppp: error in VJ decompression\n");
2505 new_count += PPP_HDRLEN;
2506 if (new_count > skb->len)
2507 skb_put(skb, new_count - skb->len);
2509 skb_trim(skb, new_count);
2510 return rcv_proto_ip(ppp, skb);
2514 * Process the receipt of an VJ Un-compressed frame
2517 rcv_proto_vjc_uncomp(struct ppp *ppp, struct sk_buff *skb)
2520 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2522 if (slhc_remember(ppp->slcomp, skb->data + PPP_HDRLEN,
2523 skb->len - PPP_HDRLEN) <= 0) {
2524 if (ppp->flags & SC_DEBUG)
2525 printk(KERN_NOTICE "ppp: error in VJ memorizing\n");
2528 return rcv_proto_ip(ppp, skb);
2532 rcv_proto_ccp(struct ppp *ppp, struct sk_buff *skb)
2535 ppp_proto_ccp (ppp, skb->data + PPP_HDRLEN, skb->len - PPP_HDRLEN, 1);
2536 return rcv_proto_unknown(ppp, skb);
2540 * Receive all unclassified protocols.
2543 rcv_proto_unknown(struct ppp *ppp, struct sk_buff *skb)
2548 * Limit queue length by dropping old frames.
2550 skb_queue_tail(&ppp->rcv_q, skb);
2551 while (ppp->rcv_q.qlen > PPP_MAX_RCV_QLEN) {
2552 struct sk_buff *skb = skb_dequeue(&ppp->rcv_q);
2557 wake_up_interruptible (&ppp->read_wait);
2558 if (ppp->tty->fasync != NULL)
2559 kill_fasync (ppp->tty->fasync, SIGIO);
2564 /*************************************************************
2565 * TRANSMIT-SIDE ROUTINES
2566 *************************************************************/
2568 /* local function to store a value into the LQR frame */
2569 extern inline __u8 * store_long (register __u8 *p, register int value) {
2570 *p++ = (__u8) (value >> 24);
2571 *p++ = (__u8) (value >> 16);
2572 *p++ = (__u8) (value >> 8);
2573 *p++ = (__u8) value;
2578 * Compress and send an frame to the peer.
2579 * Should be called with xmit_busy == 1, having been set by the caller.
2580 * That is, we use xmit_busy as a lock to prevent reentry of this
2584 ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
2596 /* dump the buffer */
2597 if (ppp->flags & SC_LOG_OUTPKT)
2598 ppp_print_buffer ("write frame", data, count);
2601 * Handle various types of protocol-specific compression
2602 * and other processing, including:
2603 * - VJ TCP header compression
2604 * - updating LQR packets
2605 * - updating CCP state on CCP packets
2607 proto = PPP_PROTOCOL(data);
2610 if ((ppp->flags & SC_COMP_TCP) && ppp->slcomp != NULL)
2611 skb = ppp_vj_compress(ppp, skb);
2616 * Update the LQR frame with the current MIB information.
2617 * This way the information is accurate and up-to-date.
2621 p = data + 40; /* Point to last two items. */
2622 p = store_long(p, ppp->stats.ppp_opackets + 1);
2623 p = store_long(p, ppp->stats.ppp_ooctects + count);
2624 ++ppp->stats.ppp_olqrs;
2629 * Outbound compression control frames
2631 ppp_proto_ccp(ppp, data + PPP_HDRLEN, count - PPP_HDRLEN, 0);
2638 * Compress the whole frame if possible.
2640 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2641 (ppp->sc_xc_state != (void *) 0) &&
2642 (proto != PPP_LCP) &&
2643 (proto != PPP_CCP)) {
2644 struct sk_buff *new_skb;
2647 /* Allocate an skb for the compressed frame. */
2648 new_skb = alloc_skb(ppp->mtu + PPP_HDRLEN, GFP_ATOMIC);
2649 if (new_skb == NULL) {
2650 printk(KERN_ERR "ppp_send_frame: no memory\n");
2655 LIBERATE_SKB(new_skb);
2657 /* Compress the frame. */
2658 new_count = (*ppp->sc_xcomp->compress)
2659 (ppp->sc_xc_state, data, new_skb->data,
2660 count, ppp->mtu + PPP_HDRLEN);
2662 /* Did it compress? */
2663 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2664 skb_put(new_skb, new_count);
2669 * The frame could not be compressed, or it could not
2670 * be sent in compressed form because CCP is down.
2679 if ( ppp->flags & SC_SYNC )
2680 ret = ppp_sync_send(ppp, skb);
2682 ret = ppp_async_send(ppp, skb);
2684 /* we can release the lock */
2686 } else if (ret < 0) {
2687 /* can't happen, since the caller got the xmit_busy lock */
2688 printk(KERN_ERR "ppp: ppp_async_send didn't accept pkt\n");
2693 * Apply VJ TCP header compression to a packet.
2695 static struct sk_buff *
2696 ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb)
2698 __u8 *orig_data, *data;
2699 struct sk_buff *new_skb;
2702 new_skb = alloc_skb(skb->len, GFP_ATOMIC);
2703 if (new_skb == NULL) {
2704 printk(KERN_ERR "ppp: no memory for vj compression\n");
2707 LIBERATE_SKB(new_skb);
2709 orig_data = data = skb->data + PPP_HDRLEN;
2710 len = slhc_compress(ppp->slcomp, data, skb->len - PPP_HDRLEN,
2711 new_skb->data + PPP_HDRLEN, &data,
2712 (ppp->flags & SC_NO_TCP_CCID) == 0);
2714 if (data == orig_data) {
2715 /* Couldn't compress the data */
2720 /* The data has been changed */
2721 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2722 proto = PPP_VJC_COMP;
2723 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2725 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2726 proto = PPP_VJC_UNCOMP;
2729 data[0] = orig_data[0];
2732 data = skb_put(new_skb, len + PPP_HDRLEN);
2733 data[0] = PPP_ALLSTATIONS;
2743 ppp_send_frames(struct ppp *ppp)
2745 struct sk_buff *skb;
2747 while (!test_and_set_bit(0, &ppp->xmit_busy)) {
2748 skb = skb_dequeue(&ppp->xmt_q);
2753 ppp_send_frame(ppp, skb);
2755 if (!ppp->xmit_busy && ppp->dev.tbusy) {
2762 * Called from the hardware (tty) layer when it can accept
2766 ppp_output_wakeup(struct ppp *ppp)
2770 if (!ppp->xmit_busy) {
2771 printk(KERN_ERR "ppp_output_wakeup called but xmit_busy==0\n");
2775 ppp_send_frames(ppp);
2779 * Send a control frame (from pppd).
2782 ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb)
2787 * Put the packet on the queue, then send as many as we can.
2789 skb_queue_tail(&ppp->xmt_q, skb);
2790 ppp_send_frames(ppp);
2794 /*************************************************************
2796 * This routine accepts requests from the network layer
2797 * and attempts to deliver the packets.
2798 *************************************************************/
2800 * Send a frame to the peer.
2801 * Returns 1 iff the frame was not accepted.
2804 ppp_dev_xmit(struct sk_buff *skb, struct device *dev)
2806 struct ppp *ppp = dev2ppp(dev);
2807 struct tty_struct *tty = ppp2tty(ppp);
2812 /* just a little sanity check. */
2815 if (skb->data == NULL) {
2821 * Avoid timing problem should tty hangup while data is
2822 * queued to be sent.
2830 * Validate the tty interface
2833 if (ppp->flags & SC_DEBUG)
2835 "ppp_dev_xmit: %s not connected to a TTY!\n",
2842 * Work out the appropriate network-protocol mode for this packet.
2844 npmode = NPMODE_PASS; /* default */
2845 switch (ntohs(skb->protocol)) {
2848 npmode = ppp->sc_npmode[NP_IP];
2852 npmode = ppp->sc_npmode[NP_IPV6];
2856 npmode = ppp->sc_npmode[NP_IPX];
2861 npmode = ppp->sc_npmode[NP_AT];
2864 if (ppp->flags & SC_DEBUG)
2865 printk(KERN_INFO "%s: packet for unknown proto %x\n",
2866 ppp->name, ntohs(skb->protocol));
2872 * Drop, accept or reject the packet depending on the mode.
2880 * We may not send the packet now, so drop it.
2881 * XXX It would be nice to be able to return it to the
2882 * network system to be queued and retransmitted later.
2884 if (ppp->flags & SC_DEBUG)
2885 printk(KERN_DEBUG "%s: returning frame\n", ppp->name);
2891 if (ppp->flags & SC_DEBUG)
2893 "ppp_dev_xmit: dropping (npmode = %d) on %s\n",
2900 * The dev->tbusy field acts as a lock to allow only
2901 * one packet to be processed at a time. If we can't
2902 * get the lock, try again later.
2903 * We deliberately queue as little as possible inside
2904 * the ppp driver in order to minimize the latency
2905 * for high-priority packets.
2907 if (test_and_set_bit(0, &ppp->xmit_busy)) {
2908 dev->tbusy = 1; /* can't take it now */
2914 * Put the 4-byte PPP header on the packet.
2915 * If there isn't room for it, we have to copy the packet.
2917 if (skb_headroom(skb) < PPP_HDRLEN) {
2918 struct sk_buff *new_skb;
2920 new_skb = alloc_skb(skb->len + PPP_HDRLEN, GFP_ATOMIC);
2921 if (new_skb == NULL) {
2922 printk(KERN_ERR "%s: skb hdr alloc failed\n",
2926 ppp_send_frames(ppp);
2929 LIBERATE_SKB(new_skb);
2930 skb_reserve(new_skb, PPP_HDRLEN);
2931 memcpy(skb_put(new_skb, skb->len), skb->data, skb->len);
2936 hdr = skb_push(skb, PPP_HDRLEN);
2937 hdr[0] = PPP_ALLSTATIONS;
2939 hdr[2] = proto >> 8;
2942 ppp_send_frame(ppp, skb);
2943 if (!ppp->xmit_busy)
2944 ppp_send_frames(ppp);
2948 #if LINUX_VERSION_CODE < VERSION(2,1,15)
2950 * Null hard_header and header_rebuild routines.
2952 static int ppp_dev_header(struct sk_buff *skb, struct device *dev,
2953 unsigned short type, void *daddr,
2954 void *saddr, unsigned int len)
2959 static int ppp_dev_rebuild(void *eth, struct device *dev,
2960 unsigned long raddr, struct sk_buff *skb)
2964 #endif /* < 2.1.15 */
2967 * Generate the statistic information for the /proc/net/dev listing.
2969 static struct net_device_stats *
2970 ppp_dev_stats (struct device *dev)
2972 struct ppp *ppp = dev2ppp (dev);
2974 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
2975 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
2976 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
2977 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
2978 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
2979 ppp->estats.rx_bytes = ppp->stats.ppp_ibytes;
2980 ppp->estats.tx_bytes = ppp->stats.ppp_obytes;
2983 return &ppp->estats;
2986 /*************************************************************
2988 * Miscellany called by various functions above.
2989 *************************************************************/
2991 /* Locate the previous instance of the PPP channel */
2993 ppp_find(int pid_value)
2997 /* try to find the device which this pid is already using */
2998 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2999 if (ppp->inuse && ppp->sc_xfer == pid_value) {
3007 /* allocate or create a PPP channel */
3016 /* try to find an free device */
3017 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3018 if (!test_and_set_bit(0, &ppp->inuse)) {
3020 if (dev->flags & IFF_UP) {
3021 clear_bit(0, &ppp->inuse);
3024 /* Reregister device */
3025 unregister_netdev(dev);
3026 if (register_netdev(dev) == 0)
3028 printk(KERN_DEBUG "could not reregister ppp device\n");
3029 /* leave inuse set in this case */
3034 * There are no available units, so make a new one.
3036 ppp = (struct ppp *) kmalloc(sizeof(struct ppp), GFP_KERNEL);
3038 printk(KERN_ERR "ppp: struct ppp allocation failed\n");
3041 memset(ppp, 0, sizeof(*ppp));
3043 /* initialize channel control data */
3044 ppp->magic = PPP_MAGIC;
3047 ppp->read_wait = NULL;
3050 * Make up a suitable name for this device
3053 dev->name = ppp->name;
3054 #if LINUX_VERSION_CODE < VERSION(2,1,31)
3055 if_num = (ppp_list == 0)? 0: ppp_last->line + 1;
3056 sprintf(ppp->name, "ppp%d", if_num);
3058 if_num = dev_alloc_name(dev, "ppp%d");
3061 printk(KERN_ERR "ppp: dev_alloc_name failed (%d)\n", if_num);
3069 dev->init = ppp_init_dev;
3070 dev->name = ppp->name;
3071 dev->priv = (void *) ppp;
3073 /* register device so that we can be ifconfig'd */
3074 /* ppp_init_dev() will be called as a side-effect */
3075 status = register_netdev (dev);
3077 printk(KERN_INFO "registered device %s\n", dev->name);
3080 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3086 /* link this unit into our list */
3090 ppp_last->next = ppp;
3097 * Initialize the generic parts of the ppp structure.
3100 ppp_generic_init(struct ppp *ppp)
3108 skb_queue_head_init(&ppp->xmt_q);
3109 skb_queue_head_init(&ppp->rcv_q);
3111 ppp->last_xmit = jiffies;
3112 ppp->last_recv = jiffies;
3115 /* clear statistics */
3116 memset(&ppp->stats, 0, sizeof (struct pppstat));
3117 memset(&ppp->estats, 0, sizeof(struct net_device_stats));
3119 /* PPP compression data */
3120 ppp->sc_xc_state = NULL;
3121 ppp->sc_rc_state = NULL;
3123 for (indx = 0; indx < NUM_NP; ++indx)
3124 ppp->sc_npmode[indx] = NPMODE_PASS;
3128 * Called to clean up the generic parts of the ppp structure.
3131 ppp_release(struct ppp *ppp)
3133 struct sk_buff *skb;
3135 CHECK_PPP_MAGIC(ppp);
3137 if (ppp->flags & SC_DEBUG)
3138 printk(KERN_DEBUG "%s released\n", ppp->name);
3140 ppp_ccp_closed(ppp);
3142 /* Ensure that the pppd process is not hanging on select()/poll() */
3143 wake_up_interruptible(&ppp->read_wait);
3146 slhc_free(ppp->slcomp);
3150 while ((skb = skb_dequeue(&ppp->rcv_q)) != NULL)
3152 while ((skb = skb_dequeue(&ppp->xmt_q)) != NULL)
3156 if (ppp->dev.tbusy) {
3163 * Utility procedures to print a buffer in hex/ascii
3166 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3168 register __u8 next_ch;
3169 static char hex[] = "0123456789ABCDEF";
3171 while (count-- > 0) {
3173 *out++ = hex[(next_ch >> 4) & 0x0F];
3174 *out++ = hex[next_ch & 0x0F];
3180 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3182 register __u8 next_ch;
3184 while (count-- > 0) {
3187 if (next_ch < 0x20 || next_ch > 0x7e)
3191 if (next_ch == '%') /* printk/syslogd has a bug !! */
3199 ppp_print_buffer (const char *name, const __u8 *buf, int count)
3204 printk(KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3207 memset (line, 32, 44);
3208 ppp_print_hex (line, buf, 8);
3209 ppp_print_char (&line[8 * 3], buf, 8);
3210 printk(KERN_DEBUG "%s\n", line);
3216 memset (line, 32, 44);
3217 ppp_print_hex (line, buf, count);
3218 ppp_print_char (&line[8 * 3], buf, count);
3219 printk(KERN_DEBUG "%s\n", line);
3223 /*************************************************************
3224 * Compressor module interface
3225 *************************************************************/
3227 struct compressor_link {
3228 struct compressor_link *next;
3229 struct compressor *comp;
3232 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3234 static struct compressor *find_compressor (int type)
3236 struct compressor_link *lnk;
3237 unsigned long flags;
3242 lnk = ppp_compressors;
3243 while (lnk != (struct compressor_link *) 0) {
3244 if ((int) (__u8) lnk->comp->compress_proto == type) {
3245 restore_flags(flags);
3251 restore_flags(flags);
3252 return (struct compressor *) 0;
3255 static int ppp_register_compressor (struct compressor *cp)
3257 struct compressor_link *new;
3258 unsigned long flags;
3260 new = (struct compressor_link *)
3261 kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3263 if (new == (struct compressor_link *) 0)
3269 if (find_compressor (cp->compress_proto)) {
3270 restore_flags(flags);
3275 new->next = ppp_compressors;
3277 ppp_compressors = new;
3279 restore_flags(flags);
3283 static void ppp_unregister_compressor (struct compressor *cp)
3285 struct compressor_link *prev = (struct compressor_link *) 0;
3286 struct compressor_link *lnk;
3287 unsigned long flags;
3292 lnk = ppp_compressors;
3293 while (lnk != (struct compressor_link *) 0) {
3294 if (lnk->comp == cp) {
3296 prev->next = lnk->next;
3298 ppp_compressors = lnk->next;
3305 restore_flags(flags);
3308 /*************************************************************
3309 * Module support routines
3310 *************************************************************/
3318 /* register our line disciplines */
3319 status = ppp_first_time();
3321 printk(KERN_INFO "PPP: ppp_init() failure %d\n", status);
3322 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3324 (void) register_symtab (&ppp_syms);
3331 cleanup_module(void)
3334 struct ppp *ppp, *next_ppp;
3338 * Ensure that the devices are not in operation.
3340 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3341 CHECK_PPP_MAGIC(ppp);
3342 if (ppp->inuse || (ppp->dev.flags & IFF_UP))
3346 printk(KERN_CRIT "PPP: removing despite %d units in use!\n",
3350 * Release the tty registration of the line discipline so that
3351 * ttys can no longer be put into PPP line discipline.
3353 status = tty_register_ldisc (N_PPP, NULL);
3356 "PPP: Unable to unregister ppp line discipline "
3357 "(err = %d)\n", status);
3360 "PPP: ppp line discipline successfully unregistered\n");
3363 * De-register the devices so that there is no problem with them
3365 for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3366 next_ppp = ppp->next;
3367 unregister_netdev(&ppp->dev);