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 990331==
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.24 1999/03/31 06:07:57 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);
558 if (ppp->flags & SC_DEBUG)
559 printk(KERN_INFO "ppp: channel %s closing.\n",
562 ppp_async_release(ppp);
569 * Read a PPP frame from the rcv_q list,
570 * waiting if necessary
573 ppp_tty_read(struct tty_struct *tty, struct file *file, __u8 * buf,
576 struct ppp *ppp = tty2ppp (tty);
581 * Validate the pointers
588 * Before we attempt to write the frame to the user, ensure that the
589 * user has access to the pages for the total buffer length.
591 err = verify_area(VERIFY_WRITE, buf, nr);
596 * Wait for a frame to arrive if necessary.
597 * We increment the module use count so that the module
598 * can't go away while we're sleeping.
605 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
609 skb = skb_dequeue(&ppp->rcv_q);
614 * If no frame is available, return -EAGAIN or wait.
617 if (file->f_flags & O_NONBLOCK)
620 interruptible_sleep_on(&ppp->read_wait);
622 if (signal_pending(current))
630 * Ensure that the frame will fit within the caller's buffer.
631 * If not, just discard the frame.
635 if (ppp->flags & SC_DEBUG)
637 "ppp: read of %lu bytes too small for %ld "
638 "frame\n", (unsigned long) nr, (long) len);
639 ppp->stats.ppp_ierrors++;
645 * Copy the received data from the buffer to the caller's area.
648 if (COPY_TO_USER(buf, skb->data, len))
657 * Writing to a tty in ppp line discipline sends a PPP frame.
658 * Used by pppd to send control packets (LCP, etc.).
661 ppp_tty_write(struct tty_struct *tty, struct file *file, const __u8 * data,
664 struct ppp *ppp = tty2ppp (tty);
669 * Verify the pointers.
674 if (ppp->magic != PPP_MAGIC)
680 * Ensure that the caller does not wish to send too much.
682 if (count > PPP_MTU + PPP_HDRLEN) {
683 if (ppp->flags & SC_DEBUG)
685 "ppp_tty_write: truncating user packet "
686 "from %lu to mtu %d\n", (unsigned long) count,
687 PPP_MTU + PPP_HDRLEN);
688 count = PPP_MTU + PPP_HDRLEN;
692 * Allocate a buffer for the data and fetch it from the user space.
694 skb = alloc_skb(count, GFP_KERNEL);
696 printk(KERN_ERR "ppp_tty_write: no memory\n");
700 new_data = skb_put(skb, count);
703 * Retrieve the user's buffer
705 if (COPY_FROM_USER(new_data, data, count)) {
713 ppp_send_ctrl(ppp, skb);
715 return (rw_ret_t) count;
719 * Process the IOCTL call for the tty device.
720 * Only the ioctls that relate to using ppp on async serial lines
721 * are processed here; the rest are handled by ppp_ioctl.
724 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
725 unsigned int param2, unsigned long param3)
727 struct ppp *ppp = tty2ppp (tty);
728 register int temp_i = 0;
732 * Verify the status of the PPP device.
734 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
738 * The user must have an euid of root to do these requests.
744 case PPPIOCGASYNCMAP:
746 * Retrieve the transmit async map
748 if (PUT_USER(ppp->xmit_async_map[0], (int *) param3))
753 case PPPIOCSASYNCMAP:
755 * Set the transmit async map
757 if (GET_USER(temp_i, (int *) param3))
759 ppp->xmit_async_map[0] = temp_i;
760 if (ppp->flags & SC_DEBUG)
762 "ppp_tty_ioctl: set xmit asyncmap %x\n",
763 ppp->xmit_async_map[0]);
767 case PPPIOCSRASYNCMAP:
769 * Set the receive async map
771 if (GET_USER(temp_i, (int *) param3))
773 ppp->recv_async_map = temp_i;
774 if (ppp->flags & SC_DEBUG)
776 "ppp_tty_ioctl: set rcv asyncmap %x\n",
777 ppp->recv_async_map);
781 case PPPIOCGXASYNCMAP:
783 * Get the map of characters to be escaped on transmission.
785 if (COPY_TO_USER((void *) param3, ppp->xmit_async_map,
786 sizeof (ppp->xmit_async_map)))
791 case PPPIOCSXASYNCMAP:
793 * Set the map of characters to be escaped on transmission.
798 if (COPY_FROM_USER(temp_tbl, (void *) param3,
802 temp_tbl[1] = 0x00000000;
803 temp_tbl[2] &= ~0x40000000;
804 temp_tbl[3] |= 0x60000000;
806 memcpy(ppp->xmit_async_map, temp_tbl,
807 sizeof (ppp->xmit_async_map));
809 if (ppp->flags & SC_DEBUG)
811 "ppp_tty_ioctl: set xasyncmap\n");
818 * Set up this PPP unit to be used next time this
819 * process sets a tty to PPP line discipline.
821 ppp->backup_tty = tty;
822 ppp->sc_xfer = current->pid;
829 * Allow users to read, but not set, the serial port parameters
831 error = n_tty_ioctl (tty, file, param2, param3);
836 * Returns how many bytes are available for a read().
845 skb = skb_peek(&ppp->rcv_q);
848 restore_flags(flags);
849 if (PUT_USER(count, (int *) param3))
857 * All other ioctl() events will come here.
859 error = ppp_ioctl(ppp, param2, param3);
868 * Process the select() or poll() statement for the PPP device.
871 #if LINUX_VERSION_CODE < VERSION(2,1,23)
873 ppp_tty_select(struct tty_struct *tty, struct inode *inode,
874 struct file *filp, int sel_type, select_table * wait)
876 struct ppp *ppp = tty2ppp(tty);
880 * Verify the status of the PPP device.
882 if (!ppp || tty != ppp->tty)
889 /* The fd is readable if the receive queue isn't empty. */
890 if (skb_peek(&ppp->rcv_q) != NULL)
894 /* Check for exceptions or read errors. */
895 /* Is this a pty link and the remote disconnected? */
896 if (tty->flags & (1 << TTY_OTHER_CLOSED))
899 /* Is this a local link and the modem disconnected? */
900 if (tty_hung_up_p (filp))
903 select_wait(&ppp->read_wait, wait);
908 /* The fd is always writable. */
914 #else /* 2.1.23 or later */
917 ppp_tty_poll(struct tty_struct *tty, struct file *filp, poll_table * wait)
919 struct ppp *ppp = tty2ppp(tty);
920 unsigned int mask = 0;
922 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
925 poll_wait(filp, &ppp->read_wait, wait);
927 if (skb_peek(&ppp->rcv_q) != NULL)
928 mask |= POLLIN | POLLRDNORM;
929 if (tty->flags & (1 << TTY_OTHER_CLOSED)
930 || tty_hung_up_p(filp))
932 mask |= POLLOUT | POLLWRNORM;
936 #endif /* >= 2.1.23 */
939 * This function is called by the tty driver when the transmit buffer has
940 * additional space. It is used by the ppp code to continue to transmit
941 * the current buffer should the buffer have been partially sent.
944 ppp_tty_wakeup (struct tty_struct *tty)
946 struct ppp *ppp = tty2ppp (tty);
948 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
955 if (ppp_tty_push(ppp))
956 ppp_output_wakeup(ppp);
960 * Send a packet to the peer over a synchronous tty line.
961 * All encoding and FCS are handled by hardware.
962 * Addr/Ctrl and Protocol field compression implemented.
963 * Returns -1 iff the packet could not be accepted at present,
964 * 0 if the packet was accepted but we can't accept another yet, or
965 * 1 if we can accept another packet immediately.
966 * If this procedure returns 0, ppp_output_wakeup will be called
970 ppp_sync_send(struct ppp *ppp, struct sk_buff *skb)
977 if (ppp->tpkt != NULL)
981 data = ppp->tpkt->data;
984 * LCP packets with code values between 1 (configure-reqest)
985 * and 7 (code-reject) must be sent as though no options
986 * had been negotiated.
988 islcp = PPP_PROTOCOL(data) == PPP_LCP
989 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
991 /* only reset idle time for data packets */
992 if (PPP_PROTOCOL(data) < 0x8000)
993 ppp->last_xmit = jiffies;
994 ++ppp->stats.ppp_opackets;
995 ppp->stats.ppp_ooctects += ppp->tpkt->len;
997 if ( !(data[2]) && (ppp->flags & SC_COMP_PROT) ) {
998 /* compress protocol field */
1001 skb_pull(ppp->tpkt,1);
1002 data = ppp->tpkt->data;
1006 * Do address/control compression
1008 if ((ppp->flags & SC_COMP_AC) && !islcp
1009 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1010 && PPP_CONTROL(data) == PPP_UI) {
1011 /* strip addr and control field */
1012 skb_pull(ppp->tpkt,2);
1015 return ppp_tty_sync_push(ppp);
1019 * Push a synchronous frame out to the tty.
1020 * Returns 1 if frame accepted (or discarded), 0 otherwise.
1023 ppp_tty_sync_push(struct ppp *ppp)
1026 struct tty_struct *tty = ppp2tty(ppp);
1027 unsigned long flags;
1031 if (ppp->tpkt == NULL)
1034 /* prevent reentrancy with tty_pushing flag */
1037 if (ppp->tty_pushing) {
1038 /* record wakeup attempt so we don't loose */
1039 /* a wakeup call while doing push processing */
1041 restore_flags(flags);
1044 ppp->tty_pushing = 1;
1045 restore_flags(flags);
1047 if (tty == NULL || tty->disc_data != (void *) ppp)
1053 /* Note: Sync driver accepts complete frame or nothing */
1054 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1055 sent = tty->driver.write(tty, 0, ppp->tpkt->data, ppp->tpkt->len);
1057 /* write error (possible loss of CD) */
1058 /* record error and discard current packet */
1059 ppp->stats.ppp_oerrors++;
1062 ppp->stats.ppp_obytes += sent;
1063 if (sent < ppp->tpkt->len) {
1064 /* driver unable to accept frame just yet */
1068 /* wake up called while processing */
1069 /* try to send the frame again */
1070 restore_flags(flags);
1073 /* wait for wakeup callback to try send again */
1074 ppp->tty_pushing = 0;
1075 restore_flags(flags);
1081 /* done with current packet (sent or discarded) */
1082 KFREE_SKB(ppp->tpkt);
1084 ppp->tty_pushing = 0;
1089 * Send a packet to the peer over an async tty line.
1090 * Returns -1 iff the packet could not be accepted at present,
1091 * 0 if the packet was accepted but we can't accept another yet, or
1092 * 1 if we can accept another packet immediately.
1093 * If this procedure returns 0, ppp_output_wakeup will be called
1097 ppp_async_send(struct ppp *ppp, struct sk_buff *skb)
1103 if (ppp->tpkt != NULL)
1108 return ppp_tty_push(ppp);
1112 * Push as much data as possible out to the tty.
1113 * Returns 1 if we finished encoding the current frame, 0 otherwise.
1116 ppp_tty_push(struct ppp *ppp)
1118 int avail, sent, done = 0;
1119 struct tty_struct *tty = ppp2tty(ppp);
1121 if ( ppp->flags & SC_SYNC )
1122 return ppp_tty_sync_push(ppp);
1125 if (ppp->tty_pushing)
1127 if (tty == NULL || tty->disc_data != (void *) ppp)
1129 while (ppp->optr < ppp->olim || ppp->tpkt != 0) {
1130 ppp->tty_pushing = 1;
1131 avail = ppp->olim - ppp->optr;
1133 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1134 sent = tty->driver.write(tty, 0, ppp->optr, avail);
1136 goto flush; /* error, e.g. loss of CD */
1137 ppp->stats.ppp_obytes += sent;
1140 ppp->tty_pushing = 0;
1145 done = ppp_async_encode(ppp);
1146 ppp->tty_pushing = 0;
1151 ppp->tty_pushing = 1;
1152 ppp->stats.ppp_oerrors++;
1153 if (ppp->tpkt != 0) {
1154 KFREE_SKB(ppp->tpkt);
1158 ppp->optr = ppp->olim;
1159 ppp->tty_pushing = 0;
1164 * Procedure to encode the data for async serial transmission.
1165 * Does octet stuffing (escaping) and address/control
1166 * and protocol compression.
1167 * Assumes ppp->opkt != 0 on entry.
1168 * Returns 1 if we finished the current frame, 0 otherwise.
1171 ppp_async_encode(struct ppp *ppp)
1173 int fcs, i, count, c;
1174 unsigned char *buf, *buflim;
1175 unsigned char *data;
1184 data = ppp->tpkt->data;
1185 count = ppp->tpkt->len;
1189 * LCP packets with code values between 1 (configure-reqest)
1190 * and 7 (code-reject) must be sent as though no options
1191 * had been negotiated.
1193 islcp = PPP_PROTOCOL(data) == PPP_LCP
1194 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
1198 * Start of a new packet - insert the leading FLAG
1199 * character if necessary.
1201 if (islcp || flag_time == 0
1202 || jiffies - ppp->last_xmit >= flag_time)
1204 /* only reset idle time for data packets */
1205 if (PPP_PROTOCOL(data) < 0x8000)
1206 ppp->last_xmit = jiffies;
1208 ++ppp->stats.ppp_opackets;
1209 ppp->stats.ppp_ooctects += count;
1212 * Do address/control compression
1214 if ((ppp->flags & SC_COMP_AC) != 0 && !islcp
1215 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1216 && PPP_CONTROL(data) == PPP_UI)
1221 * Once we put in the last byte, we need to put in the FCS
1222 * and closing flag, so make sure there is at least 7 bytes
1223 * of free space in the output buffer.
1225 buflim = buf + OBUFSIZE - 6;
1226 while (i < count && buf < buflim) {
1228 if (i == 3 && c == 0 && (ppp->flags & SC_COMP_PROT))
1229 continue; /* compress protocol field */
1230 fcs = PPP_FCS(fcs, c);
1231 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1232 *buf++ = PPP_ESCAPE;
1240 * We have finished the packet. Add the FCS and flag.
1244 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1245 *buf++ = PPP_ESCAPE;
1249 c = (fcs >> 8) & 0xff;
1250 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1251 *buf++ = PPP_ESCAPE;
1258 KFREE_SKB(ppp->tpkt);
1264 * Remember where we are up to in this packet.
1273 * Callback function from tty driver. Return the amount of space left
1274 * in the receiver's buffer to decide if remote transmitter is to be
1278 ppp_tty_room (struct tty_struct *tty)
1280 return 65536; /* We can handle an infinite amount of data. :-) */
1284 * Callback function when data is available at the tty driver.
1287 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1288 char *flags, int count)
1290 register struct ppp *ppp = tty2ppp (tty);
1291 struct sk_buff *skb;
1298 * This can happen if stuff comes in on the backup tty.
1300 if (ppp == 0 || tty != ppp->tty)
1303 * Verify the table pointer and ensure that the line is
1304 * still in PPP discipline.
1306 if (ppp->magic != PPP_MAGIC) {
1307 if (ppp->flags & SC_DEBUG)
1309 "PPP: tty_receive called but couldn't find "
1314 * Print the buffer if desired
1316 if (ppp->flags & SC_LOG_RAWIN)
1317 ppp_print_buffer ("receive buffer", data, count);
1319 ppp->stats.ppp_ibytes += count;
1322 if ( ppp->flags & SC_SYNC ) {
1323 /* synchronous mode */
1325 if (ppp->toss==0xE0) {
1326 /* this is the 1st frame, reset vj comp */
1327 ppp_receive_error(ppp);
1332 * Allocate an skbuff for frame.
1333 * The 128 is room for VJ header expansion.
1337 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1340 if (ppp->flags & SC_DEBUG)
1341 printk(KERN_DEBUG "couldn't "
1342 "alloc skb for recv\n");
1346 * Decompress A/C and protocol compression here.
1348 p = skb_put(skb, 2);
1349 p[0] = PPP_ALLSTATIONS;
1351 if (*data == PPP_ALLSTATIONS) {
1355 if ((*data & 1) != 0) {
1356 p = skb_put(skb, 1);
1360 /* copy frame to socket buffer */
1361 p = skb_put(skb, count);
1362 memcpy(p,data,count);
1365 * Check if we've overflowed the MRU
1367 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1368 || skb_tailroom(skb) <= 0) {
1369 ++ppp->estats.rx_length_errors;
1370 if (ppp->flags & SC_DEBUG)
1371 printk(KERN_DEBUG "rcv frame too long: "
1372 "len=%d mru=%d hroom=%d troom=%d\n",
1373 skb->len, ppp->mru, skb_headroom(skb),
1376 if (!ppp_receive_frame(ppp, skb)) {
1378 ppp_receive_error(ppp);
1382 /* Reset for the next frame */
1389 while (count-- > 0) {
1391 * Collect the character and error condition for the character.
1392 * Set the toss flag for the first character error.
1402 ++ppp->estats.rx_fifo_errors;
1406 ++ppp->estats.rx_frame_errors;
1414 * Set the flags for d7 being 0/1 and parity being
1415 * even/odd so that the normal processing would have
1416 * all flags set at the end of the session. A
1417 * missing flag bit indicates an error condition.
1420 #ifdef CHECK_CHARACTERS
1422 ppp->flags |= SC_RCV_B7_1;
1424 ppp->flags |= SC_RCV_B7_0;
1426 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1427 ppp->flags |= SC_RCV_ODDP;
1429 ppp->flags |= SC_RCV_EVNP;
1432 if (chr == PPP_FLAG) {
1434 * FLAG. This is the end of the block. If the block
1435 * ends with ESC FLAG, then the block is to be ignored.
1440 * Process the frame if it was received correctly.
1441 * If there was an error, let the VJ decompressor know.
1442 * There are 4 cases here:
1443 * skb != NULL, toss != 0: error in frame
1444 * skb != NULL, toss == 0: frame ok
1445 * skb == NULL, toss != 0: very first frame,
1446 * error on 1st char, or alloc_skb failed
1447 * skb == NULL, toss == 0: empty frame (~~)
1449 if (ppp->toss || !ppp_receive_frame(ppp, skb)) {
1450 if (ppp->toss && (ppp->flags & SC_DEBUG))
1452 "ppp: tossing frame (%x)\n",
1456 if (!(ppp->toss == 0xE0 || ppp->toss == 0x80))
1457 ++ppp->stats.ppp_ierrors;
1458 ppp_receive_error(ppp);
1461 * Reset for the next frame.
1464 ppp->rfcs = PPP_INITFCS;
1470 /* If we're tossing, look no further. */
1474 /* If this is a control char to be ignored, do so */
1475 if (in_rmap(ppp, chr))
1479 * Modify the next character if preceded by escape.
1480 * The escape character (0x7d) could be an escaped
1481 * 0x5d, if it follows an escape :-)
1486 } else if (chr == PPP_ESCAPE) {
1487 ppp->escape = PPP_TRANS;
1492 * Allocate an skbuff on the first character received.
1493 * The 128 is room for VJ header expansion and FCS.
1496 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1498 if (ppp->flags & SC_DEBUG)
1499 printk(KERN_DEBUG "couldn't "
1500 "alloc skb for recv\n");
1508 * Decompress A/C and protocol compression here.
1510 if (skb->len == 0 && chr != PPP_ALLSTATIONS) {
1511 p = skb_put(skb, 2);
1512 p[0] = PPP_ALLSTATIONS;
1515 if (skb->len == 2 && (chr & 1) != 0) {
1516 p = skb_put(skb, 1);
1521 * Check if we've overflowed the MRU
1523 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1524 || skb_tailroom(skb) <= 0) {
1525 ++ppp->estats.rx_length_errors;
1527 if (ppp->flags & SC_DEBUG)
1528 printk(KERN_DEBUG "rcv frame too long: "
1529 "len=%d mru=%d hroom=%d troom=%d\n",
1530 skb->len, ppp->mru, skb_headroom(skb),
1536 * Store the character and update the FCS.
1538 p = skb_put(skb, 1);
1540 ppp->rfcs = PPP_FCS(ppp->rfcs, chr);
1545 /*************************************************************
1546 * PPP NETWORK INTERFACE SUPPORT
1547 * The following code implements the PPP network
1548 * interface device and handles those parts of
1549 * the PPP processing which are independent of the
1550 * type of hardware link being used, including
1551 * VJ and packet compression.
1552 *************************************************************/
1555 * Network device driver callback routines
1558 static int ppp_init_dev(struct device *dev);
1559 static int ppp_dev_open(struct device *);
1560 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
1561 static int ppp_dev_close(struct device *);
1562 static int ppp_dev_xmit(struct sk_buff *, struct device *);
1563 static struct net_device_stats *ppp_dev_stats (struct device *);
1565 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1566 static int ppp_dev_header(struct sk_buff *, struct device *, __u16,
1567 void *, void *, unsigned int);
1568 static int ppp_dev_rebuild(void *eth, struct device *dev,
1569 unsigned long raddr, struct sk_buff *skb);
1573 * Information for the protocol decoder
1576 typedef int (*pfn_proto) (struct ppp *, struct sk_buff *);
1578 typedef struct ppp_proto_struct {
1583 static int rcv_proto_ip (struct ppp *, struct sk_buff *);
1584 static int rcv_proto_ipv6 (struct ppp *, struct sk_buff *);
1585 static int rcv_proto_ipx (struct ppp *, struct sk_buff *);
1586 static int rcv_proto_at (struct ppp *, struct sk_buff *);
1587 static int rcv_proto_vjc_comp (struct ppp *, struct sk_buff *);
1588 static int rcv_proto_vjc_uncomp (struct ppp *, struct sk_buff *);
1589 static int rcv_proto_ccp (struct ppp *, struct sk_buff *);
1590 static int rcv_proto_unknown (struct ppp *, struct sk_buff *);
1593 ppp_proto_type proto_list[] = {
1594 { PPP_IP, rcv_proto_ip },
1595 { PPP_IPV6, rcv_proto_ipv6 },
1596 { PPP_IPX, rcv_proto_ipx },
1597 { PPP_AT, rcv_proto_at },
1598 { PPP_VJC_COMP, rcv_proto_vjc_comp },
1599 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
1600 { PPP_CCP, rcv_proto_ccp },
1601 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
1605 * Called when the PPP network interface device is actually created.
1608 ppp_init_dev (struct device *dev)
1610 dev->hard_header_len = PPP_HDRLEN;
1611 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1612 dev->hard_header = ppp_dev_header;
1613 dev->rebuild_header = ppp_dev_rebuild;
1618 dev->hard_start_xmit = ppp_dev_xmit;
1619 dev->open = ppp_dev_open;
1620 dev->stop = ppp_dev_close;
1621 dev->get_stats = ppp_dev_stats;
1622 dev->do_ioctl = ppp_dev_ioctl;
1624 dev->tx_queue_len = 10;
1625 dev->type = ARPHRD_PPP;
1627 #if LINUX_VERSION_CODE < VERSION(2,1,20)
1631 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
1632 skb_queue_head_init (&dev->buffs[indx]);
1635 dev_init_buffers(dev);
1638 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
1644 * Callback from the network layer when the device goes up.
1648 ppp_dev_open (struct device *dev)
1650 struct ppp *ppp = dev2ppp(dev);
1652 if (!ppp->inuse || ppp2tty(ppp) == NULL) {
1653 printk(KERN_ERR "ppp: %s not active\n", dev->name);
1663 * Callback from the network layer when the ppp device goes down.
1667 ppp_dev_close (struct device *dev)
1669 struct ppp *ppp = dev2ppp (dev);
1671 CHECK_PPP_MAGIC(ppp);
1679 get_vj_stats(struct vjstat *vj, struct slcompress *slc)
1681 vj->vjs_packets = slc->sls_o_compressed + slc->sls_o_uncompressed;
1682 vj->vjs_compressed = slc->sls_o_compressed;
1683 vj->vjs_searches = slc->sls_o_searches;
1684 vj->vjs_misses = slc->sls_o_misses;
1685 vj->vjs_errorin = slc->sls_i_error;
1686 vj->vjs_tossed = slc->sls_i_tossed;
1687 vj->vjs_uncompressedin = slc->sls_i_uncompressed;
1688 vj->vjs_compressedin = slc->sls_i_compressed;
1692 * Callback from the network layer to process the sockioctl functions.
1695 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
1697 struct ppp *ppp = dev2ppp(dev);
1700 struct ppp_stats stats;
1701 struct ppp_comp_stats cstats;
1705 CHECK_PPP_MAGIC(ppp);
1707 memset(&u, 0, sizeof(u));
1710 u.stats.p = ppp->stats;
1711 if (ppp->slcomp != NULL)
1712 get_vj_stats(&u.stats.vj, ppp->slcomp);
1713 nb = sizeof(u.stats);
1716 case SIOCGPPPCSTATS:
1717 if (ppp->sc_xc_state != NULL)
1718 (*ppp->sc_xcomp->comp_stat)
1719 (ppp->sc_xc_state, &u.cstats.c);
1720 if (ppp->sc_rc_state != NULL)
1721 (*ppp->sc_rcomp->decomp_stat)
1722 (ppp->sc_rc_state, &u.cstats.d);
1723 nb = sizeof(u.cstats);
1727 strcpy(u.vers, szVersion);
1728 nb = strlen(u.vers) + 1;
1735 if (COPY_TO_USER((void *) ifr->ifr_ifru.ifru_data, &u, nb))
1741 * Process the generic PPP ioctls, i.e. those which are not specific
1742 * to any particular type of hardware link.
1745 ppp_ioctl(struct ppp *ppp, unsigned int param2, unsigned long param3)
1747 register int temp_i = 0, oldflags;
1748 int error = -EFAULT;
1749 unsigned long flags;
1750 struct ppp_idle cur_ddinfo;
1756 * The user must have an euid of root to do these requests.
1766 if (GET_USER(temp_i, (int *) param3))
1768 if (temp_i < PPP_MRU)
1771 if (ppp->flags & SC_DEBUG)
1773 "ppp_ioctl: set mru to %x\n", temp_i);
1779 * Fetch the current flags
1781 temp_i = ppp->flags & SC_MASK;
1782 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
1783 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
1784 SC_RCV_ODDP | SC_RCV_EVNP;
1786 if (PUT_USER(temp_i, (int *) param3))
1793 * Set the flags for the various options
1795 if (GET_USER(temp_i, (int *) param3))
1798 if (ppp->flags & ~temp_i & SC_CCP_OPEN)
1799 ppp_ccp_closed(ppp);
1803 oldflags = ppp->flags;
1804 temp_i = (temp_i & SC_MASK) | (oldflags & ~SC_MASK);
1805 ppp->flags = temp_i;
1806 restore_flags(flags);
1808 if ((oldflags | temp_i) & SC_DEBUG)
1810 "ppp_ioctl: set flags to %x\n", temp_i);
1814 case PPPIOCSCOMPRESS:
1816 * Set the compression mode
1818 error = ppp_set_compression
1819 (ppp, (struct ppp_option_data *) param3);
1824 * Obtain the unit number for this device.
1826 if (PUT_USER(ppp->line, (int *) param3))
1828 if (ppp->flags & SC_DEBUG)
1830 "ppp_ioctl: get unit: %d\n", ppp->line);
1836 * Set the debug level
1838 if (GET_USER(temp_i, (int *) param3))
1840 temp_i = (temp_i & 0x1F) << 16;
1842 if ((ppp->flags | temp_i) & SC_DEBUG)
1844 "ppp_ioctl: set dbg flags to %x\n", temp_i);
1848 ppp->flags = (ppp->flags & ~0x1F0000) | temp_i;
1849 restore_flags(flags);
1855 * Get the debug level
1857 temp_i = (ppp->flags >> 16) & 0x1F;
1858 if (PUT_USER(temp_i, (int *) param3))
1865 * Get the times since the last send/receive frame operation
1867 /* change absolute times to relative times. */
1868 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
1869 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
1870 if (COPY_TO_USER((void *) param3, &cur_ddinfo,
1871 sizeof (cur_ddinfo)))
1878 * Set the maximum VJ header compression slot number.
1880 if (GET_USER(temp_i, (int *) param3))
1883 if (temp_i < 2 || temp_i > 255)
1886 if (ppp->flags & SC_DEBUG)
1887 printk(KERN_INFO "ppp_ioctl: set maxcid to %d\n",
1889 if (ppp->slcomp != NULL)
1890 slhc_free(ppp->slcomp);
1891 ppp->slcomp = slhc_init(16, temp_i);
1894 if (ppp->slcomp == NULL) {
1895 printk(KERN_ERR "ppp: no memory for VJ compression\n");
1903 if (COPY_FROM_USER(&npi, (void *) param3, sizeof(npi)))
1906 switch (npi.protocol) {
1908 npi.protocol = NP_IP;
1911 npi.protocol = NP_IPX;
1914 npi.protocol = NP_AT;
1917 if (ppp->flags & SC_DEBUG)
1918 printk(KERN_DEBUG "pppioc[gs]npmode: "
1919 "invalid proto %d\n", npi.protocol);
1924 if (param2 == PPPIOCGNPMODE) {
1925 npi.mode = ppp->sc_npmode[npi.protocol];
1926 if (COPY_TO_USER((void *) param3, &npi, sizeof(npi)))
1929 ppp->sc_npmode[npi.protocol] = npi.mode;
1930 if (ppp->flags & SC_DEBUG)
1931 printk(KERN_DEBUG "ppp: set np %d to %d\n",
1932 npi.protocol, npi.mode);
1940 * All other ioctl() events will come here.
1942 if (ppp->flags & SC_DEBUG)
1944 "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
1947 error = -ENOIOCTLCMD;
1955 * Process the set-compression ioctl.
1958 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
1960 struct compressor *cp;
1962 unsigned long flags;
1964 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
1965 struct ppp_option_data data;
1968 * Fetch the compression parameters
1971 if (COPY_FROM_USER(&data, odp, sizeof (data)))
1976 if ((unsigned) nb >= CCP_MAX_OPTION_LENGTH)
1977 nb = CCP_MAX_OPTION_LENGTH;
1979 if (COPY_FROM_USER(ccp_option, ptr, nb))
1983 if (ccp_option[1] < 2) /* preliminary check on the length byte */
1988 ppp->flags &= ~(data.transmit? SC_COMP_RUN: SC_DECOMP_RUN);
1989 restore_flags(flags);
1991 cp = find_compressor (ccp_option[0]);
1992 #if defined(CONFIG_KMOD) || defined(CONFIG_KERNELD)
1995 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
1996 request_module(modname);
1997 cp = find_compressor(ccp_option[0]);
1999 #endif /* CONFIG_KMOD */
2002 if (ppp->flags & SC_DEBUG)
2004 "%s: no compressor for [%x %x %x], %x\n",
2005 ppp->name, ccp_option[0], ccp_option[1],
2007 goto out; /* compressor not loaded */
2011 * Found a handler for the protocol - try to allocate
2012 * a compressor or decompressor.
2015 if (data.transmit) {
2016 if (ppp->sc_xc_state != NULL)
2017 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2018 ppp->sc_xc_state = NULL;
2021 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2022 if (ppp->sc_xc_state == NULL) {
2023 if (ppp->flags & SC_DEBUG)
2024 printk(KERN_DEBUG "%s: comp_alloc failed\n",
2029 if (ppp->sc_rc_state != NULL)
2030 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2031 ppp->sc_rc_state = NULL;
2034 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2035 if (ppp->sc_rc_state == NULL) {
2036 if (ppp->flags & SC_DEBUG)
2037 printk(KERN_DEBUG "%s: decomp_alloc failed\n",
2047 * Handle a CCP packet.
2049 * The CCP packet is passed along to the pppd process just like any
2050 * other PPP frame. The difference is that some processing needs to be
2051 * immediate or the compressors will become confused on the peer.
2054 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd)
2056 int slen = CCP_LENGTH(dp);
2057 __u8 *opt = dp + CCP_HDRLEN;
2058 int opt_len = slen - CCP_HDRLEN;
2059 unsigned long flags;
2064 if (ppp->flags & SC_DEBUG)
2065 printk(KERN_DEBUG "ppp_proto_ccp rcvd=%d code=%x flags=%x\n",
2066 rcvd, CCP_CODE(dp), ppp->flags);
2068 switch (CCP_CODE(dp)) {
2073 * CCP must be going down - disable compression
2075 if (ppp->flags & SC_CCP_UP) {
2077 ppp->flags &= ~(SC_CCP_UP |
2084 if ((ppp->flags & SC_CCP_OPEN) == 0)
2086 if (ppp->flags & SC_CCP_UP)
2088 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
2090 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
2094 * we're agreeing to send compressed packets.
2096 if (ppp->sc_xc_state == NULL)
2099 if ((*ppp->sc_xcomp->comp_init)
2102 ppp->line, 0, ppp->flags & SC_DEBUG)) {
2103 if (ppp->flags & SC_DEBUG)
2104 printk(KERN_DEBUG "%s: comp running\n",
2107 ppp->flags |= SC_COMP_RUN;
2113 * peer is agreeing to send compressed packets.
2115 if (ppp->sc_rc_state == NULL)
2118 if ((*ppp->sc_rcomp->decomp_init)
2121 ppp->line, 0, ppp->mru, ppp->flags & SC_DEBUG)) {
2122 if (ppp->flags & SC_DEBUG)
2123 printk(KERN_DEBUG "%s: decomp running\n",
2126 ppp->flags |= SC_DECOMP_RUN;
2127 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
2133 * CCP Reset-ack resets compressors and decompressors
2134 * as it passes through.
2136 if ((ppp->flags & SC_CCP_UP) == 0)
2140 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
2141 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
2142 if (ppp->flags & SC_DEBUG)
2143 printk(KERN_DEBUG "%s: comp reset\n",
2147 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
2148 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
2149 if (ppp->flags & SC_DEBUG)
2150 printk(KERN_DEBUG "%s: decomp reset\n",
2153 ppp->flags &= ~SC_DC_ERROR;
2158 restore_flags(flags);
2162 * CCP is down; free (de)compressor state if necessary.
2166 ppp_ccp_closed(struct ppp *ppp)
2168 unsigned long flags;
2172 ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
2173 restore_flags(flags);
2174 if (ppp->flags & SC_DEBUG)
2175 printk(KERN_DEBUG "%s: ccp closed\n", ppp->name);
2176 if (ppp->sc_xc_state) {
2177 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
2178 ppp->sc_xc_state = NULL;
2181 if (ppp->sc_rc_state) {
2182 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
2183 ppp->sc_rc_state = NULL;
2187 /*************************************************************
2188 * RECEIVE-SIDE ROUTINES
2189 *************************************************************/
2192 * On entry, a received frame is in skb.
2193 * Check it and dispose as appropriate.
2196 ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb)
2202 struct sk_buff *new_skb;
2203 ppp_proto_type *proto_ptr;
2206 * An empty frame is ignored. This occurs if the FLAG sequence
2207 * precedes and follows each frame.
2211 if (skb->len == 0) {
2219 * Generate an error if the frame is too small.
2221 if (count < PPP_HDRLEN + 2) {
2222 if (ppp->flags & SC_DEBUG)
2224 "ppp: got runt ppp frame, %d chars\n", count);
2225 ++ppp->estats.rx_length_errors;
2229 if ( !(ppp->flags & SC_SYNC) ) {
2231 * Verify the FCS of the frame and discard the FCS characters
2232 * from the end of the buffer.
2234 if (ppp->rfcs != PPP_GOODFCS) {
2235 if (ppp->flags & SC_DEBUG) {
2237 "ppp: frame with bad fcs, length = %d\n",
2239 ppp_print_buffer("bad frame", data, count);
2241 ++ppp->estats.rx_crc_errors;
2244 count -= 2; /* ignore the fcs characters */
2245 skb_trim(skb, count);
2249 * Process the active decompressor.
2251 if (ppp->sc_rc_state != NULL &&
2252 (ppp->flags & SC_DECOMP_RUN) &&
2253 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
2254 if (PPP_PROTOCOL(data) == PPP_COMP) {
2256 * If the frame is compressed then decompress it.
2258 new_skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
2259 if (new_skb == NULL) {
2260 printk(KERN_ERR "ppp_recv_frame: no memory\n");
2261 new_count = DECOMP_ERROR;
2263 LIBERATE_SKB(new_skb);
2264 new_count = (*ppp->sc_rcomp->decompress)
2265 (ppp->sc_rc_state, data, count,
2266 new_skb->data, ppp->mru + PPP_HDRLEN);
2268 if (new_count > 0) {
2269 /* Frame was decompressed OK */
2273 data = skb_put(skb, count);
2277 * On a decompression error, we pass the
2278 * compressed frame up to pppd as an
2281 if (ppp->flags & SC_DEBUG)
2282 printk(KERN_INFO "%s: decomp err %d\n",
2283 ppp->name, new_count);
2286 if (ppp->slcomp != 0)
2287 slhc_toss(ppp->slcomp);
2288 ++ppp->stats.ppp_ierrors;
2289 if (new_count == DECOMP_FATALERROR) {
2290 ppp->flags |= SC_DC_FERROR;
2292 ppp->flags |= SC_DC_ERROR;
2299 * The frame is not compressed. Pass it to the
2300 * decompression code so it can update its
2301 * dictionary if necessary.
2303 (*ppp->sc_rcomp->incomp)(ppp->sc_rc_state,
2307 else if (PPP_PROTOCOL(data) == PPP_COMP && (ppp->flags & SC_DEBUG))
2308 printk(KERN_INFO "%s: not decomp, rc_state=%p flags=%x\n",
2309 ppp->name, ppp->sc_rc_state, ppp->flags);
2312 * Count the frame and print it
2314 ++ppp->stats.ppp_ipackets;
2315 ppp->stats.ppp_ioctects += count;
2316 if (ppp->flags & SC_LOG_INPKT)
2317 ppp_print_buffer ("receive frame", data, count);
2320 * Find the procedure to handle this protocol.
2321 * The last one is marked as protocol 0 which is the 'catch-all'
2322 * to feed it to the pppd daemon.
2324 proto = PPP_PROTOCOL(data);
2325 proto_ptr = proto_list;
2326 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
2330 * Update the appropriate statistic counter.
2332 if (!(*proto_ptr->func)(ppp, skb)) {
2334 ++ppp->stats.ppp_discards;
2341 * An input error has been detected, so we need to inform
2342 * the VJ decompressor.
2345 ppp_receive_error(struct ppp *ppp)
2349 if (ppp->slcomp != 0)
2350 slhc_toss(ppp->slcomp);
2354 * Put the input frame into the networking system for the indicated protocol
2357 ppp_rcv_rx(struct ppp *ppp, __u16 proto, struct sk_buff *skb)
2361 * Fill in a few fields of the skb and give it to netif_rx().
2363 skb->dev = ppp2dev(ppp); /* We are the device */
2364 skb->protocol = htons(proto);
2365 skb_pull(skb, PPP_HDRLEN); /* pull off ppp header */
2366 skb->mac.raw = skb->data;
2367 ppp->last_recv = jiffies;
2373 * Process the receipt of an IP frame
2376 rcv_proto_ip(struct ppp *ppp, struct sk_buff *skb)
2379 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2380 && ppp->sc_npmode[NP_IP] == NPMODE_PASS)
2381 return ppp_rcv_rx(ppp, ETH_P_IP, skb);
2386 * Process the receipt of an IPv6 frame
2389 rcv_proto_ipv6(struct ppp *ppp, struct sk_buff *skb)
2392 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2393 && ppp->sc_npmode[NP_IPV6] == NPMODE_PASS)
2394 return ppp_rcv_rx(ppp, ETH_P_IPV6, skb);
2399 * Process the receipt of an IPX frame
2402 rcv_proto_ipx(struct ppp *ppp, struct sk_buff *skb)
2405 if (((ppp2dev(ppp)->flags & IFF_UP) != 0) && (skb->len > 0)
2406 && ppp->sc_npmode[NP_IPX] == NPMODE_PASS)
2407 return ppp_rcv_rx(ppp, ETH_P_IPX, skb);
2412 * Process the receipt of an Appletalk frame
2415 rcv_proto_at(struct ppp *ppp, struct sk_buff *skb)
2418 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2419 && ppp->sc_npmode[NP_AT] == NPMODE_PASS)
2420 return ppp_rcv_rx(ppp, ETH_P_PPPTALK, skb);
2425 * Process the receipt of an VJ Compressed frame
2428 rcv_proto_vjc_comp(struct ppp *ppp, struct sk_buff *skb)
2433 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2435 new_count = slhc_uncompress(ppp->slcomp, skb->data + PPP_HDRLEN,
2436 skb->len - PPP_HDRLEN);
2437 if (new_count <= 0) {
2438 if (ppp->flags & SC_DEBUG)
2440 "ppp: error in VJ decompression\n");
2443 new_count += PPP_HDRLEN;
2444 if (new_count > skb->len)
2445 skb_put(skb, new_count - skb->len);
2447 skb_trim(skb, new_count);
2448 return rcv_proto_ip(ppp, skb);
2452 * Process the receipt of an VJ Un-compressed frame
2455 rcv_proto_vjc_uncomp(struct ppp *ppp, struct sk_buff *skb)
2458 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2460 if (slhc_remember(ppp->slcomp, skb->data + PPP_HDRLEN,
2461 skb->len - PPP_HDRLEN) <= 0) {
2462 if (ppp->flags & SC_DEBUG)
2463 printk(KERN_NOTICE "ppp: error in VJ memorizing\n");
2466 return rcv_proto_ip(ppp, skb);
2470 rcv_proto_ccp(struct ppp *ppp, struct sk_buff *skb)
2473 ppp_proto_ccp (ppp, skb->data + PPP_HDRLEN, skb->len - PPP_HDRLEN, 1);
2474 return rcv_proto_unknown(ppp, skb);
2478 * Receive all unclassified protocols.
2481 rcv_proto_unknown(struct ppp *ppp, struct sk_buff *skb)
2486 * Limit queue length by dropping old frames.
2488 skb_queue_tail(&ppp->rcv_q, skb);
2489 while (ppp->rcv_q.qlen > PPP_MAX_RCV_QLEN) {
2490 struct sk_buff *skb = skb_dequeue(&ppp->rcv_q);
2495 wake_up_interruptible (&ppp->read_wait);
2496 if (ppp->tty->fasync != NULL)
2497 kill_fasync (ppp->tty->fasync, SIGIO);
2502 /*************************************************************
2503 * TRANSMIT-SIDE ROUTINES
2504 *************************************************************/
2506 /* local function to store a value into the LQR frame */
2507 extern inline __u8 * store_long (register __u8 *p, register int value) {
2508 *p++ = (__u8) (value >> 24);
2509 *p++ = (__u8) (value >> 16);
2510 *p++ = (__u8) (value >> 8);
2511 *p++ = (__u8) value;
2516 * Compress and send an frame to the peer.
2517 * Should be called with xmit_busy == 1, having been set by the caller.
2518 * That is, we use xmit_busy as a lock to prevent reentry of this
2522 ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
2534 /* dump the buffer */
2535 if (ppp->flags & SC_LOG_OUTPKT)
2536 ppp_print_buffer ("write frame", data, count);
2539 * Handle various types of protocol-specific compression
2540 * and other processing, including:
2541 * - VJ TCP header compression
2542 * - updating LQR packets
2543 * - updating CCP state on CCP packets
2545 proto = PPP_PROTOCOL(data);
2548 if ((ppp->flags & SC_COMP_TCP) && ppp->slcomp != NULL)
2549 skb = ppp_vj_compress(ppp, skb);
2554 * Update the LQR frame with the current MIB information.
2555 * This way the information is accurate and up-to-date.
2559 p = data + 40; /* Point to last two items. */
2560 p = store_long(p, ppp->stats.ppp_opackets + 1);
2561 p = store_long(p, ppp->stats.ppp_ooctects + count);
2562 ++ppp->stats.ppp_olqrs;
2567 * Outbound compression control frames
2569 ppp_proto_ccp(ppp, data + PPP_HDRLEN, count - PPP_HDRLEN, 0);
2576 * Compress the whole frame if possible.
2578 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2579 (ppp->sc_xc_state != (void *) 0) &&
2580 (proto != PPP_LCP) &&
2581 (proto != PPP_CCP)) {
2582 struct sk_buff *new_skb;
2585 /* Allocate an skb for the compressed frame. */
2586 new_skb = alloc_skb(ppp->mtu + PPP_HDRLEN, GFP_ATOMIC);
2587 if (new_skb == NULL) {
2588 printk(KERN_ERR "ppp_send_frame: no memory\n");
2593 LIBERATE_SKB(new_skb);
2595 /* Compress the frame. */
2596 new_count = (*ppp->sc_xcomp->compress)
2597 (ppp->sc_xc_state, data, new_skb->data,
2598 count, ppp->mtu + PPP_HDRLEN);
2600 /* Did it compress? */
2601 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2602 skb_put(new_skb, new_count);
2607 * The frame could not be compressed, or it could not
2608 * be sent in compressed form because CCP is down.
2617 if ( ppp->flags & SC_SYNC )
2618 ret = ppp_sync_send(ppp, skb);
2620 ret = ppp_async_send(ppp, skb);
2622 /* we can release the lock */
2624 } else if (ret < 0) {
2625 /* can't happen, since the caller got the xmit_busy lock */
2626 printk(KERN_ERR "ppp: ppp_async_send didn't accept pkt\n");
2631 * Apply VJ TCP header compression to a packet.
2633 static struct sk_buff *
2634 ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb)
2636 __u8 *orig_data, *data;
2637 struct sk_buff *new_skb;
2640 new_skb = alloc_skb(skb->len, GFP_ATOMIC);
2641 if (new_skb == NULL) {
2642 printk(KERN_ERR "ppp: no memory for vj compression\n");
2645 LIBERATE_SKB(new_skb);
2647 orig_data = data = skb->data + PPP_HDRLEN;
2648 len = slhc_compress(ppp->slcomp, data, skb->len - PPP_HDRLEN,
2649 new_skb->data + PPP_HDRLEN, &data,
2650 (ppp->flags & SC_NO_TCP_CCID) == 0);
2652 if (data == orig_data) {
2653 /* Couldn't compress the data */
2658 /* The data has been changed */
2659 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2660 proto = PPP_VJC_COMP;
2661 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2663 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2664 proto = PPP_VJC_UNCOMP;
2667 data[0] = orig_data[0];
2670 data = skb_put(new_skb, len + PPP_HDRLEN);
2671 data[0] = PPP_ALLSTATIONS;
2681 ppp_send_frames(struct ppp *ppp)
2683 struct sk_buff *skb;
2685 while (!test_and_set_bit(0, &ppp->xmit_busy)) {
2686 skb = skb_dequeue(&ppp->xmt_q);
2691 ppp_send_frame(ppp, skb);
2693 if (!ppp->xmit_busy && ppp->dev.tbusy) {
2700 * Called from the hardware (tty) layer when it can accept
2704 ppp_output_wakeup(struct ppp *ppp)
2708 if (!ppp->xmit_busy) {
2709 printk(KERN_ERR "ppp_output_wakeup called but xmit_busy==0\n");
2713 ppp_send_frames(ppp);
2717 * Send a control frame (from pppd).
2720 ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb)
2725 * Put the packet on the queue, then send as many as we can.
2727 skb_queue_tail(&ppp->xmt_q, skb);
2728 ppp_send_frames(ppp);
2732 /*************************************************************
2734 * This routine accepts requests from the network layer
2735 * and attempts to deliver the packets.
2736 *************************************************************/
2738 * Send a frame to the peer.
2739 * Returns 1 iff the frame was not accepted.
2742 ppp_dev_xmit(struct sk_buff *skb, struct device *dev)
2744 struct ppp *ppp = dev2ppp(dev);
2745 struct tty_struct *tty = ppp2tty(ppp);
2750 /* just a little sanity check. */
2753 if (skb->data == NULL) {
2759 * Avoid timing problem should tty hangup while data is
2760 * queued to be sent.
2768 * Validate the tty interface
2771 if (ppp->flags & SC_DEBUG)
2773 "ppp_dev_xmit: %s not connected to a TTY!\n",
2780 * Work out the appropriate network-protocol mode for this packet.
2782 npmode = NPMODE_PASS; /* default */
2783 switch (ntohs(skb->protocol)) {
2786 npmode = ppp->sc_npmode[NP_IP];
2790 npmode = ppp->sc_npmode[NP_IPV6];
2794 npmode = ppp->sc_npmode[NP_IPX];
2799 npmode = ppp->sc_npmode[NP_AT];
2802 if (ppp->flags & SC_DEBUG)
2803 printk(KERN_INFO "%s: packet for unknown proto %x\n",
2804 ppp->name, ntohs(skb->protocol));
2810 * Drop, accept or reject the packet depending on the mode.
2818 * We may not send the packet now, so drop it.
2819 * XXX It would be nice to be able to return it to the
2820 * network system to be queued and retransmitted later.
2822 if (ppp->flags & SC_DEBUG)
2823 printk(KERN_DEBUG "%s: returning frame\n", ppp->name);
2829 if (ppp->flags & SC_DEBUG)
2831 "ppp_dev_xmit: dropping (npmode = %d) on %s\n",
2838 * The dev->tbusy field acts as a lock to allow only
2839 * one packet to be processed at a time. If we can't
2840 * get the lock, try again later.
2841 * We deliberately queue as little as possible inside
2842 * the ppp driver in order to minimize the latency
2843 * for high-priority packets.
2845 if (test_and_set_bit(0, &ppp->xmit_busy)) {
2846 dev->tbusy = 1; /* can't take it now */
2852 * Put the 4-byte PPP header on the packet.
2853 * If there isn't room for it, we have to copy the packet.
2855 if (skb_headroom(skb) < PPP_HDRLEN) {
2856 struct sk_buff *new_skb;
2858 new_skb = alloc_skb(skb->len + PPP_HDRLEN, GFP_ATOMIC);
2859 if (new_skb == NULL) {
2860 printk(KERN_ERR "%s: skb hdr alloc failed\n",
2864 ppp_send_frames(ppp);
2867 LIBERATE_SKB(new_skb);
2868 skb_reserve(new_skb, PPP_HDRLEN);
2869 memcpy(skb_put(new_skb, skb->len), skb->data, skb->len);
2874 hdr = skb_push(skb, PPP_HDRLEN);
2875 hdr[0] = PPP_ALLSTATIONS;
2877 hdr[2] = proto >> 8;
2880 ppp_send_frame(ppp, skb);
2881 if (!ppp->xmit_busy)
2882 ppp_send_frames(ppp);
2886 #if LINUX_VERSION_CODE < VERSION(2,1,15)
2888 * Null hard_header and header_rebuild routines.
2890 static int ppp_dev_header(struct sk_buff *skb, struct device *dev,
2891 unsigned short type, void *daddr,
2892 void *saddr, unsigned int len)
2897 static int ppp_dev_rebuild(void *eth, struct device *dev,
2898 unsigned long raddr, struct sk_buff *skb)
2902 #endif /* < 2.1.15 */
2905 * Generate the statistic information for the /proc/net/dev listing.
2907 static struct net_device_stats *
2908 ppp_dev_stats (struct device *dev)
2910 struct ppp *ppp = dev2ppp (dev);
2912 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
2913 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
2914 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
2915 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
2916 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
2917 ppp->estats.rx_bytes = ppp->stats.ppp_ibytes;
2918 ppp->estats.tx_bytes = ppp->stats.ppp_obytes;
2921 return &ppp->estats;
2924 /*************************************************************
2926 * Miscellany called by various functions above.
2927 *************************************************************/
2929 /* Locate the previous instance of the PPP channel */
2931 ppp_find(int pid_value)
2935 /* try to find the device which this pid is already using */
2936 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2937 if (ppp->inuse && ppp->sc_xfer == pid_value) {
2945 /* allocate or create a PPP channel */
2954 /* try to find an free device */
2955 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2956 if (!test_and_set_bit(0, &ppp->inuse)) {
2958 if (dev->flags & IFF_UP) {
2959 clear_bit(0, &ppp->inuse);
2962 /* Reregister device */
2963 unregister_netdev(dev);
2964 if (register_netdev(dev) == 0)
2966 printk(KERN_DEBUG "could not reregister ppp device\n");
2967 /* leave inuse set in this case */
2972 * There are no available units, so make a new one.
2974 ppp = (struct ppp *) kmalloc(sizeof(struct ppp), GFP_KERNEL);
2976 printk(KERN_ERR "ppp: struct ppp allocation failed\n");
2979 memset(ppp, 0, sizeof(*ppp));
2981 /* initialize channel control data */
2982 ppp->magic = PPP_MAGIC;
2985 ppp->read_wait = NULL;
2988 * Make up a suitable name for this device
2991 dev->name = ppp->name;
2992 #if LINUX_VERSION_CODE < VERSION(2,1,31)
2993 if_num = (ppp_list == 0)? 0: ppp_last->line + 1;
2994 sprintf(ppp->name, "ppp%d", if_num);
2996 if_num = dev_alloc_name(dev, "ppp%d");
2999 printk(KERN_ERR "ppp: dev_alloc_name failed (%d)\n", if_num);
3007 dev->init = ppp_init_dev;
3008 dev->name = ppp->name;
3009 dev->priv = (void *) ppp;
3011 /* register device so that we can be ifconfig'd */
3012 /* ppp_init_dev() will be called as a side-effect */
3013 status = register_netdev (dev);
3015 printk(KERN_INFO "registered device %s\n", dev->name);
3018 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3024 /* link this unit into our list */
3028 ppp_last->next = ppp;
3035 * Initialize the generic parts of the ppp structure.
3038 ppp_generic_init(struct ppp *ppp)
3046 skb_queue_head_init(&ppp->xmt_q);
3047 skb_queue_head_init(&ppp->rcv_q);
3049 ppp->last_xmit = jiffies;
3050 ppp->last_recv = jiffies;
3053 /* clear statistics */
3054 memset(&ppp->stats, 0, sizeof (struct pppstat));
3055 memset(&ppp->estats, 0, sizeof(struct net_device_stats));
3057 /* PPP compression data */
3058 ppp->sc_xc_state = NULL;
3059 ppp->sc_rc_state = NULL;
3061 for (indx = 0; indx < NUM_NP; ++indx)
3062 ppp->sc_npmode[indx] = NPMODE_PASS;
3066 * Called to clean up the generic parts of the ppp structure.
3069 ppp_release(struct ppp *ppp)
3071 struct sk_buff *skb;
3073 CHECK_PPP_MAGIC(ppp);
3075 if (ppp->flags & SC_DEBUG)
3076 printk(KERN_DEBUG "%s released\n", ppp->name);
3078 ppp_ccp_closed(ppp);
3080 /* Ensure that the pppd process is not hanging on select()/poll() */
3081 wake_up_interruptible(&ppp->read_wait);
3084 slhc_free(ppp->slcomp);
3088 while ((skb = skb_dequeue(&ppp->rcv_q)) != NULL)
3090 while ((skb = skb_dequeue(&ppp->xmt_q)) != NULL)
3094 if (ppp->dev.tbusy) {
3101 * Utility procedures to print a buffer in hex/ascii
3104 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3106 register __u8 next_ch;
3107 static char hex[] = "0123456789ABCDEF";
3109 while (count-- > 0) {
3111 *out++ = hex[(next_ch >> 4) & 0x0F];
3112 *out++ = hex[next_ch & 0x0F];
3118 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3120 register __u8 next_ch;
3122 while (count-- > 0) {
3125 if (next_ch < 0x20 || next_ch > 0x7e)
3129 if (next_ch == '%') /* printk/syslogd has a bug !! */
3137 ppp_print_buffer (const char *name, const __u8 *buf, int count)
3142 printk(KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3145 memset (line, 32, 44);
3146 ppp_print_hex (line, buf, 8);
3147 ppp_print_char (&line[8 * 3], buf, 8);
3148 printk(KERN_DEBUG "%s\n", line);
3154 memset (line, 32, 44);
3155 ppp_print_hex (line, buf, count);
3156 ppp_print_char (&line[8 * 3], buf, count);
3157 printk(KERN_DEBUG "%s\n", line);
3161 /*************************************************************
3162 * Compressor module interface
3163 *************************************************************/
3165 struct compressor_link {
3166 struct compressor_link *next;
3167 struct compressor *comp;
3170 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3172 static struct compressor *find_compressor (int type)
3174 struct compressor_link *lnk;
3175 unsigned long flags;
3180 lnk = ppp_compressors;
3181 while (lnk != (struct compressor_link *) 0) {
3182 if ((int) (__u8) lnk->comp->compress_proto == type) {
3183 restore_flags(flags);
3189 restore_flags(flags);
3190 return (struct compressor *) 0;
3193 #ifdef CONFIG_MODULES
3194 static int ppp_register_compressor (struct compressor *cp)
3196 struct compressor_link *new;
3197 unsigned long flags;
3199 new = (struct compressor_link *)
3200 kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3202 if (new == (struct compressor_link *) 0)
3208 if (find_compressor (cp->compress_proto)) {
3209 restore_flags(flags);
3214 new->next = ppp_compressors;
3216 ppp_compressors = new;
3218 restore_flags(flags);
3222 static void ppp_unregister_compressor (struct compressor *cp)
3224 struct compressor_link *prev = (struct compressor_link *) 0;
3225 struct compressor_link *lnk;
3226 unsigned long flags;
3231 lnk = ppp_compressors;
3232 while (lnk != (struct compressor_link *) 0) {
3233 if (lnk->comp == cp) {
3235 prev->next = lnk->next;
3237 ppp_compressors = lnk->next;
3244 restore_flags(flags);
3248 /*************************************************************
3249 * Module support routines
3250 *************************************************************/
3258 /* register our line disciplines */
3259 status = ppp_first_time();
3261 printk(KERN_INFO "PPP: ppp_init() failure %d\n", status);
3262 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3264 (void) register_symtab (&ppp_syms);
3271 cleanup_module(void)
3274 struct ppp *ppp, *next_ppp;
3278 * Ensure that the devices are not in operation.
3280 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3281 CHECK_PPP_MAGIC(ppp);
3282 if (ppp->inuse || (ppp->dev.flags & IFF_UP))
3286 printk(KERN_CRIT "PPP: removing despite %d units in use!\n",
3290 * Release the tty registration of the line discipline so that
3291 * ttys can no longer be put into PPP line discipline.
3293 status = tty_register_ldisc (N_PPP, NULL);
3296 "PPP: Unable to unregister ppp line discipline "
3297 "(err = %d)\n", status);
3300 "PPP: ppp line discipline successfully unregistered\n");
3303 * De-register the devices so that there is no problem with them
3305 for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3306 next_ppp = ppp->next;
3307 unregister_netdev(&ppp->dev);