3 * Michael Callahan <callahan@maths.ox.ac.uk>
4 * Al Longyear <longyear@netcom.com>
5 * Paul Mackerras <Paul.Mackerras@cs.anu.edu.au>
7 * Dynamic PPP devices by Jim Freeman <jfree@caldera.com>.
8 * ppp_tty_receive ``noisy-raise-bug'' fixed by Ove Ewerlid <ewerlid@syscon.uu.se>
10 * ==FILEVERSION 971205==
12 * NOTE TO MAINTAINERS:
13 * If you modify this file at all, please set the number above to the
14 * date of the modification as YYMMDD (year month day).
15 * ppp.c is shipped with a PPP distribution as well as with the kernel;
16 * if everyone increases the FILEVERSION number above, then scripts
17 * can do the right thing when deciding whether to install a new ppp.c
18 * file. Don't change the format of that line otherwise, so the
19 * installation script can recognize it.
27 RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
28 Multi-protocol Datagrams over Point-to-Point Links
34 Flags for this module (any combination is acceptable for testing.):
36 OPTIMIZE_FLAG_TIME - Number of jiffies to force sending of leading flag
37 character. This is normally set to ((HZ * 3) / 2).
38 This is 1.5 seconds. If zero then the leading
41 CHECK_CHARACTERS - Enable the checking on all received characters for
42 8 data bits, no parity. This adds a small amount of
43 processing for each received character.
46 #define OPTIMIZE_FLAG_TIME ((HZ * 3)/2)
48 #define CHECK_CHARACTERS 1
49 #define PPP_COMPRESS 1
51 /* $Id: ppp.c,v 1.15 1998/02/04 01:38:11 paulus Exp $ */
53 #include <linux/version.h>
54 #include <linux/module.h>
55 #include <linux/kernel.h>
56 #include <linux/sched.h>
57 #include <linux/types.h>
58 #include <linux/fcntl.h>
59 #include <linux/interrupt.h>
60 #include <linux/ptrace.h>
63 /* a nice define to generate linux version numbers */
64 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
66 #if LINUX_VERSION_CODE < VERSION(2,1,14)
67 #include <linux/ioport.h>
70 #if LINUX_VERSION_CODE >= VERSION(2,1,23)
71 #include <linux/poll.h>
75 #include <linux/malloc.h>
76 #include <linux/tty.h>
77 #include <linux/errno.h>
78 #include <linux/sched.h> /* to get the struct task_struct */
79 #include <linux/string.h> /* used in new tty drivers */
80 #include <linux/signal.h> /* used in new tty drivers */
81 #include <asm/system.h>
82 #include <asm/bitops.h>
84 #include <linux/if_ether.h>
85 #include <linux/netdevice.h>
86 #include <linux/skbuff.h>
88 #if LINUX_VERSION_CODE >= VERSION(2,1,68)
89 #include <linux/rtnetlink.h>
92 #include <linux/inet.h>
93 #include <linux/ioctl.h>
95 typedef struct sk_buff sk_buff;
96 #define skb_data(skb) ((__u8 *) (skb)->data)
99 #include <linux/tcp.h>
100 #include <linux/if_arp.h>
101 #include <net/slhc_vj.h>
103 #define fcstab ppp_crc16_table /* Name of the table in the kernel */
104 #include <linux/ppp_defs.h>
106 #include <linux/socket.h>
107 #include <linux/if_ppp.h>
108 #include <linux/if_pppvar.h>
109 #include <linux/ppp-comp.h>
111 #ifdef CONFIG_KERNELD
112 #include <linux/kerneld.h>
116 #define PPP_IPX 0x2b /* IPX protocol over PPP */
120 #define PPP_LQR 0xc025 /* Link Quality Reporting Protocol */
123 #if LINUX_VERSION_CODE >= VERSION(2,1,4)
124 #include <asm/segment.h>
125 #define GET_USER(error,value,addr) error = get_user(value,addr)
126 #define COPY_FROM_USER(error,dest,src,size) error = copy_from_user(dest,src,size) ? -EFAULT : 0
127 #define PUT_USER(error,value,addr) error = put_user(value,addr)
128 #define COPY_TO_USER(error,dest,src,size) error = copy_to_user(dest,src,size) ? -EFAULT : 0
130 #if LINUX_VERSION_CODE >= VERSION(2,1,5)
131 #include <asm/uaccess.h>
134 #else /* 2.0.x and 2.1.x before 2.1.4 */
136 #define GET_USER(error,value,addr) \
138 error = verify_area (VERIFY_READ, (void *) addr, sizeof (value)); \
140 value = get_user(addr); \
143 #define COPY_FROM_USER(error,dest,src,size) \
145 error = verify_area (VERIFY_READ, (void *) src, size); \
147 memcpy_fromfs (dest, src, size); \
150 #define PUT_USER(error,value,addr) \
152 error = verify_area (VERIFY_WRITE, (void *) addr, sizeof (value)); \
154 put_user (value, addr); \
157 #define COPY_TO_USER(error,dest,src,size) \
159 error = verify_area (VERIFY_WRITE, (void *) dest, size); \
161 memcpy_tofs (dest, src, size); \
166 #if LINUX_VERSION_CODE < VERSION(2,1,37)
167 #define test_and_set_bit(nr, addr) set_bit(nr, addr)
170 #if LINUX_VERSION_CODE < VERSION(2,1,57)
171 #define signal_pending(p) ((p)->signal & ~(p)->blocked)
174 #if LINUX_VERSION_CODE < VERSION(2,1,25)
175 #define net_device_stats enet_statistics
178 #if LINUX_VERSION_CODE < VERSION(2,1,60)
179 typedef int rw_ret_t;
180 typedef unsigned int rw_count_t;
182 typedef ssize_t rw_ret_t;
183 typedef size_t rw_count_t;
186 static int ppp_register_compressor (struct compressor *cp);
187 static void ppp_unregister_compressor (struct compressor *cp);
193 static struct compressor *find_compressor (int type);
194 static void ppp_init_ctrl_blk (register struct ppp *);
195 static void ppp_kick_tty (struct ppp *, struct ppp_buffer *bfr);
196 static struct ppp *ppp_alloc (void);
197 static struct ppp *ppp_find (int pid_value);
198 static void ppp_print_buffer (const __u8 *, const __u8 *, int);
199 extern inline void ppp_stuff_char (struct ppp *ppp,
200 register struct ppp_buffer *buf,
202 extern inline int lock_buffer (register struct ppp_buffer *buf);
203 static int ppp_dev_xmit_ip (struct ppp *ppp, struct ppp_buffer *buf,
204 __u8 *data, int len, enum NPmode npmode);
206 static int rcv_proto_ip (struct ppp *, __u16, __u8 *, int);
207 static int rcv_proto_ipx (struct ppp *, __u16, __u8 *, int);
208 static int rcv_proto_vjc_comp (struct ppp *, __u16, __u8 *, int);
209 static int rcv_proto_vjc_uncomp (struct ppp *, __u16, __u8 *, int);
210 static int rcv_proto_unknown (struct ppp *, __u16, __u8 *, int);
211 static int rcv_proto_lqr (struct ppp *, __u16, __u8 *, int);
212 static void ppp_doframe_lower (struct ppp *, __u8 *, int);
213 static int ppp_doframe (struct ppp *);
215 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd);
216 static int rcv_proto_ccp (struct ppp *, __u16, __u8 *, int);
218 #define ins_char(pbuf,c) (buf_base(pbuf) [(pbuf)->count++] = (__u8)(c))
220 #ifndef OPTIMIZE_FLAG_TIME
221 #define OPTIMIZE_FLAG_TIME 0
225 * Parameters which may be changed via insmod.
228 static int flag_time = OPTIMIZE_FLAG_TIME;
230 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
231 MODULE_PARM(flag_time, "i");
235 * The "main" procedure to the ppp device
238 int ppp_init (struct device *);
241 * Network device driver callback routines
244 static int ppp_dev_open (struct device *);
245 static int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
246 static int ppp_dev_close (struct device *);
247 static int ppp_dev_xmit (sk_buff *, struct device *);
248 static struct net_device_stats *ppp_dev_stats (struct device *);
250 #if LINUX_VERSION_CODE < VERSION(2,1,15)
251 static int ppp_dev_header (sk_buff *, struct device *, __u16,
252 void *, void *, unsigned int);
253 static int ppp_dev_rebuild (void *eth, struct device *dev,
254 unsigned long raddr, struct sk_buff *skb);
261 static rw_ret_t ppp_tty_read(struct tty_struct *, struct file *, __u8 *,
263 static rw_ret_t ppp_tty_write(struct tty_struct *, struct file *, const __u8 *,
265 static int ppp_tty_ioctl (struct tty_struct *, struct file *, unsigned int,
267 #if LINUX_VERSION_CODE < VERSION(2,1,23)
268 static int ppp_tty_select (struct tty_struct *tty, struct inode *inode,
269 struct file *filp, int sel_type, select_table * wait);
271 static unsigned int ppp_tty_poll (struct tty_struct *tty, struct file *filp, poll_table * wait);
273 static int ppp_tty_open (struct tty_struct *);
274 static void ppp_tty_close (struct tty_struct *);
275 static int ppp_tty_room (struct tty_struct *tty);
276 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
277 char *fp, int count);
278 static void ppp_tty_wakeup (struct tty_struct *tty);
280 #define CHECK_PPP_MAGIC(ppp) do { \
281 if (ppp->magic != PPP_MAGIC) { \
282 printk(KERN_WARNING "bad magic for ppp %p at %s:%d\n", \
283 ppp, __FILE__, __LINE__); \
286 #define CHECK_PPP(a) do { \
287 CHECK_PPP_MAGIC(ppp); \
289 printk (ppp_warning, __LINE__); \
293 #define CHECK_PPP_VOID() do { \
294 CHECK_PPP_MAGIC(ppp); \
296 printk (ppp_warning, __LINE__); \
300 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
301 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
302 ppp->recv_async_map & (1 << (c)))
304 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
306 #define tty2ppp(tty) ((struct ppp *) ((tty)->disc_data))
307 #define dev2ppp(dev) ((struct ppp *) ((dev)->priv))
308 #define ppp2tty(ppp) ((ppp)->tty)
309 #define ppp2dev(ppp) (&(ppp)->dev)
311 static struct ppp *ppp_list = NULL;
312 static struct ppp *ppp_last = NULL;
315 #define BUFFER_TYPE_DEV_RD 0 /* ppp read buffer */
316 #define BUFFER_TYPE_TTY_WR 1 /* tty write buffer */
317 #define BUFFER_TYPE_DEV_WR 2 /* ppp write buffer */
318 #define BUFFER_TYPE_TTY_RD 3 /* tty read buffer */
319 #define BUFFER_TYPE_VJ 4 /* vj compression buffer */
321 /* Define this string only once for all macro invocations */
322 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
324 static char szVersion[] = PPP_VERSION;
327 * Information for the protocol decoder
330 typedef int (*pfn_proto) (struct ppp *, __u16, __u8 *, int);
332 typedef struct ppp_proto_struct {
338 ppp_proto_type proto_list[] = {
339 { PPP_IP, rcv_proto_ip },
340 { PPP_IPX, rcv_proto_ipx },
341 { PPP_VJC_COMP, rcv_proto_vjc_comp },
342 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
343 { PPP_LQR, rcv_proto_lqr },
344 { PPP_CCP, rcv_proto_ccp },
345 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
348 __u16 ppp_crc16_table[256] =
350 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
351 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
352 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
353 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
354 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
355 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
356 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
357 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
358 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
359 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
360 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
361 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
362 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
363 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
364 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
365 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
366 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
367 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
368 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
369 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
370 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
371 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
372 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
373 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
374 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
375 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
376 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
377 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
378 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
379 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
380 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
381 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
384 #ifdef CHECK_CHARACTERS
385 static __u32 paritytab[8] =
387 0x96696996, 0x69969669, 0x69969669, 0x96696996,
388 0x69969669, 0x96696996, 0x96696996, 0x69969669
392 /* local function to store a value into the LQR frame */
393 extern inline __u8 * store_long (register __u8 *p, register int value) {
394 *p++ = (__u8) (value >> 24);
395 *p++ = (__u8) (value >> 16);
396 *p++ = (__u8) (value >> 8);
401 /*************************************************************
403 *************************************************************/
405 /* This procedure is called once and once only to define who we are to
406 * the operating system and the various procedures that it may use in
407 * accessing the ppp protocol.
411 ppp_first_time (void)
413 static struct tty_ldisc ppp_ldisc;
417 "PPP: version %s (demand dialling)"
420 #ifndef MODULE /* slhc module logic has its own copyright announcement */
422 "TCP compression code copyright 1989 Regents of the "
423 "University of California\n");
427 * Register the tty discipline
429 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
430 ppp_ldisc.magic = TTY_LDISC_MAGIC;
431 #if LINUX_VERSION_CODE >= VERSION(2,1,28)
432 ppp_ldisc.name = "ppp";
434 ppp_ldisc.open = ppp_tty_open;
435 ppp_ldisc.close = ppp_tty_close;
436 ppp_ldisc.read = ppp_tty_read;
437 ppp_ldisc.write = ppp_tty_write;
438 ppp_ldisc.ioctl = ppp_tty_ioctl;
439 #if LINUX_VERSION_CODE < VERSION(2,1,23)
440 ppp_ldisc.select = ppp_tty_select;
442 ppp_ldisc.poll = ppp_tty_poll;
444 ppp_ldisc.receive_room = ppp_tty_room;
445 ppp_ldisc.receive_buf = ppp_tty_receive;
446 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
448 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
450 printk (KERN_INFO "PPP line discipline registered.\n");
452 printk (KERN_ERR "error registering line discipline: %d\n",
457 /*************************************************************
459 *************************************************************/
461 /* called when the device is actually created */
464 ppp_init_dev (struct device *dev)
466 #if LINUX_VERSION_CODE < VERSION(2,1,15)
467 dev->hard_header = ppp_dev_header;
468 dev->rebuild_header = ppp_dev_rebuild;
471 dev->hard_header_len = PPP_HDRLEN;
475 dev->hard_start_xmit = ppp_dev_xmit;
476 dev->open = ppp_dev_open;
477 dev->stop = ppp_dev_close;
478 dev->get_stats = ppp_dev_stats;
479 dev->do_ioctl = ppp_dev_ioctl;
481 dev->tx_queue_len = 10;
482 dev->type = ARPHRD_PPP;
484 #if LINUX_VERSION_CODE < VERSION(2,1,20)
488 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
489 skb_queue_head_init (&dev->buffs[indx]);
492 dev_init_buffers(dev);
495 /* New-style flags */
496 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
497 #if LINUX_VERSION_CODE < VERSION(2,1,67)
498 dev->family = AF_INET;
502 dev->pa_alen = 4; /* sizeof (__u32) */
509 * Local procedure to initialize the ppp structure
513 ppp_init_ctrl_blk (register struct ppp *ppp)
515 ppp->magic = PPP_MAGIC;
523 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
524 ppp->xmit_async_map[0] = 0xffffffff;
525 ppp->xmit_async_map[3] = 0x60000000;
526 ppp->recv_async_map = 0x00000000;
533 ppp->read_wait = NULL;
534 ppp->write_wait = NULL;
535 ppp->last_xmit = jiffies - flag_time;
536 ppp->last_recv = jiffies;
538 /* clear statistics */
539 memset(&ppp->stats, 0, sizeof (struct pppstat));
540 memset(&ppp->estats, 0, sizeof(ppp->estats));
542 /* PPP compression data */
544 ppp->sc_rc_state = NULL;
547 #if LINUX_VERSION_CODE < VERSION(2,1,18)
548 static struct symbol_table ppp_syms = {
549 #include <linux/symtab_begin.h>
550 X(ppp_register_compressor),
551 X(ppp_unregister_compressor),
553 #include <linux/symtab_end.h>
556 EXPORT_SYMBOL(ppp_register_compressor);
557 EXPORT_SYMBOL(ppp_unregister_compressor);
558 EXPORT_SYMBOL(ppp_crc16_table);
561 /* called at boot/load time for each ppp device defined in the kernel */
565 ppp_init (struct device *dev)
567 static int first_time = 1;
572 answer = ppp_first_time();
573 #if LINUX_VERSION_CODE < VERSION(2,1,18)
575 (void) register_symtab (&ppp_syms);
584 #define BUFFER_MAGIC 0x1d10
585 #define CHECK_BUF_MAGIC(buf) do { \
586 if (buf->magic != BUFFER_MAGIC) { \
587 printk(KERN_WARNING "bad magic for ppp buffer %p at %s:%d\n", \
588 buf, __FILE__, __LINE__); \
593 * Routine to allocate a buffer for later use by the driver.
596 static struct ppp_buffer *
597 ppp_alloc_buf (int size, int type)
599 struct ppp_buffer *buf;
601 buf = (struct ppp_buffer *) kmalloc (size + sizeof (struct ppp_buffer),
605 buf->size = size - 1; /* Mask for the buffer size */
611 buf->fcs = PPP_INITFCS;
612 buf->magic = BUFFER_MAGIC;
618 * Routine to release the allocated buffer.
622 ppp_free_buf (struct ppp_buffer *ptr)
625 CHECK_BUF_MAGIC(ptr);
631 * Lock the indicated transmit buffer
635 lock_buffer (register struct ppp_buffer *buf)
640 * Save the current state and if free then set it to the "busy" state
642 CHECK_BUF_MAGIC(buf);
649 restore_flags (flags);
654 * MTU has been changed by the IP layer. Unfortunately we are not told
655 * about this, but we spot it ourselves and fix things up. We could be
656 * in an upcall from the tty driver, or in an ip packet queue.
660 ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
665 struct ppp_buffer *new_rbuf;
666 struct ppp_buffer *new_wbuf;
667 struct ppp_buffer *new_cbuf;
668 struct ppp_buffer *new_tbuf;
670 struct ppp_buffer *old_rbuf;
671 struct ppp_buffer *old_wbuf;
672 struct ppp_buffer *old_cbuf;
673 struct ppp_buffer *old_tbuf;
677 * Allocate the buffer from the kernel for the data
681 if (ppp->flags & SC_DEBUG)
682 printk(KERN_DEBUG "%s: changedmtu %d %d\n", ppp->name,
685 /* allow for possible escaping of every character */
686 mtu = (new_mtu * 2) + 20;
688 /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
694 new_wbuf = ppp_alloc_buf (mtu+PPP_HDRLEN, BUFFER_TYPE_DEV_WR);
695 new_tbuf = ppp_alloc_buf ((PPP_MTU * 2) + 24, BUFFER_TYPE_TTY_WR);
696 new_rbuf = ppp_alloc_buf (mru + 84, BUFFER_TYPE_DEV_RD);
697 new_cbuf = ppp_alloc_buf (mru+PPP_HDRLEN, BUFFER_TYPE_VJ);
699 * If the buffers failed to allocate then complain and release the partial
702 if (new_wbuf == NULL || new_tbuf == NULL ||
703 new_rbuf == NULL || new_cbuf == NULL) {
704 if (ppp->flags & SC_DEBUG)
706 "ppp: failed to allocate new buffers\n");
708 ppp_free_buf (new_wbuf);
709 ppp_free_buf (new_tbuf);
710 ppp_free_buf (new_rbuf);
711 ppp_free_buf (new_cbuf);
715 * Update the pointers to the new buffer structures.
719 old_wbuf = ppp->wbuf;
720 old_rbuf = ppp->rbuf;
721 old_cbuf = ppp->cbuf;
722 old_tbuf = ppp->tbuf;
724 ppp->wbuf = new_wbuf;
725 ppp->rbuf = new_rbuf;
726 ppp->cbuf = new_cbuf;
727 ppp->tbuf = new_tbuf;
730 new_wbuf->locked = old_wbuf->locked;
732 ppp->rbuf->size -= 80; /* reserve space for vj header expansion */
734 dev->mem_start = (unsigned long) buf_base (new_wbuf);
735 dev->mem_end = (unsigned long) (dev->mem_start + mtu);
736 dev->rmem_start = (unsigned long) buf_base (new_rbuf);
737 dev->rmem_end = (unsigned long) (dev->rmem_start + mru);
739 * Update the parameters for the new buffer sizes
741 ppp->toss = 0xE0; /* To ignore characters until new FLAG */
742 ppp->escape = 0; /* No pending escape character */
752 ppp->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
753 ppp->flags &= ~SC_XMIT_BUSY;
755 restore_flags(flags);
757 * Release old buffer pointers
759 ppp_free_buf (old_rbuf);
760 ppp_free_buf (old_wbuf);
761 ppp_free_buf (old_cbuf);
762 ppp_free_buf (old_tbuf);
767 * CCP is down; free (de)compressor state if necessary.
771 ppp_ccp_closed (struct ppp *ppp)
777 ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
778 restore_flags(flags);
779 if (ppp->flags & SC_DEBUG)
780 printk(KERN_DEBUG "%s: ccp closed\n", ppp->name);
781 if (ppp->sc_xc_state) {
782 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
783 ppp->sc_xc_state = NULL;
786 if (ppp->sc_rc_state) {
787 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
788 ppp->sc_rc_state = NULL;
793 * Called to release all of the information in the current PPP structure.
795 * It is called when the ppp device goes down or if it is unable to go
800 ppp_release (struct ppp *ppp)
802 struct tty_struct *tty;
805 CHECK_PPP_MAGIC(ppp);
809 if (ppp->flags & SC_DEBUG)
810 printk(KERN_DEBUG "%s released\n", ppp->name);
812 ppp_ccp_closed (ppp);
814 /* Ensure that the pppd process is not hanging on select()/poll() */
815 wake_up_interruptible (&ppp->read_wait);
816 wake_up_interruptible (&ppp->write_wait);
818 if (tty != NULL && tty->disc_data == ppp)
819 tty->disc_data = NULL; /* Break the tty->ppp link */
821 #if LINUX_VERSION_CODE >= VERSION(2,1,68)
824 /* Strong layering violation. */
825 if (dev && dev->flags & IFF_UP) {
826 dev_close (dev); /* close the device properly */
828 #if LINUX_VERSION_CODE >= VERSION(2,1,68)
832 ppp_free_buf (ppp->rbuf);
833 ppp_free_buf (ppp->wbuf);
834 ppp_free_buf (ppp->cbuf);
835 ppp_free_buf (ppp->ubuf);
836 ppp_free_buf (ppp->tbuf);
848 slhc_free (ppp->slcomp);
854 ppp->backup_tty = NULL;
860 * Called when the line discipline is changed to something
861 * else, the tty is closed, or the tty detects a hangup.
865 ppp_tty_close (struct tty_struct *tty)
867 struct ppp *ppp = tty2ppp (tty);
870 if (ppp->magic != PPP_MAGIC) {
871 if (ppp->flags & SC_DEBUG)
873 "ppp: trying to close unopened tty!\n");
877 tty->disc_data = NULL;
878 if (tty == ppp->backup_tty)
882 if (ppp->backup_tty) {
883 ppp->tty = ppp->backup_tty;
886 if (ppp->flags & SC_DEBUG)
887 printk (KERN_INFO "ppp: channel %s closing.\n",
898 * Called when the tty discipline is switched to PPP.
902 ppp_tty_open (struct tty_struct *tty)
904 struct ppp *ppp = tty2ppp (tty);
907 * There should not be an existing table for this slot.
910 if (ppp->flags & SC_DEBUG)
912 "ppp_tty_open: gack! tty already associated to %s!\n",
913 ppp->magic == PPP_MAGIC ? ppp2dev(ppp)->name
918 * Allocate the structure from the system
920 ppp = ppp_find(current->pid);
923 * If we are taking over a ppp unit which is currently
924 * connected to a loopback pty, there's not much to do.
927 tty->disc_data = ppp;
933 if (ppp->flags & SC_DEBUG)
934 printk (KERN_ERR "ppp_alloc failed\n");
938 * Initialize the control block
940 ppp_init_ctrl_blk (ppp);
941 tty->disc_data = ppp;
944 * Allocate space for the default VJ header compression slots
946 ppp->slcomp = slhc_init (16, 16);
947 if (ppp->slcomp == NULL) {
948 if (ppp->flags & SC_DEBUG)
949 printk (KERN_ERR "ppp_tty_open: "
950 "no space for compression buffers!\n");
955 * Allocate space for the MTU and MRU buffers
957 if (ppp_changedmtu (ppp, ppp2dev(ppp)->mtu, ppp->mru) == 0) {
962 * Allocate space for a user level buffer
964 ppp->ubuf = ppp_alloc_buf (RBUFSIZE, BUFFER_TYPE_TTY_RD);
965 if (ppp->ubuf == NULL) {
966 if (ppp->flags & SC_DEBUG)
967 printk (KERN_ERR "ppp_tty_open: "
968 "no space for user receive buffer\n");
973 if (ppp->flags & SC_DEBUG)
974 printk (KERN_INFO "ppp: channel %s open\n",
977 for (indx = 0; indx < NUM_NP; ++indx)
978 ppp->sc_npmode[indx] = NPMODE_PASS;
983 * Flush any pending characters in the driver and discipline.
985 if (tty->ldisc.flush_buffer)
986 tty->ldisc.flush_buffer (tty);
988 if (tty->driver.flush_buffer)
989 tty->driver.flush_buffer (tty);
994 * Local function to send the next portion of the buffer.
996 * Called by the tty driver's tty_wakeup function should it be entered
997 * because the partial buffer was transmitted.
999 * Called by kick_tty to send the initial portion of the buffer.
1001 * Completion processing of the buffer transmission is handled here.
1005 ppp_tty_wakeup_code (struct ppp *ppp, struct tty_struct *tty,
1006 struct ppp_buffer *xbuf)
1008 register int count, actual;
1009 unsigned long flags;
1012 CHECK_BUF_MAGIC(xbuf);
1014 * Prevent re-entrancy by ensuring that this routine is called only once.
1018 if (ppp->flags & SC_XMIT_BUSY) {
1019 restore_flags(flags);
1022 ppp->flags |= SC_XMIT_BUSY;
1023 restore_flags(flags);
1025 * Send the next block of data to the modem
1027 count = xbuf->count - xbuf->tail;
1028 actual = tty->driver.write (tty, 0,
1029 buf_base (xbuf) + xbuf->tail, count);
1031 * Terminate transmission of any block which may have an error.
1032 * This could occur should the carrier drop.
1035 ppp->stats.ppp_oerrors++;
1038 ppp->bytes_sent += actual;
1040 * If the buffer has been transmitted then clear the indicators.
1042 xbuf->tail += actual;
1043 if (actual == count) {
1045 ppp->flags &= ~SC_XMIT_BUSY;
1047 * Complete the transmission on the current buffer.
1051 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1055 * If the completed buffer came from the device write, then complete the
1056 * transmission block.
1058 ppp2dev (ppp)->tbusy = 0;
1061 * Wake up the transmission queue for all completion events.
1063 wake_up_interruptible (&ppp->write_wait);
1065 * Look at the priorities. Choose a daemon write over the device driver.
1076 * If there is a pending buffer then transmit it now.
1079 ppp->flags &= ~SC_XMIT_BUSY;
1080 ppp_kick_tty (ppp, xbuf);
1081 restore_flags(flags);
1084 restore_flags(flags);
1088 * Clear the re-entry flag
1090 save_flags(flags); /* &=~ may not be atomic */
1092 ppp->flags &= ~SC_XMIT_BUSY;
1093 restore_flags(flags);
1097 * This function is called by the tty driver when the transmit buffer has
1098 * additional space. It is used by the ppp code to continue to transmit
1099 * the current buffer should the buffer have been partially sent.
1101 * In addition, it is used to send the first part of the buffer since the
1102 * logic and the inter-locking would be identical.
1106 ppp_tty_wakeup (struct tty_struct *tty)
1108 struct ppp_buffer *xbuf;
1109 struct ppp *ppp = tty2ppp (tty);
1115 if (tty != ppp->tty) {
1116 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1120 * Ensure that there is a transmission pending. Clear the re-entry flag if
1121 * there is no pending buffer. Otherwise, send the buffer.
1125 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1127 ppp_tty_wakeup_code (ppp, tty, xbuf);
1131 * This function is called to transmit a buffer to the remote. The buffer
1132 * is placed on the pending queue if there is presently a buffer being
1133 * sent or it is transmitted with the aid of ppp_tty_wakeup.
1137 ppp_kick_tty (struct ppp *ppp, struct ppp_buffer *xbuf)
1139 unsigned long flags;
1142 CHECK_BUF_MAGIC(xbuf);
1149 * Control the flags which are best performed with the interrupts masked.
1154 * If the transmitter is busy then place the buffer on the appropriate
1157 if (ppp->xbuf != NULL) {
1158 if (xbuf->type == BUFFER_TYPE_TTY_WR)
1162 restore_flags (flags);
1166 * If the transmitter is not busy then this is the highest priority frame
1168 ppp->flags &= ~SC_XMIT_BUSY;
1169 ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1171 restore_flags (flags);
1173 * Do the "tty wakeup_code" to actually send this buffer.
1175 ppp_tty_wakeup_code (ppp, ppp2tty (ppp), xbuf);
1178 /*************************************************************
1180 * The following functions handle input that arrives from
1181 * the TTY. It recognizes PPP frames and either hands them
1182 * to the network layer or queues them for delivery to a
1183 * user process reading this TTY.
1184 *************************************************************/
1187 * Callback function from tty driver. Return the amount of space left
1188 * in the receiver's buffer to decide if remote transmitter is to be
1193 ppp_tty_room (struct tty_struct *tty)
1195 return 65536; /* We can handle an infinite amount of data. :-) */
1199 * Callback function when data is available at the tty driver.
1202 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1203 char *flags, int count)
1205 register struct ppp *ppp = tty2ppp (tty);
1206 register struct ppp_buffer *buf = NULL;
1212 * This can happen if stuff comes in on the backup tty.
1214 if (ppp == 0 || tty != ppp->tty)
1217 * Fetch the pointer to the buffer. Be careful about race conditions.
1223 * Verify the table pointer and ensure that the line is
1224 * still in PPP discipline.
1226 if (ppp->magic != PPP_MAGIC) {
1227 if (ppp->flags & SC_DEBUG)
1229 "PPP: tty_receive called but couldn't find "
1235 * Print the buffer if desired
1237 if (ppp->flags & SC_LOG_RAWIN)
1238 ppp_print_buffer ("receive buffer", data, count);
1241 * Collect the character and error condition for the character. Set the toss
1242 * flag for the first character error.
1244 while (count-- > 0) {
1248 if (*flags && ppp->toss == 0) {
1250 switch (ppp->toss) {
1252 ++ppp->estats.rx_fifo_errors;
1256 ++ppp->estats.rx_frame_errors;
1264 * Set the flags for d7 being 0/1 and parity being even/odd so that
1265 * the normal processing would have all flags set at the end of the
1266 * session. A missing flag bit indicates an error condition.
1269 #ifdef CHECK_CHARACTERS
1271 ppp->flags |= SC_RCV_B7_1;
1273 ppp->flags |= SC_RCV_B7_0;
1275 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1276 ppp->flags |= SC_RCV_ODDP;
1278 ppp->flags |= SC_RCV_EVNP;
1281 * Branch on the character.
1285 * FLAG. This is the end of the block. If the block terminated by ESC FLAG,
1286 * then the block is to be ignored. In addition, characters before the very
1287 * first FLAG are also tossed by this procedure.
1289 case PPP_FLAG: /* PPP_FLAG: end of frame */
1290 ppp->stats.ppp_ibytes += ppp->rbuf->count;
1294 * Process frames which are not to be ignored. If the processing failed,
1295 * then clean up the VJ tables.
1297 if (ppp_doframe (ppp) == 0) {
1298 ++ppp->stats.ppp_ierrors;
1299 slhc_toss (ppp->slcomp);
1302 * Reset all indicators for the new frame to follow.
1305 buf->fcs = PPP_INITFCS;
1310 * All other characters in the data come here. If the character is in the
1311 * receive mask then ignore the character.
1314 /* If we're tossing, look no further. */
1318 /* If this is a control char to be ignored, do so */
1319 if (in_rmap (ppp, chr))
1323 * Modify the next character if preceded by escape.
1324 * The escape character (0x7d) could be an escaped
1325 * 0x5d, if it follows an escape :-)
1330 } else if (chr == PPP_ESCAPE) {
1331 ppp->escape = PPP_TRANS;
1336 * Decompress A/C and protocol compression here.
1338 if (buf->count == 0 && chr != PPP_ALLSTATIONS) {
1339 buf_base(buf)[0] = PPP_ALLSTATIONS;
1340 buf_base(buf)[1] = PPP_UI;
1343 if (buf->count == 2 && (chr & 1) != 0) {
1344 buf_base(buf)[2] = 0;
1348 * If the count sent is within reason then store the character, bump the
1349 * count, and update the FCS for the character.
1351 if (buf->count < buf->size) {
1352 buf_base (buf)[buf->count++] = chr;
1353 buf->fcs = PPP_FCS (buf->fcs, chr);
1357 * The peer sent too much data. Set the flags to discard the current frame
1358 * and wait for the re-synchronization FLAG to be sent.
1360 ++ppp->estats.rx_length_errors;
1367 /* on entry, a received frame is in ppp->rbuf.bufr
1368 check it and dispose as appropriate */
1371 ppp_doframe (struct ppp *ppp)
1373 __u8 *data = buf_base (ppp->rbuf);
1374 int count = ppp->rbuf->count;
1380 CHECK_BUF_MAGIC(ppp->rbuf);
1383 * If there is a pending error from the receiver then log it and discard
1384 * the damaged frame.
1387 if ((ppp->flags & SC_DEBUG) && count > 0)
1389 "ppp_toss: tossing frame, reason = %x\n",
1394 * An empty frame is ignored. This occurs if the FLAG sequence precedes and
1395 * follows each frame.
1400 * Generate an error if the frame is too small.
1402 if (count < PPP_HDRLEN + 2) {
1403 if (ppp->flags & SC_DEBUG)
1405 "ppp: got runt ppp frame, %d chars\n", count);
1406 ++ppp->estats.rx_length_errors;
1410 * Verify the CRC of the frame and discard the CRC characters from the
1411 * end of the buffer.
1413 if (ppp->rbuf->fcs != PPP_GOODFCS) {
1414 if (ppp->flags & SC_DEBUG) {
1416 "ppp: frame with bad fcs, length = %d\n",
1418 ppp_print_buffer("bad frame", data, count);
1420 ++ppp->estats.rx_crc_errors;
1423 count -= 2; /* ignore the fcs characters */
1425 * Obtain the protocol from the frame
1427 proto = PPP_PROTOCOL(data);
1429 * Process the active decompressor.
1431 if ((ppp->sc_rc_state != (void *) 0) &&
1432 (ppp->flags & SC_DECOMP_RUN) &&
1433 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
1434 if (proto == PPP_COMP) {
1436 * If the frame is compressed then decompress it.
1438 new_data = kmalloc (ppp->mru + PPP_HDRLEN, GFP_ATOMIC);
1439 if (new_data == NULL) {
1440 if (ppp->flags & SC_DEBUG)
1442 "ppp_doframe: no memory\n");
1443 new_count = DECOMP_ERROR;
1445 new_count = (*ppp->sc_rcomp->decompress)
1446 (ppp->sc_rc_state, data, count,
1447 new_data, ppp->mru + PPP_HDRLEN);
1449 switch (new_count) {
1451 ppp_doframe_lower (ppp, new_data, new_count);
1456 ppp->flags |= SC_DC_ERROR;
1459 case DECOMP_FATALERROR:
1460 ppp->flags |= SC_DC_FERROR;
1461 if (ppp->flags & SC_DEBUG)
1462 printk(KERN_ERR "ppp: fatal decomp error\n");
1466 * Log the error condition and discard the frame.
1470 slhc_toss (ppp->slcomp);
1471 ++ppp->stats.ppp_ierrors;
1474 * The frame is not special. Pass it through the compressor without
1475 * actually compressing the data
1477 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1482 * Process the uncompressed frame.
1484 ppp_doframe_lower (ppp, data, count);
1488 static void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
1490 __u16 proto = PPP_PROTOCOL (data);
1491 ppp_proto_type *proto_ptr;
1495 * Ignore empty frames
1497 if (count <= PPP_HDRLEN)
1500 * Count the frame and print it
1502 ++ppp->stats.ppp_ipackets;
1503 if (ppp->flags & SC_LOG_INPKT)
1504 ppp_print_buffer ("receive frame", data, count);
1506 * Find the procedure to handle this protocol. The last one is marked
1507 * as a protocol 0 which is the 'catch-all' to feed it to the pppd daemon.
1509 proto_ptr = proto_list;
1510 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
1513 * Update the appropriate statistic counter.
1515 if ((*proto_ptr->func) (ppp, proto,
1517 count - PPP_HDRLEN))
1518 ppp->stats.ppp_ioctects += count;
1520 ++ppp->stats.ppp_discards;
1524 * Put the input frame into the networking system for the indicated protocol
1528 ppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1530 sk_buff *skb = dev_alloc_skb (count);
1532 * Generate a skb buffer for the new frame.
1535 if (ppp->flags & SC_DEBUG)
1537 "ppp_do_ip: packet dropped on %s (no memory)!\n",
1538 ppp2dev (ppp)->name);
1542 * Move the received data from the input buffer to the skb buffer.
1544 skb->dev = ppp2dev (ppp); /* We are the device */
1545 skb->protocol = proto;
1546 skb->mac.raw = skb_data(skb);
1547 memcpy (skb_put(skb,count), data, count); /* move data */
1549 * Tag the frame and kick it to the proper receive routine
1551 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1555 ppp->last_recv = jiffies;
1561 * Process the receipt of an IP frame
1565 rcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1568 if ((ppp2dev (ppp)->flags & IFF_UP) && (count > 0))
1569 if (ppp->sc_npmode[NP_IP] == NPMODE_PASS)
1570 return ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
1575 * Process the receipt of an IPX frame
1579 rcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1582 if (((ppp2dev (ppp)->flags & IFF_UP) != 0) && (count > 0))
1583 return ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
1588 * Process the receipt of an VJ Compressed frame
1592 rcv_proto_vjc_comp (struct ppp *ppp, __u16 proto,
1593 __u8 *data, int count)
1596 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1597 int new_count = slhc_uncompress (ppp->slcomp, data, count);
1598 if (new_count >= 0) {
1599 return rcv_proto_ip (ppp, PPP_IP, data, new_count);
1601 if (ppp->flags & SC_DEBUG)
1603 "ppp: error in VJ decompression\n");
1609 * Process the receipt of an VJ Un-compressed frame
1613 rcv_proto_vjc_uncomp (struct ppp *ppp, __u16 proto,
1614 __u8 *data, int count)
1617 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1618 if (slhc_remember (ppp->slcomp, data, count) > 0) {
1619 return rcv_proto_ip (ppp, PPP_IP, data, count);
1621 if (ppp->flags & SC_DEBUG)
1623 "ppp: error in VJ memorizing\n");
1629 * Receive all unclassified protocols.
1633 rcv_proto_unknown (struct ppp *ppp, __u16 proto,
1634 __u8 *data, int len)
1637 register int current_idx;
1641 buf_base (ppp->ubuf) [current_idx++] = (__u8) (c); \
1642 current_idx &= ppp->ubuf->size; \
1643 if (current_idx == ppp->ubuf->tail) \
1649 * The total length includes the protocol data.
1650 * Lock the user information buffer.
1652 if (test_and_set_bit (0, &ppp->ubuf->locked)) {
1653 if (ppp->flags & SC_DEBUG)
1655 "ppp: rcv_proto_unknown: can't get lock\n");
1657 CHECK_BUF_MAGIC(ppp->ubuf);
1658 current_idx = ppp->ubuf->head;
1660 * Insert the buffer length (not counted), the protocol, and the data
1670 while (totlen-- > 0) {
1675 * The frame is complete. Update the head pointer and wakeup the pppd
1678 ppp->ubuf->head = current_idx;
1680 clear_bit (0, &ppp->ubuf->locked);
1681 wake_up_interruptible (&ppp->read_wait);
1682 if (ppp->tty->fasync != NULL)
1683 kill_fasync (ppp->tty->fasync, SIGIO);
1687 * The buffer is full. Unlock the header
1690 clear_bit (0, &ppp->ubuf->locked);
1691 if (ppp->flags & SC_DEBUG)
1693 "ppp: rcv_proto_unknown: buffer overflow\n");
1696 * Discard the frame. There are no takers for this protocol.
1698 if (ppp->flags & SC_DEBUG)
1700 "ppp: rcv_proto_unknown: dropping packet\n");
1705 * Handle a CCP packet.
1707 * The CCP packet is passed along to the pppd process just like any
1708 * other PPP frame. The difference is that some processing needs to be
1709 * immediate or the compressors will become confused on the peer.
1712 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd)
1714 int slen = CCP_LENGTH(dp);
1715 __u8 *opt = dp + CCP_HDRLEN;
1716 int opt_len = slen - CCP_HDRLEN;
1717 unsigned long flags;
1723 switch (CCP_CODE(dp)) {
1728 * CCP must be going down - disable compression
1730 if (ppp->flags & SC_CCP_UP) {
1732 ppp->flags &= ~(SC_CCP_UP |
1739 if ((ppp->flags & SC_CCP_OPEN) == 0)
1741 if (ppp->flags & SC_CCP_UP)
1743 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1745 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1748 * we're agreeing to send compressed packets.
1751 if (ppp->sc_xc_state == NULL)
1754 if ((*ppp->sc_xcomp->comp_init)
1758 ppp2dev (ppp)->base_addr,
1760 ppp->flags & SC_DEBUG)) {
1761 if (ppp->flags & SC_DEBUG)
1762 printk(KERN_DEBUG "%s: comp running\n",
1765 ppp->flags |= SC_COMP_RUN;
1770 * peer is agreeing to send compressed packets.
1772 if (ppp->sc_rc_state == NULL)
1775 if ((*ppp->sc_rcomp->decomp_init)
1779 ppp2dev (ppp)->base_addr,
1782 ppp->flags & SC_DEBUG)) {
1783 if (ppp->flags & SC_DEBUG)
1784 printk(KERN_DEBUG "%s: decomp running\n",
1787 ppp->flags |= SC_DECOMP_RUN;
1788 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1792 * CCP Reset-ack resets compressors and decompressors as it passes through.
1795 if ((ppp->flags & SC_CCP_UP) == 0)
1799 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
1800 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1801 if (ppp->flags & SC_DEBUG)
1802 printk(KERN_DEBUG "%s: comp reset\n",
1806 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1807 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1808 if (ppp->flags & SC_DEBUG)
1809 printk(KERN_DEBUG "%s: decomp reset\n",
1812 ppp->flags &= ~SC_DC_ERROR;
1817 restore_flags(flags);
1821 rcv_proto_ccp (struct ppp *ppp, __u16 proto, __u8 *dp, int len)
1824 ppp_proto_ccp (ppp, dp, len, 1);
1825 return rcv_proto_unknown (ppp, proto, dp, len);
1829 * Handle a LQR packet.
1833 rcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
1835 return rcv_proto_unknown (ppp, proto, data, len);
1838 /*************************************************************
1839 * LINE DISCIPLINE SUPPORT
1840 * The following functions form support user programs
1841 * which read and write data on a TTY with the PPP line
1842 * discipline. Reading is done from a circular queue,
1843 * filled by the lower TTY levels.
1844 *************************************************************/
1846 /* read a PPP frame from the us_rbuff circular buffer,
1847 waiting if necessary
1851 ppp_tty_read (struct tty_struct *tty, struct file *file, __u8 * buf,
1854 struct ppp *ppp = tty2ppp (tty);
1861 c = buf_base (ppp->ubuf) [ppp->ubuf->tail++]; \
1862 ppp->ubuf->tail &= ppp->ubuf->size; \
1866 * Validate the pointers
1871 /* if (ppp->magic != PPP_MAGIC)
1877 * Before we attempt to write the frame to the user, ensure that the
1878 * user has access to the pages for the total buffer length.
1880 error = verify_area (VERIFY_WRITE, buf, nr);
1885 * Acquire the read lock.
1888 ppp = tty2ppp (tty);
1889 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
1893 if (test_and_set_bit (0, &ppp->ubuf->locked) != 0) {
1895 if (ppp->flags & SC_DEBUG)
1897 "ppp_tty_read: sleeping(ubuf)\n");
1899 current->timeout = 0;
1900 current->state = TASK_INTERRUPTIBLE;
1903 if (signal_pending(current))
1909 * Fetch the length of the buffer from the first two bytes.
1911 if (ppp->ubuf->head == ppp->ubuf->tail)
1923 * If there is no length then wait for the data to arrive.
1926 clear_bit (0, &ppp->ubuf->locked);
1927 if (file->f_flags & O_NONBLOCK)
1929 current->timeout = 0;
1931 if (ppp->flags & SC_DEBUG)
1933 "ppp_tty_read: sleeping(read_wait)\n");
1935 interruptible_sleep_on (&ppp->read_wait);
1936 if (signal_pending(current))
1941 * Ensure that the frame will fit within the caller's buffer. If not, then
1942 * discard the frame from the input buffer.
1945 /* Can't copy it, update us_rbuff_head */
1947 if (ppp->flags & SC_DEBUG)
1949 "ppp: read of %lu bytes too small for %ld "
1950 "frame\n", (unsigned long) nr, (long) len + 2);
1951 ppp->stats.ppp_ierrors++;
1957 * Fake the insertion of the ADDRESS and CONTROL information because these
1958 * were not saved in the buffer.
1960 PUT_USER (error, (u_char) PPP_ALLSTATIONS, buf);
1964 PUT_USER (error, (u_char) PPP_UI, buf);
1970 * Copy the received data from the buffer to the caller's area.
1972 ret = len + 2; /* Account for ADDRESS and CONTROL bytes */
1975 PUT_USER (error, c, buf);
1981 clear_bit (0, &ppp->ubuf->locked);
1985 ppp->ubuf->tail += len;
1986 ppp->ubuf->tail &= ppp->ubuf->size;
1987 clear_bit (0, &ppp->ubuf->locked);
1992 /* stuff a character into the transmit buffer, using PPP's way of escaping
1994 also, update fcs to take account of new character */
1997 ppp_stuff_char (struct ppp *ppp, register struct ppp_buffer *buf,
2001 * The buffer should not be full.
2003 if (ppp->flags & SC_DEBUG) {
2004 if ((buf->count < 0) || (buf->count > 3000))
2005 printk (KERN_DEBUG "ppp_stuff_char: %d %x\n",
2006 (unsigned int) buf->count,
2007 (unsigned int) chr);
2010 * Update the FCS and if the character needs to be escaped, do it.
2012 buf->fcs = PPP_FCS (buf->fcs, chr);
2013 if (in_xmap (ppp, chr)) {
2015 ins_char (buf, PPP_ESCAPE);
2018 * Add the character to the buffer.
2020 ins_char (buf, chr);
2024 * Procedure to encode the data with the proper escaping and send the
2025 * data to the remote system.
2029 ppp_dev_xmit_lower (struct ppp *ppp, struct ppp_buffer *buf,
2030 __u8 *data, int count, int non_ip)
2033 int address, control;
2037 CHECK_BUF_MAGIC(buf);
2038 ++ppp->stats.ppp_opackets;
2039 ppp->stats.ppp_ooctects += count;
2042 * Insert the leading FLAG character
2046 if (non_ip || flag_time == 0)
2047 ins_char (buf, PPP_FLAG);
2049 if (jiffies - ppp->last_xmit >= flag_time)
2050 ins_char (buf, PPP_FLAG);
2052 ppp->last_xmit = jiffies;
2053 buf->fcs = PPP_INITFCS;
2055 * Emit the address/control information if needed
2057 address = PPP_ADDRESS (data);
2058 control = PPP_CONTROL (data);
2059 proto = PPP_PROTOCOL (data);
2061 if (address != PPP_ALLSTATIONS ||
2062 control != PPP_UI ||
2063 (ppp->flags & SC_COMP_AC) == 0) {
2064 ppp_stuff_char (ppp, buf, address);
2065 ppp_stuff_char (ppp, buf, control);
2068 * Emit the protocol (compressed if possible)
2070 if ((ppp->flags & SC_COMP_PROT) == 0 || (proto & 0xFF00))
2071 ppp_stuff_char (ppp, buf, proto >> 8);
2073 ppp_stuff_char (ppp, buf, proto);
2081 ppp_stuff_char (ppp, buf, *data++);
2083 * Add the trailing CRC and the final flag character
2085 write_fcs = buf->fcs ^ 0xFFFF;
2086 ppp_stuff_char (ppp, buf, write_fcs);
2087 ppp_stuff_char (ppp, buf, write_fcs >> 8);
2089 * Add the trailing flag character
2091 ins_char (buf, PPP_FLAG);
2093 * Send the block to the tty driver.
2095 ppp->stats.ppp_obytes += buf->count;
2096 ppp_kick_tty (ppp, buf);
2100 * Compress and send an frame to the peer.
2102 * Return 0 if frame was queued for transmission.
2103 * 1 if frame must be re-queued for later driver support.
2107 ppp_dev_xmit_frame (struct ppp *ppp, struct ppp_buffer *buf,
2108 __u8 *data, int count)
2111 int address, control;
2116 CHECK_BUF_MAGIC(buf);
2120 if (ppp->flags & SC_LOG_OUTPKT)
2121 ppp_print_buffer ("write frame", data, count);
2123 * Determine if the frame may be compressed. Attempt to compress the
2124 * frame if possible.
2126 proto = PPP_PROTOCOL (data);
2127 address = PPP_ADDRESS (data);
2128 control = PPP_CONTROL (data);
2130 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2131 (ppp->sc_xc_state != (void *) 0) &&
2132 (address == PPP_ALLSTATIONS) &&
2133 (control == PPP_UI) &&
2134 (proto != PPP_LCP) &&
2135 (proto != PPP_CCP)) {
2136 new_data = kmalloc (ppp->mtu, GFP_ATOMIC);
2137 if (new_data == NULL) {
2138 if (ppp->flags & SC_DEBUG)
2140 "ppp_dev_xmit_frame: no memory\n");
2144 new_count = (*ppp->sc_xcomp->compress)
2145 (ppp->sc_xc_state, data, new_data, count, ppp->mtu);
2147 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2148 ppp_dev_xmit_lower (ppp, buf, new_data, new_count, 0);
2153 * The frame could not be compressed, or it could not be sent in
2154 * compressed form because CCP is not yet up.
2159 * Go to the escape encoding
2161 ppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
2166 * Revise the tty frame for specific protocols.
2170 send_revise_frame (register struct ppp *ppp, __u8 *data, int len)
2174 switch (PPP_PROTOCOL (data)) {
2176 * Update the LQR frame with the current MIB information. This saves having
2177 * the daemon read old MIB data from the driver.
2180 len = 48; /* total size of this frame */
2181 p = (__u8 *) &data [40]; /* Point to last two items. */
2182 p = store_long (p, ppp->stats.ppp_opackets + 1);
2183 p = store_long (p, ppp->stats.ppp_ooctects + len);
2186 * Outbound compression frames
2203 * write a frame with NR chars from BUF to TTY
2204 * we have to put the FCS field on ourselves
2208 ppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
2211 struct ppp *ppp = tty2ppp (tty);
2216 * Verify the pointers.
2221 if (ppp->magic != PPP_MAGIC)
2226 * Ensure that the caller does not wish to send too much.
2228 if (count > PPP_MTU + PPP_HDRLEN) {
2229 if (ppp->flags & SC_DEBUG)
2230 printk (KERN_WARNING
2231 "ppp_tty_write: truncating user packet "
2232 "from %lu to mtu %d\n", (unsigned long) count,
2233 PPP_MTU + PPP_HDRLEN);
2234 count = PPP_MTU + PPP_HDRLEN;
2237 * Allocate a buffer for the data and fetch it from the user space.
2239 new_data = kmalloc (count, GFP_KERNEL);
2240 if (new_data == NULL) {
2241 if (ppp->flags & SC_DEBUG)
2243 "ppp_tty_write: no memory\n");
2247 * Retrieve the user's buffer
2249 COPY_FROM_USER (error, new_data, data, count);
2255 * lock this PPP unit so we will be the only writer;
2256 * sleep if necessary
2258 while (lock_buffer (ppp->tbuf) != 0) {
2259 current->timeout = 0;
2261 if (ppp->flags & SC_DEBUG)
2262 printk (KERN_DEBUG "ppp_tty_write: sleeping\n");
2264 interruptible_sleep_on (&ppp->write_wait);
2266 ppp = tty2ppp (tty);
2267 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
2268 || tty != ppp->tty) {
2273 if (signal_pending(current)) {
2279 * Change the LQR frame
2281 count = send_revise_frame (ppp, new_data, count);
2285 if (PPP_PROTOCOL(new_data) == PPP_IP) {
2287 * IP frames can be sent by pppd when we're doing
2288 * demand-dialling. We send them via ppp_dev_xmit_ip
2289 * to make sure that VJ compression happens properly.
2291 ppp_dev_xmit_ip(ppp, ppp->tbuf, new_data + PPP_HDRLEN,
2292 count - PPP_HDRLEN, NPMODE_PASS);
2295 ppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
2299 return (rw_ret_t) count;
2303 * Process the BSD compression IOCTL event for the tty device.
2307 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
2309 struct compressor *cp;
2310 struct ppp_option_data data;
2314 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
2315 unsigned long flags;
2318 * Fetch the compression parameters
2320 COPY_FROM_USER (error, &data, odp, sizeof (data));
2327 if ((__u32) nb >= (__u32)CCP_MAX_OPTION_LENGTH)
2328 nb = CCP_MAX_OPTION_LENGTH;
2330 COPY_FROM_USER (error, ccp_option, ptr, nb);
2335 if (ccp_option[1] < 2) /* preliminary check on the length byte */
2340 ppp->flags &= ~(SC_COMP_RUN | SC_DECOMP_RUN);
2341 restore_flags(flags);
2343 cp = find_compressor (ccp_option[0]);
2344 #ifdef CONFIG_KERNELD
2347 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
2348 request_module(modname);
2349 cp = find_compressor(ccp_option[0]);
2351 #endif /* CONFIG_KERNELD */
2353 if (cp != (struct compressor *) 0) {
2355 * Found a handler for the protocol - try to allocate
2356 * a compressor or decompressor.
2359 if (data.transmit) {
2360 if (ppp->sc_xc_state != NULL)
2361 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2364 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2366 if (ppp->sc_xc_state == NULL) {
2367 if (ppp->flags & SC_DEBUG)
2368 printk(KERN_DEBUG "%s: comp_alloc failed\n",
2372 if (ppp->flags & SC_DEBUG)
2373 printk(KERN_DEBUG "%s: comp_alloc -> %p\n",
2374 ppp->name, ppp->sc_xc_state);
2377 if (ppp->sc_rc_state != NULL)
2378 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2380 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2381 if (ppp->sc_rc_state == NULL) {
2382 if (ppp->flags & SC_DEBUG)
2383 printk(KERN_DEBUG "%s: decomp_alloc failed\n",
2387 if (ppp->flags & SC_DEBUG)
2388 printk(KERN_DEBUG "%s: decomp_alloc -> %p\n",
2389 ppp->name, ppp->sc_rc_state);
2395 if (ppp->flags & SC_DEBUG)
2396 printk(KERN_DEBUG "%s: no compressor for [%x %x %x], %x\n",
2397 ppp->name, ccp_option[0], ccp_option[1],
2399 return (-EINVAL); /* no handler found */
2403 * Process the IOCTL event for the tty device.
2407 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
2408 unsigned int param2, unsigned long param3)
2410 struct ppp *ppp = tty2ppp (tty);
2411 register int temp_i = 0;
2414 * Verify the status of the PPP device.
2419 if (ppp->magic != PPP_MAGIC)
2424 * The user must have an euid of root to do these requests.
2433 GET_USER (error, temp_i, (int *) param3);
2436 if (ppp->flags & SC_DEBUG)
2438 "ppp_tty_ioctl: set mru to %x\n", temp_i);
2440 if (ppp->mru != temp_i)
2441 ppp_changedmtu (ppp, ppp2dev (ppp)->mtu, temp_i);
2447 temp_i = (ppp->flags & SC_MASK);
2448 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
2449 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
2450 SC_RCV_ODDP | SC_RCV_EVNP;
2452 PUT_USER (error, temp_i, (int *) param3);
2455 * Set the flags for the various options
2458 GET_USER (error, temp_i, (int *) param3);
2462 temp_i |= (ppp->flags & ~SC_MASK);
2464 if ((ppp->flags & SC_CCP_OPEN) &&
2465 (temp_i & SC_CCP_OPEN) == 0)
2466 ppp_ccp_closed (ppp);
2468 if ((ppp->flags | temp_i) & SC_DEBUG)
2470 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2471 ppp->flags = temp_i;
2474 * Set the compression mode
2476 case PPPIOCSCOMPRESS:
2477 error = ppp_set_compression (ppp,
2478 (struct ppp_option_data *) param3);
2481 * Retrieve the transmit async map
2483 case PPPIOCGASYNCMAP:
2484 PUT_USER (error, ppp->xmit_async_map[0], (int *) param3);
2487 * Set the transmit async map
2489 case PPPIOCSASYNCMAP:
2490 GET_USER (error, temp_i, (int *) param3);
2493 ppp->xmit_async_map[0] = temp_i;
2494 if (ppp->flags & SC_DEBUG)
2496 "ppp_tty_ioctl: set xmit asyncmap %x\n",
2497 ppp->xmit_async_map[0]);
2500 * Set the receive async map
2502 case PPPIOCSRASYNCMAP:
2503 GET_USER (error, temp_i, (int *) param3);
2506 ppp->recv_async_map = temp_i;
2507 if (ppp->flags & SC_DEBUG)
2509 "ppp_tty_ioctl: set rcv asyncmap %x\n",
2510 ppp->recv_async_map);
2513 * Obtain the unit number for this device.
2516 PUT_USER (error, ppp2dev (ppp)->base_addr, (int *) param3);
2519 if (ppp->flags & SC_DEBUG)
2521 "ppp_tty_ioctl: get unit: %ld\n",
2522 ppp2dev (ppp)->base_addr);
2525 * Set the debug level
2528 GET_USER (error, temp_i, (int *) param3);
2531 temp_i = (temp_i & 0x1F) << 16;
2532 temp_i |= (ppp->flags & ~0x1F0000);
2534 if ((ppp->flags | temp_i) & SC_DEBUG)
2536 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2537 ppp->flags = temp_i;
2540 * Get the debug level
2543 temp_i = (ppp->flags >> 16) & 0x1F;
2544 PUT_USER (error, temp_i, (int *) param3);
2547 * Get the times since the last send/receive frame operation
2551 struct ppp_idle cur_ddinfo;
2553 /* change absolute times to relative times. */
2554 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
2555 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
2556 COPY_TO_USER (error, (void *) param3, &cur_ddinfo,
2557 sizeof (cur_ddinfo));
2561 * Retrieve the extended async map
2563 case PPPIOCGXASYNCMAP:
2564 COPY_TO_USER (error, (void *) param3, ppp->xmit_async_map,
2565 sizeof (ppp->xmit_async_map));
2568 * Set the async extended map
2570 case PPPIOCSXASYNCMAP:
2574 COPY_FROM_USER (error, temp_tbl, (void *) param3,
2579 temp_tbl[1] = 0x00000000;
2580 temp_tbl[2] &= ~0x40000000;
2581 temp_tbl[3] |= 0x60000000;
2583 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
2584 (temp_tbl[4] & temp_tbl[5]) != 0 ||
2585 (temp_tbl[6] & temp_tbl[7]) != 0)
2588 memcpy (ppp->xmit_async_map,
2590 sizeof (ppp->xmit_async_map));
2592 if (ppp->flags & SC_DEBUG)
2594 "ppp_tty_ioctl: set xasyncmap\n");
2599 * Set the maximum VJ header compression slot number.
2602 GET_USER (error, temp_i, (int *) param3);
2605 temp_i = (temp_i & 255) + 1;
2606 if (ppp->flags & SC_DEBUG)
2608 "ppp_tty_ioctl: set maxcid to %d\n",
2610 if (ppp->slcomp != NULL)
2611 slhc_free (ppp->slcomp);
2612 ppp->slcomp = slhc_init (16, temp_i);
2614 if (ppp->slcomp == NULL) {
2615 if (ppp->flags & SC_DEBUG)
2617 "ppp: no space for compression buffers!\n");
2623 case PPPIOCXFERUNIT:
2624 ppp->backup_tty = tty;
2625 ppp->sc_xfer = current->pid;
2633 COPY_FROM_USER (error, &npi, (void *) param3,
2638 switch (npi.protocol) {
2640 npi.protocol = NP_IP;
2643 if (ppp->flags & SC_DEBUG)
2644 printk(KERN_DEBUG "pppioc[gs]npmode: "
2645 "invalid proto %d\n", npi.protocol);
2652 if (param2 == PPPIOCGNPMODE) {
2653 npi.mode = ppp->sc_npmode[npi.protocol];
2655 COPY_TO_USER (error, (void *) param3, &npi,
2660 ppp->sc_npmode[npi.protocol] = npi.mode;
2661 if (ppp->flags & SC_DEBUG)
2662 printk(KERN_DEBUG "ppp: set np %d to %d\n",
2663 npi.protocol, npi.mode);
2664 ppp2dev(ppp)->tbusy = 0;
2669 * Allow users to read, but not set, the serial port parameters
2673 error = n_tty_ioctl (tty, file, param2, param3);
2678 int count = ppp->ubuf->tail - ppp->ubuf->head;
2680 count += (ppp->ubuf->size + 1);
2681 PUT_USER (error, count, (int *) param3);
2685 * All other ioctl() events will come here.
2688 if (ppp->flags & SC_DEBUG)
2690 "ppp_tty_ioctl: invalid ioctl: %x, addr %lx\n",
2694 error = -ENOIOCTLCMD;
2703 * Process the select() (or poll()) statement for the PPP device.
2706 #if LINUX_VERSION_CODE < VERSION(2,1,23)
2708 ppp_tty_select (struct tty_struct *tty, struct inode *inode,
2709 struct file *filp, int sel_type, select_table * wait)
2711 struct ppp *ppp = tty2ppp (tty);
2714 * Verify the status of the PPP device.
2719 if (ppp->magic != PPP_MAGIC || tty != ppp->tty)
2724 * Branch on the type of select mode. A read request must lock the user
2729 if (test_and_set_bit (0, &ppp->ubuf->locked) == 0) {
2730 /* Test for the presence of data in the queue */
2731 if (ppp->ubuf->head != ppp->ubuf->tail) {
2732 clear_bit (0, &ppp->ubuf->locked);
2735 clear_bit (0, &ppp->ubuf->locked);
2736 } /* fall through */
2738 * Exceptions or read errors.
2741 /* Is this a pty link and the remote disconnected? */
2742 if (tty->flags & (1 << TTY_OTHER_CLOSED))
2745 /* Is this a local link and the modem disconnected? */
2746 if (tty_hung_up_p (filp))
2749 select_wait (&ppp->read_wait, wait);
2753 * Write mode. A write is allowed if there is no current transmission.
2756 if (ppp->tbuf->locked != 0) {
2757 select_wait (&ppp->write_wait, wait);
2765 #else /* 2.1.23 or later */
2768 ppp_tty_poll (struct tty_struct *tty, struct file *filp, poll_table * wait)
2770 struct ppp *ppp = tty2ppp (tty);
2771 unsigned int mask = 0;
2773 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
2776 poll_wait(&ppp->read_wait, wait);
2777 poll_wait(&ppp->write_wait, wait);
2779 /* Must lock the user buffer area while checking. */
2780 CHECK_BUF_MAGIC(ppp->ubuf);
2781 if(test_and_set_bit(0, &ppp->ubuf->locked) == 0) {
2782 if(ppp->ubuf->head != ppp->ubuf->tail)
2783 mask |= POLLIN | POLLRDNORM;
2784 clear_bit(0, &ppp->ubuf->locked);
2786 if(tty->flags & (1 << TTY_OTHER_CLOSED))
2788 if(tty_hung_up_p(filp))
2790 if(ppp->tbuf->locked == 0)
2791 mask |= POLLOUT | POLLWRNORM;
2798 /*************************************************************
2800 * This routine accepts requests from the network layer
2801 * and attempts to deliver the packets.
2802 * It also includes various routines we are compelled to
2803 * have to make the network layer work (arp, etc...).
2804 *************************************************************/
2807 * Callback from the network layer when the device goes up.
2811 ppp_dev_open (struct device *dev)
2813 struct ppp *ppp = dev2ppp (dev);
2815 if (ppp2tty (ppp) == NULL) {
2816 if (ppp->flags & SC_DEBUG)
2818 "ppp: %s not connected to a TTY! can't go open!\n",
2823 if (ppp->flags & SC_DEBUG)
2825 "ppp: channel %s going up for IP packets!\n",
2833 * Callback from the network layer when the ppp device goes down.
2837 ppp_dev_close (struct device *dev)
2839 struct ppp *ppp = dev2ppp (dev);
2841 if (ppp2tty (ppp) == NULL) {
2845 * We don't do anything about the device going down. It is not important
2848 if (ppp->flags & SC_DEBUG)
2850 "ppp: channel %s going down for IP packets!\n",
2857 * IOCTL operation to read the version of the driver.
2861 ppp_dev_ioctl_version (struct ppp *ppp, struct ifreq *ifr)
2864 char *result = (char *) ifr->ifr_ifru.ifru_data;
2865 int len = strlen (szVersion) + 1;
2867 * Move the version data
2869 COPY_TO_USER (error, result, szVersion, len);
2875 * IOCTL to read the statistics for the pppstats program.
2879 ppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2881 struct ppp_stats *result, temp;
2884 * Supply the information for the caller. First move the version data
2885 * then move the ppp stats; and finally the vj stats.
2887 memset (&temp, 0, sizeof(temp));
2888 if (dev->flags & IFF_UP) {
2889 memcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
2890 if (ppp->slcomp != NULL) {
2891 temp.vj.vjs_packets = ppp->slcomp->sls_o_compressed+
2892 ppp->slcomp->sls_o_uncompressed;
2893 temp.vj.vjs_compressed = ppp->slcomp->sls_o_compressed;
2894 temp.vj.vjs_searches = ppp->slcomp->sls_o_searches;
2895 temp.vj.vjs_misses = ppp->slcomp->sls_o_misses;
2896 temp.vj.vjs_errorin = ppp->slcomp->sls_i_error;
2897 temp.vj.vjs_tossed = ppp->slcomp->sls_i_tossed;
2898 temp.vj.vjs_uncompressedin = ppp->slcomp->sls_i_uncompressed;
2899 temp.vj.vjs_compressedin = ppp->slcomp->sls_i_compressed;
2903 result = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
2905 COPY_TO_USER (error, result, &temp, sizeof (temp));
2911 * IOCTL to read the compression statistics for the pppstats program.
2915 ppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2917 struct ppp_comp_stats *result, temp;
2920 * Supply the information for the caller.
2922 memset (&temp, 0, sizeof(temp));
2923 if (dev->flags & IFF_UP) {
2924 if (ppp->sc_xc_state != NULL)
2925 (*ppp->sc_xcomp->comp_stat) (ppp->sc_xc_state,
2928 if (ppp->sc_rc_state != NULL)
2929 (*ppp->sc_rcomp->decomp_stat) (ppp->sc_rc_state,
2933 * Move the data to the caller's buffer
2935 result = (struct ppp_comp_stats *) ifr->ifr_ifru.ifru_data;
2937 COPY_TO_USER (error, result, &temp, sizeof (temp));
2943 * Callback from the network layer to process the sockioctl functions.
2947 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
2949 struct ppp *ppp = dev2ppp (dev);
2952 CHECK_PPP_MAGIC(ppp);
2954 * Process the requests
2958 error = ppp_dev_ioctl_stats (ppp, ifr, dev);
2961 case SIOCGPPPCSTATS:
2962 error = ppp_dev_ioctl_comp_stats (ppp, ifr, dev);
2966 error = ppp_dev_ioctl_version (ppp, ifr);
2977 * Send an IP frame to the remote with vj header compression.
2979 * Return 0 if frame was queued for transmission.
2980 * 1 if frame must be re-queued for later driver support.
2981 * -1 if frame should be dropped.
2985 ppp_dev_xmit_ip (struct ppp *ppp, struct ppp_buffer *buf,
2986 __u8 *data, int len, enum NPmode npmode)
2991 * Branch on the type of processing for the IP frame.
2999 * We may not send the packet now, so drop it.
3000 * XXX It would be nice to be able to return it to the
3001 * network system to be queued and retransmitted later.
3003 if (ppp->flags & SC_DEBUG)
3004 printk(KERN_DEBUG "%s: returning frame\n",
3010 if (ppp->flags & SC_DEBUG)
3012 "ppp_dev_xmit: npmode = %d on %s\n",
3013 ppp->sc_npmode[NP_IP], ppp->name);
3017 if (ppp->flags & SC_DEBUG)
3018 printk (KERN_WARNING
3019 "ppp_dev_xmit: unknown npmode %d on %s\n",
3020 ppp->sc_npmode[NP_IP], ppp->name);
3024 * At this point, the buffer will be transmitted. There is no other exit.
3026 * Try to compress the header.
3028 if (ppp->flags & SC_COMP_TCP) {
3029 len = slhc_compress (ppp->slcomp, data, len,
3030 buf_base (ppp->cbuf) + PPP_HDRLEN,
3032 (ppp->flags & SC_NO_TCP_CCID) == 0);
3034 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
3035 proto = PPP_VJC_COMP;
3036 data[0] ^= SL_TYPE_COMPRESSED_TCP;
3038 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
3039 proto = PPP_VJC_UNCOMP;
3040 data[0] = (data[0] & 0x0f) | 0x40;
3047 hdr = data - PPP_HDRLEN;
3049 hdr[0] = PPP_ALLSTATIONS;
3054 return ppp_dev_xmit_frame (ppp, buf, hdr, len);
3058 * Send a non-IP data frame (such as an IPX frame) to the remote.
3060 * Return 0 if frame was queued for transmission.
3061 * 1 if frame must be re-queued for later driver support.
3064 ppp_dev_xmit_other (struct device *dev, struct ppp *ppp,
3065 __u8 *data, int len, int proto)
3072 hdr = data - PPP_HDRLEN;
3074 hdr[0] = PPP_ALLSTATIONS;
3076 hdr[2] = proto >> 8;
3079 return ppp_dev_xmit_frame (ppp, ppp->wbuf, hdr, len);
3083 * Send a frame to the remote.
3087 ppp_dev_xmit (sk_buff *skb, struct device *dev)
3091 struct ppp *ppp = dev2ppp (dev);
3092 struct tty_struct *tty = ppp2tty (ppp);
3094 * just a little sanity check.
3097 if (ppp->flags & SC_DEBUG)
3098 printk (KERN_WARNING "ppp_dev_xmit: null packet!\n");
3102 * Avoid timing problem should tty hangup while data is queued to be sent
3105 dev_kfree_skb (skb, FREE_WRITE);
3109 * Validate the tty interface
3112 if (ppp->flags & SC_DEBUG)
3114 "ppp_dev_xmit: %s not connected to a TTY!\n",
3116 dev_kfree_skb (skb, FREE_WRITE);
3120 * Fetch the pointer to the data
3123 data = skb_data(skb);
3125 if (data == (__u8 *) 0) {
3126 if (ppp->flags & SC_DEBUG)
3127 printk (KERN_CRIT "ppp_dev_xmit: %s Null skb data\n",
3129 dev_kfree_skb (skb, FREE_WRITE);
3133 * Detect a change in the transfer size
3135 if (ppp->mtu != ppp2dev (ppp)->mtu) {
3136 ppp_changedmtu (ppp,
3141 * Acquire the lock on the transmission buffer. If the buffer was busy then
3142 * mark the device as busy.
3143 * We also require that ppp->tbuf be unlocked, in order to serialize
3144 * calls to ppp_dev_xmit_frame (which does compression) and the output
3145 * of frames w.r.t. tty writes from pppd.
3147 CHECK_BUF_MAGIC(ppp->wbuf);
3148 if (ppp->tbuf->locked || lock_buffer (ppp->wbuf) != 0) {
3150 if (ppp->flags & SC_DEBUG)
3151 printk(KERN_DEBUG "dev_xmit blocked, t=%lu w=%lu\n",
3152 ppp->tbuf->locked, ppp->wbuf->locked);
3156 * Look at the protocol in the skb to determine the difference between
3157 * an IP frame and an IPX frame.
3159 switch (ntohs (skb->protocol)) {
3161 answer = ppp_dev_xmit_other (dev, ppp, data, len, PPP_IPX);
3165 answer = ppp_dev_xmit_ip (ppp, ppp->wbuf, data, len,
3166 ppp->sc_npmode[NP_IP]);
3169 default: /* All others have no support at this time. */
3170 dev_kfree_skb (skb, FREE_WRITE);
3174 * This is the end of the transmission. Release the buffer if it was sent.
3177 /* packet queued OK */
3178 dev_kfree_skb (skb, FREE_WRITE);
3180 ppp->wbuf->locked = 0;
3182 /* packet should be dropped */
3183 dev_kfree_skb (skb, FREE_WRITE);
3186 /* packet should be queued for later */
3194 * Generate the statistic information for the /proc/net/dev listing.
3197 static struct net_device_stats *
3198 ppp_dev_stats (struct device *dev)
3200 struct ppp *ppp = dev2ppp (dev);
3202 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
3203 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
3204 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
3205 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
3206 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
3207 ppp->estats.rx_bytes = ppp->stats.ppp_ibytes;
3208 ppp->estats.tx_bytes = ppp->stats.ppp_obytes;
3211 return &ppp->estats;
3214 #if LINUX_VERSION_CODE < VERSION(2,1,15)
3215 static int ppp_dev_header (sk_buff *skb, struct device *dev,
3216 __u16 type, void *daddr,
3217 void *saddr, unsigned int len)
3223 ppp_dev_rebuild (void *eth, struct device *dev,
3224 unsigned long raddr, struct sk_buff *skb)
3230 /*************************************************************
3232 * Miscellany called by various functions above.
3233 *************************************************************/
3235 /* Locate the previous instance of the PPP channel */
3237 ppp_find (int pid_value)
3241 /* try to find the device which this pid is already using */
3242 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3243 if (ppp->inuse && ppp->sc_xfer == pid_value) {
3251 /* allocate or create a PPP channel */
3260 /* try to find an free device */
3262 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3263 if (!test_and_set_bit(0, &ppp->inuse))
3268 * There are no available units, so make a new one.
3270 ppp = (struct ppp *) kmalloc (sizeof(struct ppp), GFP_KERNEL);
3273 memset(ppp, 0, sizeof(*ppp));
3275 /* initialize channel control data */
3276 set_bit(0, &ppp->inuse);
3280 ppp->backup_tty = NULL;
3284 ppp_last->next = ppp;
3290 dev->init = ppp_init_dev;
3291 dev->name = ppp->name;
3292 sprintf(dev->name, "ppp%d", if_num);
3293 dev->base_addr = (__u32) if_num;
3294 dev->priv = (void *) ppp;
3296 /* register device so that we can be ifconfig'd */
3297 /* ppp_init_dev() will be called as a side-effect */
3298 status = register_netdev (dev);
3300 printk (KERN_INFO "registered device %s\n", dev->name);
3303 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3306 /* This one will forever be busy as it is not initialized */
3312 * Utility procedures to print a buffer in hex/ascii
3316 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3318 register __u8 next_ch;
3319 static char hex[] = "0123456789ABCDEF";
3321 while (count-- > 0) {
3323 *out++ = hex[(next_ch >> 4) & 0x0F];
3324 *out++ = hex[next_ch & 0x0F];
3330 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3332 register __u8 next_ch;
3334 while (count-- > 0) {
3337 if (next_ch < 0x20 || next_ch > 0x7e)
3341 if (next_ch == '%') /* printk/syslogd has a bug !! */
3349 ppp_print_buffer (const __u8 * name, const __u8 * buf, int count)
3353 if (name != (__u8 *) NULL)
3354 printk (KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3357 memset (line, 32, 44);
3358 ppp_print_hex (line, buf, 8);
3359 ppp_print_char (&line[8 * 3], buf, 8);
3360 printk (KERN_DEBUG "%s\n", line);
3366 memset (line, 32, 44);
3367 ppp_print_hex (line, buf, count);
3368 ppp_print_char (&line[8 * 3], buf, count);
3369 printk (KERN_DEBUG "%s\n", line);
3373 /*************************************************************
3374 * Compressor module interface
3375 *************************************************************/
3377 struct compressor_link {
3378 struct compressor_link *next;
3379 struct compressor *comp;
3382 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3384 static struct compressor *find_compressor (int type)
3386 struct compressor_link *lnk;
3387 unsigned long flags;
3392 lnk = ppp_compressors;
3393 while (lnk != (struct compressor_link *) 0) {
3394 if ((int) (__u8) lnk->comp->compress_proto == type) {
3395 restore_flags(flags);
3401 restore_flags(flags);
3402 return (struct compressor *) 0;
3405 static int ppp_register_compressor (struct compressor *cp)
3407 struct compressor_link *new;
3408 unsigned long flags;
3410 new = (struct compressor_link *) kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3412 if (new == (struct compressor_link *) 0)
3418 if (find_compressor (cp->compress_proto)) {
3419 restore_flags(flags);
3424 new->next = ppp_compressors;
3426 ppp_compressors = new;
3428 restore_flags(flags);
3432 static void ppp_unregister_compressor (struct compressor *cp)
3434 struct compressor_link *prev = (struct compressor_link *) 0;
3435 struct compressor_link *lnk;
3436 unsigned long flags;
3441 lnk = ppp_compressors;
3442 while (lnk != (struct compressor_link *) 0) {
3443 if (lnk->comp == cp) {
3445 prev->next = lnk->next;
3447 ppp_compressors = lnk->next;
3454 restore_flags(flags);
3457 /*************************************************************
3458 * Module support routines
3459 *************************************************************/
3467 /* register our line disciplines */
3468 status = ppp_first_time();
3471 "PPP: ppp_init() failure %d\n", status);
3472 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3474 (void) register_symtab (&ppp_syms);
3480 cleanup_module(void)
3484 struct ppp *ppp, *next_ppp;
3487 * Ensure that the devices are not in operation.
3489 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3490 if (ppp->inuse && ppp->tty != NULL) {
3495 dev = ppp2dev (ppp);
3496 if (dev->start || dev->flags & IFF_UP) {
3502 * Ensure that there are no compressor modules registered
3504 if (ppp_compressors != NULL)
3509 "PPP: device busy, remove delayed\n");
3513 * Release the tty registration of the line discipline so that no new entries
3516 status = tty_register_ldisc (N_PPP, NULL);
3519 "PPP: Unable to unregister ppp line discipline "
3520 "(err = %d)\n", status);
3523 "PPP: ppp line discipline successfully unregistered\n");
3525 * De-register the devices so that there is no problem with them
3527 for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3528 next_ppp = ppp->next;
3530 unregister_netdev (&ppp->dev);