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 980319==
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.17 1998/03/24 23:54:59 paulus Exp $ */
53 #include <linux/version.h>
54 #include <linux/config.h> /* for CONFIG_KERNELD */
55 #include <linux/module.h>
56 #include <linux/kernel.h>
57 #include <linux/sched.h>
58 #include <linux/types.h>
59 #include <linux/fcntl.h>
60 #include <linux/interrupt.h>
61 #include <linux/ptrace.h>
64 /* a nice define to generate linux version numbers */
65 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
67 #if LINUX_VERSION_CODE < VERSION(2,1,14)
68 #include <linux/ioport.h>
71 #if LINUX_VERSION_CODE >= VERSION(2,1,23)
72 #include <linux/poll.h>
76 #include <linux/malloc.h>
77 #include <linux/tty.h>
78 #include <linux/errno.h>
79 #include <linux/sched.h> /* to get the struct task_struct */
80 #include <linux/string.h> /* used in new tty drivers */
81 #include <linux/signal.h> /* used in new tty drivers */
82 #include <asm/system.h>
83 #include <asm/bitops.h>
85 #include <linux/if_ether.h>
86 #include <linux/netdevice.h>
87 #include <linux/skbuff.h>
89 #if LINUX_VERSION_CODE >= VERSION(2,1,68)
90 #include <linux/rtnetlink.h>
93 #include <linux/inet.h>
94 #include <linux/ioctl.h>
96 typedef struct sk_buff sk_buff;
97 #define skb_data(skb) ((__u8 *) (skb)->data)
100 #include <linux/tcp.h>
101 #include <linux/if_arp.h>
102 #include <net/slhc_vj.h>
104 #define fcstab ppp_crc16_table /* Name of the table in the kernel */
105 #include <linux/ppp_defs.h>
107 #include <linux/socket.h>
108 #include <linux/if_ppp.h>
109 #include <linux/if_pppvar.h>
110 #include <linux/ppp-comp.h>
112 #ifdef CONFIG_KERNELD
113 #include <linux/kerneld.h>
117 #define PPP_IPX 0x2b /* IPX protocol over PPP */
121 #define PPP_LQR 0xc025 /* Link Quality Reporting Protocol */
124 #if LINUX_VERSION_CODE >= VERSION(2,1,4)
125 #include <asm/segment.h>
126 #define GET_USER(error,value,addr) error = get_user(value,addr)
127 #define COPY_FROM_USER(error,dest,src,size) error = copy_from_user(dest,src,size) ? -EFAULT : 0
128 #define PUT_USER(error,value,addr) error = put_user(value,addr)
129 #define COPY_TO_USER(error,dest,src,size) error = copy_to_user(dest,src,size) ? -EFAULT : 0
131 #if LINUX_VERSION_CODE >= VERSION(2,1,5)
132 #include <asm/uaccess.h>
135 #else /* 2.0.x and 2.1.x before 2.1.4 */
137 #define GET_USER(error,value,addr) \
139 error = verify_area (VERIFY_READ, (void *) addr, sizeof (value)); \
141 value = get_user(addr); \
144 #define COPY_FROM_USER(error,dest,src,size) \
146 error = verify_area (VERIFY_READ, (void *) src, size); \
148 memcpy_fromfs (dest, src, size); \
151 #define PUT_USER(error,value,addr) \
153 error = verify_area (VERIFY_WRITE, (void *) addr, sizeof (value)); \
155 put_user (value, addr); \
158 #define COPY_TO_USER(error,dest,src,size) \
160 error = verify_area (VERIFY_WRITE, (void *) dest, size); \
162 memcpy_tofs (dest, src, size); \
167 #if LINUX_VERSION_CODE < VERSION(2,1,37)
168 #define test_and_set_bit(nr, addr) set_bit(nr, addr)
171 #if LINUX_VERSION_CODE < VERSION(2,1,57)
172 #define signal_pending(p) ((p)->signal & ~(p)->blocked)
175 #if LINUX_VERSION_CODE < VERSION(2,1,25)
176 #define net_device_stats enet_statistics
179 #if LINUX_VERSION_CODE < VERSION(2,1,60)
180 typedef int rw_ret_t;
181 typedef unsigned int rw_count_t;
183 typedef ssize_t rw_ret_t;
184 typedef size_t rw_count_t;
187 static int ppp_register_compressor (struct compressor *cp);
188 static void ppp_unregister_compressor (struct compressor *cp);
194 static struct compressor *find_compressor (int type);
195 static void ppp_init_ctrl_blk (register struct ppp *);
196 static void ppp_kick_tty (struct ppp *, struct ppp_buffer *bfr);
197 static struct ppp *ppp_alloc (void);
198 static struct ppp *ppp_find (int pid_value);
199 static void ppp_print_buffer (const __u8 *, const __u8 *, int);
200 extern inline void ppp_stuff_char (struct ppp *ppp,
201 register struct ppp_buffer *buf,
203 extern inline int lock_buffer (register struct ppp_buffer *buf);
204 static int ppp_dev_xmit_ip (struct ppp *ppp, struct ppp_buffer *buf,
205 __u8 *data, int len, enum NPmode npmode);
207 static int rcv_proto_ip (struct ppp *, __u16, __u8 *, int);
208 static int rcv_proto_ipx (struct ppp *, __u16, __u8 *, int);
209 static int rcv_proto_vjc_comp (struct ppp *, __u16, __u8 *, int);
210 static int rcv_proto_vjc_uncomp (struct ppp *, __u16, __u8 *, int);
211 static int rcv_proto_unknown (struct ppp *, __u16, __u8 *, int);
212 static int rcv_proto_lqr (struct ppp *, __u16, __u8 *, int);
213 static void ppp_doframe_lower (struct ppp *, __u8 *, int);
214 static int ppp_doframe (struct ppp *);
216 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd);
217 static int rcv_proto_ccp (struct ppp *, __u16, __u8 *, int);
219 #define ins_char(pbuf,c) (buf_base(pbuf) [(pbuf)->count++] = (__u8)(c))
221 #ifndef OPTIMIZE_FLAG_TIME
222 #define OPTIMIZE_FLAG_TIME 0
226 * Parameters which may be changed via insmod.
229 static int flag_time = OPTIMIZE_FLAG_TIME;
231 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
232 MODULE_PARM(flag_time, "i");
236 * The "main" procedure to the ppp device
239 int ppp_init (struct device *);
242 * Network device driver callback routines
245 static int ppp_dev_open (struct device *);
246 static int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
247 static int ppp_dev_close (struct device *);
248 static int ppp_dev_xmit (sk_buff *, struct device *);
249 static struct net_device_stats *ppp_dev_stats (struct device *);
251 #if LINUX_VERSION_CODE < VERSION(2,1,15)
252 static int ppp_dev_header (sk_buff *, struct device *, __u16,
253 void *, void *, unsigned int);
254 static int ppp_dev_rebuild (void *eth, struct device *dev,
255 unsigned long raddr, struct sk_buff *skb);
262 static rw_ret_t ppp_tty_read(struct tty_struct *, struct file *, __u8 *,
264 static rw_ret_t ppp_tty_write(struct tty_struct *, struct file *, const __u8 *,
266 static int ppp_tty_ioctl (struct tty_struct *, struct file *, unsigned int,
268 #if LINUX_VERSION_CODE < VERSION(2,1,23)
269 static int ppp_tty_select (struct tty_struct *tty, struct inode *inode,
270 struct file *filp, int sel_type, select_table * wait);
272 static unsigned int ppp_tty_poll (struct tty_struct *tty, struct file *filp,
275 static int ppp_tty_open (struct tty_struct *);
276 static void ppp_tty_close (struct tty_struct *);
277 static int ppp_tty_room (struct tty_struct *tty);
278 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
279 char *fp, int count);
280 static void ppp_tty_wakeup (struct tty_struct *tty);
282 #define CHECK_PPP_MAGIC(ppp) do { \
283 if (ppp->magic != PPP_MAGIC) { \
284 printk(KERN_WARNING "bad magic for ppp %p at %s:%d\n", \
285 ppp, __FILE__, __LINE__); \
288 #define CHECK_PPP(a) do { \
289 CHECK_PPP_MAGIC(ppp); \
291 printk (ppp_warning, __LINE__); \
295 #define CHECK_PPP_VOID() do { \
296 CHECK_PPP_MAGIC(ppp); \
298 printk (ppp_warning, __LINE__); \
302 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
303 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
304 ppp->recv_async_map & (1 << (c)))
306 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
308 #define tty2ppp(tty) ((struct ppp *) ((tty)->disc_data))
309 #define dev2ppp(dev) ((struct ppp *) ((dev)->priv))
310 #define ppp2tty(ppp) ((ppp)->tty)
311 #define ppp2dev(ppp) (&(ppp)->dev)
313 static struct ppp *ppp_list = NULL;
314 static struct ppp *ppp_last = NULL;
317 #define BUFFER_TYPE_DEV_RD 0 /* ppp read buffer */
318 #define BUFFER_TYPE_TTY_WR 1 /* tty write buffer */
319 #define BUFFER_TYPE_DEV_WR 2 /* ppp write buffer */
320 #define BUFFER_TYPE_TTY_RD 3 /* tty read buffer */
321 #define BUFFER_TYPE_VJ 4 /* vj compression buffer */
323 /* Define this string only once for all macro invocations */
324 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
326 static char szVersion[] = PPP_VERSION;
329 * Information for the protocol decoder
332 typedef int (*pfn_proto) (struct ppp *, __u16, __u8 *, int);
334 typedef struct ppp_proto_struct {
340 ppp_proto_type proto_list[] = {
341 { PPP_IP, rcv_proto_ip },
342 { PPP_IPX, rcv_proto_ipx },
343 { PPP_VJC_COMP, rcv_proto_vjc_comp },
344 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
345 { PPP_LQR, rcv_proto_lqr },
346 { PPP_CCP, rcv_proto_ccp },
347 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
350 __u16 ppp_crc16_table[256] =
352 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
353 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
354 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
355 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
356 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
357 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
358 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
359 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
360 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
361 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
362 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
363 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
364 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
365 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
366 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
367 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
368 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
369 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
370 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
371 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
372 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
373 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
374 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
375 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
376 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
377 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
378 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
379 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
380 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
381 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
382 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
383 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
386 #ifdef CHECK_CHARACTERS
387 static __u32 paritytab[8] =
389 0x96696996, 0x69969669, 0x69969669, 0x96696996,
390 0x69969669, 0x96696996, 0x96696996, 0x69969669
394 /* local function to store a value into the LQR frame */
395 extern inline __u8 * store_long (register __u8 *p, register int value) {
396 *p++ = (__u8) (value >> 24);
397 *p++ = (__u8) (value >> 16);
398 *p++ = (__u8) (value >> 8);
403 /*************************************************************
405 *************************************************************/
407 /* This procedure is called once and once only to define who we are to
408 * the operating system and the various procedures that it may use in
409 * accessing the ppp protocol.
413 ppp_first_time (void)
415 static struct tty_ldisc ppp_ldisc;
419 "PPP: version %s (demand dialling)"
422 #ifndef MODULE /* slhc module logic has its own copyright announcement */
424 "TCP compression code copyright 1989 Regents of the "
425 "University of California\n");
429 * Register the tty discipline
431 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
432 ppp_ldisc.magic = TTY_LDISC_MAGIC;
433 #if LINUX_VERSION_CODE >= VERSION(2,1,28)
434 ppp_ldisc.name = "ppp";
436 ppp_ldisc.open = ppp_tty_open;
437 ppp_ldisc.close = ppp_tty_close;
438 ppp_ldisc.read = ppp_tty_read;
439 ppp_ldisc.write = ppp_tty_write;
440 ppp_ldisc.ioctl = ppp_tty_ioctl;
441 #if LINUX_VERSION_CODE < VERSION(2,1,23)
442 ppp_ldisc.select = ppp_tty_select;
444 ppp_ldisc.poll = ppp_tty_poll;
446 ppp_ldisc.receive_room = ppp_tty_room;
447 ppp_ldisc.receive_buf = ppp_tty_receive;
448 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
450 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
452 printk (KERN_INFO "PPP line discipline registered.\n");
454 printk (KERN_ERR "error registering line discipline: %d\n",
459 /*************************************************************
461 *************************************************************/
463 /* called when the device is actually created */
466 ppp_init_dev (struct device *dev)
468 #if LINUX_VERSION_CODE < VERSION(2,1,15)
469 dev->hard_header = ppp_dev_header;
470 dev->rebuild_header = ppp_dev_rebuild;
473 dev->hard_header_len = PPP_HDRLEN;
477 dev->hard_start_xmit = ppp_dev_xmit;
478 dev->open = ppp_dev_open;
479 dev->stop = ppp_dev_close;
480 dev->get_stats = ppp_dev_stats;
481 dev->do_ioctl = ppp_dev_ioctl;
483 dev->tx_queue_len = 10;
484 dev->type = ARPHRD_PPP;
486 #if LINUX_VERSION_CODE < VERSION(2,1,20)
490 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
491 skb_queue_head_init (&dev->buffs[indx]);
494 dev_init_buffers(dev);
497 /* New-style flags */
498 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
499 #if LINUX_VERSION_CODE < VERSION(2,1,67)
500 dev->family = AF_INET;
504 dev->pa_alen = 4; /* sizeof (__u32) */
511 * Local procedure to initialize the ppp structure
515 ppp_init_ctrl_blk (register struct ppp *ppp)
517 ppp->magic = PPP_MAGIC;
525 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
526 ppp->xmit_async_map[0] = 0xffffffff;
527 ppp->xmit_async_map[3] = 0x60000000;
528 ppp->recv_async_map = 0x00000000;
535 ppp->read_wait = NULL;
536 ppp->write_wait = NULL;
537 ppp->last_xmit = jiffies - flag_time;
538 ppp->last_recv = jiffies;
540 /* clear statistics */
541 memset(&ppp->stats, 0, sizeof (struct pppstat));
542 memset(&ppp->estats, 0, sizeof(ppp->estats));
544 /* PPP compression data */
546 ppp->sc_rc_state = NULL;
549 #if LINUX_VERSION_CODE < VERSION(2,1,18)
550 static struct symbol_table ppp_syms = {
551 #include <linux/symtab_begin.h>
552 X(ppp_register_compressor),
553 X(ppp_unregister_compressor),
555 #include <linux/symtab_end.h>
558 EXPORT_SYMBOL(ppp_register_compressor);
559 EXPORT_SYMBOL(ppp_unregister_compressor);
560 EXPORT_SYMBOL(ppp_crc16_table);
563 /* called at boot/load time for each ppp device defined in the kernel */
567 ppp_init (struct device *dev)
569 static int first_time = 1;
574 answer = ppp_first_time();
575 #if LINUX_VERSION_CODE < VERSION(2,1,18)
577 (void) register_symtab (&ppp_syms);
586 #define BUFFER_MAGIC 0x1d10
587 #define CHECK_BUF_MAGIC(buf) do { \
588 if (buf->magic != BUFFER_MAGIC) { \
589 printk(KERN_WARNING "bad magic for ppp buffer %p at %s:%d\n", \
590 buf, __FILE__, __LINE__); \
595 * Routine to allocate a buffer for later use by the driver.
598 static struct ppp_buffer *
599 ppp_alloc_buf (int size, int type)
601 struct ppp_buffer *buf;
603 buf = (struct ppp_buffer *) kmalloc (size + sizeof (struct ppp_buffer),
607 buf->size = size - 1; /* Mask for the buffer size */
613 buf->fcs = PPP_INITFCS;
614 buf->magic = BUFFER_MAGIC;
620 * Routine to release the allocated buffer.
624 ppp_free_buf (struct ppp_buffer *ptr)
627 CHECK_BUF_MAGIC(ptr);
633 * Lock the indicated transmit buffer
637 lock_buffer (register struct ppp_buffer *buf)
642 * Save the current state and if free then set it to the "busy" state
644 CHECK_BUF_MAGIC(buf);
651 restore_flags (flags);
656 * MTU has been changed by the IP layer. Unfortunately we are not told
657 * about this, but we spot it ourselves and fix things up. We could be
658 * in an upcall from the tty driver, or in an ip packet queue.
662 ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
667 struct ppp_buffer *new_rbuf;
668 struct ppp_buffer *new_wbuf;
669 struct ppp_buffer *new_cbuf;
670 struct ppp_buffer *new_tbuf;
672 struct ppp_buffer *old_rbuf;
673 struct ppp_buffer *old_wbuf;
674 struct ppp_buffer *old_cbuf;
675 struct ppp_buffer *old_tbuf;
679 * Allocate the buffer from the kernel for the data
683 if (ppp->flags & SC_DEBUG)
684 printk(KERN_DEBUG "%s: changedmtu %d %d\n", ppp->name,
687 /* allow for possible escaping of every character */
688 mtu = (new_mtu * 2) + 20;
690 /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
696 new_wbuf = ppp_alloc_buf (mtu+PPP_HDRLEN, BUFFER_TYPE_DEV_WR);
697 new_tbuf = ppp_alloc_buf ((PPP_MTU * 2) + 24, BUFFER_TYPE_TTY_WR);
698 new_rbuf = ppp_alloc_buf (mru + 84, BUFFER_TYPE_DEV_RD);
699 new_cbuf = ppp_alloc_buf (mru+PPP_HDRLEN, BUFFER_TYPE_VJ);
701 * If the buffers failed to allocate then complain and release the partial
704 if (new_wbuf == NULL || new_tbuf == NULL ||
705 new_rbuf == NULL || new_cbuf == NULL) {
706 printk (KERN_ERR "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 ppp_free_buf (ppp->rbuf);
822 ppp_free_buf (ppp->wbuf);
823 ppp_free_buf (ppp->cbuf);
824 ppp_free_buf (ppp->ubuf);
825 ppp_free_buf (ppp->tbuf);
837 slhc_free (ppp->slcomp);
843 ppp->backup_tty = NULL;
849 * Called when the line discipline is changed to something
850 * else, the tty is closed, or the tty detects a hangup.
854 ppp_tty_close (struct tty_struct *tty)
856 struct ppp *ppp = tty2ppp (tty);
859 if (ppp->magic != PPP_MAGIC) {
860 if (ppp->flags & SC_DEBUG)
862 "ppp: trying to close unopened tty!\n");
866 tty->disc_data = NULL;
867 if (tty == ppp->backup_tty)
871 if (ppp->backup_tty) {
872 ppp->tty = ppp->backup_tty;
875 if (ppp->flags & SC_DEBUG)
876 printk (KERN_INFO "ppp: channel %s closing.\n",
887 * Called when the tty discipline is switched to PPP.
891 ppp_tty_open (struct tty_struct *tty)
893 struct ppp *ppp = tty2ppp (tty);
896 * There should not be an existing table for this slot.
900 "ppp_tty_open: gack! tty already associated to %s!\n",
901 ppp->magic == PPP_MAGIC ? ppp2dev(ppp)->name
906 * Allocate the structure from the system
908 ppp = ppp_find(current->pid);
911 * If we are taking over a ppp unit which is currently
912 * connected to a loopback pty, there's not much to do.
915 tty->disc_data = ppp;
921 printk (KERN_ERR "ppp_alloc failed\n");
925 * Initialize the control block
927 ppp_init_ctrl_blk (ppp);
928 tty->disc_data = ppp;
931 * Allocate space for the default VJ header compression slots
933 ppp->slcomp = slhc_init (16, 16);
934 if (ppp->slcomp == NULL) {
935 printk (KERN_ERR "ppp_tty_open: "
936 "no space for compression buffers!\n");
941 * Allocate space for the MTU and MRU buffers
943 if (ppp_changedmtu (ppp, ppp2dev(ppp)->mtu, ppp->mru) == 0) {
948 * Allocate space for a user level buffer
950 ppp->ubuf = ppp_alloc_buf (RBUFSIZE, BUFFER_TYPE_TTY_RD);
951 if (ppp->ubuf == NULL) {
952 printk (KERN_ERR "ppp_tty_open: "
953 "no space for user receive buffer\n");
958 if (ppp->flags & SC_DEBUG)
959 printk (KERN_INFO "ppp: channel %s open\n",
962 for (indx = 0; indx < NUM_NP; ++indx)
963 ppp->sc_npmode[indx] = NPMODE_PASS;
968 * Flush any pending characters in the driver and discipline.
970 if (tty->ldisc.flush_buffer)
971 tty->ldisc.flush_buffer (tty);
973 if (tty->driver.flush_buffer)
974 tty->driver.flush_buffer (tty);
979 * Local function to send the next portion of the buffer.
981 * Called by the tty driver's tty_wakeup function should it be entered
982 * because the partial buffer was transmitted.
984 * Called by kick_tty to send the initial portion of the buffer.
986 * Completion processing of the buffer transmission is handled here.
990 ppp_tty_wakeup_code (struct ppp *ppp, struct tty_struct *tty,
991 struct ppp_buffer *xbuf)
993 register int count, actual;
997 CHECK_BUF_MAGIC(xbuf);
999 * Prevent re-entrancy by ensuring that this routine is called only once.
1003 if (ppp->flags & SC_XMIT_BUSY) {
1004 restore_flags(flags);
1007 ppp->flags |= SC_XMIT_BUSY;
1008 restore_flags(flags);
1010 * Send the next block of data to the modem
1012 count = xbuf->count - xbuf->tail;
1013 actual = tty->driver.write (tty, 0,
1014 buf_base (xbuf) + xbuf->tail, count);
1016 * Terminate transmission of any block which may have an error.
1017 * This could occur should the carrier drop.
1020 ppp->stats.ppp_oerrors++;
1023 ppp->bytes_sent += actual;
1025 * If the buffer has been transmitted then clear the indicators.
1027 xbuf->tail += actual;
1028 if (actual == count) {
1030 ppp->flags &= ~SC_XMIT_BUSY;
1032 * Complete the transmission on the current buffer.
1036 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1040 * If the completed buffer came from the device write, then complete the
1041 * transmission block.
1043 ppp2dev (ppp)->tbusy = 0;
1046 * Wake up the transmission queue for all completion events.
1048 wake_up_interruptible (&ppp->write_wait);
1050 * Look at the priorities. Choose a daemon write over the device driver.
1061 * If there is a pending buffer then transmit it now.
1064 ppp->flags &= ~SC_XMIT_BUSY;
1065 ppp_kick_tty (ppp, xbuf);
1066 restore_flags(flags);
1069 restore_flags(flags);
1073 * Clear the re-entry flag
1075 save_flags(flags); /* &=~ may not be atomic */
1077 ppp->flags &= ~SC_XMIT_BUSY;
1078 restore_flags(flags);
1082 * This function is called by the tty driver when the transmit buffer has
1083 * additional space. It is used by the ppp code to continue to transmit
1084 * the current buffer should the buffer have been partially sent.
1086 * In addition, it is used to send the first part of the buffer since the
1087 * logic and the inter-locking would be identical.
1091 ppp_tty_wakeup (struct tty_struct *tty)
1093 struct ppp_buffer *xbuf;
1094 struct ppp *ppp = tty2ppp (tty);
1100 if (tty != ppp->tty) {
1101 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1105 * Ensure that there is a transmission pending. Clear the re-entry flag if
1106 * there is no pending buffer. Otherwise, send the buffer.
1110 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1112 ppp_tty_wakeup_code (ppp, tty, xbuf);
1116 * This function is called to transmit a buffer to the remote. The buffer
1117 * is placed on the pending queue if there is presently a buffer being
1118 * sent or it is transmitted with the aid of ppp_tty_wakeup.
1122 ppp_kick_tty (struct ppp *ppp, struct ppp_buffer *xbuf)
1124 unsigned long flags;
1127 CHECK_BUF_MAGIC(xbuf);
1134 * Control the flags which are best performed with the interrupts masked.
1139 * If the transmitter is busy then place the buffer on the appropriate
1142 if (ppp->xbuf != NULL) {
1143 if (xbuf->type == BUFFER_TYPE_TTY_WR)
1147 restore_flags (flags);
1151 * If the transmitter is not busy then this is the highest priority frame
1153 ppp->flags &= ~SC_XMIT_BUSY;
1154 ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1156 restore_flags (flags);
1158 * Do the "tty wakeup_code" to actually send this buffer.
1160 ppp_tty_wakeup_code (ppp, ppp2tty (ppp), xbuf);
1163 /*************************************************************
1165 * The following functions handle input that arrives from
1166 * the TTY. It recognizes PPP frames and either hands them
1167 * to the network layer or queues them for delivery to a
1168 * user process reading this TTY.
1169 *************************************************************/
1172 * Callback function from tty driver. Return the amount of space left
1173 * in the receiver's buffer to decide if remote transmitter is to be
1178 ppp_tty_room (struct tty_struct *tty)
1180 return 65536; /* We can handle an infinite amount of data. :-) */
1184 * Callback function when data is available at the tty driver.
1187 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1188 char *flags, int count)
1190 register struct ppp *ppp = tty2ppp (tty);
1191 register struct ppp_buffer *buf = NULL;
1197 * This can happen if stuff comes in on the backup tty.
1199 if (ppp == 0 || tty != ppp->tty)
1202 * Fetch the pointer to the buffer. Be careful about race conditions.
1208 * Verify the table pointer and ensure that the line is
1209 * still in PPP discipline.
1211 if (ppp->magic != PPP_MAGIC) {
1212 if (ppp->flags & SC_DEBUG)
1214 "PPP: tty_receive called but couldn't find "
1220 * Print the buffer if desired
1222 if (ppp->flags & SC_LOG_RAWIN)
1223 ppp_print_buffer ("receive buffer", data, count);
1226 * Collect the character and error condition for the character. Set the toss
1227 * flag for the first character error.
1229 while (count-- > 0) {
1233 if (*flags && ppp->toss == 0) {
1235 switch (ppp->toss) {
1237 ++ppp->estats.rx_fifo_errors;
1241 ++ppp->estats.rx_frame_errors;
1249 * Set the flags for d7 being 0/1 and parity being even/odd so that
1250 * the normal processing would have all flags set at the end of the
1251 * session. A missing flag bit indicates an error condition.
1254 #ifdef CHECK_CHARACTERS
1256 ppp->flags |= SC_RCV_B7_1;
1258 ppp->flags |= SC_RCV_B7_0;
1260 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1261 ppp->flags |= SC_RCV_ODDP;
1263 ppp->flags |= SC_RCV_EVNP;
1266 * Branch on the character.
1270 * FLAG. This is the end of the block. If the block terminated by ESC FLAG,
1271 * then the block is to be ignored. In addition, characters before the very
1272 * first FLAG are also tossed by this procedure.
1274 case PPP_FLAG: /* PPP_FLAG: end of frame */
1275 ppp->stats.ppp_ibytes += ppp->rbuf->count;
1279 * Process frames which are not to be ignored. If the processing failed,
1280 * then clean up the VJ tables.
1282 if (ppp_doframe (ppp) == 0) {
1283 ++ppp->stats.ppp_ierrors;
1284 slhc_toss (ppp->slcomp);
1287 * Reset all indicators for the new frame to follow.
1290 buf->fcs = PPP_INITFCS;
1295 * All other characters in the data come here. If the character is in the
1296 * receive mask then ignore the character.
1299 /* If we're tossing, look no further. */
1303 /* If this is a control char to be ignored, do so */
1304 if (in_rmap (ppp, chr))
1308 * Modify the next character if preceded by escape.
1309 * The escape character (0x7d) could be an escaped
1310 * 0x5d, if it follows an escape :-)
1315 } else if (chr == PPP_ESCAPE) {
1316 ppp->escape = PPP_TRANS;
1321 * Decompress A/C and protocol compression here.
1323 if (buf->count == 0 && chr != PPP_ALLSTATIONS) {
1324 buf_base(buf)[0] = PPP_ALLSTATIONS;
1325 buf_base(buf)[1] = PPP_UI;
1328 if (buf->count == 2 && (chr & 1) != 0) {
1329 buf_base(buf)[2] = 0;
1333 * If the count sent is within reason then store the character, bump the
1334 * count, and update the FCS for the character.
1336 if (buf->count < buf->size) {
1337 buf_base (buf)[buf->count++] = chr;
1338 buf->fcs = PPP_FCS (buf->fcs, chr);
1342 * The peer sent too much data. Set the flags to discard the current frame
1343 * and wait for the re-synchronization FLAG to be sent.
1345 ++ppp->estats.rx_length_errors;
1352 /* on entry, a received frame is in ppp->rbuf.bufr
1353 check it and dispose as appropriate */
1356 ppp_doframe (struct ppp *ppp)
1358 __u8 *data = buf_base (ppp->rbuf);
1359 int count = ppp->rbuf->count;
1365 CHECK_BUF_MAGIC(ppp->rbuf);
1368 * If there is a pending error from the receiver then log it and discard
1369 * the damaged frame.
1372 if ((ppp->flags & SC_DEBUG) && count > 0)
1374 "ppp_toss: tossing frame, reason = %x\n",
1379 * An empty frame is ignored. This occurs if the FLAG sequence precedes and
1380 * follows each frame.
1385 * Generate an error if the frame is too small.
1387 if (count < PPP_HDRLEN + 2) {
1388 if (ppp->flags & SC_DEBUG)
1390 "ppp: got runt ppp frame, %d chars\n", count);
1391 ++ppp->estats.rx_length_errors;
1395 * Verify the CRC of the frame and discard the CRC characters from the
1396 * end of the buffer.
1398 if (ppp->rbuf->fcs != PPP_GOODFCS) {
1399 if (ppp->flags & SC_DEBUG) {
1401 "ppp: frame with bad fcs, length = %d\n",
1403 ppp_print_buffer("bad frame", data, count);
1405 ++ppp->estats.rx_crc_errors;
1408 count -= 2; /* ignore the fcs characters */
1410 * Obtain the protocol from the frame
1412 proto = PPP_PROTOCOL(data);
1414 * Process the active decompressor.
1416 if ((ppp->sc_rc_state != (void *) 0) &&
1417 (ppp->flags & SC_DECOMP_RUN) &&
1418 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
1419 if (proto == PPP_COMP) {
1421 * If the frame is compressed then decompress it.
1423 new_data = kmalloc (ppp->mru + PPP_HDRLEN, GFP_ATOMIC);
1424 if (new_data == NULL) {
1425 printk (KERN_ERR "ppp_doframe: no memory\n");
1426 new_count = DECOMP_ERROR;
1428 new_count = (*ppp->sc_rcomp->decompress)
1429 (ppp->sc_rc_state, data, count,
1430 new_data, ppp->mru + PPP_HDRLEN);
1432 switch (new_count) {
1434 ppp_doframe_lower (ppp, new_data, new_count);
1439 ppp->flags |= SC_DC_ERROR;
1442 case DECOMP_FATALERROR:
1443 ppp->flags |= SC_DC_FERROR;
1444 printk(KERN_ERR "ppp: fatal decomp error\n");
1448 * Log the error condition and discard the frame.
1452 slhc_toss (ppp->slcomp);
1453 ++ppp->stats.ppp_ierrors;
1456 * The frame is not special. Pass it through the compressor without
1457 * actually compressing the data
1459 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1462 } else if (proto == PPP_COMP && (ppp->flags & SC_DEBUG)) {
1463 printk(KERN_DEBUG "ppp: frame not decompressed: "
1464 "flags=%x, count=%d, sc_rc_state=%p\n",
1465 ppp->flags, count, ppp->sc_rc_state);
1468 * Process the uncompressed frame.
1470 ppp_doframe_lower (ppp, data, count);
1474 static void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
1476 __u16 proto = PPP_PROTOCOL (data);
1477 ppp_proto_type *proto_ptr;
1481 * Ignore empty frames
1483 if (count <= PPP_HDRLEN)
1486 * Count the frame and print it
1488 ++ppp->stats.ppp_ipackets;
1489 if (ppp->flags & SC_LOG_INPKT)
1490 ppp_print_buffer ("receive frame", data, count);
1492 * Find the procedure to handle this protocol. The last one is marked
1493 * as a protocol 0 which is the 'catch-all' to feed it to the pppd daemon.
1495 proto_ptr = proto_list;
1496 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
1499 * Update the appropriate statistic counter.
1501 if ((*proto_ptr->func) (ppp, proto,
1503 count - PPP_HDRLEN))
1504 ppp->stats.ppp_ioctects += count;
1506 ++ppp->stats.ppp_discards;
1510 * Put the input frame into the networking system for the indicated protocol
1514 ppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1516 sk_buff *skb = dev_alloc_skb (count);
1518 * Generate a skb buffer for the new frame.
1521 if (ppp->flags & SC_DEBUG)
1523 "ppp_do_ip: packet dropped on %s (no memory)!\n",
1524 ppp2dev (ppp)->name);
1528 * Move the received data from the input buffer to the skb buffer.
1530 skb->dev = ppp2dev (ppp); /* We are the device */
1531 skb->protocol = proto;
1532 skb->mac.raw = skb_data(skb);
1533 memcpy (skb_put(skb,count), data, count); /* move data */
1535 * Tag the frame and kick it to the proper receive routine
1537 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1541 ppp->last_recv = jiffies;
1547 * Process the receipt of an IP frame
1551 rcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1554 if ((ppp2dev (ppp)->flags & IFF_UP) && (count > 0))
1555 if (ppp->sc_npmode[NP_IP] == NPMODE_PASS)
1556 return ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
1561 * Process the receipt of an IPX frame
1565 rcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1568 if (((ppp2dev (ppp)->flags & IFF_UP) != 0) && (count > 0))
1569 return ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
1574 * Process the receipt of an VJ Compressed frame
1578 rcv_proto_vjc_comp (struct ppp *ppp, __u16 proto,
1579 __u8 *data, int count)
1582 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1583 int new_count = slhc_uncompress (ppp->slcomp, data, count);
1584 if (new_count >= 0) {
1585 return rcv_proto_ip (ppp, PPP_IP, data, new_count);
1587 if (ppp->flags & SC_DEBUG)
1589 "ppp: error in VJ decompression\n");
1595 * Process the receipt of an VJ Un-compressed frame
1599 rcv_proto_vjc_uncomp (struct ppp *ppp, __u16 proto,
1600 __u8 *data, int count)
1603 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1604 if (slhc_remember (ppp->slcomp, data, count) > 0) {
1605 return rcv_proto_ip (ppp, PPP_IP, data, count);
1607 if (ppp->flags & SC_DEBUG)
1609 "ppp: error in VJ memorizing\n");
1615 * Receive all unclassified protocols.
1619 rcv_proto_unknown (struct ppp *ppp, __u16 proto,
1620 __u8 *data, int len)
1623 register int current_idx;
1627 buf_base (ppp->ubuf) [current_idx++] = (__u8) (c); \
1628 current_idx &= ppp->ubuf->size; \
1629 if (current_idx == ppp->ubuf->tail) \
1635 * The total length includes the protocol data.
1636 * Lock the user information buffer.
1638 if (test_and_set_bit (0, &ppp->ubuf->locked)) {
1639 if (ppp->flags & SC_DEBUG)
1641 "ppp: rcv_proto_unknown: can't get lock\n");
1643 CHECK_BUF_MAGIC(ppp->ubuf);
1644 current_idx = ppp->ubuf->head;
1646 * Insert the buffer length (not counted), the protocol, and the data
1656 while (totlen-- > 0) {
1661 * The frame is complete. Update the head pointer and wakeup the pppd
1664 ppp->ubuf->head = current_idx;
1666 clear_bit (0, &ppp->ubuf->locked);
1667 wake_up_interruptible (&ppp->read_wait);
1668 if (ppp->tty->fasync != NULL)
1669 kill_fasync (ppp->tty->fasync, SIGIO);
1673 * The buffer is full. Unlock the header
1676 clear_bit (0, &ppp->ubuf->locked);
1677 if (ppp->flags & SC_DEBUG)
1679 "ppp: rcv_proto_unknown: buffer overflow\n");
1682 * Discard the frame. There are no takers for this protocol.
1684 if (ppp->flags & SC_DEBUG)
1686 "ppp: rcv_proto_unknown: dropping packet\n");
1691 * Handle a CCP packet.
1693 * The CCP packet is passed along to the pppd process just like any
1694 * other PPP frame. The difference is that some processing needs to be
1695 * immediate or the compressors will become confused on the peer.
1698 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd)
1700 int slen = CCP_LENGTH(dp);
1701 __u8 *opt = dp + CCP_HDRLEN;
1702 int opt_len = slen - CCP_HDRLEN;
1703 unsigned long flags;
1709 switch (CCP_CODE(dp)) {
1714 * CCP must be going down - disable compression
1716 if (ppp->flags & SC_CCP_UP) {
1718 ppp->flags &= ~(SC_CCP_UP |
1725 if ((ppp->flags & SC_CCP_OPEN) == 0)
1727 if (ppp->flags & SC_CCP_UP)
1729 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1731 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1734 * we're agreeing to send compressed packets.
1737 if (ppp->sc_xc_state == NULL)
1740 if ((*ppp->sc_xcomp->comp_init)
1744 ppp2dev (ppp)->base_addr,
1746 ppp->flags & SC_DEBUG)) {
1747 if (ppp->flags & SC_DEBUG)
1748 printk(KERN_DEBUG "%s: comp running\n",
1751 ppp->flags |= SC_COMP_RUN;
1756 * peer is agreeing to send compressed packets.
1758 if (ppp->sc_rc_state == NULL)
1761 if ((*ppp->sc_rcomp->decomp_init)
1765 ppp2dev (ppp)->base_addr,
1768 ppp->flags & SC_DEBUG)) {
1769 if (ppp->flags & SC_DEBUG)
1770 printk(KERN_DEBUG "%s: decomp running\n",
1773 ppp->flags |= SC_DECOMP_RUN;
1774 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1778 * CCP Reset-ack resets compressors and decompressors as it passes through.
1781 if ((ppp->flags & SC_CCP_UP) == 0)
1785 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
1786 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1787 if (ppp->flags & SC_DEBUG)
1788 printk(KERN_DEBUG "%s: comp reset\n",
1792 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1793 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1794 if (ppp->flags & SC_DEBUG)
1795 printk(KERN_DEBUG "%s: decomp reset\n",
1798 ppp->flags &= ~SC_DC_ERROR;
1803 if (ppp->flags & SC_DEBUG)
1804 printk(KERN_DEBUG "ppp_proto_ccp: %s code %d, flags=%x\n",
1805 (rcvd? "rcvd": "sent"), CCP_CODE(dp), ppp->flags);
1806 restore_flags(flags);
1810 rcv_proto_ccp (struct ppp *ppp, __u16 proto, __u8 *dp, int len)
1813 ppp_proto_ccp (ppp, dp, len, 1);
1814 return rcv_proto_unknown (ppp, proto, dp, len);
1818 * Handle a LQR packet.
1822 rcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
1824 return rcv_proto_unknown (ppp, proto, data, len);
1827 /*************************************************************
1828 * LINE DISCIPLINE SUPPORT
1829 * The following functions form support user programs
1830 * which read and write data on a TTY with the PPP line
1831 * discipline. Reading is done from a circular queue,
1832 * filled by the lower TTY levels.
1833 *************************************************************/
1835 /* read a PPP frame from the us_rbuff circular buffer,
1836 waiting if necessary
1840 ppp_tty_read (struct tty_struct *tty, struct file *file, __u8 * buf,
1843 struct ppp *ppp = tty2ppp (tty);
1850 c = buf_base (ppp->ubuf) [ppp->ubuf->tail++]; \
1851 ppp->ubuf->tail &= ppp->ubuf->size; \
1855 * Validate the pointers
1860 /* if (ppp->magic != PPP_MAGIC)
1866 * Before we attempt to write the frame to the user, ensure that the
1867 * user has access to the pages for the total buffer length.
1869 error = verify_area (VERIFY_WRITE, buf, nr);
1874 * Acquire the read lock.
1877 ppp = tty2ppp (tty);
1878 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
1882 if (test_and_set_bit (0, &ppp->ubuf->locked) != 0) {
1884 if (ppp->flags & SC_DEBUG)
1886 "ppp_tty_read: sleeping(ubuf)\n");
1888 current->timeout = 0;
1889 current->state = TASK_INTERRUPTIBLE;
1892 if (signal_pending(current))
1898 * Fetch the length of the buffer from the first two bytes.
1900 if (ppp->ubuf->head == ppp->ubuf->tail)
1912 * If there is no length then wait for the data to arrive.
1915 clear_bit (0, &ppp->ubuf->locked);
1916 if (file->f_flags & O_NONBLOCK)
1918 current->timeout = 0;
1920 if (ppp->flags & SC_DEBUG)
1922 "ppp_tty_read: sleeping(read_wait)\n");
1924 interruptible_sleep_on (&ppp->read_wait);
1925 if (signal_pending(current))
1930 * Ensure that the frame will fit within the caller's buffer. If not, then
1931 * discard the frame from the input buffer.
1934 /* Can't copy it, update us_rbuff_head */
1936 if (ppp->flags & SC_DEBUG)
1938 "ppp: read of %lu bytes too small for %ld "
1939 "frame\n", (unsigned long) nr, (long) len + 2);
1940 ppp->stats.ppp_ierrors++;
1946 * Fake the insertion of the ADDRESS and CONTROL information because these
1947 * were not saved in the buffer.
1949 PUT_USER (error, (u_char) PPP_ALLSTATIONS, buf);
1953 PUT_USER (error, (u_char) PPP_UI, buf);
1959 * Copy the received data from the buffer to the caller's area.
1961 ret = len + 2; /* Account for ADDRESS and CONTROL bytes */
1964 PUT_USER (error, c, buf);
1970 clear_bit (0, &ppp->ubuf->locked);
1974 ppp->ubuf->tail += len;
1975 ppp->ubuf->tail &= ppp->ubuf->size;
1976 clear_bit (0, &ppp->ubuf->locked);
1981 /* stuff a character into the transmit buffer, using PPP's way of escaping
1983 also, update fcs to take account of new character */
1986 ppp_stuff_char (struct ppp *ppp, register struct ppp_buffer *buf,
1990 * The buffer should not be full.
1992 if (ppp->flags & SC_DEBUG) {
1993 if ((buf->count < 0) || (buf->count > 3000))
1994 printk (KERN_DEBUG "ppp_stuff_char: %d %x\n",
1995 (unsigned int) buf->count,
1996 (unsigned int) chr);
1999 * Update the FCS and if the character needs to be escaped, do it.
2001 buf->fcs = PPP_FCS (buf->fcs, chr);
2002 if (in_xmap (ppp, chr)) {
2004 ins_char (buf, PPP_ESCAPE);
2007 * Add the character to the buffer.
2009 ins_char (buf, chr);
2013 * Procedure to encode the data with the proper escaping and send the
2014 * data to the remote system.
2018 ppp_dev_xmit_lower (struct ppp *ppp, struct ppp_buffer *buf,
2019 __u8 *data, int count, int non_ip)
2022 int address, control;
2026 CHECK_BUF_MAGIC(buf);
2027 ++ppp->stats.ppp_opackets;
2028 ppp->stats.ppp_ooctects += count;
2031 * Insert the leading FLAG character
2035 if (non_ip || flag_time == 0)
2036 ins_char (buf, PPP_FLAG);
2038 if (jiffies - ppp->last_xmit >= flag_time)
2039 ins_char (buf, PPP_FLAG);
2041 ppp->last_xmit = jiffies;
2042 buf->fcs = PPP_INITFCS;
2044 * Emit the address/control information if needed
2046 address = PPP_ADDRESS (data);
2047 control = PPP_CONTROL (data);
2048 proto = PPP_PROTOCOL (data);
2050 if (address != PPP_ALLSTATIONS ||
2051 control != PPP_UI ||
2052 (ppp->flags & SC_COMP_AC) == 0) {
2053 ppp_stuff_char (ppp, buf, address);
2054 ppp_stuff_char (ppp, buf, control);
2057 * Emit the protocol (compressed if possible)
2059 if ((ppp->flags & SC_COMP_PROT) == 0 || (proto & 0xFF00))
2060 ppp_stuff_char (ppp, buf, proto >> 8);
2062 ppp_stuff_char (ppp, buf, proto);
2070 ppp_stuff_char (ppp, buf, *data++);
2072 * Add the trailing CRC and the final flag character
2074 write_fcs = buf->fcs ^ 0xFFFF;
2075 ppp_stuff_char (ppp, buf, write_fcs);
2076 ppp_stuff_char (ppp, buf, write_fcs >> 8);
2078 * Add the trailing flag character
2080 ins_char (buf, PPP_FLAG);
2082 * Send the block to the tty driver.
2084 ppp->stats.ppp_obytes += buf->count;
2085 ppp_kick_tty (ppp, buf);
2089 * Compress and send an frame to the peer.
2091 * Return 0 if frame was queued for transmission.
2092 * 1 if frame must be re-queued for later driver support.
2096 ppp_dev_xmit_frame (struct ppp *ppp, struct ppp_buffer *buf,
2097 __u8 *data, int count)
2100 int address, control;
2105 CHECK_BUF_MAGIC(buf);
2109 if (ppp->flags & SC_LOG_OUTPKT)
2110 ppp_print_buffer ("write frame", data, count);
2112 * Determine if the frame may be compressed. Attempt to compress the
2113 * frame if possible.
2115 proto = PPP_PROTOCOL (data);
2116 address = PPP_ADDRESS (data);
2117 control = PPP_CONTROL (data);
2119 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2120 (ppp->sc_xc_state != (void *) 0) &&
2121 (address == PPP_ALLSTATIONS) &&
2122 (control == PPP_UI) &&
2123 (proto != PPP_LCP) &&
2124 (proto != PPP_CCP)) {
2125 new_data = kmalloc (ppp->mtu + PPP_HDRLEN, GFP_ATOMIC);
2126 if (new_data == NULL) {
2127 printk (KERN_ERR "ppp_dev_xmit_frame: no memory\n");
2131 new_count = (*ppp->sc_xcomp->compress)
2132 (ppp->sc_xc_state, data, new_data, count,
2133 ppp->mtu + PPP_HDRLEN);
2135 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2136 ppp_dev_xmit_lower (ppp, buf, new_data, new_count, 0);
2141 * The frame could not be compressed, or it could not be sent in
2142 * compressed form because CCP is not yet up.
2147 * Go to the escape encoding
2149 ppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
2154 * Revise the tty frame for specific protocols.
2158 send_revise_frame (register struct ppp *ppp, __u8 *data, int len)
2162 switch (PPP_PROTOCOL (data)) {
2164 * Update the LQR frame with the current MIB information. This saves having
2165 * the daemon read old MIB data from the driver.
2168 len = 48; /* total size of this frame */
2169 p = (__u8 *) &data [40]; /* Point to last two items. */
2170 p = store_long (p, ppp->stats.ppp_opackets + 1);
2171 p = store_long (p, ppp->stats.ppp_ooctects + len);
2174 * Outbound compression frames
2191 * write a frame with NR chars from BUF to TTY
2192 * we have to put the FCS field on ourselves
2196 ppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
2199 struct ppp *ppp = tty2ppp (tty);
2202 struct wait_queue wait = {current, NULL};
2205 * Verify the pointers.
2210 if (ppp->magic != PPP_MAGIC)
2215 * Ensure that the caller does not wish to send too much.
2217 if (count > PPP_MTU + PPP_HDRLEN) {
2218 if (ppp->flags & SC_DEBUG)
2219 printk (KERN_WARNING
2220 "ppp_tty_write: truncating user packet "
2221 "from %lu to mtu %d\n", (unsigned long) count,
2222 PPP_MTU + PPP_HDRLEN);
2223 count = PPP_MTU + PPP_HDRLEN;
2226 * Allocate a buffer for the data and fetch it from the user space.
2228 new_data = kmalloc (count, GFP_KERNEL);
2229 if (new_data == NULL) {
2230 printk (KERN_ERR "ppp_tty_write: no memory\n");
2234 * Retrieve the user's buffer
2236 COPY_FROM_USER (error, new_data, data, count);
2240 * Lock this PPP unit so we will be the only writer,
2241 * sleeping if necessary.
2243 * Note that we add our task to the wait queue before
2244 * attempting to lock, as the lock flag may be cleared
2245 * from an interrupt.
2247 add_wait_queue(&ppp->write_wait, &wait);
2250 current->timeout = 0;
2251 current->state = TASK_INTERRUPTIBLE;
2252 if (lock_buffer(ppp->tbuf) == 0)
2257 ppp = tty2ppp (tty);
2258 if (!ppp || ppp->magic != PPP_MAGIC ||
2259 !ppp->inuse || tty != ppp->tty) {
2260 printk("ppp_tty_write: %p invalid after wait!\n", ppp);
2264 if (signal_pending(current))
2267 current->state = TASK_RUNNING;
2268 remove_wait_queue(&ppp->write_wait, &wait);
2273 * Change the LQR frame
2275 count = send_revise_frame (ppp, new_data, count);
2279 if (PPP_PROTOCOL(new_data) == PPP_IP) {
2281 * IP frames can be sent by pppd when we're doing
2282 * demand-dialling. We send them via ppp_dev_xmit_ip
2283 * to make sure that VJ compression happens properly.
2285 ppp_dev_xmit_ip(ppp, ppp->tbuf, new_data + PPP_HDRLEN,
2286 count - PPP_HDRLEN, NPMODE_PASS);
2289 ppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
2299 * Process the set-compression ioctl.
2303 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
2305 struct compressor *cp;
2307 unsigned long flags;
2309 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
2310 struct ppp_option_data data;
2313 * Fetch the compression parameters
2315 COPY_FROM_USER (error, &data, odp, sizeof (data));
2321 if ((__u32) nb >= (__u32)CCP_MAX_OPTION_LENGTH)
2322 nb = CCP_MAX_OPTION_LENGTH;
2324 COPY_FROM_USER (error, ccp_option, ptr, nb);
2328 if (ccp_option[1] < 2) /* preliminary check on the length byte */
2333 ppp->flags &= ~(data.transmit? SC_COMP_RUN: SC_DECOMP_RUN);
2334 restore_flags(flags);
2336 cp = find_compressor (ccp_option[0]);
2337 #ifdef CONFIG_KERNELD
2340 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
2341 request_module(modname);
2342 cp = find_compressor(ccp_option[0]);
2344 #endif /* CONFIG_KERNELD */
2349 * Found a handler for the protocol - try to allocate
2350 * a compressor or decompressor.
2353 if (data.transmit) {
2354 if (ppp->sc_xc_state != NULL)
2355 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2356 ppp->sc_xc_state = NULL;
2359 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2360 if (ppp->sc_xc_state == NULL) {
2361 printk(KERN_WARNING "%s: comp_alloc failed\n",
2364 } else if (ppp->flags & SC_DEBUG)
2365 printk(KERN_DEBUG "%s: comp_alloc -> %p\n",
2366 ppp->name, ppp->sc_xc_state);
2368 if (ppp->sc_rc_state != NULL)
2369 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2370 ppp->sc_rc_state = NULL;
2373 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2374 if (ppp->sc_rc_state == NULL) {
2375 printk(KERN_WARNING "%s: decomp_alloc failed\n",
2378 } else if (ppp->flags & SC_DEBUG)
2379 printk(KERN_DEBUG "%s: decomp_alloc -> %p\n",
2380 ppp->name, ppp->sc_rc_state);
2385 if (ppp->flags & SC_DEBUG)
2386 printk(KERN_DEBUG "%s: no compressor for [%x %x %x], %x\n",
2387 ppp->name, ccp_option[0], ccp_option[1],
2389 return (-EINVAL); /* no handler found */
2393 * Process the IOCTL event for the tty device.
2397 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
2398 unsigned int param2, unsigned long param3)
2400 struct ppp *ppp = tty2ppp (tty);
2401 register int temp_i = 0, oldflags;
2403 unsigned long flags;
2405 * Verify the status of the PPP device.
2410 if (ppp->magic != PPP_MAGIC)
2415 * The user must have an euid of root to do these requests.
2424 GET_USER (error, temp_i, (int *) param3);
2427 if (ppp->flags & SC_DEBUG)
2429 "ppp_tty_ioctl: set mru to %x\n", temp_i);
2431 if (ppp->mru != temp_i)
2432 ppp_changedmtu (ppp, ppp2dev (ppp)->mtu, temp_i);
2438 temp_i = (ppp->flags & SC_MASK);
2439 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
2440 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
2441 SC_RCV_ODDP | SC_RCV_EVNP;
2443 PUT_USER (error, temp_i, (int *) param3);
2446 * Set the flags for the various options
2449 GET_USER (error, temp_i, (int *) param3);
2454 if ((ppp->flags & SC_CCP_OPEN) && (temp_i & SC_CCP_OPEN) == 0)
2455 ppp_ccp_closed(ppp);
2459 oldflags = ppp->flags;
2460 ppp->flags = temp_i |= (ppp->flags & ~SC_MASK);
2461 restore_flags(flags);
2462 if ((oldflags | temp_i) & SC_DEBUG)
2464 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2467 * Set the compression mode
2469 case PPPIOCSCOMPRESS:
2470 error = ppp_set_compression (ppp,
2471 (struct ppp_option_data *) param3);
2474 * Retrieve the transmit async map
2476 case PPPIOCGASYNCMAP:
2477 PUT_USER (error, ppp->xmit_async_map[0], (int *) param3);
2480 * Set the transmit async map
2482 case PPPIOCSASYNCMAP:
2483 GET_USER (error, temp_i, (int *) param3);
2486 ppp->xmit_async_map[0] = temp_i;
2487 if (ppp->flags & SC_DEBUG)
2489 "ppp_tty_ioctl: set xmit asyncmap %x\n",
2490 ppp->xmit_async_map[0]);
2493 * Set the receive async map
2495 case PPPIOCSRASYNCMAP:
2496 GET_USER (error, temp_i, (int *) param3);
2499 ppp->recv_async_map = temp_i;
2500 if (ppp->flags & SC_DEBUG)
2502 "ppp_tty_ioctl: set rcv asyncmap %x\n",
2503 ppp->recv_async_map);
2506 * Obtain the unit number for this device.
2509 PUT_USER (error, ppp2dev (ppp)->base_addr, (int *) param3);
2512 if (ppp->flags & SC_DEBUG)
2514 "ppp_tty_ioctl: get unit: %ld\n",
2515 ppp2dev (ppp)->base_addr);
2518 * Set the debug level
2521 GET_USER (error, temp_i, (int *) param3);
2524 temp_i = (temp_i & 0x1F) << 16;
2525 temp_i |= (ppp->flags & ~0x1F0000);
2527 if ((ppp->flags | temp_i) & SC_DEBUG)
2529 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2530 ppp->flags = temp_i;
2533 * Get the debug level
2536 temp_i = (ppp->flags >> 16) & 0x1F;
2537 PUT_USER (error, temp_i, (int *) param3);
2540 * Get the times since the last send/receive frame operation
2544 struct ppp_idle cur_ddinfo;
2546 /* change absolute times to relative times. */
2547 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
2548 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
2549 COPY_TO_USER (error, (void *) param3, &cur_ddinfo,
2550 sizeof (cur_ddinfo));
2554 * Retrieve the extended async map
2556 case PPPIOCGXASYNCMAP:
2557 COPY_TO_USER (error, (void *) param3, ppp->xmit_async_map,
2558 sizeof (ppp->xmit_async_map));
2561 * Set the async extended map
2563 case PPPIOCSXASYNCMAP:
2567 COPY_FROM_USER (error, temp_tbl, (void *) param3,
2572 temp_tbl[1] = 0x00000000;
2573 temp_tbl[2] &= ~0x40000000;
2574 temp_tbl[3] |= 0x60000000;
2576 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
2577 (temp_tbl[4] & temp_tbl[5]) != 0 ||
2578 (temp_tbl[6] & temp_tbl[7]) != 0)
2581 memcpy (ppp->xmit_async_map,
2583 sizeof (ppp->xmit_async_map));
2585 if (ppp->flags & SC_DEBUG)
2587 "ppp_tty_ioctl: set xasyncmap\n");
2592 * Set the maximum VJ header compression slot number.
2595 GET_USER (error, temp_i, (int *) param3);
2598 temp_i = (temp_i & 255) + 1;
2599 if (ppp->flags & SC_DEBUG)
2601 "ppp_tty_ioctl: set maxcid to %d\n", temp_i);
2602 if (ppp->slcomp != NULL)
2603 slhc_free (ppp->slcomp);
2606 ppp->slcomp = slhc_init (16, temp_i);
2607 if (ppp->slcomp == NULL) {
2608 printk (KERN_ERR "ppp_tty_ioctl: "
2609 "no space for compression buffers!\n");
2615 case PPPIOCXFERUNIT:
2616 ppp->backup_tty = tty;
2617 ppp->sc_xfer = current->pid;
2625 COPY_FROM_USER (error, &npi, (void *) param3,
2630 switch (npi.protocol) {
2632 npi.protocol = NP_IP;
2635 if (ppp->flags & SC_DEBUG)
2636 printk(KERN_DEBUG "pppioc[gs]npmode: "
2637 "invalid protocol %d\n",
2645 if (param2 == PPPIOCGNPMODE) {
2646 npi.mode = ppp->sc_npmode[npi.protocol];
2648 COPY_TO_USER (error, (void *) param3, &npi,
2653 ppp->sc_npmode[npi.protocol] = npi.mode;
2654 if (ppp->flags & SC_DEBUG)
2655 printk(KERN_DEBUG "ppp: set np %d to %d\n",
2656 npi.protocol, npi.mode);
2657 ppp2dev(ppp)->tbusy = 0;
2662 * Allow users to read, but not set, the serial port parameters
2666 error = n_tty_ioctl (tty, file, param2, param3);
2671 int count = ppp->ubuf->tail - ppp->ubuf->head;
2673 count += (ppp->ubuf->size + 1);
2674 PUT_USER (error, count, (int *) param3);
2678 * All other ioctl() events will come here.
2681 if (ppp->flags & SC_DEBUG)
2682 printk (KERN_WARNING "ppp_tty_ioctl: "
2683 "invalid ioctl=%x, addr=%lx\n", param2, param3);
2684 error = -ENOIOCTLCMD;
2693 * Process the select() (or poll()) statement for the PPP device.
2696 #if LINUX_VERSION_CODE < VERSION(2,1,23)
2698 ppp_tty_select (struct tty_struct *tty, struct inode *inode,
2699 struct file *filp, int sel_type, select_table * wait)
2701 struct ppp *ppp = tty2ppp (tty);
2704 * Verify the status of the PPP device.
2709 if (ppp->magic != PPP_MAGIC || tty != ppp->tty)
2714 * Branch on the type of select mode. A read request must lock the user
2719 if (test_and_set_bit (0, &ppp->ubuf->locked) == 0) {
2720 /* Test for the presence of data in the queue */
2721 if (ppp->ubuf->head != ppp->ubuf->tail) {
2722 clear_bit (0, &ppp->ubuf->locked);
2725 clear_bit (0, &ppp->ubuf->locked);
2726 } /* fall through */
2728 * Exceptions or read errors.
2731 /* Is this a pty link and the remote disconnected? */
2732 if (tty->flags & (1 << TTY_OTHER_CLOSED))
2735 /* Is this a local link and the modem disconnected? */
2736 if (tty_hung_up_p (filp))
2739 select_wait (&ppp->read_wait, wait);
2743 * Write mode. A write is allowed if there is no current transmission.
2746 if (ppp->tbuf->locked != 0) {
2747 select_wait (&ppp->write_wait, wait);
2755 #else /* 2.1.23 or later */
2758 ppp_tty_poll (struct tty_struct *tty, struct file *filp, poll_table * wait)
2760 struct ppp *ppp = tty2ppp (tty);
2761 unsigned int mask = 0;
2763 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
2766 #if LINUX_VERSION_CODE < VERSION(2,1,89)
2767 poll_wait(&ppp->read_wait, wait);
2768 poll_wait(&ppp->write_wait, wait);
2770 poll_wait(filp, &ppp->read_wait, wait);
2771 poll_wait(filp, &ppp->write_wait, wait);
2774 /* Must lock the user buffer area while checking. */
2775 CHECK_BUF_MAGIC(ppp->ubuf);
2776 if(test_and_set_bit(0, &ppp->ubuf->locked) == 0) {
2777 if(ppp->ubuf->head != ppp->ubuf->tail)
2778 mask |= POLLIN | POLLRDNORM;
2779 clear_bit(0, &ppp->ubuf->locked);
2781 if(tty->flags & (1 << TTY_OTHER_CLOSED))
2783 if(tty_hung_up_p(filp))
2785 if(ppp->tbuf->locked == 0)
2786 mask |= POLLOUT | POLLWRNORM;
2793 /*************************************************************
2795 * This routine accepts requests from the network layer
2796 * and attempts to deliver the packets.
2797 * It also includes various routines we are compelled to
2798 * have to make the network layer work (arp, etc...).
2799 *************************************************************/
2802 * Callback from the network layer when the device goes up.
2806 ppp_dev_open (struct device *dev)
2808 struct ppp *ppp = dev2ppp (dev);
2810 if (ppp2tty (ppp) == NULL) {
2812 "ppp: %s not connected to a TTY! can't go open!\n",
2817 if (ppp->flags & SC_DEBUG)
2819 "ppp: channel %s going up for IP packets!\n",
2827 * Callback from the network layer when the ppp device goes down.
2831 ppp_dev_close (struct device *dev)
2833 struct ppp *ppp = dev2ppp (dev);
2835 if (ppp2tty (ppp) == NULL) {
2839 * We don't do anything about the device going down. It is not important
2842 if (ppp->flags & SC_DEBUG)
2844 "ppp: channel %s going down for IP packets!\n",
2851 * IOCTL operation to read the version of the driver.
2855 ppp_dev_ioctl_version (struct ppp *ppp, struct ifreq *ifr)
2858 char *result = (char *) ifr->ifr_ifru.ifru_data;
2859 int len = strlen (szVersion) + 1;
2861 * Move the version data
2863 COPY_TO_USER (error, result, szVersion, len);
2869 * IOCTL to read the statistics for the pppstats program.
2873 ppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2875 struct ppp_stats *result, temp;
2878 * Supply the information for the caller. First move the version data
2879 * then move the ppp stats; and finally the vj stats.
2881 memset (&temp, 0, sizeof(temp));
2882 if (dev->flags & IFF_UP) {
2883 memcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
2884 if (ppp->slcomp != NULL) {
2885 temp.vj.vjs_packets = ppp->slcomp->sls_o_compressed+
2886 ppp->slcomp->sls_o_uncompressed;
2887 temp.vj.vjs_compressed = ppp->slcomp->sls_o_compressed;
2888 temp.vj.vjs_searches = ppp->slcomp->sls_o_searches;
2889 temp.vj.vjs_misses = ppp->slcomp->sls_o_misses;
2890 temp.vj.vjs_errorin = ppp->slcomp->sls_i_error;
2891 temp.vj.vjs_tossed = ppp->slcomp->sls_i_tossed;
2892 temp.vj.vjs_uncompressedin = ppp->slcomp->sls_i_uncompressed;
2893 temp.vj.vjs_compressedin = ppp->slcomp->sls_i_compressed;
2897 result = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
2899 COPY_TO_USER (error, result, &temp, sizeof (temp));
2905 * IOCTL to read the compression statistics for the pppstats program.
2909 ppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2911 struct ppp_comp_stats *result, temp;
2914 * Supply the information for the caller.
2916 memset (&temp, 0, sizeof(temp));
2917 if (dev->flags & IFF_UP) {
2918 if (ppp->sc_xc_state != NULL)
2919 (*ppp->sc_xcomp->comp_stat) (ppp->sc_xc_state,
2922 if (ppp->sc_rc_state != NULL)
2923 (*ppp->sc_rcomp->decomp_stat) (ppp->sc_rc_state,
2927 * Move the data to the caller's buffer
2929 result = (struct ppp_comp_stats *) ifr->ifr_ifru.ifru_data;
2931 COPY_TO_USER (error, result, &temp, sizeof (temp));
2937 * Callback from the network layer to process the sockioctl functions.
2941 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
2943 struct ppp *ppp = dev2ppp (dev);
2946 CHECK_PPP_MAGIC(ppp);
2948 * Process the requests
2952 error = ppp_dev_ioctl_stats (ppp, ifr, dev);
2955 case SIOCGPPPCSTATS:
2956 error = ppp_dev_ioctl_comp_stats (ppp, ifr, dev);
2960 error = ppp_dev_ioctl_version (ppp, ifr);
2971 * Send an IP frame to the remote with vj header compression.
2973 * Return 0 if frame was queued for transmission.
2974 * 1 if frame must be re-queued for later driver support.
2975 * -1 if frame should be dropped.
2979 ppp_dev_xmit_ip (struct ppp *ppp, struct ppp_buffer *buf,
2980 __u8 *data, int len, enum NPmode npmode)
2985 * Branch on the type of processing for the IP frame.
2993 * We may not send the packet now, so drop it.
2994 * XXX It would be nice to be able to return it to the
2995 * network system to be queued and retransmitted later.
2997 if (ppp->flags & SC_DEBUG)
2998 printk(KERN_DEBUG "%s: returning frame\n",
3004 if (ppp->flags & SC_DEBUG)
3006 "ppp_dev_xmit: npmode = %d on %s\n",
3007 ppp->sc_npmode[NP_IP], ppp->name);
3011 if (ppp->flags & SC_DEBUG)
3012 printk (KERN_WARNING
3013 "ppp_dev_xmit: unknown npmode %d on %s\n",
3014 ppp->sc_npmode[NP_IP], ppp->name);
3018 * At this point, the buffer will be transmitted. There is no other exit.
3020 * Try to compress the header.
3022 if (ppp->flags & SC_COMP_TCP) {
3023 len = slhc_compress (ppp->slcomp, data, len,
3024 buf_base (ppp->cbuf) + PPP_HDRLEN,
3026 (ppp->flags & SC_NO_TCP_CCID) == 0);
3028 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
3029 proto = PPP_VJC_COMP;
3030 data[0] ^= SL_TYPE_COMPRESSED_TCP;
3032 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
3033 proto = PPP_VJC_UNCOMP;
3034 data[0] = (data[0] & 0x0f) | 0x40;
3041 hdr = data - PPP_HDRLEN;
3043 hdr[0] = PPP_ALLSTATIONS;
3048 return ppp_dev_xmit_frame (ppp, buf, hdr, len);
3052 * Send a non-IP data frame (such as an IPX frame) to the remote.
3054 * Return 0 if frame was queued for transmission.
3055 * 1 if frame must be re-queued for later driver support.
3058 ppp_dev_xmit_other (struct device *dev, struct ppp *ppp,
3059 __u8 *data, int len, int proto)
3066 hdr = data - PPP_HDRLEN;
3068 hdr[0] = PPP_ALLSTATIONS;
3070 hdr[2] = proto >> 8;
3073 return ppp_dev_xmit_frame (ppp, ppp->wbuf, hdr, len);
3077 * Send a frame to the remote.
3079 #if LINUX_VERSION_CODE < VERSION(2,1,86)
3080 #define FREE_SKB(skb) dev_kfree_skb(skb)
3082 #define FREE_SKB(skb) dev_kfree_skb(skb, FREE_WRITE)
3086 ppp_dev_xmit (sk_buff *skb, struct device *dev)
3090 struct ppp *ppp = dev2ppp (dev);
3091 struct tty_struct *tty = ppp2tty (ppp);
3093 * just a little sanity check.
3096 if (ppp->flags & SC_DEBUG)
3097 printk (KERN_WARNING "ppp_dev_xmit: null packet!\n");
3101 * Avoid timing problem should tty hangup while data is queued to be sent
3108 * Validate the tty interface
3111 if (ppp->flags & SC_DEBUG)
3113 "ppp_dev_xmit: %s not connected to a TTY!\n",
3119 * Fetch the pointer to the data
3122 data = skb_data(skb);
3124 if (data == (__u8 *) 0) {
3125 if (ppp->flags & SC_DEBUG)
3126 printk (KERN_CRIT "ppp_dev_xmit: %s Null skb data\n",
3132 * Detect a change in the transfer size
3134 if (ppp->mtu != ppp2dev (ppp)->mtu) {
3135 ppp_changedmtu (ppp,
3140 * Acquire the lock on the transmission buffer. If the buffer was busy then
3141 * mark the device as busy.
3142 * We also require that ppp->tbuf be unlocked, in order to serialize
3143 * calls to ppp_dev_xmit_frame (which does compression) and the output
3144 * of frames w.r.t. tty writes from pppd.
3146 CHECK_BUF_MAGIC(ppp->wbuf);
3147 if (ppp->tbuf->locked || lock_buffer (ppp->wbuf) != 0) {
3149 if (ppp->flags & SC_DEBUG)
3150 printk(KERN_DEBUG "dev_xmit blocked, t=%lu w=%lu\n",
3151 ppp->tbuf->locked, ppp->wbuf->locked);
3155 * Look at the protocol in the skb to determine the difference between
3156 * an IP frame and an IPX frame.
3158 switch (ntohs (skb->protocol)) {
3160 answer = ppp_dev_xmit_other (dev, ppp, data, len, PPP_IPX);
3164 answer = ppp_dev_xmit_ip (ppp, ppp->wbuf, data, len,
3165 ppp->sc_npmode[NP_IP]);
3168 default: /* All others have no support at this time. */
3173 * This is the end of the transmission. Release the buffer if it was sent.
3176 /* packet queued OK */
3179 ppp->wbuf->locked = 0;
3181 /* packet should be dropped */
3185 /* packet should be queued for later */
3193 * Generate the statistic information for the /proc/net/dev listing.
3196 static struct net_device_stats *
3197 ppp_dev_stats (struct device *dev)
3199 struct ppp *ppp = dev2ppp (dev);
3201 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
3202 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
3203 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
3204 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
3205 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
3206 ppp->estats.rx_bytes = ppp->stats.ppp_ibytes;
3207 ppp->estats.tx_bytes = ppp->stats.ppp_obytes;
3210 return &ppp->estats;
3213 #if LINUX_VERSION_CODE < VERSION(2,1,15)
3214 static int ppp_dev_header (sk_buff *skb, struct device *dev,
3215 __u16 type, void *daddr,
3216 void *saddr, unsigned int len)
3222 ppp_dev_rebuild (void *eth, struct device *dev,
3223 unsigned long raddr, struct sk_buff *skb)
3229 /*************************************************************
3231 * Miscellany called by various functions above.
3232 *************************************************************/
3234 /* Locate the previous instance of the PPP channel */
3236 ppp_find (int pid_value)
3240 /* try to find the device which this pid is already using */
3241 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3242 if (ppp->inuse && ppp->sc_xfer == pid_value) {
3250 /* Collect hung up channels */
3252 static void ppp_sync(void)
3257 #if LINUX_VERSION_CODE >= VERSION(2,1,68)
3260 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3263 if (dev->flags & IFF_UP)
3267 #if LINUX_VERSION_CODE >= VERSION(2,1,68)
3273 /* allocate or create a PPP channel */
3284 /* try to find an free device */
3286 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3287 if (!test_and_set_bit(0, &ppp->inuse)) {
3289 /* Reregister device */
3292 unregister_netdev (dev);
3294 if (register_netdev (dev)) {
3295 printk(KERN_DEBUG "cannot reregister ppp device\n");
3303 * There are no available units, so make a new one.
3305 ppp = (struct ppp *) kmalloc (sizeof(struct ppp), GFP_KERNEL);
3308 memset(ppp, 0, sizeof(*ppp));
3310 /* initialize channel control data */
3311 set_bit(0, &ppp->inuse);
3315 ppp->backup_tty = NULL;
3319 ppp_last->next = ppp;
3325 dev->init = ppp_init_dev;
3326 dev->name = ppp->name;
3327 sprintf(dev->name, "ppp%d", if_num);
3328 dev->base_addr = (__u32) if_num;
3329 dev->priv = (void *) ppp;
3331 /* register device so that we can be ifconfig'd */
3332 /* ppp_init_dev() will be called as a side-effect */
3333 status = register_netdev (dev);
3335 printk (KERN_INFO "registered device %s\n", dev->name);
3338 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3341 /* This one will forever be busy as it is not initialized */
3347 * Utility procedures to print a buffer in hex/ascii
3351 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3353 register __u8 next_ch;
3354 static char hex[] = "0123456789ABCDEF";
3356 while (count-- > 0) {
3358 *out++ = hex[(next_ch >> 4) & 0x0F];
3359 *out++ = hex[next_ch & 0x0F];
3365 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3367 register __u8 next_ch;
3369 while (count-- > 0) {
3372 if (next_ch < 0x20 || next_ch > 0x7e)
3376 if (next_ch == '%') /* printk/syslogd has a bug !! */
3384 ppp_print_buffer (const __u8 * name, const __u8 * buf, int count)
3388 if (name != (__u8 *) NULL)
3389 printk (KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3392 memset (line, 32, 44);
3393 ppp_print_hex (line, buf, 8);
3394 ppp_print_char (&line[8 * 3], buf, 8);
3395 printk (KERN_DEBUG "%s\n", line);
3401 memset (line, 32, 44);
3402 ppp_print_hex (line, buf, count);
3403 ppp_print_char (&line[8 * 3], buf, count);
3404 printk (KERN_DEBUG "%s\n", line);
3408 /*************************************************************
3409 * Compressor module interface
3410 *************************************************************/
3412 struct compressor_link {
3413 struct compressor_link *next;
3414 struct compressor *comp;
3417 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3419 static struct compressor *find_compressor (int type)
3421 struct compressor_link *lnk;
3422 unsigned long flags;
3427 lnk = ppp_compressors;
3428 while (lnk != (struct compressor_link *) 0) {
3429 if ((int) (__u8) lnk->comp->compress_proto == type) {
3430 restore_flags(flags);
3436 restore_flags(flags);
3437 return (struct compressor *) 0;
3440 static int ppp_register_compressor (struct compressor *cp)
3442 struct compressor_link *new;
3443 unsigned long flags;
3445 new = (struct compressor_link *) kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3447 if (new == (struct compressor_link *) 0)
3453 if (find_compressor (cp->compress_proto)) {
3454 restore_flags(flags);
3459 new->next = ppp_compressors;
3461 ppp_compressors = new;
3463 restore_flags(flags);
3467 static void ppp_unregister_compressor (struct compressor *cp)
3469 struct compressor_link *prev = (struct compressor_link *) 0;
3470 struct compressor_link *lnk;
3471 unsigned long flags;
3476 lnk = ppp_compressors;
3477 while (lnk != (struct compressor_link *) 0) {
3478 if (lnk->comp == cp) {
3480 prev->next = lnk->next;
3482 ppp_compressors = lnk->next;
3489 restore_flags(flags);
3492 /*************************************************************
3493 * Module support routines
3494 *************************************************************/
3502 /* register our line disciplines */
3503 status = ppp_first_time();
3506 "PPP: ppp_init() failure %d\n", status);
3507 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3509 (void) register_symtab (&ppp_syms);
3515 cleanup_module(void)
3519 struct ppp *ppp, *next_ppp;
3522 * Ensure that the devices are not in operation.
3524 for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3525 if (ppp->inuse && ppp->tty != NULL) {
3530 dev = ppp2dev (ppp);
3531 if (dev->start || dev->flags & IFF_UP) {
3537 * Ensure that there are no compressor modules registered
3539 if (ppp_compressors != NULL)
3544 "PPP: device busy, remove delayed\n");
3548 * Release the tty registration of the line discipline so that no new entries
3551 status = tty_register_ldisc (N_PPP, NULL);
3554 "PPP: Unable to unregister ppp line discipline "
3555 "(err = %d)\n", status);
3558 "PPP: ppp line discipline successfully unregistered\n");
3560 * De-register the devices so that there is no problem with them
3562 for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3563 next_ppp = ppp->next;
3565 unregister_netdev (&ppp->dev);