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 990114==
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.21 1999/02/26 06:48:21 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.6"
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_push(struct ppp *ppp);
189 static int ppp_async_encode(struct ppp *ppp);
190 static int ppp_async_send(struct ppp *, struct sk_buff *);
192 static int ppp_ioctl(struct ppp *, unsigned int, unsigned long);
193 static int ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp);
194 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd);
195 static void ppp_ccp_closed(struct ppp *ppp);
196 static int ppp_receive_frame(struct ppp *, struct sk_buff *);
197 static void ppp_receive_error(struct ppp *ppp);
198 static void ppp_output_wakeup(struct ppp *ppp);
199 static void ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb);
200 static void ppp_send_frame(struct ppp *ppp, struct sk_buff *skb);
201 static void ppp_send_frames(struct ppp *ppp);
202 static struct sk_buff *ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb);
204 static struct ppp *ppp_find (int pid_value);
205 static struct ppp *ppp_alloc (void);
206 static void ppp_generic_init(struct ppp *ppp);
207 static void ppp_release(struct ppp *ppp);
208 static void ppp_print_buffer (const char *, const __u8 *, int);
209 static struct compressor *find_compressor (int type);
211 #ifndef OPTIMIZE_FLAG_TIME
212 #define OPTIMIZE_FLAG_TIME 0
216 * Parameters which may be changed via insmod.
219 static int flag_time = OPTIMIZE_FLAG_TIME;
220 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
221 MODULE_PARM(flag_time, "i");
224 #define CHECK_PPP_MAGIC(ppp) do { \
225 if (ppp->magic != PPP_MAGIC) { \
226 printk(ppp_magic_warn, ppp, __FILE__, __LINE__); \
229 #define CHECK_PPP(a) do { \
230 CHECK_PPP_MAGIC(ppp); \
232 printk(ppp_warning, __LINE__); \
236 #define CHECK_PPP_VOID() do { \
237 CHECK_PPP_MAGIC(ppp); \
239 printk(ppp_warning, __LINE__); \
244 #define tty2ppp(tty) ((struct ppp *) ((tty)->disc_data))
245 #define dev2ppp(dev) ((struct ppp *) ((dev)->priv))
246 #define ppp2tty(ppp) ((ppp)->tty)
247 #define ppp2dev(ppp) (&(ppp)->dev)
249 static struct ppp *ppp_list = NULL;
250 static struct ppp *ppp_last = NULL;
252 /* Define these strings only once for all macro invocations */
253 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
254 static char ppp_magic_warn[] = KERN_WARNING "bad magic for ppp %p at %s:%d\n";
256 static char szVersion[] = PPP_VERSION;
258 #if LINUX_VERSION_CODE < VERSION(2,1,18)
259 static struct symbol_table ppp_syms = {
260 #include <linux/symtab_begin.h>
261 X(ppp_register_compressor),
262 X(ppp_unregister_compressor),
263 #include <linux/symtab_end.h>
266 EXPORT_SYMBOL(ppp_register_compressor);
267 EXPORT_SYMBOL(ppp_unregister_compressor);
270 /*************************************************************
271 * LINE DISCIPLINE SUPPORT
272 * The following code implements the PPP line discipline
273 * and supports using PPP on an async serial line.
274 *************************************************************/
276 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
277 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
278 ppp->recv_async_map & (1 << (c)))
284 static rw_ret_t ppp_tty_read(struct tty_struct *, struct file *, __u8 *,
286 static rw_ret_t ppp_tty_write(struct tty_struct *, struct file *, const __u8 *,
288 static int ppp_tty_ioctl(struct tty_struct *, struct file *, unsigned int,
290 #if LINUX_VERSION_CODE < VERSION(2,1,23)
291 static int ppp_tty_select(struct tty_struct *tty, struct inode *inode,
292 struct file *filp, int sel_type, select_table * wait);
294 static unsigned int ppp_tty_poll(struct tty_struct *tty, struct file *filp,
297 static int ppp_tty_open (struct tty_struct *);
298 static void ppp_tty_close (struct tty_struct *);
299 static int ppp_tty_room (struct tty_struct *tty);
300 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
301 char *fp, int count);
302 static void ppp_tty_wakeup (struct tty_struct *tty);
304 __u16 ppp_crc16_table[256] =
306 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
307 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
308 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
309 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
310 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
311 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
312 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
313 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
314 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
315 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
316 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
317 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
318 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
319 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
320 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
321 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
322 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
323 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
324 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
325 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
326 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
327 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
328 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
329 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
330 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
331 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
332 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
333 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
334 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
335 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
336 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
337 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
340 #ifdef CHECK_CHARACTERS
341 static __u32 paritytab[8] =
343 0x96696996, 0x69969669, 0x69969669, 0x96696996,
344 0x69969669, 0x96696996, 0x96696996, 0x69969669
349 * This procedure is called at initialization time to register
350 * the PPP line discipline.
355 static struct tty_ldisc ppp_ldisc;
359 "PPP: version %s (demand dialling)"
362 #ifndef MODULE /* slhc module logic has its own copyright announcement */
364 "TCP compression code copyright 1989 Regents of the "
365 "University of California\n");
369 * Register the tty discipline
371 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
372 ppp_ldisc.magic = TTY_LDISC_MAGIC;
373 #if LINUX_VERSION_CODE >= VERSION(2,1,28)
374 ppp_ldisc.name = "ppp";
376 ppp_ldisc.open = ppp_tty_open;
377 ppp_ldisc.close = ppp_tty_close;
378 ppp_ldisc.read = ppp_tty_read;
379 ppp_ldisc.write = ppp_tty_write;
380 ppp_ldisc.ioctl = ppp_tty_ioctl;
381 #if LINUX_VERSION_CODE < VERSION(2,1,23)
382 ppp_ldisc.select = ppp_tty_select;
384 ppp_ldisc.poll = ppp_tty_poll;
386 ppp_ldisc.receive_room = ppp_tty_room;
387 ppp_ldisc.receive_buf = ppp_tty_receive;
388 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
390 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
392 printk(KERN_INFO "PPP line discipline registered.\n");
394 printk(KERN_ERR "error registering line discipline: %d\n",
402 * Called at boot time if the PPP driver is compiled into the kernel.
405 ppp_init(struct device *dev)
407 static int first_time = 1;
412 answer = ppp_first_time();
413 #if LINUX_VERSION_CODE < VERSION(2,1,18)
415 (void) register_symtab(&ppp_syms);
425 * Initialize the async-specific parts of the ppp structure.
428 ppp_async_init(struct ppp *ppp)
432 ppp->tty_pushing = 0;
434 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
435 ppp->xmit_async_map[0] = 0xffffffff;
436 ppp->xmit_async_map[3] = 0x60000000;
437 ppp->recv_async_map = 0xffffffff;
440 ppp->tfcs = PPP_INITFCS;
441 ppp->optr = ppp->obuf;
442 ppp->olim = ppp->obuf;
445 ppp->rfcs = PPP_INITFCS;
448 ppp->backup_tty = NULL;
455 * Clean up the async-specific parts of the ppp structure.
458 ppp_async_release(struct ppp *ppp)
462 if ((skb = ppp->rpkt) != NULL)
465 if ((skb = ppp->tpkt) != NULL)
473 * Called when the tty discipline is switched to PPP.
477 ppp_tty_open (struct tty_struct *tty)
482 * Allocate a ppp structure to use.
484 tty->disc_data = NULL;
485 ppp = ppp_find(current->pid);
488 * If we are taking over a ppp unit which is currently
489 * connected to a loopback pty, there's not much to do.
496 printk(KERN_ERR "ppp_alloc failed\n");
501 * Initialize the control block
503 ppp_generic_init(ppp);
509 tty->disc_data = ppp;
513 * Flush any pending characters in the driver
515 if (tty->driver.flush_buffer)
516 tty->driver.flush_buffer (tty);
524 * Called when the line discipline is changed to something
525 * else, the tty is closed, or the tty detects a hangup.
529 ppp_tty_close (struct tty_struct *tty)
531 struct ppp *ppp = tty2ppp(tty);
535 tty->disc_data = NULL;
536 if (ppp->magic != PPP_MAGIC) {
537 printk(KERN_WARNING "ppp_tty_close: bogus\n");
541 printk(KERN_WARNING "ppp_tty_close: not inuse\n");
542 ppp->tty = ppp->backup_tty = 0;
545 if (tty == ppp->backup_tty)
549 if (ppp->backup_tty) {
550 ppp->tty = ppp->backup_tty;
551 if (ppp_tty_push(ppp))
552 ppp_output_wakeup(ppp);
556 if (ppp->flags & SC_DEBUG)
557 printk(KERN_INFO "ppp: channel %s closing.\n",
560 ppp_async_release(ppp);
567 * Read a PPP frame from the rcv_q list,
568 * waiting if necessary
571 ppp_tty_read(struct tty_struct *tty, struct file *file, __u8 * buf,
574 struct ppp *ppp = tty2ppp (tty);
579 * Validate the pointers
586 * Before we attempt to write the frame to the user, ensure that the
587 * user has access to the pages for the total buffer length.
589 err = verify_area(VERIFY_WRITE, buf, nr);
594 * Wait for a frame to arrive if necessary.
595 * We increment the module use count so that the module
596 * can't go away while we're sleeping.
603 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
607 skb = skb_dequeue(&ppp->rcv_q);
612 * If no frame is available, return -EAGAIN or wait.
615 if (file->f_flags & O_NONBLOCK)
618 interruptible_sleep_on(&ppp->read_wait);
620 if (signal_pending(current))
628 * Ensure that the frame will fit within the caller's buffer.
629 * If not, just discard the frame.
633 if (ppp->flags & SC_DEBUG)
635 "ppp: read of %lu bytes too small for %ld "
636 "frame\n", (unsigned long) nr, (long) len);
637 ppp->stats.ppp_ierrors++;
643 * Copy the received data from the buffer to the caller's area.
646 if (COPY_TO_USER(buf, skb->data, len))
655 * Writing to a tty in ppp line discipline sends a PPP frame.
656 * Used by pppd to send control packets (LCP, etc.).
659 ppp_tty_write(struct tty_struct *tty, struct file *file, const __u8 * data,
662 struct ppp *ppp = tty2ppp (tty);
667 * Verify the pointers.
672 if (ppp->magic != PPP_MAGIC)
678 * Ensure that the caller does not wish to send too much.
680 if (count > PPP_MTU + PPP_HDRLEN) {
681 if (ppp->flags & SC_DEBUG)
683 "ppp_tty_write: truncating user packet "
684 "from %lu to mtu %d\n", (unsigned long) count,
685 PPP_MTU + PPP_HDRLEN);
686 count = PPP_MTU + PPP_HDRLEN;
690 * Allocate a buffer for the data and fetch it from the user space.
692 skb = alloc_skb(count, GFP_KERNEL);
694 printk(KERN_ERR "ppp_tty_write: no memory\n");
698 new_data = skb_put(skb, count);
701 * Retrieve the user's buffer
703 if (COPY_FROM_USER(new_data, data, count)) {
711 ppp_send_ctrl(ppp, skb);
713 return (rw_ret_t) count;
717 * Process the IOCTL call for the tty device.
718 * Only the ioctls that relate to using ppp on async serial lines
719 * are processed here; the rest are handled by ppp_ioctl.
722 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
723 unsigned int param2, unsigned long param3)
725 struct ppp *ppp = tty2ppp (tty);
726 register int temp_i = 0;
730 * Verify the status of the PPP device.
732 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
736 * The user must have an euid of root to do these requests.
742 case PPPIOCGASYNCMAP:
744 * Retrieve the transmit async map
746 if (PUT_USER(ppp->xmit_async_map[0], (int *) param3))
751 case PPPIOCSASYNCMAP:
753 * Set the transmit async map
755 if (GET_USER(temp_i, (int *) param3))
757 ppp->xmit_async_map[0] = temp_i;
758 if (ppp->flags & SC_DEBUG)
760 "ppp_tty_ioctl: set xmit asyncmap %x\n",
761 ppp->xmit_async_map[0]);
765 case PPPIOCSRASYNCMAP:
767 * Set the receive async map
769 if (GET_USER(temp_i, (int *) param3))
771 ppp->recv_async_map = temp_i;
772 if (ppp->flags & SC_DEBUG)
774 "ppp_tty_ioctl: set rcv asyncmap %x\n",
775 ppp->recv_async_map);
779 case PPPIOCGXASYNCMAP:
781 * Get the map of characters to be escaped on transmission.
783 if (COPY_TO_USER((void *) param3, ppp->xmit_async_map,
784 sizeof (ppp->xmit_async_map)))
789 case PPPIOCSXASYNCMAP:
791 * Set the map of characters to be escaped on transmission.
796 if (COPY_FROM_USER(temp_tbl, (void *) param3,
800 temp_tbl[1] = 0x00000000;
801 temp_tbl[2] &= ~0x40000000;
802 temp_tbl[3] |= 0x60000000;
804 memcpy(ppp->xmit_async_map, temp_tbl,
805 sizeof (ppp->xmit_async_map));
807 if (ppp->flags & SC_DEBUG)
809 "ppp_tty_ioctl: set xasyncmap\n");
816 * Set up this PPP unit to be used next time this
817 * process sets a tty to PPP line discipline.
819 ppp->backup_tty = tty;
820 ppp->sc_xfer = current->pid;
827 * Allow users to read, but not set, the serial port parameters
829 error = n_tty_ioctl (tty, file, param2, param3);
834 * Returns how many bytes are available for a read().
843 skb = skb_peek(&ppp->rcv_q);
846 restore_flags(flags);
847 if (PUT_USER(count, (int *) param3))
855 * All other ioctl() events will come here.
857 error = ppp_ioctl(ppp, param2, param3);
866 * Process the select() or poll() statement for the PPP device.
869 #if LINUX_VERSION_CODE < VERSION(2,1,23)
871 ppp_tty_select(struct tty_struct *tty, struct inode *inode,
872 struct file *filp, int sel_type, select_table * wait)
874 struct ppp *ppp = tty2ppp(tty);
878 * Verify the status of the PPP device.
880 if (!ppp || tty != ppp->tty)
887 /* The fd is readable if the receive queue isn't empty. */
888 if (skb_peek(&ppp->rcv_q) != NULL)
892 /* Check for exceptions or read errors. */
893 /* Is this a pty link and the remote disconnected? */
894 if (tty->flags & (1 << TTY_OTHER_CLOSED))
897 /* Is this a local link and the modem disconnected? */
898 if (tty_hung_up_p (filp))
901 select_wait(&ppp->read_wait, wait);
906 /* The fd is always writable. */
912 #else /* 2.1.23 or later */
915 ppp_tty_poll(struct tty_struct *tty, struct file *filp, poll_table * wait)
917 struct ppp *ppp = tty2ppp(tty);
918 unsigned int mask = 0;
920 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
923 poll_wait(filp, &ppp->read_wait, wait);
925 if (skb_peek(&ppp->rcv_q) != NULL)
926 mask |= POLLIN | POLLRDNORM;
927 if (tty->flags & (1 << TTY_OTHER_CLOSED)
928 || tty_hung_up_p(filp))
930 mask |= POLLOUT | POLLWRNORM;
934 #endif /* >= 2.1.23 */
937 * This function is called by the tty driver when the transmit buffer has
938 * additional space. It is used by the ppp code to continue to transmit
939 * the current buffer should the buffer have been partially sent.
942 ppp_tty_wakeup (struct tty_struct *tty)
944 struct ppp *ppp = tty2ppp (tty);
946 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
953 if (ppp_tty_push(ppp))
954 ppp_output_wakeup(ppp);
958 * Send a packet to the peer over an async tty line.
959 * Returns -1 iff the packet could not be accepted at present,
960 * 0 if the packet was accepted but we can't accept another yet, or
961 * 1 if we can accept another packet immediately.
962 * If this procedure returns 0, ppp_output_wakeup will be called
966 ppp_async_send(struct ppp *ppp, struct sk_buff *skb)
972 if (ppp->tpkt != NULL)
977 return ppp_tty_push(ppp);
981 * Push as much data as possible out to the tty.
982 * Returns 1 if we finished encoding the current frame, 0 otherwise.
985 ppp_tty_push(struct ppp *ppp)
987 int avail, sent, done = 0;
988 struct tty_struct *tty = ppp2tty(ppp);
991 if (ppp->tty_pushing)
993 if (tty == NULL || tty->disc_data != (void *) ppp)
995 while (ppp->optr < ppp->olim || ppp->tpkt != 0) {
996 ppp->tty_pushing = 1;
997 avail = ppp->olim - ppp->optr;
999 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1000 sent = tty->driver.write(tty, 0, ppp->optr, avail);
1002 goto flush; /* error, e.g. loss of CD */
1003 ppp->stats.ppp_obytes += sent;
1006 ppp->tty_pushing = 0;
1011 done = ppp_async_encode(ppp);
1012 ppp->tty_pushing = 0;
1017 ppp->tty_pushing = 1;
1018 ppp->stats.ppp_oerrors++;
1019 if (ppp->tpkt != 0) {
1020 KFREE_SKB(ppp->tpkt);
1024 ppp->optr = ppp->olim;
1025 ppp->tty_pushing = 0;
1030 * Procedure to encode the data for async serial transmission.
1031 * Does octet stuffing (escaping) and address/control
1032 * and protocol compression.
1033 * Assumes ppp->opkt != 0 on entry.
1034 * Returns 1 if we finished the current frame, 0 otherwise.
1037 ppp_async_encode(struct ppp *ppp)
1039 int fcs, i, count, c;
1040 unsigned char *buf, *buflim;
1041 unsigned char *data;
1050 data = ppp->tpkt->data;
1051 count = ppp->tpkt->len;
1055 * LCP packets with code values between 1 (configure-reqest)
1056 * and 7 (code-reject) must be sent as though no options
1057 * had been negotiated.
1059 islcp = PPP_PROTOCOL(data) == PPP_LCP
1060 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
1064 * Start of a new packet - insert the leading FLAG
1065 * character if necessary.
1067 if (islcp || flag_time == 0
1068 || jiffies - ppp->last_xmit >= flag_time)
1070 /* only reset idle time for data packets */
1071 if (PPP_PROTOCOL(data) < 0x8000)
1072 ppp->last_xmit = jiffies;
1074 ++ppp->stats.ppp_opackets;
1075 ppp->stats.ppp_ooctects += count;
1078 * Do address/control compression
1080 if ((ppp->flags & SC_COMP_AC) != 0 && !islcp
1081 && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1082 && PPP_CONTROL(data) == PPP_UI)
1087 * Once we put in the last byte, we need to put in the FCS
1088 * and closing flag, so make sure there is at least 7 bytes
1089 * of free space in the output buffer.
1091 buflim = buf + OBUFSIZE - 6;
1092 while (i < count && buf < buflim) {
1094 if (i == 3 && c == 0 && (ppp->flags & SC_COMP_PROT))
1095 continue; /* compress protocol field */
1096 fcs = PPP_FCS(fcs, c);
1097 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1098 *buf++ = PPP_ESCAPE;
1106 * We have finished the packet. Add the FCS and flag.
1110 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1111 *buf++ = PPP_ESCAPE;
1115 c = (fcs >> 8) & 0xff;
1116 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1117 *buf++ = PPP_ESCAPE;
1124 KFREE_SKB(ppp->tpkt);
1130 * Remember where we are up to in this packet.
1139 * Callback function from tty driver. Return the amount of space left
1140 * in the receiver's buffer to decide if remote transmitter is to be
1144 ppp_tty_room (struct tty_struct *tty)
1146 return 65536; /* We can handle an infinite amount of data. :-) */
1150 * Callback function when data is available at the tty driver.
1153 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1154 char *flags, int count)
1156 register struct ppp *ppp = tty2ppp (tty);
1157 struct sk_buff *skb;
1164 * This can happen if stuff comes in on the backup tty.
1166 if (ppp == 0 || tty != ppp->tty)
1169 * Verify the table pointer and ensure that the line is
1170 * still in PPP discipline.
1172 if (ppp->magic != PPP_MAGIC) {
1173 if (ppp->flags & SC_DEBUG)
1175 "PPP: tty_receive called but couldn't find "
1180 * Print the buffer if desired
1182 if (ppp->flags & SC_LOG_RAWIN)
1183 ppp_print_buffer ("receive buffer", data, count);
1185 ppp->stats.ppp_ibytes += count;
1187 while (count-- > 0) {
1189 * Collect the character and error condition for the character.
1190 * Set the toss flag for the first character error.
1200 ++ppp->estats.rx_fifo_errors;
1204 ++ppp->estats.rx_frame_errors;
1212 * Set the flags for d7 being 0/1 and parity being
1213 * even/odd so that the normal processing would have
1214 * all flags set at the end of the session. A
1215 * missing flag bit indicates an error condition.
1218 #ifdef CHECK_CHARACTERS
1220 ppp->flags |= SC_RCV_B7_1;
1222 ppp->flags |= SC_RCV_B7_0;
1224 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1225 ppp->flags |= SC_RCV_ODDP;
1227 ppp->flags |= SC_RCV_EVNP;
1230 if (chr == PPP_FLAG) {
1232 * FLAG. This is the end of the block. If the block
1233 * ends with ESC FLAG, then the block is to be ignored.
1238 * Process the frame if it was received correctly.
1239 * If there was an error, let the VJ decompressor know.
1240 * There are 4 cases here:
1241 * skb != NULL, toss != 0: error in frame
1242 * skb != NULL, toss == 0: frame ok
1243 * skb == NULL, toss != 0: very first frame,
1244 * error on 1st char, or alloc_skb failed
1245 * skb == NULL, toss == 0: empty frame (~~)
1247 if (ppp->toss || !ppp_receive_frame(ppp, skb)) {
1248 if (ppp->toss && (ppp->flags & SC_DEBUG))
1250 "ppp: tossing frame (%x)\n",
1254 if (!(ppp->toss == 0xE0 || ppp->toss == 0x80))
1255 ++ppp->stats.ppp_ierrors;
1256 ppp_receive_error(ppp);
1259 * Reset for the next frame.
1262 ppp->rfcs = PPP_INITFCS;
1268 /* If we're tossing, look no further. */
1272 /* If this is a control char to be ignored, do so */
1273 if (in_rmap(ppp, chr))
1277 * Modify the next character if preceded by escape.
1278 * The escape character (0x7d) could be an escaped
1279 * 0x5d, if it follows an escape :-)
1284 } else if (chr == PPP_ESCAPE) {
1285 ppp->escape = PPP_TRANS;
1290 * Allocate an skbuff on the first character received.
1291 * The 128 is room for VJ header expansion and FCS.
1294 skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1296 if (ppp->flags & SC_DEBUG)
1297 printk(KERN_DEBUG "couldn't "
1298 "alloc skb for recv\n");
1306 * Decompress A/C and protocol compression here.
1308 if (skb->len == 0 && chr != PPP_ALLSTATIONS) {
1309 p = skb_put(skb, 2);
1310 p[0] = PPP_ALLSTATIONS;
1313 if (skb->len == 2 && (chr & 1) != 0) {
1314 p = skb_put(skb, 1);
1319 * Check if we've overflowed the MRU
1321 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1322 || skb_tailroom(skb) <= 0) {
1323 ++ppp->estats.rx_length_errors;
1325 if (ppp->flags & SC_DEBUG)
1326 printk(KERN_DEBUG "rcv frame too long: "
1327 "len=%ld mru=%d hroom=%d troom=%d\n",
1328 skb->len, ppp->mru, skb_headroom(skb),
1334 * Store the character and update the FCS.
1336 p = skb_put(skb, 1);
1338 ppp->rfcs = PPP_FCS(ppp->rfcs, chr);
1343 /*************************************************************
1344 * PPP NETWORK INTERFACE SUPPORT
1345 * The following code implements the PPP network
1346 * interface device and handles those parts of
1347 * the PPP processing which are independent of the
1348 * type of hardware link being used, including
1349 * VJ and packet compression.
1350 *************************************************************/
1353 * Network device driver callback routines
1356 static int ppp_init_dev(struct device *dev);
1357 static int ppp_dev_open(struct device *);
1358 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
1359 static int ppp_dev_close(struct device *);
1360 static int ppp_dev_xmit(struct sk_buff *, struct device *);
1361 static struct net_device_stats *ppp_dev_stats (struct device *);
1363 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1364 static int ppp_dev_header(struct sk_buff *, struct device *, __u16,
1365 void *, void *, unsigned int);
1366 static int ppp_dev_rebuild(void *eth, struct device *dev,
1367 unsigned long raddr, struct sk_buff *skb);
1371 * Information for the protocol decoder
1374 typedef int (*pfn_proto) (struct ppp *, struct sk_buff *);
1376 typedef struct ppp_proto_struct {
1381 static int rcv_proto_ip (struct ppp *, struct sk_buff *);
1382 static int rcv_proto_ipv6 (struct ppp *, struct sk_buff *);
1383 static int rcv_proto_ipx (struct ppp *, struct sk_buff *);
1384 static int rcv_proto_at (struct ppp *, struct sk_buff *);
1385 static int rcv_proto_vjc_comp (struct ppp *, struct sk_buff *);
1386 static int rcv_proto_vjc_uncomp (struct ppp *, struct sk_buff *);
1387 static int rcv_proto_ccp (struct ppp *, struct sk_buff *);
1388 static int rcv_proto_unknown (struct ppp *, struct sk_buff *);
1391 ppp_proto_type proto_list[] = {
1392 { PPP_IP, rcv_proto_ip },
1393 { PPP_IPV6, rcv_proto_ipv6 },
1394 { PPP_IPX, rcv_proto_ipx },
1395 { PPP_AT, rcv_proto_at },
1396 { PPP_VJC_COMP, rcv_proto_vjc_comp },
1397 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
1398 { PPP_CCP, rcv_proto_ccp },
1399 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
1403 * Called when the PPP network interface device is actually created.
1406 ppp_init_dev (struct device *dev)
1408 dev->hard_header_len = PPP_HDRLEN;
1409 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1410 dev->hard_header = ppp_dev_header;
1411 dev->rebuild_header = ppp_dev_rebuild;
1416 dev->hard_start_xmit = ppp_dev_xmit;
1417 dev->open = ppp_dev_open;
1418 dev->stop = ppp_dev_close;
1419 dev->get_stats = ppp_dev_stats;
1420 dev->do_ioctl = ppp_dev_ioctl;
1422 dev->tx_queue_len = 10;
1423 dev->type = ARPHRD_PPP;
1425 #if LINUX_VERSION_CODE < VERSION(2,1,20)
1429 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
1430 skb_queue_head_init (&dev->buffs[indx]);
1433 dev_init_buffers(dev);
1436 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
1442 * Callback from the network layer when the device goes up.
1446 ppp_dev_open (struct device *dev)
1448 struct ppp *ppp = dev2ppp(dev);
1450 if (!ppp->inuse || ppp2tty(ppp) == NULL) {
1451 printk(KERN_ERR "ppp: %s not active\n", dev->name);
1461 * Callback from the network layer when the ppp device goes down.
1465 ppp_dev_close (struct device *dev)
1467 struct ppp *ppp = dev2ppp (dev);
1469 CHECK_PPP_MAGIC(ppp);
1477 get_vj_stats(struct vjstat *vj, struct slcompress *slc)
1479 vj->vjs_packets = slc->sls_o_compressed + slc->sls_o_uncompressed;
1480 vj->vjs_compressed = slc->sls_o_compressed;
1481 vj->vjs_searches = slc->sls_o_searches;
1482 vj->vjs_misses = slc->sls_o_misses;
1483 vj->vjs_errorin = slc->sls_i_error;
1484 vj->vjs_tossed = slc->sls_i_tossed;
1485 vj->vjs_uncompressedin = slc->sls_i_uncompressed;
1486 vj->vjs_compressedin = slc->sls_i_compressed;
1490 * Callback from the network layer to process the sockioctl functions.
1493 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
1495 struct ppp *ppp = dev2ppp(dev);
1498 struct ppp_stats stats;
1499 struct ppp_comp_stats cstats;
1503 CHECK_PPP_MAGIC(ppp);
1505 memset(&u, 0, sizeof(u));
1508 u.stats.p = ppp->stats;
1509 if (ppp->slcomp != NULL)
1510 get_vj_stats(&u.stats.vj, ppp->slcomp);
1511 nb = sizeof(u.stats);
1514 case SIOCGPPPCSTATS:
1515 if (ppp->sc_xc_state != NULL)
1516 (*ppp->sc_xcomp->comp_stat)
1517 (ppp->sc_xc_state, &u.cstats.c);
1518 if (ppp->sc_rc_state != NULL)
1519 (*ppp->sc_rcomp->decomp_stat)
1520 (ppp->sc_rc_state, &u.cstats.d);
1521 nb = sizeof(u.cstats);
1525 strcpy(u.vers, szVersion);
1526 nb = strlen(u.vers) + 1;
1533 if (COPY_TO_USER((void *) ifr->ifr_ifru.ifru_data, &u, nb))
1539 * Process the generic PPP ioctls, i.e. those which are not specific
1540 * to any particular type of hardware link.
1543 ppp_ioctl(struct ppp *ppp, unsigned int param2, unsigned long param3)
1545 register int temp_i = 0, oldflags;
1546 int error = -EFAULT;
1547 unsigned long flags;
1548 struct ppp_idle cur_ddinfo;
1554 * The user must have an euid of root to do these requests.
1564 if (GET_USER(temp_i, (int *) param3))
1566 if (temp_i < PPP_MRU)
1569 if (ppp->flags & SC_DEBUG)
1571 "ppp_ioctl: set mru to %x\n", temp_i);
1577 * Fetch the current flags
1579 temp_i = ppp->flags & SC_MASK;
1580 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
1581 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
1582 SC_RCV_ODDP | SC_RCV_EVNP;
1584 if (PUT_USER(temp_i, (int *) param3))
1591 * Set the flags for the various options
1593 if (GET_USER(temp_i, (int *) param3))
1596 if (ppp->flags & ~temp_i & SC_CCP_OPEN)
1597 ppp_ccp_closed(ppp);
1601 oldflags = ppp->flags;
1602 temp_i = (temp_i & SC_MASK) | (oldflags & ~SC_MASK);
1603 ppp->flags = temp_i;
1604 restore_flags(flags);
1606 if ((oldflags | temp_i) & SC_DEBUG)
1608 "ppp_ioctl: set flags to %x\n", temp_i);
1612 case PPPIOCSCOMPRESS:
1614 * Set the compression mode
1616 error = ppp_set_compression
1617 (ppp, (struct ppp_option_data *) param3);
1622 * Obtain the unit number for this device.
1624 if (PUT_USER(ppp->line, (int *) param3))
1626 if (ppp->flags & SC_DEBUG)
1628 "ppp_ioctl: get unit: %d\n", ppp->line);
1634 * Set the debug level
1636 if (GET_USER(temp_i, (int *) param3))
1638 temp_i = (temp_i & 0x1F) << 16;
1640 if ((ppp->flags | temp_i) & SC_DEBUG)
1642 "ppp_ioctl: set dbg flags to %x\n", temp_i);
1646 ppp->flags = (ppp->flags & ~0x1F0000) | temp_i;
1647 restore_flags(flags);
1653 * Get the debug level
1655 temp_i = (ppp->flags >> 16) & 0x1F;
1656 if (PUT_USER(temp_i, (int *) param3))
1663 * Get the times since the last send/receive frame operation
1665 /* change absolute times to relative times. */
1666 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
1667 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
1668 if (COPY_TO_USER((void *) param3, &cur_ddinfo,
1669 sizeof (cur_ddinfo)))
1676 * Set the maximum VJ header compression slot number.
1678 if (GET_USER(temp_i, (int *) param3))
1681 if (temp_i < 2 || temp_i > 255)
1684 if (ppp->flags & SC_DEBUG)
1685 printk(KERN_INFO "ppp_ioctl: set maxcid to %d\n",
1687 if (ppp->slcomp != NULL)
1688 slhc_free(ppp->slcomp);
1689 ppp->slcomp = slhc_init(16, temp_i);
1692 if (ppp->slcomp == NULL) {
1693 printk(KERN_ERR "ppp: no memory for VJ compression\n");
1701 if (COPY_FROM_USER(&npi, (void *) param3, sizeof(npi)))
1704 switch (npi.protocol) {
1706 npi.protocol = NP_IP;
1709 npi.protocol = NP_IPX;
1712 npi.protocol = NP_AT;
1715 if (ppp->flags & SC_DEBUG)
1716 printk(KERN_DEBUG "pppioc[gs]npmode: "
1717 "invalid proto %d\n", npi.protocol);
1722 if (param2 == PPPIOCGNPMODE) {
1723 npi.mode = ppp->sc_npmode[npi.protocol];
1724 if (COPY_TO_USER((void *) param3, &npi, sizeof(npi)))
1727 ppp->sc_npmode[npi.protocol] = npi.mode;
1728 if (ppp->flags & SC_DEBUG)
1729 printk(KERN_DEBUG "ppp: set np %d to %d\n",
1730 npi.protocol, npi.mode);
1738 * All other ioctl() events will come here.
1740 if (ppp->flags & SC_DEBUG)
1742 "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
1745 error = -ENOIOCTLCMD;
1753 * Process the set-compression ioctl.
1756 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
1758 struct compressor *cp;
1760 unsigned long flags;
1762 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
1763 struct ppp_option_data data;
1766 * Fetch the compression parameters
1769 if (COPY_FROM_USER(&data, odp, sizeof (data)))
1774 if ((unsigned) nb >= CCP_MAX_OPTION_LENGTH)
1775 nb = CCP_MAX_OPTION_LENGTH;
1777 if (COPY_FROM_USER(ccp_option, ptr, nb))
1781 if (ccp_option[1] < 2) /* preliminary check on the length byte */
1786 ppp->flags &= ~(data.transmit? SC_COMP_RUN: SC_DECOMP_RUN);
1787 restore_flags(flags);
1789 cp = find_compressor (ccp_option[0]);
1790 #if defined(CONFIG_KMOD) || defined(CONFIG_KERNELD)
1793 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
1794 request_module(modname);
1795 cp = find_compressor(ccp_option[0]);
1797 #endif /* CONFIG_KMOD */
1800 if (ppp->flags & SC_DEBUG)
1802 "%s: no compressor for [%x %x %x], %x\n",
1803 ppp->name, ccp_option[0], ccp_option[1],
1805 goto out; /* compressor not loaded */
1809 * Found a handler for the protocol - try to allocate
1810 * a compressor or decompressor.
1813 if (data.transmit) {
1814 if (ppp->sc_xc_state != NULL)
1815 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
1816 ppp->sc_xc_state = NULL;
1819 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
1820 if (ppp->sc_xc_state == NULL) {
1821 if (ppp->flags & SC_DEBUG)
1822 printk(KERN_DEBUG "%s: comp_alloc failed\n",
1827 if (ppp->sc_rc_state != NULL)
1828 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
1829 ppp->sc_rc_state = NULL;
1832 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
1833 if (ppp->sc_rc_state == NULL) {
1834 if (ppp->flags & SC_DEBUG)
1835 printk(KERN_DEBUG "%s: decomp_alloc failed\n",
1845 * Handle a CCP packet.
1847 * The CCP packet is passed along to the pppd process just like any
1848 * other PPP frame. The difference is that some processing needs to be
1849 * immediate or the compressors will become confused on the peer.
1852 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd)
1854 int slen = CCP_LENGTH(dp);
1855 __u8 *opt = dp + CCP_HDRLEN;
1856 int opt_len = slen - CCP_HDRLEN;
1857 unsigned long flags;
1862 if (ppp->flags & SC_DEBUG)
1863 printk(KERN_DEBUG "ppp_proto_ccp rcvd=%d code=%x flags=%x\n",
1864 rcvd, CCP_CODE(dp), ppp->flags);
1866 switch (CCP_CODE(dp)) {
1871 * CCP must be going down - disable compression
1873 if (ppp->flags & SC_CCP_UP) {
1875 ppp->flags &= ~(SC_CCP_UP |
1882 if ((ppp->flags & SC_CCP_OPEN) == 0)
1884 if (ppp->flags & SC_CCP_UP)
1886 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1888 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1892 * we're agreeing to send compressed packets.
1894 if (ppp->sc_xc_state == NULL)
1897 if ((*ppp->sc_xcomp->comp_init)
1900 ppp->line, 0, ppp->flags & SC_DEBUG)) {
1901 if (ppp->flags & SC_DEBUG)
1902 printk(KERN_DEBUG "%s: comp running\n",
1905 ppp->flags |= SC_COMP_RUN;
1911 * peer is agreeing to send compressed packets.
1913 if (ppp->sc_rc_state == NULL)
1916 if ((*ppp->sc_rcomp->decomp_init)
1919 ppp->line, 0, ppp->mru, ppp->flags & SC_DEBUG)) {
1920 if (ppp->flags & SC_DEBUG)
1921 printk(KERN_DEBUG "%s: decomp running\n",
1924 ppp->flags |= SC_DECOMP_RUN;
1925 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1931 * CCP Reset-ack resets compressors and decompressors
1932 * as it passes through.
1934 if ((ppp->flags & SC_CCP_UP) == 0)
1938 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
1939 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1940 if (ppp->flags & SC_DEBUG)
1941 printk(KERN_DEBUG "%s: comp reset\n",
1945 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1946 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1947 if (ppp->flags & SC_DEBUG)
1948 printk(KERN_DEBUG "%s: decomp reset\n",
1951 ppp->flags &= ~SC_DC_ERROR;
1956 restore_flags(flags);
1960 * CCP is down; free (de)compressor state if necessary.
1964 ppp_ccp_closed(struct ppp *ppp)
1966 unsigned long flags;
1970 ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
1971 restore_flags(flags);
1972 if (ppp->flags & SC_DEBUG)
1973 printk(KERN_DEBUG "%s: ccp closed\n", ppp->name);
1974 if (ppp->sc_xc_state) {
1975 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
1976 ppp->sc_xc_state = NULL;
1979 if (ppp->sc_rc_state) {
1980 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
1981 ppp->sc_rc_state = NULL;
1985 /*************************************************************
1986 * RECEIVE-SIDE ROUTINES
1987 *************************************************************/
1990 * On entry, a received frame is in skb.
1991 * Check it and dispose as appropriate.
1994 ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb)
2000 struct sk_buff *new_skb;
2001 ppp_proto_type *proto_ptr;
2004 * An empty frame is ignored. This occurs if the FLAG sequence
2005 * precedes and follows each frame.
2009 if (skb->len == 0) {
2017 * Generate an error if the frame is too small.
2019 if (count < PPP_HDRLEN + 2) {
2020 if (ppp->flags & SC_DEBUG)
2022 "ppp: got runt ppp frame, %d chars\n", count);
2023 ++ppp->estats.rx_length_errors;
2028 * Verify the FCS of the frame and discard the FCS characters
2029 * from the end of the buffer.
2031 if (ppp->rfcs != PPP_GOODFCS) {
2032 if (ppp->flags & SC_DEBUG) {
2034 "ppp: frame with bad fcs, length = %d\n",
2036 ppp_print_buffer("bad frame", data, count);
2038 ++ppp->estats.rx_crc_errors;
2041 count -= 2; /* ignore the fcs characters */
2042 skb_trim(skb, count);
2045 * Process the active decompressor.
2047 if (ppp->sc_rc_state != NULL &&
2048 (ppp->flags & SC_DECOMP_RUN) &&
2049 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
2050 if (PPP_PROTOCOL(data) == PPP_COMP) {
2052 * If the frame is compressed then decompress it.
2054 new_skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
2055 if (new_skb == NULL) {
2056 printk(KERN_ERR "ppp_recv_frame: no memory\n");
2057 new_count = DECOMP_ERROR;
2059 LIBERATE_SKB(new_skb);
2060 new_count = (*ppp->sc_rcomp->decompress)
2061 (ppp->sc_rc_state, data, count,
2062 new_skb->data, ppp->mru + PPP_HDRLEN);
2064 if (new_count > 0) {
2065 /* Frame was decompressed OK */
2069 data = skb_put(skb, count);
2073 * On a decompression error, we pass the
2074 * compressed frame up to pppd as an
2077 if (ppp->flags & SC_DEBUG)
2078 printk(KERN_INFO "%s: decomp err %d\n",
2079 ppp->name, new_count);
2082 if (ppp->slcomp != 0)
2083 slhc_toss(ppp->slcomp);
2084 ++ppp->stats.ppp_ierrors;
2085 if (new_count == DECOMP_FATALERROR) {
2086 ppp->flags |= SC_DC_FERROR;
2088 ppp->flags |= SC_DC_ERROR;
2095 * The frame is not compressed. Pass it to the
2096 * decompression code so it can update its
2097 * dictionary if necessary.
2099 (*ppp->sc_rcomp->incomp)(ppp->sc_rc_state,
2103 else if (PPP_PROTOCOL(data) == PPP_COMP && (ppp->flags & SC_DEBUG))
2104 printk(KERN_INFO "%s: not decomp, rc_state=%p flags=%x\n",
2105 ppp->name, ppp->sc_rc_state, ppp->flags);
2108 * Count the frame and print it
2110 ++ppp->stats.ppp_ipackets;
2111 ppp->stats.ppp_ioctects += count;
2112 if (ppp->flags & SC_LOG_INPKT)
2113 ppp_print_buffer ("receive frame", data, count);
2116 * Find the procedure to handle this protocol.
2117 * The last one is marked as protocol 0 which is the 'catch-all'
2118 * to feed it to the pppd daemon.
2120 proto = PPP_PROTOCOL(data);
2121 proto_ptr = proto_list;
2122 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
2126 * Update the appropriate statistic counter.
2128 if (!(*proto_ptr->func)(ppp, skb)) {
2130 ++ppp->stats.ppp_discards;
2137 * An input error has been detected, so we need to inform
2138 * the VJ decompressor.
2141 ppp_receive_error(struct ppp *ppp)
2145 if (ppp->slcomp != 0)
2146 slhc_toss(ppp->slcomp);
2150 * Put the input frame into the networking system for the indicated protocol
2153 ppp_rcv_rx(struct ppp *ppp, __u16 proto, struct sk_buff *skb)
2157 * Fill in a few fields of the skb and give it to netif_rx().
2159 skb->dev = ppp2dev(ppp); /* We are the device */
2160 skb->protocol = htons(proto);
2161 skb_pull(skb, PPP_HDRLEN); /* pull off ppp header */
2162 skb->mac.raw = skb->data;
2163 ppp->last_recv = jiffies;
2169 * Process the receipt of an IP frame
2172 rcv_proto_ip(struct ppp *ppp, struct sk_buff *skb)
2175 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2176 && ppp->sc_npmode[NP_IP] == NPMODE_PASS)
2177 return ppp_rcv_rx(ppp, ETH_P_IP, skb);
2182 * Process the receipt of an IPv6 frame
2185 rcv_proto_ipv6(struct ppp *ppp, struct sk_buff *skb)
2188 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2189 && ppp->sc_npmode[NP_IPV6] == NPMODE_PASS)
2190 return ppp_rcv_rx(ppp, ETH_P_IPV6, skb);
2195 * Process the receipt of an IPX frame
2198 rcv_proto_ipx(struct ppp *ppp, struct sk_buff *skb)
2201 if (((ppp2dev(ppp)->flags & IFF_UP) != 0) && (skb->len > 0)
2202 && ppp->sc_npmode[NP_IPX] == NPMODE_PASS)
2203 return ppp_rcv_rx(ppp, ETH_P_IPX, skb);
2208 * Process the receipt of an Appletalk frame
2211 rcv_proto_at(struct ppp *ppp, struct sk_buff *skb)
2214 if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2215 && ppp->sc_npmode[NP_AT] == NPMODE_PASS)
2216 return ppp_rcv_rx(ppp, ETH_P_PPPTALK, skb);
2221 * Process the receipt of an VJ Compressed frame
2224 rcv_proto_vjc_comp(struct ppp *ppp, struct sk_buff *skb)
2229 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2231 new_count = slhc_uncompress(ppp->slcomp, skb->data + PPP_HDRLEN,
2232 skb->len - PPP_HDRLEN);
2233 if (new_count <= 0) {
2234 if (ppp->flags & SC_DEBUG)
2236 "ppp: error in VJ decompression\n");
2239 new_count += PPP_HDRLEN;
2240 if (new_count > skb->len)
2241 skb_put(skb, new_count - skb->len);
2243 skb_trim(skb, new_count);
2244 return rcv_proto_ip(ppp, skb);
2248 * Process the receipt of an VJ Un-compressed frame
2251 rcv_proto_vjc_uncomp(struct ppp *ppp, struct sk_buff *skb)
2254 if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2256 if (slhc_remember(ppp->slcomp, skb->data + PPP_HDRLEN,
2257 skb->len - PPP_HDRLEN) <= 0) {
2258 if (ppp->flags & SC_DEBUG)
2259 printk(KERN_NOTICE "ppp: error in VJ memorizing\n");
2262 return rcv_proto_ip(ppp, skb);
2266 rcv_proto_ccp(struct ppp *ppp, struct sk_buff *skb)
2269 ppp_proto_ccp (ppp, skb->data + PPP_HDRLEN, skb->len - PPP_HDRLEN, 1);
2270 return rcv_proto_unknown(ppp, skb);
2274 * Receive all unclassified protocols.
2277 rcv_proto_unknown(struct ppp *ppp, struct sk_buff *skb)
2282 * Limit queue length by dropping old frames.
2284 skb_queue_tail(&ppp->rcv_q, skb);
2285 while (ppp->rcv_q.qlen > PPP_MAX_RCV_QLEN) {
2286 struct sk_buff *skb = skb_dequeue(&ppp->rcv_q);
2291 wake_up_interruptible (&ppp->read_wait);
2292 if (ppp->tty->fasync != NULL)
2293 kill_fasync (ppp->tty->fasync, SIGIO);
2298 /*************************************************************
2299 * TRANSMIT-SIDE ROUTINES
2300 *************************************************************/
2302 /* local function to store a value into the LQR frame */
2303 extern inline __u8 * store_long (register __u8 *p, register int value) {
2304 *p++ = (__u8) (value >> 24);
2305 *p++ = (__u8) (value >> 16);
2306 *p++ = (__u8) (value >> 8);
2307 *p++ = (__u8) value;
2312 * Compress and send an frame to the peer.
2313 * Should be called with xmit_busy == 1, having been set by the caller.
2314 * That is, we use xmit_busy as a lock to prevent reentry of this
2318 ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
2330 /* dump the buffer */
2331 if (ppp->flags & SC_LOG_OUTPKT)
2332 ppp_print_buffer ("write frame", data, count);
2335 * Handle various types of protocol-specific compression
2336 * and other processing, including:
2337 * - VJ TCP header compression
2338 * - updating LQR packets
2339 * - updating CCP state on CCP packets
2341 proto = PPP_PROTOCOL(data);
2344 if ((ppp->flags & SC_COMP_TCP) && ppp->slcomp != NULL)
2345 skb = ppp_vj_compress(ppp, skb);
2350 * Update the LQR frame with the current MIB information.
2351 * This way the information is accurate and up-to-date.
2355 p = data + 40; /* Point to last two items. */
2356 p = store_long(p, ppp->stats.ppp_opackets + 1);
2357 p = store_long(p, ppp->stats.ppp_ooctects + count);
2358 ++ppp->stats.ppp_olqrs;
2363 * Outbound compression control frames
2365 ppp_proto_ccp(ppp, data + PPP_HDRLEN, count - PPP_HDRLEN, 0);
2372 * Compress the whole frame if possible.
2374 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2375 (ppp->sc_xc_state != (void *) 0) &&
2376 (proto != PPP_LCP) &&
2377 (proto != PPP_CCP)) {
2378 struct sk_buff *new_skb;
2381 /* Allocate an skb for the compressed frame. */
2382 new_skb = alloc_skb(ppp->mtu + PPP_HDRLEN, GFP_ATOMIC);
2383 if (new_skb == NULL) {
2384 printk(KERN_ERR "ppp_send_frame: no memory\n");
2389 LIBERATE_SKB(new_skb);
2391 /* Compress the frame. */
2392 new_count = (*ppp->sc_xcomp->compress)
2393 (ppp->sc_xc_state, data, new_skb->data,
2394 count, ppp->mtu + PPP_HDRLEN);
2396 /* Did it compress? */
2397 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2398 skb_put(new_skb, new_count);
2403 * The frame could not be compressed, or it could not
2404 * be sent in compressed form because CCP is down.
2413 ret = ppp_async_send(ppp, skb);
2415 /* we can release the lock */
2417 } else if (ret < 0) {
2418 /* can't happen, since the caller got the xmit_busy lock */
2419 printk(KERN_ERR "ppp: ppp_async_send didn't accept pkt\n");
2424 * Apply VJ TCP header compression to a packet.
2426 static struct sk_buff *
2427 ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb)
2429 __u8 *orig_data, *data;
2430 struct sk_buff *new_skb;
2433 new_skb = alloc_skb(skb->len, GFP_ATOMIC);
2434 if (new_skb == NULL) {
2435 printk(KERN_ERR "ppp: no memory for vj compression\n");
2438 LIBERATE_SKB(new_skb);
2440 orig_data = data = skb->data + PPP_HDRLEN;
2441 len = slhc_compress(ppp->slcomp, data, skb->len - PPP_HDRLEN,
2442 new_skb->data + PPP_HDRLEN, &data,
2443 (ppp->flags & SC_NO_TCP_CCID) == 0);
2445 if (data == orig_data) {
2446 /* Couldn't compress the data */
2451 /* The data has been changed */
2452 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2453 proto = PPP_VJC_COMP;
2454 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2456 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2457 proto = PPP_VJC_UNCOMP;
2460 data[0] = orig_data[0];
2463 data = skb_put(new_skb, len + PPP_HDRLEN);
2464 data[0] = PPP_ALLSTATIONS;
2474 ppp_send_frames(struct ppp *ppp)
2476 struct sk_buff *skb;
2478 while (!test_and_set_bit(0, &ppp->xmit_busy)) {
2479 skb = skb_dequeue(&ppp->xmt_q);
2484 ppp_send_frame(ppp, skb);
2486 if (!ppp->xmit_busy && ppp->dev.tbusy) {
2493 * Called from the hardware (tty) layer when it can accept
2497 ppp_output_wakeup(struct ppp *ppp)
2501 if (!ppp->xmit_busy) {
2502 printk(KERN_ERR "ppp_output_wakeup called but xmit_busy==0\n");
2506 ppp_send_frames(ppp);
2510 * Send a control frame (from pppd).
2513 ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb)
2518 * Put the packet on the queue, then send as many as we can.
2520 skb_queue_tail(&ppp->xmt_q, skb);
2521 ppp_send_frames(ppp);
2525 /*************************************************************
2527 * This routine accepts requests from the network layer
2528 * and attempts to deliver the packets.
2529 *************************************************************/
2531 * Send a frame to the peer.
2532 * Returns 1 iff the frame was not accepted.
2535 ppp_dev_xmit(struct sk_buff *skb, struct device *dev)
2537 struct ppp *ppp = dev2ppp(dev);
2538 struct tty_struct *tty = ppp2tty(ppp);
2543 /* just a little sanity check. */
2546 if (skb->data == NULL) {
2552 * Avoid timing problem should tty hangup while data is
2553 * queued to be sent.
2561 * Validate the tty interface
2564 if (ppp->flags & SC_DEBUG)
2566 "ppp_dev_xmit: %s not connected to a TTY!\n",
2573 * Work out the appropriate network-protocol mode for this packet.
2575 npmode = NPMODE_PASS; /* default */
2576 switch (ntohs(skb->protocol)) {
2579 npmode = ppp->sc_npmode[NP_IP];
2583 npmode = ppp->sc_npmode[NP_IPV6];
2587 npmode = ppp->sc_npmode[NP_IPX];
2592 npmode = ppp->sc_npmode[NP_AT];
2595 if (ppp->flags & SC_DEBUG)
2596 printk(KERN_INFO "%s: packet for unknown proto %x\n",
2597 ppp->name, ntohs(skb->protocol));
2603 * Drop, accept or reject the packet depending on the mode.
2611 * We may not send the packet now, so drop it.
2612 * XXX It would be nice to be able to return it to the
2613 * network system to be queued and retransmitted later.
2615 if (ppp->flags & SC_DEBUG)
2616 printk(KERN_DEBUG "%s: returning frame\n", ppp->name);
2622 if (ppp->flags & SC_DEBUG)
2624 "ppp_dev_xmit: dropping (npmode = %d) on %s\n",
2631 * The dev->tbusy field acts as a lock to allow only
2632 * one packet to be processed at a time. If we can't
2633 * get the lock, try again later.
2634 * We deliberately queue as little as possible inside
2635 * the ppp driver in order to minimize the latency
2636 * for high-priority packets.
2638 if (test_and_set_bit(0, &ppp->xmit_busy)) {
2639 dev->tbusy = 1; /* can't take it now */
2645 * Put the 4-byte PPP header on the packet.
2646 * If there isn't room for it, we have to copy the packet.
2648 if (skb_headroom(skb) < PPP_HDRLEN) {
2649 struct sk_buff *new_skb;
2651 new_skb = alloc_skb(skb->len + PPP_HDRLEN, GFP_ATOMIC);
2652 if (new_skb == NULL) {
2653 printk(KERN_ERR "%s: skb hdr alloc failed\n",
2657 ppp_send_frames(ppp);
2660 LIBERATE_SKB(new_skb);
2661 skb_reserve(new_skb, PPP_HDRLEN);
2662 memcpy(skb_put(new_skb, skb->len), skb->data, skb->len);
2667 hdr = skb_push(skb, PPP_HDRLEN);
2668 hdr[0] = PPP_ALLSTATIONS;
2670 hdr[2] = proto >> 8;
2673 ppp_send_frame(ppp, skb);
2674 if (!ppp->xmit_busy)
2675 ppp_send_frames(ppp);
2679 #if LINUX_VERSION_CODE < VERSION(2,1,15)
2681 * Null hard_header and header_rebuild routines.
2683 static int ppp_dev_header(struct sk_buff *skb, struct device *dev,
2684 unsigned short type, void *daddr,
2685 void *saddr, unsigned int len)
2690 static int ppp_dev_rebuild(void *eth, struct device *dev,
2691 unsigned long raddr, struct sk_buff *skb)
2695 #endif /* < 2.1.15 */
2698 * Generate the statistic information for the /proc/net/dev listing.
2700 static struct net_device_stats *
2701 ppp_dev_stats (struct device *dev)
2703 struct ppp *ppp = dev2ppp (dev);
2705 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
2706 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
2707 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
2708 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
2709 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
2710 ppp->estats.rx_bytes = ppp->stats.ppp_ibytes;
2711 ppp->estats.tx_bytes = ppp->stats.ppp_obytes;
2714 return &ppp->estats;
2717 /*************************************************************
2719 * Miscellany called by various functions above.
2720 *************************************************************/
2722 /* Locate the previous instance of the PPP channel */
2724 ppp_find(int pid_value)
2728 /* try to find the device which this pid is already using */
2729 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2730 if (ppp->inuse && ppp->sc_xfer == pid_value) {
2738 /* allocate or create a PPP channel */
2747 /* try to find an free device */
2748 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2749 if (!test_and_set_bit(0, &ppp->inuse)) {
2751 if (dev->flags & IFF_UP) {
2752 clear_bit(0, &ppp->inuse);
2755 /* Reregister device */
2756 unregister_netdev(dev);
2757 if (register_netdev(dev) == 0)
2759 printk(KERN_DEBUG "could not reregister ppp device\n");
2760 /* leave inuse set in this case */
2765 * There are no available units, so make a new one.
2767 ppp = (struct ppp *) kmalloc(sizeof(struct ppp), GFP_KERNEL);
2769 printk(KERN_ERR "ppp: struct ppp allocation failed\n");
2772 memset(ppp, 0, sizeof(*ppp));
2774 /* initialize channel control data */
2775 ppp->magic = PPP_MAGIC;
2778 ppp->read_wait = NULL;
2781 * Make up a suitable name for this device
2784 dev->name = ppp->name;
2785 #if LINUX_VERSION_CODE < VERSION(2,1,31)
2786 if_num = (ppp_list == 0)? 0: ppp_last->line + 1;
2787 sprintf(ppp->name, "ppp%d", if_num);
2789 if_num = dev_alloc_name(dev, "ppp%d");
2792 printk(KERN_ERR "ppp: dev_alloc_name failed (%d)\n", if_num);
2800 dev->init = ppp_init_dev;
2801 dev->name = ppp->name;
2802 dev->priv = (void *) ppp;
2804 /* register device so that we can be ifconfig'd */
2805 /* ppp_init_dev() will be called as a side-effect */
2806 status = register_netdev (dev);
2808 printk(KERN_INFO "registered device %s\n", dev->name);
2811 "ppp_alloc - register_netdev(%s) = %d failure.\n",
2817 /* link this unit into our list */
2821 ppp_last->next = ppp;
2828 * Initialize the generic parts of the ppp structure.
2831 ppp_generic_init(struct ppp *ppp)
2839 skb_queue_head_init(&ppp->xmt_q);
2840 skb_queue_head_init(&ppp->rcv_q);
2842 ppp->last_xmit = jiffies;
2843 ppp->last_recv = jiffies;
2846 /* clear statistics */
2847 memset(&ppp->stats, 0, sizeof (struct pppstat));
2848 memset(&ppp->estats, 0, sizeof(struct net_device_stats));
2850 /* PPP compression data */
2851 ppp->sc_xc_state = NULL;
2852 ppp->sc_rc_state = NULL;
2854 for (indx = 0; indx < NUM_NP; ++indx)
2855 ppp->sc_npmode[indx] = NPMODE_PASS;
2859 * Called to clean up the generic parts of the ppp structure.
2862 ppp_release(struct ppp *ppp)
2864 struct sk_buff *skb;
2866 CHECK_PPP_MAGIC(ppp);
2868 if (ppp->flags & SC_DEBUG)
2869 printk(KERN_DEBUG "%s released\n", ppp->name);
2871 ppp_ccp_closed(ppp);
2873 /* Ensure that the pppd process is not hanging on select()/poll() */
2874 wake_up_interruptible(&ppp->read_wait);
2877 slhc_free(ppp->slcomp);
2881 while ((skb = skb_dequeue(&ppp->rcv_q)) != NULL)
2883 while ((skb = skb_dequeue(&ppp->xmt_q)) != NULL)
2887 if (ppp->dev.tbusy) {
2894 * Utility procedures to print a buffer in hex/ascii
2897 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
2899 register __u8 next_ch;
2900 static char hex[] = "0123456789ABCDEF";
2902 while (count-- > 0) {
2904 *out++ = hex[(next_ch >> 4) & 0x0F];
2905 *out++ = hex[next_ch & 0x0F];
2911 ppp_print_char (register __u8 * out, const __u8 * in, int count)
2913 register __u8 next_ch;
2915 while (count-- > 0) {
2918 if (next_ch < 0x20 || next_ch > 0x7e)
2922 if (next_ch == '%') /* printk/syslogd has a bug !! */
2930 ppp_print_buffer (const char *name, const __u8 *buf, int count)
2935 printk(KERN_DEBUG "ppp: %s, count = %d\n", name, count);
2938 memset (line, 32, 44);
2939 ppp_print_hex (line, buf, 8);
2940 ppp_print_char (&line[8 * 3], buf, 8);
2941 printk(KERN_DEBUG "%s\n", line);
2947 memset (line, 32, 44);
2948 ppp_print_hex (line, buf, count);
2949 ppp_print_char (&line[8 * 3], buf, count);
2950 printk(KERN_DEBUG "%s\n", line);
2954 /*************************************************************
2955 * Compressor module interface
2956 *************************************************************/
2958 struct compressor_link {
2959 struct compressor_link *next;
2960 struct compressor *comp;
2963 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
2965 static struct compressor *find_compressor (int type)
2967 struct compressor_link *lnk;
2968 unsigned long flags;
2973 lnk = ppp_compressors;
2974 while (lnk != (struct compressor_link *) 0) {
2975 if ((int) (__u8) lnk->comp->compress_proto == type) {
2976 restore_flags(flags);
2982 restore_flags(flags);
2983 return (struct compressor *) 0;
2986 #ifdef CONFIG_MODULES
2987 static int ppp_register_compressor (struct compressor *cp)
2989 struct compressor_link *new;
2990 unsigned long flags;
2992 new = (struct compressor_link *)
2993 kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
2995 if (new == (struct compressor_link *) 0)
3001 if (find_compressor (cp->compress_proto)) {
3002 restore_flags(flags);
3007 new->next = ppp_compressors;
3009 ppp_compressors = new;
3011 restore_flags(flags);
3015 static void ppp_unregister_compressor (struct compressor *cp)
3017 struct compressor_link *prev = (struct compressor_link *) 0;
3018 struct compressor_link *lnk;
3019 unsigned long flags;
3024 lnk = ppp_compressors;
3025 while (lnk != (struct compressor_link *) 0) {
3026 if (lnk->comp == cp) {
3028 prev->next = lnk->next;
3030 ppp_compressors = lnk->next;
3037 restore_flags(flags);
3041 /*************************************************************
3042 * Module support routines
3043 *************************************************************/
3051 /* register our line disciplines */
3052 status = ppp_first_time();
3054 printk(KERN_INFO "PPP: ppp_init() failure %d\n", status);
3055 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3057 (void) register_symtab (&ppp_syms);
3064 cleanup_module(void)
3067 struct ppp *ppp, *next_ppp;
3071 * Ensure that the devices are not in operation.
3073 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3074 CHECK_PPP_MAGIC(ppp);
3075 if (ppp->inuse || (ppp->dev.flags & IFF_UP))
3079 printk(KERN_CRIT "PPP: removing despite %d units in use!\n",
3083 * Release the tty registration of the line discipline so that
3084 * ttys can no longer be put into PPP line discipline.
3086 status = tty_register_ldisc (N_PPP, NULL);
3089 "PPP: Unable to unregister ppp line discipline "
3090 "(err = %d)\n", status);
3093 "PPP: ppp line discipline successfully unregistered\n");
3096 * De-register the devices so that there is no problem with them
3098 for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3099 next_ppp = ppp->next;
3100 unregister_netdev(&ppp->dev);