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 990412==
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.25 1999/04/16 11:29:13 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.7"
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)
181 #ifdef CONFIG_MODULES
182 static int ppp_register_compressor (struct compressor *cp);
183 static void ppp_unregister_compressor (struct compressor *cp);
186 static void ppp_async_init(struct ppp *ppp);
187 static void ppp_async_release(struct ppp *ppp);
188 static int ppp_tty_sync_push(struct ppp *ppp);
189 static int ppp_tty_push(struct ppp *ppp);
190 static int ppp_async_encode(struct ppp *ppp);
191 static int ppp_async_send(struct ppp *, struct sk_buff *);
192 static int ppp_sync_send(struct ppp *, struct sk_buff *);
194 static int ppp_ioctl(struct ppp *, unsigned int, unsigned long);
195 static int ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp);
196 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd);
197 static void ppp_ccp_closed(struct ppp *ppp);
198 static int ppp_receive_frame(struct ppp *, struct sk_buff *);
199 static void ppp_receive_error(struct ppp *ppp);
200 static void ppp_output_wakeup(struct ppp *ppp);
201 static void ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb);
202 static void ppp_send_frame(struct ppp *ppp, struct sk_buff *skb);
203 static void ppp_send_frames(struct ppp *ppp);
204 static struct sk_buff *ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb);
206 static struct ppp *ppp_find (int pid_value);
207 static struct ppp *ppp_alloc (void);
208 static void ppp_generic_init(struct ppp *ppp);
209 static void ppp_release(struct ppp *ppp);
210 static void ppp_print_buffer (const char *, const __u8 *, int);
211 static struct compressor *find_compressor (int type);
213 #ifndef OPTIMIZE_FLAG_TIME
214 #define OPTIMIZE_FLAG_TIME 0
218 * Parameters which may be changed via insmod.
221 static int flag_time = OPTIMIZE_FLAG_TIME;
222 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
223 MODULE_PARM(flag_time, "i");
226 #define CHECK_PPP_MAGIC(ppp) do { \
227 if (ppp->magic != PPP_MAGIC) { \
228 printk(ppp_magic_warn, ppp, __FILE__, __LINE__); \
231 #define CHECK_PPP(a) do { \
232 CHECK_PPP_MAGIC(ppp); \
234 printk(ppp_warning, __LINE__); \
238 #define CHECK_PPP_VOID() do { \
239 CHECK_PPP_MAGIC(ppp); \
241 printk(ppp_warning, __LINE__); \
246 #define tty2ppp(tty) ((struct ppp *) ((tty)->disc_data))
247 #define dev2ppp(dev) ((struct ppp *) ((dev)->priv))
248 #define ppp2tty(ppp) ((ppp)->tty)
249 #define ppp2dev(ppp) (&(ppp)->dev)
251 static struct ppp *ppp_list = NULL;
252 static struct ppp *ppp_last = NULL;
254 /* Define these strings only once for all macro invocations */
255 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
256 static char ppp_magic_warn[] = KERN_WARNING "bad magic for ppp %p at %s:%d\n";
258 static char szVersion[] = PPP_VERSION;
260 #if LINUX_VERSION_CODE < VERSION(2,1,18)
261 static struct symbol_table ppp_syms = {
262 #include <linux/symtab_begin.h>
263 X(ppp_register_compressor),
264 X(ppp_unregister_compressor),
265 #include <linux/symtab_end.h>
268 EXPORT_SYMBOL(ppp_register_compressor);
269 EXPORT_SYMBOL(ppp_unregister_compressor);
272 /*************************************************************
273 * LINE DISCIPLINE SUPPORT
274 * The following code implements the PPP line discipline
275 * and supports using PPP on an async serial line.
276 *************************************************************/
278 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
279 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
280 ppp->recv_async_map & (1 << (c)))
286 static rw_ret_t ppp_tty_read(struct tty_struct *, struct file *, __u8 *,
288 static rw_ret_t ppp_tty_write(struct tty_struct *, struct file *, const __u8 *,
290 static int ppp_tty_ioctl(struct tty_struct *, struct file *, unsigned int,
292 #if LINUX_VERSION_CODE < VERSION(2,1,23)
293 static int ppp_tty_select(struct tty_struct *tty, struct inode *inode,
294 struct file *filp, int sel_type, select_table * wait);
296 static unsigned int ppp_tty_poll(struct tty_struct *tty, struct file *filp,
299 static int ppp_tty_open (struct tty_struct *);
300 static void ppp_tty_close (struct tty_struct *);
301 static int ppp_tty_room (struct tty_struct *tty);
302 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
303 char *fp, int count);
304 static void ppp_tty_wakeup (struct tty_struct *tty);
306 __u16 ppp_crc16_table[256] =
308 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
309 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
310 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
311 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
312 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
313 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
314 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
315 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
316 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
317 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
318 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
319 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
320 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
321 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
322 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
323 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
324 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
325 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
326 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
327 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
328 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
329 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
330 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
331 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
332 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
333 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
334 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
335 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
336 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
337 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
338 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
339 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
342 #ifdef CHECK_CHARACTERS
343 static __u32 paritytab[8] =
345 0x96696996, 0x69969669, 0x69969669, 0x96696996,
346 0x69969669, 0x96696996, 0x96696996, 0x69969669
351 * This procedure is called at initialization time to register
352 * the PPP line discipline.
357 static struct tty_ldisc ppp_ldisc;
361 "PPP: version %s (demand dialling)"
364 #ifndef MODULE /* slhc module logic has its own copyright announcement */
366 "TCP compression code copyright 1989 Regents of the "
367 "University of California\n");
371 * Register the tty discipline
373 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
374 ppp_ldisc.magic = TTY_LDISC_MAGIC;
375 #if LINUX_VERSION_CODE >= VERSION(2,1,28)
376 ppp_ldisc.name = "ppp";
378 ppp_ldisc.open = ppp_tty_open;
379 ppp_ldisc.close = ppp_tty_close;
380 ppp_ldisc.read = ppp_tty_read;
381 ppp_ldisc.write = ppp_tty_write;
382 ppp_ldisc.ioctl = ppp_tty_ioctl;
383 #if LINUX_VERSION_CODE < VERSION(2,1,23)
384 ppp_ldisc.select = ppp_tty_select;
386 ppp_ldisc.poll = ppp_tty_poll;
388 ppp_ldisc.receive_room = ppp_tty_room;
389 ppp_ldisc.receive_buf = ppp_tty_receive;
390 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
392 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
394 printk(KERN_INFO "PPP line discipline registered.\n");
396 printk(KERN_ERR "error registering line discipline: %d\n",
404 * Called at boot time if the PPP driver is compiled into the kernel.
407 ppp_init(struct device *dev)
409 static int first_time = 1;
414 answer = ppp_first_time();
415 #if LINUX_VERSION_CODE < VERSION(2,1,18)
417 (void) register_symtab(&ppp_syms);
427 * Initialize the async-specific parts of the ppp structure.
430 ppp_async_init(struct ppp *ppp)
434 ppp->tty_pushing = 0;
436 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
437 ppp->xmit_async_map[0] = 0xffffffff;
438 ppp->xmit_async_map[3] = 0x60000000;
439 ppp->recv_async_map = 0xffffffff;
442 ppp->tfcs = PPP_INITFCS;
443 ppp->optr = ppp->obuf;
444 ppp->olim = ppp->obuf;
447 ppp->rfcs = PPP_INITFCS;
450 ppp->backup_tty = NULL;
457 * Clean up the async-specific parts of the ppp structure.
460 ppp_async_release(struct ppp *ppp)
464 if ((skb = ppp->rpkt) != NULL)
467 if ((skb = ppp->tpkt) != NULL)
475 * Called when the tty discipline is switched to PPP.
479 ppp_tty_open (struct tty_struct *tty)
484 * Allocate a ppp structure to use.
486 tty->disc_data = NULL;
487 ppp = ppp_find(current->pid);
490 * If we are taking over a ppp unit which is currently
491 * connected to a loopback pty, there's not much to do.
498 printk(KERN_ERR "ppp_alloc failed\n");
503 * Initialize the control block
505 ppp_generic_init(ppp);
511 tty->disc_data = ppp;
515 * Flush any pending characters in the driver
517 if (tty->driver.flush_buffer)
518 tty->driver.flush_buffer (tty);
526 * Called when the line discipline is changed to something
527 * else, the tty is closed, or the tty detects a hangup.
531 ppp_tty_close (struct tty_struct *tty)
533 struct ppp *ppp = tty2ppp(tty);
537 tty->disc_data = NULL;
538 if (ppp->magic != PPP_MAGIC) {
539 printk(KERN_WARNING "ppp_tty_close: bogus\n");
543 printk(KERN_WARNING "ppp_tty_close: not inuse\n");
544 ppp->tty = ppp->backup_tty = 0;
547 if (tty == ppp->backup_tty)
551 if (ppp->backup_tty) {
552 ppp->tty = ppp->backup_tty;
553 if (ppp_tty_push(ppp))
554 ppp_output_wakeup(ppp);
555 wake_up_interruptible(&ppp->read_wait);
559 if (ppp->flags & SC_DEBUG)
560 printk(KERN_INFO "ppp: channel %s closing.\n",
563 ppp_async_release(ppp);
570 * Read a PPP frame from the rcv_q list,
571 * waiting if necessary
574 ppp_tty_read(struct tty_struct *tty, struct file *file, __u8 * buf,
577 struct ppp *ppp = tty2ppp (tty);
582 * Validate the pointers
589 * Before we attempt to write the frame to the user, ensure that the
590 * user has access to the pages for the total buffer length.
592 err = verify_area(VERIFY_WRITE, buf, nr);
597 * Wait for a frame to arrive if necessary.
598 * We increment the module use count so that the module
599 * can't go away while we're sleeping.
606 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
610 skb = skb_dequeue(&ppp->rcv_q);
615 * If no frame is available, return -EAGAIN or wait.
618 if (file->f_flags & O_NONBLOCK)
621 interruptible_sleep_on(&ppp->read_wait);
623 if (signal_pending(current))
631 * Ensure that the frame will fit within the caller's buffer.
632 * If not, just discard the frame.
636 if (ppp->flags & SC_DEBUG)
638 "ppp: read of %lu bytes too small for %ld "
639 "frame\n", (unsigned long) nr, (long) len);
640 ppp->stats.ppp_ierrors++;
646 * Copy the received data from the buffer to the caller's area.
649 if (COPY_TO_USER(buf, skb->data, len))
658 * Writing to a tty in ppp line discipline sends a PPP frame.
659 * Used by pppd to send control packets (LCP, etc.).
662 ppp_tty_write(struct tty_struct *tty, struct file *file, const __u8 * data,
665 struct ppp *ppp = tty2ppp (tty);
670 * Verify the pointers.
675 if (ppp->magic != PPP_MAGIC)
681 * Ensure that the caller does not wish to send too much.
683 if (count > PPP_MTU + PPP_HDRLEN) {
684 if (ppp->flags & SC_DEBUG)
686 "ppp_tty_write: truncating user packet "
687 "from %lu to mtu %d\n", (unsigned long) count,
688 PPP_MTU + PPP_HDRLEN);
689 count = PPP_MTU + PPP_HDRLEN;
693 * Allocate a buffer for the data and fetch it from the user space.
695 skb = alloc_skb(count, GFP_KERNEL);
697 printk(KERN_ERR "ppp_tty_write: no memory\n");
701 new_data = skb_put(skb, count);
704 * Retrieve the user's buffer
706 if (COPY_FROM_USER(new_data, data, count)) {
714 ppp_send_ctrl(ppp, skb);
716 return (rw_ret_t) count;
720 * Process the IOCTL call for the tty device.
721 * Only the ioctls that relate to using ppp on async serial lines
722 * are processed here; the rest are handled by ppp_ioctl.
725 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
726 unsigned int param2, unsigned long param3)
728 struct ppp *ppp = tty2ppp (tty);
729 register int temp_i = 0;
733 * Verify the status of the PPP device.
735 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
739 * The user must have an euid of root to do these requests.
745 case PPPIOCGASYNCMAP:
747 * Retrieve the transmit async map
749 if (PUT_USER(ppp->xmit_async_map[0], (int *) param3))
754 case PPPIOCSASYNCMAP:
756 * Set the transmit async map
758 if (GET_USER(temp_i, (int *) param3))
760 ppp->xmit_async_map[0] = temp_i;
761 if (ppp->flags & SC_DEBUG)
763 "ppp_tty_ioctl: set xmit asyncmap %x\n",
764 ppp->xmit_async_map[0]);
768 case PPPIOCSRASYNCMAP:
770 * Set the receive async map
772 if (GET_USER(temp_i, (int *) param3))
774 ppp->recv_async_map = temp_i;
775 if (ppp->flags & SC_DEBUG)
777 "ppp_tty_ioctl: set rcv asyncmap %x\n",
778 ppp->recv_async_map);
782 case PPPIOCGXASYNCMAP:
784 * Get the map of characters to be escaped on transmission.
786 if (COPY_TO_USER((void *) param3, ppp->xmit_async_map,
787 sizeof (ppp->xmit_async_map)))
792 case PPPIOCSXASYNCMAP:
794 * Set the map of characters to be escaped on transmission.
799 if (COPY_FROM_USER(temp_tbl, (void *) param3,
803 temp_tbl[1] = 0x00000000;
804 temp_tbl[2] &= ~0x40000000;
805 temp_tbl[3] |= 0x60000000;
807 memcpy(ppp->xmit_async_map, temp_tbl,
808 sizeof (ppp->xmit_async_map));
810 if (ppp->flags & SC_DEBUG)
812 "ppp_tty_ioctl: set xasyncmap\n");
819 * Set up this PPP unit to be used next time this
820 * process sets a tty to PPP line discipline.
822 ppp->backup_tty = tty;
823 ppp->sc_xfer = current->pid;
830 * Allow users to read, but not set, the serial port parameters
832 error = n_tty_ioctl (tty, file, param2, param3);
837 * Returns how many bytes are available for a read().
846 skb = skb_peek(&ppp->rcv_q);
849 restore_flags(flags);
850 if (PUT_USER(count, (int *) param3))
858 * All other ioctl() events will come here.
860 error = ppp_ioctl(ppp, param2, param3);
869 * Process the select() or poll() statement for the PPP device.
872 #if LINUX_VERSION_CODE < VERSION(2,1,23)
874 ppp_tty_select(struct tty_struct *tty, struct inode *inode,
875 struct file *filp, int sel_type, select_table * wait)
877 struct ppp *ppp = tty2ppp(tty);
881 * Verify the status of the PPP device.
883 if (!ppp || tty != ppp->tty)
890 /* The fd is readable if the receive queue isn't empty. */
891 if (skb_peek(&ppp->rcv_q) != NULL)
895 /* Check for exceptions or read errors. */
896 /* Is this a pty link and the remote disconnected? */
897 if (tty->flags & (1 << TTY_OTHER_CLOSED))
900 /* Is this a local link and the modem disconnected? */
901 if (tty_hung_up_p (filp))
904 select_wait(&ppp->read_wait, wait);
909 /* The fd is always writable. */
915 #else /* 2.1.23 or later */
918 ppp_tty_poll(struct tty_struct *tty, struct file *filp, poll_table * wait)
920 struct ppp *ppp = tty2ppp(tty);
921 unsigned int mask = 0;
923 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
926 poll_wait(filp, &ppp->read_wait, wait);
928 if (skb_peek(&ppp->rcv_q) != NULL)
929 mask |= POLLIN | POLLRDNORM;
930 if (tty->flags & (1 << TTY_OTHER_CLOSED)
931 || tty_hung_up_p(filp))
933 mask |= POLLOUT | POLLWRNORM;
937 #endif /* >= 2.1.23 */
940 * This function is called by the tty driver when the transmit buffer has
941 * additional space. It is used by the ppp code to continue to transmit
942 * the current buffer should the buffer have been partially sent.
945 ppp_tty_wakeup (struct tty_struct *tty)
947 struct ppp *ppp = tty2ppp (tty);
949 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
956 if (ppp_tty_push(ppp))
957 ppp_output_wakeup(ppp);
961 * Send a packet to the peer over a synchronous tty line.
962 * All encoding and FCS are handled by hardware.
963 * Addr/Ctrl and Protocol field compression implemented.
964 * Returns -1 iff the packet could not be accepted at present,
965 * 0 if the packet was accepted but we can't accept another yet, or
966 * 1 if we can accept another packet immediately.
967 * If this procedure returns 0, ppp_output_wakeup will be called
971 ppp_sync_send(struct ppp *ppp, struct sk_buff *skb)
978 if (ppp->tpkt != NULL)
982 data = ppp->tpkt->data;
985 * LCP packets with code values between 1 (configure-reqest)
986 * and 7 (code-reject) must be sent as though no options
987 * had been negotiated.
989 islcp = PPP_PROTOCOL(data) == PPP_LCP
990 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
992 /* only reset idle time for data packets */
993 if (PPP_PROTOCOL(data) < 0x8000)
994 ppp->last_xmit = jiffies;
995 ++ppp->stats.ppp_opackets;
996 ppp->stats.ppp_ooctects += ppp->tpkt->len;
998 if ( !(data[2]) && (ppp->flags & SC_COMP_PROT) ) {
999 /* compress protocol field */
1002 skb_pull(ppp->tpkt,1);
1003 data = ppp->tpkt->data;
1007 * Do address/control compression
1009 if ((ppp->flags & SC_COMP_AC) && !islcp
1010 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1011 && PPP_CONTROL(data) == PPP_UI) {
1012 /* strip addr and control field */
1013 skb_pull(ppp->tpkt,2);
1016 return ppp_tty_sync_push(ppp);
1020 * Push a synchronous frame out to the tty.
1021 * Returns 1 if frame accepted (or discarded), 0 otherwise.
1024 ppp_tty_sync_push(struct ppp *ppp)
1027 struct tty_struct *tty = ppp2tty(ppp);
1028 unsigned long flags;
1032 if (ppp->tpkt == NULL)
1035 /* prevent reentrancy with tty_pushing flag */
1038 if (ppp->tty_pushing) {
1039 /* record wakeup attempt so we don't loose */
1040 /* a wakeup call while doing push processing */
1042 restore_flags(flags);
1045 ppp->tty_pushing = 1;
1046 restore_flags(flags);
1048 if (tty == NULL || tty->disc_data != (void *) ppp)
1054 /* Note: Sync driver accepts complete frame or nothing */
1055 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1056 sent = tty->driver.write(tty, 0, ppp->tpkt->data, ppp->tpkt->len);
1058 /* write error (possible loss of CD) */
1059 /* record error and discard current packet */
1060 ppp->stats.ppp_oerrors++;
1063 ppp->stats.ppp_obytes += sent;
1064 if (sent < ppp->tpkt->len) {
1065 /* driver unable to accept frame just yet */
1069 /* wake up called while processing */
1070 /* try to send the frame again */
1071 restore_flags(flags);
1074 /* wait for wakeup callback to try send again */
1075 ppp->tty_pushing = 0;
1076 restore_flags(flags);
1082 /* done with current packet (sent or discarded) */
1083 KFREE_SKB(ppp->tpkt);
1085 ppp->tty_pushing = 0;
1090 * Send a packet to the peer over an async tty line.
1091 * Returns -1 iff the packet could not be accepted at present,
1092 * 0 if the packet was accepted but we can't accept another yet, or
1093 * 1 if we can accept another packet immediately.
1094 * If this procedure returns 0, ppp_output_wakeup will be called
1098 ppp_async_send(struct ppp *ppp, struct sk_buff *skb)
1104 if (ppp->tpkt != NULL)
1109 return ppp_tty_push(ppp);
1113 * Push as much data as possible out to the tty.
1114 * Returns 1 if we finished encoding the current frame, 0 otherwise.
1117 ppp_tty_push(struct ppp *ppp)
1119 int avail, sent, done = 0;
1120 struct tty_struct *tty = ppp2tty(ppp);
1122 if ( ppp->flags & SC_SYNC )
1123 return ppp_tty_sync_push(ppp);
1126 if (ppp->tty_pushing)
1128 if (tty == NULL || tty->disc_data != (void *) ppp)
1130 while (ppp->optr < ppp->olim || ppp->tpkt != 0) {
1131 ppp->tty_pushing = 1;
1132 avail = ppp->olim - ppp->optr;
1134 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1135 sent = tty->driver.write(tty, 0, ppp->optr, avail);
1137 goto flush; /* error, e.g. loss of CD */
1138 ppp->stats.ppp_obytes += sent;
1141 ppp->tty_pushing = 0;
1146 done = ppp_async_encode(ppp);
1147 ppp->tty_pushing = 0;
1152 ppp->tty_pushing = 1;
1153 ppp->stats.ppp_oerrors++;
1154 if (ppp->tpkt != 0) {
1155 KFREE_SKB(ppp->tpkt);
1159 ppp->optr = ppp->olim;
1160 ppp->tty_pushing = 0;
1165 * Procedure to encode the data for async serial transmission.
1166 * Does octet stuffing (escaping) and address/control
1167 * and protocol compression.
1168 * Assumes ppp->opkt != 0 on entry.
1169 * Returns 1 if we finished the current frame, 0 otherwise.
1172 ppp_async_encode(struct ppp *ppp)
1174 int fcs, i, count, c;
1175 unsigned char *buf, *buflim;
1176 unsigned char *data;
1185 data = ppp->tpkt->data;
1186 count = ppp->tpkt->len;
1190 * LCP packets with code values between 1 (configure-reqest)
1191 * and 7 (code-reject) must be sent as though no options
1192 * had been negotiated.
1194 islcp = PPP_PROTOCOL(data) == PPP_LCP
1195 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
1199 * Start of a new packet - insert the leading FLAG
1200 * character if necessary.
1202 if (islcp || flag_time == 0
1203 || jiffies - ppp->last_xmit >= flag_time)
1205 /* only reset idle time for data packets */
1206 if (PPP_PROTOCOL(data) < 0x8000)
1207 ppp->last_xmit = jiffies;
1209 ++ppp->stats.ppp_opackets;
1210 ppp->stats.ppp_ooctects += count;
1213 * Do address/control compression
1215 if ((ppp->flags & SC_COMP_AC) != 0 && !islcp
1216 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1217 && PPP_CONTROL(data) == PPP_UI)
1222 * Once we put in the last byte, we need to put in the FCS
1223 * and closing flag, so make sure there is at least 7 bytes
1224 * of free space in the output buffer.
1226 buflim = buf + OBUFSIZE - 6;
1227 while (i < count && buf < buflim) {
1229 if (i == 3 && c == 0 && (ppp->flags & SC_COMP_PROT))
1230 continue; /* compress protocol field */
1231 fcs = PPP_FCS(fcs, c);
1232 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1233 *buf++ = PPP_ESCAPE;
1241 * We have finished the packet. Add the FCS and flag.
1245 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1246 *buf++ = PPP_ESCAPE;
1250 c = (fcs >> 8) & 0xff;
1251 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1252 *buf++ = PPP_ESCAPE;
1259 KFREE_SKB(ppp->tpkt);
1265 * Remember where we are up to in this packet.
1274 * Callback function from tty driver. Return the amount of space left
1275 * in the receiver's buffer to decide if remote transmitter is to be
1279 ppp_tty_room (struct tty_struct *tty)
1281 return 65536; /* We can handle an infinite amount of data. :-) */
1285 * Callback function when data is available at the tty driver.
1288 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1289 char *flags, int count)
1291 register struct ppp *ppp = tty2ppp (tty);
1292 struct sk_buff *skb;
1299 * This can happen if stuff comes in on the backup tty.
1301 if (ppp == 0 || tty != ppp->tty)
1304 * Verify the table pointer and ensure that the line is
1305 * still in PPP discipline.
1307 if (ppp->magic != PPP_MAGIC) {
1308 if (ppp->flags & SC_DEBUG)
1310 "PPP: tty_receive called but couldn't find "
1315 * Print the buffer if desired
1317 if (ppp->flags & SC_LOG_RAWIN)
1318 ppp_print_buffer ("receive buffer", data, count);
1320 ppp->stats.ppp_ibytes += count;
1323 if ( ppp->flags & SC_SYNC ) {
1324 /* synchronous mode */
1326 if (ppp->toss==0xE0) {
1327 /* this is the 1st frame, reset vj comp */
1328 ppp_receive_error(ppp);
1333 * Allocate an skbuff for frame.
1334 * The 128 is room for VJ header expansion.
1338 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1341 if (ppp->flags & SC_DEBUG)
1342 printk(KERN_DEBUG "couldn't "
1343 "alloc skb for recv\n");
1347 * Decompress A/C and protocol compression here.
1349 p = skb_put(skb, 2);
1350 p[0] = PPP_ALLSTATIONS;
1352 if (*data == PPP_ALLSTATIONS) {
1356 if ((*data & 1) != 0) {
1357 p = skb_put(skb, 1);
1361 /* copy frame to socket buffer */
1362 p = skb_put(skb, count);
1363 memcpy(p,data,count);
1366 * Check if we've overflowed the MRU
1368 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1369 || skb_tailroom(skb) <= 0) {
1370 ++ppp->estats.rx_length_errors;
1371 if (ppp->flags & SC_DEBUG)
1372 printk(KERN_DEBUG "rcv frame too long: "
1373 "len=%d mru=%d hroom=%d troom=%d\n",
1374 skb->len, ppp->mru, skb_headroom(skb),
1377 if (!ppp_receive_frame(ppp, skb)) {
1379 ppp_receive_error(ppp);
1383 /* Reset for the next frame */
1390 while (count-- > 0) {
1392 * Collect the character and error condition for the character.
1393 * Set the toss flag for the first character error.
1403 ++ppp->estats.rx_fifo_errors;
1407 ++ppp->estats.rx_frame_errors;
1415 * Set the flags for d7 being 0/1 and parity being
1416 * even/odd so that the normal processing would have
1417 * all flags set at the end of the session. A
1418 * missing flag bit indicates an error condition.
1421 #ifdef CHECK_CHARACTERS
1423 ppp->flags |= SC_RCV_B7_1;
1425 ppp->flags |= SC_RCV_B7_0;
1427 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1428 ppp->flags |= SC_RCV_ODDP;
1430 ppp->flags |= SC_RCV_EVNP;
1433 if (chr == PPP_FLAG) {
1435 * FLAG. This is the end of the block. If the block
1436 * ends with ESC FLAG, then the block is to be ignored.
1441 * Process the frame if it was received correctly.
1442 * If there was an error, let the VJ decompressor know.
1443 * There are 4 cases here:
1444 * skb != NULL, toss != 0: error in frame
1445 * skb != NULL, toss == 0: frame ok
1446 * skb == NULL, toss != 0: very first frame,
1447 * error on 1st char, or alloc_skb failed
1448 * skb == NULL, toss == 0: empty frame (~~)
1450 if (ppp->toss || !ppp_receive_frame(ppp, skb)) {
1451 if (ppp->toss && (ppp->flags & SC_DEBUG))
1453 "ppp: tossing frame (%x)\n",
1457 if (!(ppp->toss == 0xE0 || ppp->toss == 0x80))
1458 ++ppp->stats.ppp_ierrors;
1459 ppp_receive_error(ppp);
1462 * Reset for the next frame.
1465 ppp->rfcs = PPP_INITFCS;
1471 /* If we're tossing, look no further. */
1475 /* If this is a control char to be ignored, do so */
1476 if (in_rmap(ppp, chr))
1480 * Modify the next character if preceded by escape.
1481 * The escape character (0x7d) could be an escaped
1482 * 0x5d, if it follows an escape :-)
1487 } else if (chr == PPP_ESCAPE) {
1488 ppp->escape = PPP_TRANS;
1493 * Allocate an skbuff on the first character received.
1494 * The 128 is room for VJ header expansion and FCS.
1497 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1499 if (ppp->flags & SC_DEBUG)
1500 printk(KERN_DEBUG "couldn't "
1501 "alloc skb for recv\n");
1509 * Decompress A/C and protocol compression here.
1511 if (skb->len == 0 && chr != PPP_ALLSTATIONS) {
1512 p = skb_put(skb, 2);
1513 p[0] = PPP_ALLSTATIONS;
1516 if (skb->len == 2 && (chr & 1) != 0) {
1517 p = skb_put(skb, 1);
1522 * Check if we've overflowed the MRU
1524 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1525 || skb_tailroom(skb) <= 0) {
1526 ++ppp->estats.rx_length_errors;
1528 if (ppp->flags & SC_DEBUG)
1529 printk(KERN_DEBUG "rcv frame too long: "
1530 "len=%d mru=%d hroom=%d troom=%d\n",
1531 skb->len, ppp->mru, skb_headroom(skb),
1537 * Store the character and update the FCS.
1539 p = skb_put(skb, 1);
1541 ppp->rfcs = PPP_FCS(ppp->rfcs, chr);
1546 /*************************************************************
1547 * PPP NETWORK INTERFACE SUPPORT
1548 * The following code implements the PPP network
1549 * interface device and handles those parts of
1550 * the PPP processing which are independent of the
1551 * type of hardware link being used, including
1552 * VJ and packet compression.
1553 *************************************************************/
1556 * Network device driver callback routines
1559 static int ppp_init_dev(struct device *dev);
1560 static int ppp_dev_open(struct device *);
1561 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
1562 static int ppp_dev_close(struct device *);
1563 static int ppp_dev_xmit(struct sk_buff *, struct device *);
1564 static struct net_device_stats *ppp_dev_stats (struct device *);
1566 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1567 static int ppp_dev_header(struct sk_buff *, struct device *, __u16,
1568 void *, void *, unsigned int);
1569 static int ppp_dev_rebuild(void *eth, struct device *dev,
1570 unsigned long raddr, struct sk_buff *skb);
1574 * Information for the protocol decoder
1577 typedef int (*pfn_proto) (struct ppp *, struct sk_buff *);
1579 typedef struct ppp_proto_struct {
1584 static int rcv_proto_ip (struct ppp *, struct sk_buff *);
1585 static int rcv_proto_ipv6 (struct ppp *, struct sk_buff *);
1586 static int rcv_proto_ipx (struct ppp *, struct sk_buff *);
1587 static int rcv_proto_at (struct ppp *, struct sk_buff *);
1588 static int rcv_proto_vjc_comp (struct ppp *, struct sk_buff *);
1589 static int rcv_proto_vjc_uncomp (struct ppp *, struct sk_buff *);
1590 static int rcv_proto_ccp (struct ppp *, struct sk_buff *);
1591 static int rcv_proto_unknown (struct ppp *, struct sk_buff *);
1594 ppp_proto_type proto_list[] = {
1595 { PPP_IP, rcv_proto_ip },
1596 { PPP_IPV6, rcv_proto_ipv6 },
1597 { PPP_IPX, rcv_proto_ipx },
1598 { PPP_AT, rcv_proto_at },
1599 { PPP_VJC_COMP, rcv_proto_vjc_comp },
1600 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
1601 { PPP_CCP, rcv_proto_ccp },
1602 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
1606 * Called when the PPP network interface device is actually created.
1609 ppp_init_dev (struct device *dev)
1611 dev->hard_header_len = PPP_HDRLEN;
1612 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1613 dev->hard_header = ppp_dev_header;
1614 dev->rebuild_header = ppp_dev_rebuild;
1619 dev->hard_start_xmit = ppp_dev_xmit;
1620 dev->open = ppp_dev_open;
1621 dev->stop = ppp_dev_close;
1622 dev->get_stats = ppp_dev_stats;
1623 dev->do_ioctl = ppp_dev_ioctl;
1625 dev->tx_queue_len = 10;
1626 dev->type = ARPHRD_PPP;
1628 #if LINUX_VERSION_CODE < VERSION(2,1,20)
1632 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
1633 skb_queue_head_init (&dev->buffs[indx]);
1636 dev_init_buffers(dev);
1639 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
1645 * Callback from the network layer when the device goes up.
1649 ppp_dev_open (struct device *dev)
1651 struct ppp *ppp = dev2ppp(dev);
1653 if (!ppp->inuse || ppp2tty(ppp) == NULL) {
1654 printk(KERN_ERR "ppp: %s not active\n", dev->name);
1664 * Callback from the network layer when the ppp device goes down.
1668 ppp_dev_close (struct device *dev)
1670 struct ppp *ppp = dev2ppp (dev);
1672 CHECK_PPP_MAGIC(ppp);
1680 get_vj_stats(struct vjstat *vj, struct slcompress *slc)
1682 vj->vjs_packets = slc->sls_o_compressed + slc->sls_o_uncompressed;
1683 vj->vjs_compressed = slc->sls_o_compressed;
1684 vj->vjs_searches = slc->sls_o_searches;
1685 vj->vjs_misses = slc->sls_o_misses;
1686 vj->vjs_errorin = slc->sls_i_error;
1687 vj->vjs_tossed = slc->sls_i_tossed;
1688 vj->vjs_uncompressedin = slc->sls_i_uncompressed;
1689 vj->vjs_compressedin = slc->sls_i_compressed;
1693 * Callback from the network layer to process the sockioctl functions.
1696 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
1698 struct ppp *ppp = dev2ppp(dev);
1701 struct ppp_stats stats;
1702 struct ppp_comp_stats cstats;
1706 CHECK_PPP_MAGIC(ppp);
1708 memset(&u, 0, sizeof(u));
1711 u.stats.p = ppp->stats;
1712 if (ppp->slcomp != NULL)
1713 get_vj_stats(&u.stats.vj, ppp->slcomp);
1714 nb = sizeof(u.stats);
1717 case SIOCGPPPCSTATS:
1718 if (ppp->sc_xc_state != NULL)
1719 (*ppp->sc_xcomp->comp_stat)
1720 (ppp->sc_xc_state, &u.cstats.c);
1721 if (ppp->sc_rc_state != NULL)
1722 (*ppp->sc_rcomp->decomp_stat)
1723 (ppp->sc_rc_state, &u.cstats.d);
1724 nb = sizeof(u.cstats);
1728 strcpy(u.vers, szVersion);
1729 nb = strlen(u.vers) + 1;
1736 if (COPY_TO_USER((void *) ifr->ifr_ifru.ifru_data, &u, nb))
1742 * Process the generic PPP ioctls, i.e. those which are not specific
1743 * to any particular type of hardware link.
1746 ppp_ioctl(struct ppp *ppp, unsigned int param2, unsigned long param3)
1748 register int temp_i = 0, oldflags;
1749 int error = -EFAULT;
1750 unsigned long flags;
1751 struct ppp_idle cur_ddinfo;
1757 * The user must have an euid of root to do these requests.
1767 if (GET_USER(temp_i, (int *) param3))
1769 if (temp_i < PPP_MRU)
1772 if (ppp->flags & SC_DEBUG)
1774 "ppp_ioctl: set mru to %x\n", temp_i);
1780 * Fetch the current flags
1782 temp_i = ppp->flags & SC_MASK;
1783 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
1784 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
1785 SC_RCV_ODDP | SC_RCV_EVNP;
1787 if (PUT_USER(temp_i, (int *) param3))
1794 * Set the flags for the various options
1796 if (GET_USER(temp_i, (int *) param3))
1799 if (ppp->flags & ~temp_i & SC_CCP_OPEN)
1800 ppp_ccp_closed(ppp);
1804 oldflags = ppp->flags;
1805 temp_i = (temp_i & SC_MASK) | (oldflags & ~SC_MASK);
1806 ppp->flags = temp_i;
1807 restore_flags(flags);
1809 if ((oldflags | temp_i) & SC_DEBUG)
1811 "ppp_ioctl: set flags to %x\n", temp_i);
1815 case PPPIOCSCOMPRESS:
1817 * Set the compression mode
1819 error = ppp_set_compression
1820 (ppp, (struct ppp_option_data *) param3);
1825 * Obtain the unit number for this device.
1827 if (PUT_USER(ppp->line, (int *) param3))
1829 if (ppp->flags & SC_DEBUG)
1831 "ppp_ioctl: get unit: %d\n", ppp->line);
1837 * Set the debug level
1839 if (GET_USER(temp_i, (int *) param3))
1841 temp_i = (temp_i & 0x1F) << 16;
1843 if ((ppp->flags | temp_i) & SC_DEBUG)
1845 "ppp_ioctl: set dbg flags to %x\n", temp_i);
1849 ppp->flags = (ppp->flags & ~0x1F0000) | temp_i;
1850 restore_flags(flags);
1856 * Get the debug level
1858 temp_i = (ppp->flags >> 16) & 0x1F;
1859 if (PUT_USER(temp_i, (int *) param3))
1866 * Get the times since the last send/receive frame operation
1868 /* change absolute times to relative times. */
1869 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
1870 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
1871 if (COPY_TO_USER((void *) param3, &cur_ddinfo,
1872 sizeof (cur_ddinfo)))
1879 * Set the maximum VJ header compression slot number.
1881 if (GET_USER(temp_i, (int *) param3))
1884 if (temp_i < 2 || temp_i > 255)
1887 if (ppp->flags & SC_DEBUG)
1888 printk(KERN_INFO "ppp_ioctl: set maxcid to %d\n",
1890 if (ppp->slcomp != NULL)
1891 slhc_free(ppp->slcomp);
1892 ppp->slcomp = slhc_init(16, temp_i);
1895 if (ppp->slcomp == NULL) {
1896 printk(KERN_ERR "ppp: no memory for VJ compression\n");
1904 if (COPY_FROM_USER(&npi, (void *) param3, sizeof(npi)))
1907 switch (npi.protocol) {
1909 npi.protocol = NP_IP;
1912 npi.protocol = NP_IPX;
1915 npi.protocol = NP_AT;
1918 if (ppp->flags & SC_DEBUG)
1919 printk(KERN_DEBUG "pppioc[gs]npmode: "
1920 "invalid proto %d\n", npi.protocol);
1925 if (param2 == PPPIOCGNPMODE) {
1926 npi.mode = ppp->sc_npmode[npi.protocol];
1927 if (COPY_TO_USER((void *) param3, &npi, sizeof(npi)))
1930 ppp->sc_npmode[npi.protocol] = npi.mode;
1931 if (ppp->flags & SC_DEBUG)
1932 printk(KERN_DEBUG "ppp: set np %d to %d\n",
1933 npi.protocol, npi.mode);
1941 * All other ioctl() events will come here.
1943 if (ppp->flags & SC_DEBUG)
1945 "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
1948 error = -ENOIOCTLCMD;
1956 * Process the set-compression ioctl.
1959 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
1961 struct compressor *cp;
1963 unsigned long flags;
1965 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
1966 struct ppp_option_data data;
1969 * Fetch the compression parameters
1972 if (COPY_FROM_USER(&data, odp, sizeof (data)))
1977 if ((unsigned) nb >= CCP_MAX_OPTION_LENGTH)
1978 nb = CCP_MAX_OPTION_LENGTH;
1980 if (COPY_FROM_USER(ccp_option, ptr, nb))
1984 if (ccp_option[1] < 2) /* preliminary check on the length byte */
1989 ppp->flags &= ~(data.transmit? SC_COMP_RUN: SC_DECOMP_RUN);
1990 restore_flags(flags);
1992 cp = find_compressor (ccp_option[0]);
1993 #if defined(CONFIG_KMOD) || defined(CONFIG_KERNELD)
1996 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
1997 request_module(modname);
1998 cp = find_compressor(ccp_option[0]);
2000 #endif /* CONFIG_KMOD */
2003 if (ppp->flags & SC_DEBUG)
2005 "%s: no compressor for [%x %x %x], %x\n",
2006 ppp->name, ccp_option[0], ccp_option[1],
2008 goto out; /* compressor not loaded */
2012 * Found a handler for the protocol - try to allocate
2013 * a compressor or decompressor.
2016 if (data.transmit) {
2017 if (ppp->sc_xc_state != NULL)
2018 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2019 ppp->sc_xc_state = NULL;
2022 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2023 if (ppp->sc_xc_state == NULL) {
2024 if (ppp->flags & SC_DEBUG)
2025 printk(KERN_DEBUG "%s: comp_alloc failed\n",
2030 if (ppp->sc_rc_state != NULL)
2031 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2032 ppp->sc_rc_state = NULL;
2035 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2036 if (ppp->sc_rc_state == NULL) {
2037 if (ppp->flags & SC_DEBUG)
2038 printk(KERN_DEBUG "%s: decomp_alloc failed\n",
2048 * Handle a CCP packet.
2050 * The CCP packet is passed along to the pppd process just like any
2051 * other PPP frame. The difference is that some processing needs to be
2052 * immediate or the compressors will become confused on the peer.
2055 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd)
2057 int slen = CCP_LENGTH(dp);
2058 __u8 *opt = dp + CCP_HDRLEN;
2059 int opt_len = slen - CCP_HDRLEN;
2060 unsigned long flags;
2065 if (ppp->flags & SC_DEBUG)
2066 printk(KERN_DEBUG "ppp_proto_ccp rcvd=%d code=%x flags=%x\n",
2067 rcvd, CCP_CODE(dp), ppp->flags);
2069 switch (CCP_CODE(dp)) {
2074 * CCP must be going down - disable compression
2076 if (ppp->flags & SC_CCP_UP) {
2078 ppp->flags &= ~(SC_CCP_UP |
2085 if ((ppp->flags & SC_CCP_OPEN) == 0)
2087 if (ppp->flags & SC_CCP_UP)
2089 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
2091 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
2095 * we're agreeing to send compressed packets.
2097 if (ppp->sc_xc_state == NULL)
2100 if ((*ppp->sc_xcomp->comp_init)
2103 ppp->line, 0, ppp->flags & SC_DEBUG)) {
2104 if (ppp->flags & SC_DEBUG)
2105 printk(KERN_DEBUG "%s: comp running\n",
2108 ppp->flags |= SC_COMP_RUN;
2114 * peer is agreeing to send compressed packets.
2116 if (ppp->sc_rc_state == NULL)
2119 if ((*ppp->sc_rcomp->decomp_init)
2122 ppp->line, 0, ppp->mru, ppp->flags & SC_DEBUG)) {
2123 if (ppp->flags & SC_DEBUG)
2124 printk(KERN_DEBUG "%s: decomp running\n",
2127 ppp->flags |= SC_DECOMP_RUN;
2128 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
2134 * CCP Reset-ack resets compressors and decompressors
2135 * as it passes through.
2137 if ((ppp->flags & SC_CCP_UP) == 0)
2141 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
2142 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
2143 if (ppp->flags & SC_DEBUG)
2144 printk(KERN_DEBUG "%s: comp reset\n",
2148 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
2149 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
2150 if (ppp->flags & SC_DEBUG)
2151 printk(KERN_DEBUG "%s: decomp reset\n",
2154 ppp->flags &= ~SC_DC_ERROR;
2159 restore_flags(flags);
2163 * CCP is down; free (de)compressor state if necessary.
2167 ppp_ccp_closed(struct ppp *ppp)
2169 unsigned long flags;
2173 ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
2174 restore_flags(flags);
2175 if (ppp->flags & SC_DEBUG)
2176 printk(KERN_DEBUG "%s: ccp closed\n", ppp->name);
2177 if (ppp->sc_xc_state) {
2178 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
2179 ppp->sc_xc_state = NULL;
2182 if (ppp->sc_rc_state) {
2183 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
2184 ppp->sc_rc_state = NULL;
2188 /*************************************************************
2189 * RECEIVE-SIDE ROUTINES
2190 *************************************************************/
2193 * On entry, a received frame is in skb.
2194 * Check it and dispose as appropriate.
2197 ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb)
2203 struct sk_buff *new_skb;
2204 ppp_proto_type *proto_ptr;
2207 * An empty frame is ignored. This occurs if the FLAG sequence
2208 * precedes and follows each frame.
2212 if (skb->len == 0) {
2220 * Generate an error if the frame is too small.
2222 if (count < PPP_HDRLEN + 2) {
2223 if (ppp->flags & SC_DEBUG)
2225 "ppp: got runt ppp frame, %d chars\n", count);
2226 ++ppp->estats.rx_length_errors;
2230 if ( !(ppp->flags & SC_SYNC) ) {
2232 * Verify the FCS of the frame and discard the FCS characters
2233 * from the end of the buffer.
2235 if (ppp->rfcs != PPP_GOODFCS) {
2236 if (ppp->flags & SC_DEBUG) {
2238 "ppp: frame with bad fcs, length = %d\n",
2240 ppp_print_buffer("bad frame", data, count);
2242 ++ppp->estats.rx_crc_errors;
2245 count -= 2; /* ignore the fcs characters */
2246 skb_trim(skb, count);
2250 * Process the active decompressor.
2252 if (ppp->sc_rc_state != NULL &&
2253 (ppp->flags & SC_DECOMP_RUN) &&
2254 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
2255 if (PPP_PROTOCOL(data) == PPP_COMP) {
2257 * If the frame is compressed then decompress it.
2259 new_skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
2260 if (new_skb == NULL) {
2261 printk(KERN_ERR "ppp_recv_frame: no memory\n");
2262 new_count = DECOMP_ERROR;
2264 LIBERATE_SKB(new_skb);
2265 new_count = (*ppp->sc_rcomp->decompress)
2266 (ppp->sc_rc_state, data, count,
2267 new_skb->data, ppp->mru + PPP_HDRLEN);
2269 if (new_count > 0) {
2270 /* Frame was decompressed OK */
2274 data = skb_put(skb, count);
2278 * On a decompression error, we pass the
2279 * compressed frame up to pppd as an
2282 if (ppp->flags & SC_DEBUG)
2283 printk(KERN_INFO "%s: decomp err %d\n",
2284 ppp->name, new_count);
2287 if (ppp->slcomp != 0)
2288 slhc_toss(ppp->slcomp);
2289 ++ppp->stats.ppp_ierrors;
2290 if (new_count == DECOMP_FATALERROR) {
2291 ppp->flags |= SC_DC_FERROR;
2293 ppp->flags |= SC_DC_ERROR;
2300 * The frame is not compressed. Pass it to the
2301 * decompression code so it can update its
2302 * dictionary if necessary.
2304 (*ppp->sc_rcomp->incomp)(ppp->sc_rc_state,
2308 else if (PPP_PROTOCOL(data) == PPP_COMP && (ppp->flags & SC_DEBUG))
2309 printk(KERN_INFO "%s: not decomp, rc_state=%p flags=%x\n",
2310 ppp->name, ppp->sc_rc_state, ppp->flags);
2313 * Count the frame and print it
2315 ++ppp->stats.ppp_ipackets;
2316 ppp->stats.ppp_ioctects += count;
2317 if (ppp->flags & SC_LOG_INPKT)
2318 ppp_print_buffer ("receive frame", data, count);
2321 * Find the procedure to handle this protocol.
2322 * The last one is marked as protocol 0 which is the 'catch-all'
2323 * to feed it to the pppd daemon.
2325 proto = PPP_PROTOCOL(data);
2326 proto_ptr = proto_list;
2327 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
2331 * Update the appropriate statistic counter.
2333 if (!(*proto_ptr->func)(ppp, skb)) {
2335 ++ppp->stats.ppp_discards;
2342 * An input error has been detected, so we need to inform
2343 * the VJ decompressor.
2346 ppp_receive_error(struct ppp *ppp)
2350 if (ppp->slcomp != 0)
2351 slhc_toss(ppp->slcomp);
2355 * Put the input frame into the networking system for the indicated protocol
2358 ppp_rcv_rx(struct ppp *ppp, __u16 proto, struct sk_buff *skb)
2362 * Fill in a few fields of the skb and give it to netif_rx().
2364 skb->dev = ppp2dev(ppp); /* We are the device */
2365 skb->protocol = htons(proto);
2366 skb_pull(skb, PPP_HDRLEN); /* pull off ppp header */
2367 skb->mac.raw = skb->data;
2368 ppp->last_recv = jiffies;
2374 * Process the receipt of an IP frame
2377 rcv_proto_ip(struct ppp *ppp, struct sk_buff *skb)
2380 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2381 && ppp->sc_npmode[NP_IP] == NPMODE_PASS)
2382 return ppp_rcv_rx(ppp, ETH_P_IP, skb);
2387 * Process the receipt of an IPv6 frame
2390 rcv_proto_ipv6(struct ppp *ppp, struct sk_buff *skb)
2393 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2394 && ppp->sc_npmode[NP_IPV6] == NPMODE_PASS)
2395 return ppp_rcv_rx(ppp, ETH_P_IPV6, skb);
2400 * Process the receipt of an IPX frame
2403 rcv_proto_ipx(struct ppp *ppp, struct sk_buff *skb)
2406 if (((ppp2dev(ppp)->flags & IFF_UP) != 0) && (skb->len > 0)
2407 && ppp->sc_npmode[NP_IPX] == NPMODE_PASS)
2408 return ppp_rcv_rx(ppp, ETH_P_IPX, skb);
2413 * Process the receipt of an Appletalk frame
2416 rcv_proto_at(struct ppp *ppp, struct sk_buff *skb)
2419 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2420 && ppp->sc_npmode[NP_AT] == NPMODE_PASS)
2421 return ppp_rcv_rx(ppp, ETH_P_PPPTALK, skb);
2426 * Process the receipt of an VJ Compressed frame
2429 rcv_proto_vjc_comp(struct ppp *ppp, struct sk_buff *skb)
2434 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2436 new_count = slhc_uncompress(ppp->slcomp, skb->data + PPP_HDRLEN,
2437 skb->len - PPP_HDRLEN);
2438 if (new_count <= 0) {
2439 if (ppp->flags & SC_DEBUG)
2441 "ppp: error in VJ decompression\n");
2444 new_count += PPP_HDRLEN;
2445 if (new_count > skb->len)
2446 skb_put(skb, new_count - skb->len);
2448 skb_trim(skb, new_count);
2449 return rcv_proto_ip(ppp, skb);
2453 * Process the receipt of an VJ Un-compressed frame
2456 rcv_proto_vjc_uncomp(struct ppp *ppp, struct sk_buff *skb)
2459 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2461 if (slhc_remember(ppp->slcomp, skb->data + PPP_HDRLEN,
2462 skb->len - PPP_HDRLEN) <= 0) {
2463 if (ppp->flags & SC_DEBUG)
2464 printk(KERN_NOTICE "ppp: error in VJ memorizing\n");
2467 return rcv_proto_ip(ppp, skb);
2471 rcv_proto_ccp(struct ppp *ppp, struct sk_buff *skb)
2474 ppp_proto_ccp (ppp, skb->data + PPP_HDRLEN, skb->len - PPP_HDRLEN, 1);
2475 return rcv_proto_unknown(ppp, skb);
2479 * Receive all unclassified protocols.
2482 rcv_proto_unknown(struct ppp *ppp, struct sk_buff *skb)
2487 * Limit queue length by dropping old frames.
2489 skb_queue_tail(&ppp->rcv_q, skb);
2490 while (ppp->rcv_q.qlen > PPP_MAX_RCV_QLEN) {
2491 struct sk_buff *skb = skb_dequeue(&ppp->rcv_q);
2496 wake_up_interruptible (&ppp->read_wait);
2497 if (ppp->tty->fasync != NULL)
2498 kill_fasync (ppp->tty->fasync, SIGIO);
2503 /*************************************************************
2504 * TRANSMIT-SIDE ROUTINES
2505 *************************************************************/
2507 /* local function to store a value into the LQR frame */
2508 extern inline __u8 * store_long (register __u8 *p, register int value) {
2509 *p++ = (__u8) (value >> 24);
2510 *p++ = (__u8) (value >> 16);
2511 *p++ = (__u8) (value >> 8);
2512 *p++ = (__u8) value;
2517 * Compress and send an frame to the peer.
2518 * Should be called with xmit_busy == 1, having been set by the caller.
2519 * That is, we use xmit_busy as a lock to prevent reentry of this
2523 ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
2535 /* dump the buffer */
2536 if (ppp->flags & SC_LOG_OUTPKT)
2537 ppp_print_buffer ("write frame", data, count);
2540 * Handle various types of protocol-specific compression
2541 * and other processing, including:
2542 * - VJ TCP header compression
2543 * - updating LQR packets
2544 * - updating CCP state on CCP packets
2546 proto = PPP_PROTOCOL(data);
2549 if ((ppp->flags & SC_COMP_TCP) && ppp->slcomp != NULL)
2550 skb = ppp_vj_compress(ppp, skb);
2555 * Update the LQR frame with the current MIB information.
2556 * This way the information is accurate and up-to-date.
2560 p = data + 40; /* Point to last two items. */
2561 p = store_long(p, ppp->stats.ppp_opackets + 1);
2562 p = store_long(p, ppp->stats.ppp_ooctects + count);
2563 ++ppp->stats.ppp_olqrs;
2568 * Outbound compression control frames
2570 ppp_proto_ccp(ppp, data + PPP_HDRLEN, count - PPP_HDRLEN, 0);
2577 * Compress the whole frame if possible.
2579 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2580 (ppp->sc_xc_state != (void *) 0) &&
2581 (proto != PPP_LCP) &&
2582 (proto != PPP_CCP)) {
2583 struct sk_buff *new_skb;
2586 /* Allocate an skb for the compressed frame. */
2587 new_skb = alloc_skb(ppp->mtu + PPP_HDRLEN, GFP_ATOMIC);
2588 if (new_skb == NULL) {
2589 printk(KERN_ERR "ppp_send_frame: no memory\n");
2594 LIBERATE_SKB(new_skb);
2596 /* Compress the frame. */
2597 new_count = (*ppp->sc_xcomp->compress)
2598 (ppp->sc_xc_state, data, new_skb->data,
2599 count, ppp->mtu + PPP_HDRLEN);
2601 /* Did it compress? */
2602 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2603 skb_put(new_skb, new_count);
2608 * The frame could not be compressed, or it could not
2609 * be sent in compressed form because CCP is down.
2618 if ( ppp->flags & SC_SYNC )
2619 ret = ppp_sync_send(ppp, skb);
2621 ret = ppp_async_send(ppp, skb);
2623 /* we can release the lock */
2625 } else if (ret < 0) {
2626 /* can't happen, since the caller got the xmit_busy lock */
2627 printk(KERN_ERR "ppp: ppp_async_send didn't accept pkt\n");
2632 * Apply VJ TCP header compression to a packet.
2634 static struct sk_buff *
2635 ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb)
2637 __u8 *orig_data, *data;
2638 struct sk_buff *new_skb;
2641 new_skb = alloc_skb(skb->len, GFP_ATOMIC);
2642 if (new_skb == NULL) {
2643 printk(KERN_ERR "ppp: no memory for vj compression\n");
2646 LIBERATE_SKB(new_skb);
2648 orig_data = data = skb->data + PPP_HDRLEN;
2649 len = slhc_compress(ppp->slcomp, data, skb->len - PPP_HDRLEN,
2650 new_skb->data + PPP_HDRLEN, &data,
2651 (ppp->flags & SC_NO_TCP_CCID) == 0);
2653 if (data == orig_data) {
2654 /* Couldn't compress the data */
2659 /* The data has been changed */
2660 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2661 proto = PPP_VJC_COMP;
2662 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2664 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2665 proto = PPP_VJC_UNCOMP;
2668 data[0] = orig_data[0];
2671 data = skb_put(new_skb, len + PPP_HDRLEN);
2672 data[0] = PPP_ALLSTATIONS;
2682 ppp_send_frames(struct ppp *ppp)
2684 struct sk_buff *skb;
2686 while (!test_and_set_bit(0, &ppp->xmit_busy)) {
2687 skb = skb_dequeue(&ppp->xmt_q);
2692 ppp_send_frame(ppp, skb);
2694 if (!ppp->xmit_busy && ppp->dev.tbusy) {
2701 * Called from the hardware (tty) layer when it can accept
2705 ppp_output_wakeup(struct ppp *ppp)
2709 if (!ppp->xmit_busy) {
2710 printk(KERN_ERR "ppp_output_wakeup called but xmit_busy==0\n");
2714 ppp_send_frames(ppp);
2718 * Send a control frame (from pppd).
2721 ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb)
2726 * Put the packet on the queue, then send as many as we can.
2728 skb_queue_tail(&ppp->xmt_q, skb);
2729 ppp_send_frames(ppp);
2733 /*************************************************************
2735 * This routine accepts requests from the network layer
2736 * and attempts to deliver the packets.
2737 *************************************************************/
2739 * Send a frame to the peer.
2740 * Returns 1 iff the frame was not accepted.
2743 ppp_dev_xmit(struct sk_buff *skb, struct device *dev)
2745 struct ppp *ppp = dev2ppp(dev);
2746 struct tty_struct *tty = ppp2tty(ppp);
2751 /* just a little sanity check. */
2754 if (skb->data == NULL) {
2760 * Avoid timing problem should tty hangup while data is
2761 * queued to be sent.
2769 * Validate the tty interface
2772 if (ppp->flags & SC_DEBUG)
2774 "ppp_dev_xmit: %s not connected to a TTY!\n",
2781 * Work out the appropriate network-protocol mode for this packet.
2783 npmode = NPMODE_PASS; /* default */
2784 switch (ntohs(skb->protocol)) {
2787 npmode = ppp->sc_npmode[NP_IP];
2791 npmode = ppp->sc_npmode[NP_IPV6];
2795 npmode = ppp->sc_npmode[NP_IPX];
2800 npmode = ppp->sc_npmode[NP_AT];
2803 if (ppp->flags & SC_DEBUG)
2804 printk(KERN_INFO "%s: packet for unknown proto %x\n",
2805 ppp->name, ntohs(skb->protocol));
2811 * Drop, accept or reject the packet depending on the mode.
2819 * We may not send the packet now, so drop it.
2820 * XXX It would be nice to be able to return it to the
2821 * network system to be queued and retransmitted later.
2823 if (ppp->flags & SC_DEBUG)
2824 printk(KERN_DEBUG "%s: returning frame\n", ppp->name);
2830 if (ppp->flags & SC_DEBUG)
2832 "ppp_dev_xmit: dropping (npmode = %d) on %s\n",
2839 * The dev->tbusy field acts as a lock to allow only
2840 * one packet to be processed at a time. If we can't
2841 * get the lock, try again later.
2842 * We deliberately queue as little as possible inside
2843 * the ppp driver in order to minimize the latency
2844 * for high-priority packets.
2846 if (test_and_set_bit(0, &ppp->xmit_busy)) {
2847 dev->tbusy = 1; /* can't take it now */
2853 * Put the 4-byte PPP header on the packet.
2854 * If there isn't room for it, we have to copy the packet.
2856 if (skb_headroom(skb) < PPP_HDRLEN) {
2857 struct sk_buff *new_skb;
2859 new_skb = alloc_skb(skb->len + PPP_HDRLEN, GFP_ATOMIC);
2860 if (new_skb == NULL) {
2861 printk(KERN_ERR "%s: skb hdr alloc failed\n",
2865 ppp_send_frames(ppp);
2868 LIBERATE_SKB(new_skb);
2869 skb_reserve(new_skb, PPP_HDRLEN);
2870 memcpy(skb_put(new_skb, skb->len), skb->data, skb->len);
2875 hdr = skb_push(skb, PPP_HDRLEN);
2876 hdr[0] = PPP_ALLSTATIONS;
2878 hdr[2] = proto >> 8;
2881 ppp_send_frame(ppp, skb);
2882 if (!ppp->xmit_busy)
2883 ppp_send_frames(ppp);
2887 #if LINUX_VERSION_CODE < VERSION(2,1,15)
2889 * Null hard_header and header_rebuild routines.
2891 static int ppp_dev_header(struct sk_buff *skb, struct device *dev,
2892 unsigned short type, void *daddr,
2893 void *saddr, unsigned int len)
2898 static int ppp_dev_rebuild(void *eth, struct device *dev,
2899 unsigned long raddr, struct sk_buff *skb)
2903 #endif /* < 2.1.15 */
2906 * Generate the statistic information for the /proc/net/dev listing.
2908 static struct net_device_stats *
2909 ppp_dev_stats (struct device *dev)
2911 struct ppp *ppp = dev2ppp (dev);
2913 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
2914 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
2915 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
2916 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
2917 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
2918 ppp->estats.rx_bytes = ppp->stats.ppp_ibytes;
2919 ppp->estats.tx_bytes = ppp->stats.ppp_obytes;
2922 return &ppp->estats;
2925 /*************************************************************
2927 * Miscellany called by various functions above.
2928 *************************************************************/
2930 /* Locate the previous instance of the PPP channel */
2932 ppp_find(int pid_value)
2936 /* try to find the device which this pid is already using */
2937 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2938 if (ppp->inuse && ppp->sc_xfer == pid_value) {
2946 /* allocate or create a PPP channel */
2955 /* try to find an free device */
2956 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2957 if (!test_and_set_bit(0, &ppp->inuse)) {
2959 if (dev->flags & IFF_UP) {
2960 clear_bit(0, &ppp->inuse);
2963 /* Reregister device */
2964 unregister_netdev(dev);
2965 if (register_netdev(dev) == 0)
2967 printk(KERN_DEBUG "could not reregister ppp device\n");
2968 /* leave inuse set in this case */
2973 * There are no available units, so make a new one.
2975 ppp = (struct ppp *) kmalloc(sizeof(struct ppp), GFP_KERNEL);
2977 printk(KERN_ERR "ppp: struct ppp allocation failed\n");
2980 memset(ppp, 0, sizeof(*ppp));
2982 /* initialize channel control data */
2983 ppp->magic = PPP_MAGIC;
2986 ppp->read_wait = NULL;
2989 * Make up a suitable name for this device
2992 dev->name = ppp->name;
2993 #if LINUX_VERSION_CODE < VERSION(2,1,31)
2994 if_num = (ppp_list == 0)? 0: ppp_last->line + 1;
2995 sprintf(ppp->name, "ppp%d", if_num);
2997 if_num = dev_alloc_name(dev, "ppp%d");
3000 printk(KERN_ERR "ppp: dev_alloc_name failed (%d)\n", if_num);
3008 dev->init = ppp_init_dev;
3009 dev->name = ppp->name;
3010 dev->priv = (void *) ppp;
3012 /* register device so that we can be ifconfig'd */
3013 /* ppp_init_dev() will be called as a side-effect */
3014 status = register_netdev (dev);
3016 printk(KERN_INFO "registered device %s\n", dev->name);
3019 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3025 /* link this unit into our list */
3029 ppp_last->next = ppp;
3036 * Initialize the generic parts of the ppp structure.
3039 ppp_generic_init(struct ppp *ppp)
3047 skb_queue_head_init(&ppp->xmt_q);
3048 skb_queue_head_init(&ppp->rcv_q);
3050 ppp->last_xmit = jiffies;
3051 ppp->last_recv = jiffies;
3054 /* clear statistics */
3055 memset(&ppp->stats, 0, sizeof (struct pppstat));
3056 memset(&ppp->estats, 0, sizeof(struct net_device_stats));
3058 /* PPP compression data */
3059 ppp->sc_xc_state = NULL;
3060 ppp->sc_rc_state = NULL;
3062 for (indx = 0; indx < NUM_NP; ++indx)
3063 ppp->sc_npmode[indx] = NPMODE_PASS;
3067 * Called to clean up the generic parts of the ppp structure.
3070 ppp_release(struct ppp *ppp)
3072 struct sk_buff *skb;
3074 CHECK_PPP_MAGIC(ppp);
3076 if (ppp->flags & SC_DEBUG)
3077 printk(KERN_DEBUG "%s released\n", ppp->name);
3079 ppp_ccp_closed(ppp);
3081 /* Ensure that the pppd process is not hanging on select()/poll() */
3082 wake_up_interruptible(&ppp->read_wait);
3085 slhc_free(ppp->slcomp);
3089 while ((skb = skb_dequeue(&ppp->rcv_q)) != NULL)
3091 while ((skb = skb_dequeue(&ppp->xmt_q)) != NULL)
3095 if (ppp->dev.tbusy) {
3102 * Utility procedures to print a buffer in hex/ascii
3105 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3107 register __u8 next_ch;
3108 static char hex[] = "0123456789ABCDEF";
3110 while (count-- > 0) {
3112 *out++ = hex[(next_ch >> 4) & 0x0F];
3113 *out++ = hex[next_ch & 0x0F];
3119 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3121 register __u8 next_ch;
3123 while (count-- > 0) {
3126 if (next_ch < 0x20 || next_ch > 0x7e)
3130 if (next_ch == '%') /* printk/syslogd has a bug !! */
3138 ppp_print_buffer (const char *name, const __u8 *buf, int count)
3143 printk(KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3146 memset (line, 32, 44);
3147 ppp_print_hex (line, buf, 8);
3148 ppp_print_char (&line[8 * 3], buf, 8);
3149 printk(KERN_DEBUG "%s\n", line);
3155 memset (line, 32, 44);
3156 ppp_print_hex (line, buf, count);
3157 ppp_print_char (&line[8 * 3], buf, count);
3158 printk(KERN_DEBUG "%s\n", line);
3162 /*************************************************************
3163 * Compressor module interface
3164 *************************************************************/
3166 struct compressor_link {
3167 struct compressor_link *next;
3168 struct compressor *comp;
3171 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3173 static struct compressor *find_compressor (int type)
3175 struct compressor_link *lnk;
3176 unsigned long flags;
3181 lnk = ppp_compressors;
3182 while (lnk != (struct compressor_link *) 0) {
3183 if ((int) (__u8) lnk->comp->compress_proto == type) {
3184 restore_flags(flags);
3190 restore_flags(flags);
3191 return (struct compressor *) 0;
3194 #ifdef CONFIG_MODULES
3195 static int ppp_register_compressor (struct compressor *cp)
3197 struct compressor_link *new;
3198 unsigned long flags;
3200 new = (struct compressor_link *)
3201 kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3203 if (new == (struct compressor_link *) 0)
3209 if (find_compressor (cp->compress_proto)) {
3210 restore_flags(flags);
3215 new->next = ppp_compressors;
3217 ppp_compressors = new;
3219 restore_flags(flags);
3223 static void ppp_unregister_compressor (struct compressor *cp)
3225 struct compressor_link *prev = (struct compressor_link *) 0;
3226 struct compressor_link *lnk;
3227 unsigned long flags;
3232 lnk = ppp_compressors;
3233 while (lnk != (struct compressor_link *) 0) {
3234 if (lnk->comp == cp) {
3236 prev->next = lnk->next;
3238 ppp_compressors = lnk->next;
3245 restore_flags(flags);
3249 /*************************************************************
3250 * Module support routines
3251 *************************************************************/
3259 /* register our line disciplines */
3260 status = ppp_first_time();
3262 printk(KERN_INFO "PPP: ppp_init() failure %d\n", status);
3263 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3265 (void) register_symtab (&ppp_syms);
3272 cleanup_module(void)
3275 struct ppp *ppp, *next_ppp;
3279 * Ensure that the devices are not in operation.
3281 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3282 CHECK_PPP_MAGIC(ppp);
3283 if (ppp->inuse || (ppp->dev.flags & IFF_UP))
3287 printk(KERN_CRIT "PPP: removing despite %d units in use!\n",
3291 * Release the tty registration of the line discipline so that
3292 * ttys can no longer be put into PPP line discipline.
3294 status = tty_register_ldisc (N_PPP, NULL);
3297 "PPP: Unable to unregister ppp line discipline "
3298 "(err = %d)\n", status);
3301 "PPP: ppp line discipline successfully unregistered\n");
3304 * De-register the devices so that there is no problem with them
3306 for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3307 next_ppp = ppp->next;
3308 unregister_netdev(&ppp->dev);