3 * Michael Callahan <callahan@maths.ox.ac.uk>
4 * Al Longyear <longyear@netcom.com>
6 * Dynamic PPP devices by Jim Freeman <jfree@caldera.com>.
7 * ppp_tty_receive ``noisy-raise-bug'' fixed by Ove Ewerlid <ewerlid@syscon.uu.se>
9 * ==FILEVERSION 970522==
11 * NOTE TO MAINTAINERS:
12 * If you modify this file at all, please set the number above to the
13 * date of the modification as YYMMDD (year month day).
14 * ppp.c is shipped with a PPP distribution as well as with the kernel;
15 * if everyone increases the FILEVERSION number above, then scripts
16 * can do the right thing when deciding whether to install a new ppp.c
17 * file. Don't change the format of that line otherwise, so the
18 * installation script can recognize it.
26 RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
27 Multi-protocol Datagrams over Point-to-Point Links
33 Flags for this module (any combination is acceptable for testing.):
35 OPTIMIZE_FLAG_TIME - Number of jiffies to force sending of leading flag
36 character. This is normally set to ((HZ * 3) / 2).
37 This is 1.5 seconds. If zero then the leading
40 CHECK_CHARACTERS - Enable the checking on all received characters for
41 8 data bits, no parity. This adds a small amount of
42 processing for each received character.
45 #define OPTIMIZE_FLAG_TIME ((HZ * 3)/2)
47 #define CHECK_CHARACTERS 1
48 #define PPP_COMPRESS 1
51 #define PPP_MAX_DEV 256
54 /* $Id: ppp.c,v 1.12 1997/05/22 06:45:12 paulus Exp $
55 * Added dynamic allocation of channels to eliminate
56 * compiled-in limits on the number of channels.
58 * Dynamic channel allocation code Copyright 1995 Caldera, Inc.,
59 * released under the GNU General Public License Version 2.
62 #include <linux/version.h>
63 #include <linux/module.h>
64 #include <linux/kernel.h>
65 #include <linux/sched.h>
66 #include <linux/types.h>
67 #include <linux/fcntl.h>
68 #include <linux/interrupt.h>
69 #include <linux/ptrace.h>
72 /* a nice define to generate linux version numbers */
73 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
75 #if LINUX_VERSION_CODE < VERSION(2,1,14)
76 #include <linux/ioport.h>
79 #if LINUX_VERSION_CODE >= VERSION(2,1,23)
80 #include <linux/poll.h>
84 #include <linux/malloc.h>
85 #include <linux/tty.h>
86 #include <linux/errno.h>
87 #include <linux/sched.h> /* to get the struct task_struct */
88 #include <linux/string.h> /* used in new tty drivers */
89 #include <linux/signal.h> /* used in new tty drivers */
90 #include <asm/system.h>
91 #include <asm/bitops.h>
93 #include <linux/if_ether.h>
94 #include <linux/netdevice.h>
95 #include <linux/skbuff.h>
96 #include <linux/inet.h>
97 #include <linux/ioctl.h>
99 typedef struct sk_buff sk_buff;
100 #define skb_data(skb) ((__u8 *) (skb)->data)
102 #include <linux/ip.h>
103 #include <linux/tcp.h>
104 #include <linux/if_arp.h>
105 #include <net/slhc_vj.h>
107 #define fcstab ppp_crc16_table /* Name of the table in the kernel */
108 #include <linux/ppp_defs.h>
110 #include <linux/socket.h>
111 #include <linux/if_ppp.h>
112 #include <linux/if_pppvar.h>
113 #include <linux/ppp-comp.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 static int ppp_register_compressor (struct compressor *cp);
171 static void ppp_unregister_compressor (struct compressor *cp);
177 static struct compressor *find_compressor (int type);
178 static void ppp_init_ctrl_blk (register struct ppp *);
179 static void ppp_kick_tty (struct ppp *, struct ppp_buffer *bfr);
180 static int ppp_doframe (struct ppp *);
181 static struct ppp *ppp_alloc (void);
182 static struct ppp *ppp_find (int pid_value);
183 static void ppp_print_buffer (const __u8 *, const __u8 *, int);
184 extern inline void ppp_stuff_char (struct ppp *ppp,
185 register struct ppp_buffer *buf,
187 extern inline int lock_buffer (register struct ppp_buffer *buf);
189 static int rcv_proto_ip (struct ppp *, __u16, __u8 *, int);
190 static int rcv_proto_ipx (struct ppp *, __u16, __u8 *, int);
191 static int rcv_proto_vjc_comp (struct ppp *, __u16, __u8 *, int);
192 static int rcv_proto_vjc_uncomp (struct ppp *, __u16, __u8 *, int);
193 static int rcv_proto_unknown (struct ppp *, __u16, __u8 *, int);
194 static int rcv_proto_lqr (struct ppp *, __u16, __u8 *, int);
195 static void ppp_doframe_lower (struct ppp *, __u8 *, int);
196 static int ppp_doframe (struct ppp *);
198 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd);
199 static int rcv_proto_ccp (struct ppp *, __u16, __u8 *, int);
201 #define ins_char(pbuf,c) (buf_base(pbuf) [(pbuf)->count++] = (__u8)(c))
203 #ifndef OPTIMIZE_FLAG_TIME
204 #define OPTIMIZE_FLAG_TIME 0
208 #define PPP_MAX_DEV 256
212 * Parameters which may be changed via insmod.
215 static int flag_time = OPTIMIZE_FLAG_TIME;
216 static int max_dev = PPP_MAX_DEV;
218 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
219 MODULE_PARM(flag_time, "i");
220 MODULE_PARM(max_dev, "i");
224 * The "main" procedure to the ppp device
227 int ppp_init (struct device *);
230 * Network device driver callback routines
233 static int ppp_dev_open (struct device *);
234 static int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
235 static int ppp_dev_close (struct device *);
236 static int ppp_dev_xmit (sk_buff *, struct device *);
237 static struct enet_statistics *ppp_dev_stats (struct device *);
239 #if LINUX_VERSION_CODE < VERSION(2,1,15)
240 static int ppp_dev_header (sk_buff *, struct device *, __u16,
241 void *, void *, unsigned int);
242 static int ppp_dev_rebuild (void *eth, struct device *dev,
243 unsigned long raddr, struct sk_buff *skb);
250 static int ppp_tty_read (struct tty_struct *, struct file *, __u8 *,
252 static int ppp_tty_write (struct tty_struct *, struct file *, const __u8 *,
254 static int ppp_tty_ioctl (struct tty_struct *, struct file *, unsigned int,
256 #if LINUX_VERSION_CODE < VERSION(2,1,23)
257 static int ppp_tty_select (struct tty_struct *tty, struct inode *inode,
258 struct file *filp, int sel_type, select_table * wait);
260 static unsigned int ppp_tty_poll (struct tty_struct *tty, struct file *filp, poll_table * wait);
262 static int ppp_tty_open (struct tty_struct *);
263 static void ppp_tty_close (struct tty_struct *);
264 static int ppp_tty_room (struct tty_struct *tty);
265 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
266 char *fp, int count);
267 static void ppp_tty_wakeup (struct tty_struct *tty);
269 #define CHECK_PPP(a) if (!ppp->inuse) { printk (ppp_warning, __LINE__); return a;}
270 #define CHECK_PPP_VOID() if (!ppp->inuse) { printk (ppp_warning, __LINE__); return;}
272 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
273 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
274 ppp->recv_async_map & (1 << (c)))
276 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
278 #define tty2ppp(tty) ((struct ppp *) (tty->disc_data))
279 #define dev2ppp(dev) ((struct ppp *) (dev->priv))
280 #define ppp2tty(ppp) ((struct tty_struct *) ppp->tty)
281 #define ppp2dev(ppp) ((struct device *) ppp->dev)
289 #define PPP_HARD_HDR_LEN (sizeof (struct ppp_hdr))
291 typedef struct ppp_ctrl {
292 struct ppp_ctrl *next; /* Next structure in the list */
293 char name [8]; /* Name of the device */
294 struct ppp ppp; /* PPP control table */
295 struct device dev; /* Device information table */
298 static ppp_ctrl_t *ppp_list = NULL;
300 #define ctl2ppp(ctl) (struct ppp *) &ctl->ppp
301 #define ctl2dev(ctl) (struct device *) &ctl->dev
305 #define BUFFER_TYPE_DEV_RD 0 /* ppp read buffer */
306 #define BUFFER_TYPE_TTY_WR 1 /* tty write buffer */
307 #define BUFFER_TYPE_DEV_WR 2 /* ppp write buffer */
308 #define BUFFER_TYPE_TTY_RD 3 /* tty read buffer */
309 #define BUFFER_TYPE_VJ 4 /* vj compression buffer */
311 /* Define this string only once for all macro invocations */
312 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
314 static char szVersion[] = PPP_VERSION;
317 * Information for the protocol decoder
320 typedef int (*pfn_proto) (struct ppp *, __u16, __u8 *, int);
322 typedef struct ppp_proto_struct {
328 ppp_proto_type proto_list[] = {
329 { PPP_IP, rcv_proto_ip },
330 { PPP_IPX, rcv_proto_ipx },
331 { PPP_VJC_COMP, rcv_proto_vjc_comp },
332 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
333 { PPP_LQR, rcv_proto_lqr },
334 { PPP_CCP, rcv_proto_ccp },
335 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
338 __u16 ppp_crc16_table[256] =
340 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
341 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
342 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
343 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
344 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
345 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
346 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
347 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
348 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
349 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
350 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
351 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
352 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
353 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
354 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
355 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
356 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
357 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
358 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
359 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
360 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
361 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
362 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
363 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
364 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
365 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
366 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
367 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
368 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
369 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
370 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
371 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
374 #ifdef CHECK_CHARACTERS
375 static __u32 paritytab[8] =
377 0x96696996, 0x69969669, 0x69969669, 0x96696996,
378 0x69969669, 0x96696996, 0x96696996, 0x69969669
382 /* local function to store a value into the LQR frame */
383 extern inline __u8 * store_long (register __u8 *p, register int value) {
384 *p++ = (__u8) (value >> 24);
385 *p++ = (__u8) (value >> 16);
386 *p++ = (__u8) (value >> 8);
391 /*************************************************************
393 *************************************************************/
395 /* This procedure is called once and once only to define who we are to
396 * the operating system and the various procedures that it may use in
397 * accessing the ppp protocol.
401 ppp_first_time (void)
403 static struct tty_ldisc ppp_ldisc;
407 "PPP: version %s (demand dialling)"
410 #ifndef MODULE /* slhc module logic has its own copyright announcement */
412 "TCP compression code copyright 1989 Regents of the "
413 "University of California\n");
417 "PPP Dynamic channel allocation code copyright 1995 "
420 * Register the tty discipline
422 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
423 ppp_ldisc.magic = TTY_LDISC_MAGIC;
424 ppp_ldisc.open = ppp_tty_open;
425 ppp_ldisc.close = ppp_tty_close;
426 ppp_ldisc.read = ppp_tty_read;
427 ppp_ldisc.write = ppp_tty_write;
428 ppp_ldisc.ioctl = ppp_tty_ioctl;
429 #if LINUX_VERSION_CODE < VERSION(2,1,23)
430 ppp_ldisc.select = ppp_tty_select;
432 ppp_ldisc.poll = ppp_tty_poll;
434 ppp_ldisc.receive_room = ppp_tty_room;
435 ppp_ldisc.receive_buf = ppp_tty_receive;
436 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
438 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
440 printk (KERN_INFO "PPP line discipline registered.\n");
442 printk (KERN_ERR "error registering line discipline: %d\n",
447 /*************************************************************
449 *************************************************************/
451 /* called when the device is actually created */
454 ppp_init_dev (struct device *dev)
456 #if LINUX_VERSION_CODE < VERSION(2,1,15)
457 dev->hard_header = ppp_dev_header;
458 dev->rebuild_header = ppp_dev_rebuild;
461 dev->hard_header_len = PPP_HARD_HDR_LEN;
465 dev->hard_start_xmit = ppp_dev_xmit;
466 dev->open = ppp_dev_open;
467 dev->stop = ppp_dev_close;
468 dev->get_stats = ppp_dev_stats;
469 dev->do_ioctl = ppp_dev_ioctl;
471 dev->tx_queue_len = 10;
472 dev->type = ARPHRD_PPP;
474 #if LINUX_VERSION_CODE < VERSION(2,1,20)
478 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
479 skb_queue_head_init (&dev->buffs[indx]);
482 dev_init_buffers(dev);
485 /* New-style flags */
486 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
487 dev->family = AF_INET;
491 dev->pa_alen = 4; /* sizeof (__u32) */
497 * Local procedure to initialize the ppp structure
501 ppp_init_ctrl_blk (register struct ppp *ppp)
503 ppp->magic = PPP_MAGIC;
511 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
512 ppp->xmit_async_map[0] = 0xffffffff;
513 ppp->xmit_async_map[3] = 0x60000000;
514 ppp->recv_async_map = 0x00000000;
521 ppp->read_wait = NULL;
522 ppp->write_wait = NULL;
523 ppp->last_xmit = jiffies - flag_time;
525 /* clear statistics */
526 memset(&ppp->stats, 0, sizeof (struct pppstat));
527 memset(&ppp->estats, 0, sizeof(struct enet_statistics));
529 /* Reset the demand dial information */
530 ppp->ddinfo.xmit_idle= /* time since last NP packet sent */
531 ppp->ddinfo.recv_idle=jiffies; /* time since last NP packet received */
533 /* PPP compression data */
535 ppp->sc_rc_state = NULL;
538 #if LINUX_VERSION_CODE < VERSION(2,1,18)
539 static struct symbol_table ppp_syms = {
540 #include <linux/symtab_begin.h>
541 X(ppp_register_compressor),
542 X(ppp_unregister_compressor),
544 #include <linux/symtab_end.h>
547 EXPORT_SYMBOL(ppp_register_compressor);
548 EXPORT_SYMBOL(ppp_unregister_compressor);
549 EXPORT_SYMBOL(ppp_crc16_table);
552 /* called at boot/load time for each ppp device defined in the kernel */
556 ppp_init (struct device *dev)
558 static int first_time = 1;
563 answer = ppp_first_time();
564 #if LINUX_VERSION_CODE < VERSION(2,1,18)
566 (void) register_symtab (&ppp_syms);
576 * Routine to allocate a buffer for later use by the driver.
579 static struct ppp_buffer *
580 ppp_alloc_buf (int size, int type)
582 struct ppp_buffer *buf;
584 buf = (struct ppp_buffer *) kmalloc (size + sizeof (struct ppp_buffer),
588 buf->size = size - 1; /* Mask for the buffer size */
594 buf->fcs = PPP_INITFCS;
601 * Routine to release the allocated buffer.
605 ppp_free_buf (struct ppp_buffer *ptr)
612 * Lock the indicated transmit buffer
616 lock_buffer (register struct ppp_buffer *buf)
621 * Save the current state and if free then set it to the "busy" state
629 restore_flags (flags);
634 * MTU has been changed by the IP layer. Unfortunately we are not told
635 * about this, but we spot it ourselves and fix things up. We could be
636 * in an upcall from the tty driver, or in an ip packet queue.
640 ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
644 struct ppp_buffer *new_rbuf;
645 struct ppp_buffer *new_wbuf;
646 struct ppp_buffer *new_cbuf;
647 struct ppp_buffer *new_tbuf;
649 struct ppp_buffer *old_rbuf;
650 struct ppp_buffer *old_wbuf;
651 struct ppp_buffer *old_cbuf;
652 struct ppp_buffer *old_tbuf;
656 * Allocate the buffer from the kernel for the data
660 /* allow for possible escaping of every character */
661 mtu = (new_mtu * 2) + 20;
663 /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
669 new_wbuf = ppp_alloc_buf (mtu+PPP_HARD_HDR_LEN, BUFFER_TYPE_DEV_WR);
670 new_tbuf = ppp_alloc_buf ((PPP_MTU * 2) + 24, BUFFER_TYPE_TTY_WR);
671 new_rbuf = ppp_alloc_buf (mru + 84, BUFFER_TYPE_DEV_RD);
672 new_cbuf = ppp_alloc_buf (mru+PPP_HARD_HDR_LEN, BUFFER_TYPE_VJ);
674 * If the buffers failed to allocate then complain and release the partial
677 if (new_wbuf == NULL || new_tbuf == NULL ||
678 new_rbuf == NULL || new_cbuf == NULL) {
679 if (ppp->flags & SC_DEBUG)
681 "ppp: failed to allocate new buffers\n");
683 ppp_free_buf (new_wbuf);
684 ppp_free_buf (new_tbuf);
685 ppp_free_buf (new_rbuf);
686 ppp_free_buf (new_cbuf);
690 * Update the pointers to the new buffer structures.
693 old_wbuf = ppp->wbuf;
694 old_rbuf = ppp->rbuf;
695 old_cbuf = ppp->cbuf;
696 old_tbuf = ppp->tbuf;
698 ppp->wbuf = new_wbuf;
699 ppp->rbuf = new_rbuf;
700 ppp->cbuf = new_cbuf;
701 ppp->tbuf = new_tbuf;
703 ppp->rbuf->size -= 80; /* reserve space for vj header expansion */
705 dev->mem_start = (unsigned long) buf_base (new_wbuf);
706 dev->mem_end = (unsigned long) (dev->mem_start + mtu);
707 dev->rmem_start = (unsigned long) buf_base (new_rbuf);
708 dev->rmem_end = (unsigned long) (dev->rmem_start + mru);
710 * Update the parameters for the new buffer sizes
712 ppp->toss = 0xE0; /* To ignore characters until new FLAG */
713 ppp->escape = 0; /* No pending escape character */
723 ppp->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
724 ppp->flags &= ~SC_XMIT_BUSY;
728 * Release old buffer pointers
730 ppp_free_buf (old_rbuf);
731 ppp_free_buf (old_wbuf);
732 ppp_free_buf (old_cbuf);
733 ppp_free_buf (old_tbuf);
738 * CCP is down; free (de)compressor state if necessary.
742 ppp_ccp_closed (struct ppp *ppp)
744 ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
745 if (ppp->sc_xc_state) {
746 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
747 ppp->sc_xc_state = NULL;
750 if (ppp->sc_rc_state) {
751 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
752 ppp->sc_rc_state = NULL;
757 * Called to release all of the information in the current PPP structure.
759 * It is called when the ppp device goes down or if it is unable to go
764 ppp_release (struct ppp *ppp)
766 struct tty_struct *tty;
772 ppp_ccp_closed (ppp);
774 /* Ensure that the pppd process is not hanging on select()/poll() */
775 wake_up_interruptible (&ppp->read_wait);
776 wake_up_interruptible (&ppp->write_wait);
778 if (tty != NULL && tty->disc_data == ppp)
779 tty->disc_data = NULL; /* Break the tty->ppp link */
781 if (dev && dev->flags & IFF_UP) {
782 dev_close (dev); /* close the device properly */
783 dev->flags &= ~IFF_UP; /* prevent recursion */
786 ppp_free_buf (ppp->rbuf);
787 ppp_free_buf (ppp->wbuf);
788 ppp_free_buf (ppp->cbuf);
789 ppp_free_buf (ppp->ubuf);
790 ppp_free_buf (ppp->tbuf);
802 slhc_free (ppp->slcomp);
808 ppp->backup_tty = NULL;
814 * Called when the line discipline is changed to something
815 * else, the tty is closed, or the tty detects a hangup.
819 ppp_tty_close (struct tty_struct *tty)
821 struct ppp *ppp = tty2ppp (tty);
824 if (ppp->magic != PPP_MAGIC) {
825 if (ppp->flags & SC_DEBUG)
827 "ppp: trying to close unopened tty!\n");
831 tty->disc_data = NULL;
832 if (tty == ppp->backup_tty)
836 if (ppp->backup_tty) {
837 ppp->tty = ppp->backup_tty;
840 if (ppp->flags & SC_DEBUG)
841 printk (KERN_INFO "ppp: channel %s closing.\n",
852 * Called when the tty discipline is switched to PPP.
856 ppp_tty_open (struct tty_struct *tty)
858 struct ppp *ppp = tty2ppp (tty);
861 * There should not be an existing table for this slot.
864 if (ppp->flags & SC_DEBUG)
866 "ppp_tty_open: gack! tty already associated to %s!\n",
867 ppp->magic == PPP_MAGIC ? ppp2dev(ppp)->name
872 * Allocate the structure from the system
874 ppp = ppp_find(current->pid);
877 * If we are taking over a ppp unit which is currently
878 * connected to a loopback pty, there's not much to do.
881 tty->disc_data = ppp;
886 if (ppp->flags & SC_DEBUG)
887 printk (KERN_ERR "ppp_alloc failed\n");
891 * Initialize the control block
893 ppp_init_ctrl_blk (ppp);
895 tty->disc_data = ppp;
897 * Allocate space for the default VJ header compression slots
899 ppp->slcomp = slhc_init (16, 16);
900 if (ppp->slcomp == NULL) {
901 if (ppp->flags & SC_DEBUG)
902 printk (KERN_ERR "ppp_tty_open: "
903 "no space for compression buffers!\n");
908 * Allocate space for the MTU and MRU buffers
910 if (ppp_changedmtu (ppp, ppp2dev(ppp)->mtu, ppp->mru) == 0) {
915 * Allocate space for a user level buffer
917 ppp->ubuf = ppp_alloc_buf (RBUFSIZE, BUFFER_TYPE_TTY_RD);
918 if (ppp->ubuf == NULL) {
919 if (ppp->flags & SC_DEBUG)
920 printk (KERN_ERR "ppp_tty_open: "
921 "no space for user receive buffer\n");
926 if (ppp->flags & SC_DEBUG)
927 printk (KERN_INFO "ppp: channel %s open\n",
930 for (indx = 0; indx < NUM_NP; ++indx)
931 ppp->sc_npmode[indx] = NPMODE_PASS;
936 * Flush any pending characters in the driver and discipline.
938 if (tty->ldisc.flush_buffer)
939 tty->ldisc.flush_buffer (tty);
941 if (tty->driver.flush_buffer)
942 tty->driver.flush_buffer (tty);
947 * Local function to send the next portion of the buffer.
949 * Called by the tty driver's tty_wakeup function should it be entered
950 * because the partial buffer was transmitted.
952 * Called by kick_tty to send the initial portion of the buffer.
954 * Completion processing of the buffer transmission is handled here.
958 ppp_tty_wakeup_code (struct ppp *ppp, struct tty_struct *tty,
959 struct ppp_buffer *xbuf)
961 register int count, actual;
963 * Prevent re-entrancy by ensuring that this routine is called only once.
966 if (ppp->flags & SC_XMIT_BUSY) {
970 ppp->flags |= SC_XMIT_BUSY;
973 * Send the next block of data to the modem
975 count = xbuf->count - xbuf->tail;
976 actual = tty->driver.write (tty, 0,
977 buf_base (xbuf) + xbuf->tail, count);
979 * Terminate transmission of any block which may have an error.
980 * This could occur should the carrier drop.
983 ppp->stats.ppp_oerrors++;
986 ppp->bytes_sent += actual;
988 * If the buffer has been transmitted then clear the indicators.
990 xbuf->tail += actual;
991 if (actual == count) {
993 ppp->flags &= ~SC_XMIT_BUSY;
995 * Complete the transmission on the current buffer.
999 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1003 * If the completed buffer came from the device write, then complete the
1004 * transmission block.
1006 if (ppp2dev (ppp) -> flags & IFF_UP) {
1007 if (xbuf->type == BUFFER_TYPE_DEV_WR)
1008 ppp2dev (ppp)->tbusy = 0;
1012 * Wake up the transmission queue for all completion events.
1014 wake_up_interruptible (&ppp->write_wait);
1016 * Look at the priorities. Choose a daemon write over the device driver.
1027 * If there is a pending buffer then transmit it now.
1030 ppp->flags &= ~SC_XMIT_BUSY;
1031 ppp_kick_tty (ppp, xbuf);
1037 * Clear the re-entry flag
1039 ppp->flags &= ~SC_XMIT_BUSY;
1043 * This function is called by the tty driver when the transmit buffer has
1044 * additional space. It is used by the ppp code to continue to transmit
1045 * the current buffer should the buffer have been partially sent.
1047 * In addition, it is used to send the first part of the buffer since the
1048 * logic and the inter-locking would be identical.
1052 ppp_tty_wakeup (struct tty_struct *tty)
1054 struct ppp_buffer *xbuf;
1055 struct ppp *ppp = tty2ppp (tty);
1060 if (ppp->magic != PPP_MAGIC)
1063 if (tty != ppp->tty) {
1064 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1068 * Ensure that there is a transmission pending. Clear the re-entry flag if
1069 * there is no pending buffer. Otherwise, send the buffer.
1073 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
1075 ppp_tty_wakeup_code (ppp, tty, xbuf);
1079 * This function is called to transmit a buffer to the remote. The buffer
1080 * is placed on the pending queue if there is presently a buffer being
1081 * sent or it is transmitted with the aid of ppp_tty_wakeup.
1085 ppp_kick_tty (struct ppp *ppp, struct ppp_buffer *xbuf)
1087 unsigned long flags;
1094 * Control the flags which are best performed with the interrupts masked.
1099 * If the transmitter is busy then place the buffer on the appropriate
1102 if (ppp->xbuf != NULL) {
1103 if (xbuf->type == BUFFER_TYPE_TTY_WR)
1107 restore_flags (flags);
1111 * If the transmitter is not busy then this is the highest priority frame
1113 ppp->flags &= ~SC_XMIT_BUSY;
1114 ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1116 restore_flags (flags);
1118 * Do the "tty wakeup_code" to actually send this buffer.
1120 ppp_tty_wakeup_code (ppp, ppp2tty (ppp), xbuf);
1123 /*************************************************************
1125 * The following functions handle input that arrives from
1126 * the TTY. It recognizes PPP frames and either hands them
1127 * to the network layer or queues them for delivery to a
1128 * user process reading this TTY.
1129 *************************************************************/
1132 * Callback function from tty driver. Return the amount of space left
1133 * in the receiver's buffer to decide if remote transmitter is to be
1138 ppp_tty_room (struct tty_struct *tty)
1140 return 65536; /* We can handle an infinite amount of data. :-) */
1144 * Callback function when data is available at the tty driver.
1147 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1148 char *flags, int count)
1150 register struct ppp *ppp = tty2ppp (tty);
1151 register struct ppp_buffer *buf = NULL;
1155 * This can happen if stuff comes in on the backup tty.
1157 if (tty != ppp->tty)
1160 * Fetch the pointer to the buffer. Be careful about race conditions.
1168 * Verify the table pointer and ensure that the line is
1169 * still in PPP discipline.
1171 if (ppp->magic != PPP_MAGIC) {
1172 if (ppp->flags & SC_DEBUG)
1174 "PPP: handler called but couldn't find "
1180 * Print the buffer if desired
1182 if (ppp->flags & SC_LOG_RAWIN)
1183 ppp_print_buffer ("receive buffer", data, count);
1185 * Collect the character and error condition for the character. Set the toss
1186 * flag for the first character error.
1188 while (count-- > 0) {
1192 if (*flags && ppp->toss == 0) {
1194 switch (ppp->toss) {
1196 ++ppp->estats.rx_fifo_errors;
1200 ++ppp->estats.rx_frame_errors;
1207 * Set the flags for d7 being 0/1 and parity being even/odd so that
1208 * the normal processing would have all flags set at the end of the
1209 * session. A missing flag bit indicates an error condition.
1212 #ifdef CHECK_CHARACTERS
1214 ppp->flags |= SC_RCV_B7_1;
1216 ppp->flags |= SC_RCV_B7_0;
1218 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1219 ppp->flags |= SC_RCV_ODDP;
1221 ppp->flags |= SC_RCV_EVNP;
1224 * Branch on the character.
1228 * FLAG. This is the end of the block. If the block terminated by ESC FLAG,
1229 * then the block is to be ignored. In addition, characters before the very
1230 * first FLAG are also tossed by this procedure.
1232 case PPP_FLAG: /* PPP_FLAG: end of frame */
1233 ppp->stats.ppp_ibytes += ppp->rbuf->count;
1237 * Process frames which are not to be ignored. If the processing failed,
1238 * then clean up the VJ tables.
1240 if (ppp_doframe (ppp) == 0) {
1241 ++ppp->stats.ppp_ierrors;
1242 slhc_toss (ppp->slcomp);
1245 * Reset all indicators for the new frame to follow.
1248 buf->fcs = PPP_INITFCS;
1253 * All other characters in the data come here. If the character is in the
1254 * receive mask then ignore the character.
1257 /* If we're tossing, look no further. */
1261 /* If this is a control char to be ignored, do so */
1262 if (in_rmap (ppp, chr))
1266 * Modify the next character if preceded by escape.
1267 * The escape character (0x7d) could be an escaped
1268 * 0x5d, if it follows an escape :-)
1273 } else if (chr == PPP_ESCAPE) {
1274 ppp->escape = PPP_TRANS;
1279 * If the count sent is within reason then store the character, bump the
1280 * count, and update the FCS for the character.
1282 if (buf->count < buf->size) {
1283 buf_base (buf)[buf->count++] = chr;
1284 buf->fcs = PPP_FCS (buf->fcs, chr);
1288 * The peer sent too much data. Set the flags to discard the current frame
1289 * and wait for the re-synchronization FLAG to be sent.
1291 ++ppp->estats.rx_length_errors;
1299 * Put the input frame into the networking system for the indicated protocol
1303 ppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1305 sk_buff *skb = dev_alloc_skb (count);
1307 * Generate a skb buffer for the new frame.
1310 if (ppp->flags & SC_DEBUG)
1312 "ppp_do_ip: packet dropped on %s (no memory)!\n",
1313 ppp2dev (ppp)->name);
1317 * Move the received data from the input buffer to the skb buffer.
1319 skb->dev = ppp2dev (ppp); /* We are the device */
1320 skb->protocol = proto;
1321 skb->mac.raw = skb_data(skb);
1322 memcpy (skb_put(skb,count), data, count); /* move data */
1324 * Tag the frame and kick it to the proper receive routine
1326 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1330 ppp->ddinfo.recv_idle = jiffies;
1336 * Process the receipt of an IP frame
1340 rcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1342 if ((ppp2dev (ppp)->flags & IFF_UP) && (count > 0))
1343 if (ppp->sc_npmode[NP_IP] == NPMODE_PASS)
1344 return ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
1349 * Process the receipt of an IPX frame
1353 rcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1355 if (((ppp2dev (ppp)->flags & IFF_UP) != 0) && (count > 0))
1356 return ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
1361 * Process the receipt of an VJ Compressed frame
1365 rcv_proto_vjc_comp (struct ppp *ppp, __u16 proto,
1366 __u8 *data, int count)
1368 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1369 int new_count = slhc_uncompress (ppp->slcomp, data, count);
1370 if (new_count >= 0) {
1371 return rcv_proto_ip (ppp, PPP_IP, data, new_count);
1373 if (ppp->flags & SC_DEBUG)
1375 "ppp: error in VJ decompression\n");
1381 * Process the receipt of an VJ Un-compressed frame
1385 rcv_proto_vjc_uncomp (struct ppp *ppp, __u16 proto,
1386 __u8 *data, int count)
1388 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1389 if (slhc_remember (ppp->slcomp, data, count) > 0) {
1390 return rcv_proto_ip (ppp, PPP_IP, data, count);
1392 if (ppp->flags & SC_DEBUG)
1394 "ppp: error in VJ memorizing\n");
1400 * Receive all unclassified protocols.
1404 rcv_proto_unknown (struct ppp *ppp, __u16 proto,
1405 __u8 *data, int len)
1408 register int current_idx;
1412 buf_base (ppp->ubuf) [current_idx++] = (__u8) (c); \
1413 current_idx &= ppp->ubuf->size; \
1414 if (current_idx == ppp->ubuf->tail) \
1419 * The total length includes the protocol data.
1420 * Lock the user information buffer.
1422 if (test_and_set_bit (0, &ppp->ubuf->locked)) {
1423 if (ppp->flags & SC_DEBUG)
1425 "ppp_us_queue: can't get lock\n");
1427 current_idx = ppp->ubuf->head;
1429 * Insert the buffer length (not counted), the protocol, and the data
1439 while (totlen-- > 0) {
1444 * The frame is complete. Update the head pointer and wakeup the pppd
1447 ppp->ubuf->head = current_idx;
1449 clear_bit (0, &ppp->ubuf->locked);
1450 wake_up_interruptible (&ppp->read_wait);
1451 if (ppp->tty->fasync != NULL)
1452 kill_fasync (ppp->tty->fasync, SIGIO);
1456 * The buffer is full. Unlock the header
1459 clear_bit (0, &ppp->ubuf->locked);
1460 if (ppp->flags & SC_DEBUG)
1462 "ppp_us_queue: ran out of buffer space.\n");
1465 * Discard the frame. There are no takers for this protocol.
1467 if (ppp->flags & SC_DEBUG)
1469 "ppp: dropping packet on the floor.\n");
1470 slhc_toss (ppp->slcomp);
1475 * Handle a CCP packet.
1477 * The CCP packet is passed along to the pppd process just like any
1478 * other PPP frame. The difference is that some processing needs to be
1479 * immediate or the compressors will become confused on the peer.
1482 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd)
1484 int slen = CCP_LENGTH(dp);
1485 __u8 *opt = dp + CCP_HDRLEN;
1486 int opt_len = slen - CCP_HDRLEN;
1491 switch (CCP_CODE(dp)) {
1496 * CCP must be going down - disable compression
1498 if (ppp->flags & SC_CCP_UP) {
1499 ppp->flags &= ~(SC_CCP_UP |
1506 if ((ppp->flags & SC_CCP_OPEN) == 0)
1508 if (ppp->flags & SC_CCP_UP)
1510 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1512 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1515 * we're agreeing to send compressed packets.
1518 if (ppp->sc_xc_state == NULL)
1521 if ((*ppp->sc_xcomp->comp_init)
1525 ppp2dev (ppp)->base_addr,
1527 ppp->flags & SC_DEBUG))
1528 ppp->flags |= SC_COMP_RUN;
1532 * peer is agreeing to send compressed packets.
1534 if (ppp->sc_rc_state == NULL)
1537 if ((*ppp->sc_rcomp->decomp_init)
1541 ppp2dev (ppp)->base_addr,
1544 ppp->flags & SC_DEBUG)) {
1545 ppp->flags |= SC_DECOMP_RUN;
1546 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1550 * The protocol sequence is complete at this end
1553 if ((ppp->flags & SC_CCP_UP) == 0)
1557 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN))
1558 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1560 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1561 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1562 ppp->flags &= ~SC_DC_ERROR;
1570 rcv_proto_ccp (struct ppp *ppp, __u16 proto, __u8 *dp, int len)
1572 ppp_proto_ccp (ppp, dp, len, 1);
1573 return rcv_proto_unknown (ppp, proto, dp, len);
1577 * Handle a LQR packet.
1581 rcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
1583 return rcv_proto_unknown (ppp, proto, data, len);
1586 static void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
1588 __u16 proto = PPP_PROTOCOL (data);
1589 ppp_proto_type *proto_ptr;
1591 * Ignore empty frames
1593 if (count <= PPP_HDRLEN)
1596 * Count the frame and print it
1598 ++ppp->stats.ppp_ipackets;
1599 if (ppp->flags & SC_LOG_INPKT)
1600 ppp_print_buffer ("receive frame", data, count);
1602 * Find the procedure to handle this protocol. The last one is marked
1603 * as a protocol 0 which is the 'catch-all' to feed it to the pppd daemon.
1605 proto_ptr = proto_list;
1606 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
1609 * Update the appropriate statistic counter.
1611 if ((*proto_ptr->func) (ppp, proto,
1612 &data[PPP_HARD_HDR_LEN],
1613 count - PPP_HARD_HDR_LEN))
1614 ppp->stats.ppp_ioctects += count;
1616 ++ppp->stats.ppp_discards;
1619 /* on entry, a received frame is in ppp->rbuf.bufr
1620 check it and dispose as appropriate */
1623 ppp_doframe (struct ppp *ppp)
1625 __u8 *data = buf_base (ppp->rbuf);
1626 int count = ppp->rbuf->count;
1627 int addr, ctrl, proto;
1631 * If there is a pending error from the receiver then log it and discard
1632 * the damaged frame.
1635 if ((ppp->flags & SC_DEBUG) && count > 0)
1637 "ppp_toss: tossing frame, reason = %x\n",
1642 * An empty frame is ignored. This occurs if the FLAG sequence precedes and
1643 * follows each frame.
1648 * Generate an error if the frame is too small.
1650 if (count < PPP_HARD_HDR_LEN) {
1651 if (ppp->flags & SC_DEBUG)
1653 "ppp: got runt ppp frame, %d chars\n", count);
1654 ++ppp->estats.rx_length_errors;
1658 * Verify the CRC of the frame and discard the CRC characters from the
1659 * end of the buffer.
1661 if (ppp->rbuf->fcs != PPP_GOODFCS) {
1662 if (ppp->flags & SC_DEBUG) {
1664 "ppp: frame with bad fcs, length = %d\n",
1666 ppp_print_buffer("bad frame", data, count);
1668 ++ppp->estats.rx_crc_errors;
1671 count -= 2; /* ignore the fcs characters */
1673 * Ignore the leading ADDRESS and CONTROL fields in the frame.
1675 addr = PPP_ALLSTATIONS;
1678 if ((data[0] == PPP_ALLSTATIONS) && (data[1] == PPP_UI)) {
1683 * Obtain the protocol from the frame
1685 proto = (__u16) *data++;
1686 if ((proto & 1) == 0) {
1687 proto = (proto << 8) | (__u16) *data++;
1691 * Rewrite the header with the full information. This may encroach upon
1692 * the 'filler' area in the buffer header. This is the purpose for the
1696 *(--data) = proto >> 8;
1701 * Process the active decompressor.
1703 if ((ppp->sc_rc_state != (void *) 0) &&
1704 (ppp->flags & SC_DECOMP_RUN) &&
1705 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
1706 if (proto == PPP_COMP) {
1708 * If the frame is compressed then decompress it.
1710 new_data = kmalloc (ppp->mru + PPP_HDRLEN, GFP_ATOMIC);
1711 if (new_data == NULL) {
1712 if (ppp->flags & SC_DEBUG)
1714 "ppp_doframe: no memory\n");
1715 new_count = DECOMP_ERROR;
1717 new_count = (*ppp->sc_rcomp->decompress)
1718 (ppp->sc_rc_state, data, count,
1719 new_data, ppp->mru + PPP_HDRLEN);
1721 switch (new_count) {
1723 ppp_doframe_lower (ppp, new_data, new_count);
1728 ppp->flags |= SC_DC_ERROR;
1731 case DECOMP_FATALERROR:
1732 ppp->flags |= SC_DC_FERROR;
1733 if (ppp->flags & SC_DEBUG)
1734 printk(KERN_ERR "ppp: fatal decomp error\n");
1738 * Log the error condition and discard the frame.
1742 slhc_toss (ppp->slcomp);
1743 ++ppp->stats.ppp_ierrors;
1746 * The frame is not special. Pass it through the compressor without
1747 * actually compressing the data
1749 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1754 * Process the uncompressed frame.
1756 ppp_doframe_lower (ppp, data, count);
1760 /*************************************************************
1761 * LINE DISCIPLINE SUPPORT
1762 * The following functions form support user programs
1763 * which read and write data on a TTY with the PPP line
1764 * discipline. Reading is done from a circular queue,
1765 * filled by the lower TTY levels.
1766 *************************************************************/
1768 /* read a PPP frame from the us_rbuff circular buffer,
1769 waiting if necessary
1773 ppp_tty_read (struct tty_struct *tty, struct file *file, __u8 * buf,
1776 struct ppp *ppp = tty2ppp (tty);
1783 c = buf_base (ppp->ubuf) [ppp->ubuf->tail++]; \
1784 ppp->ubuf->tail &= ppp->ubuf->size; \
1788 * Validate the pointers
1793 if (ppp->magic != PPP_MAGIC)
1798 * Acquire the read lock.
1801 ppp = tty2ppp (tty);
1802 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
1806 if (test_and_set_bit (0, &ppp->ubuf->locked) != 0) {
1807 if (ppp->flags & SC_DEBUG)
1809 "ppp_tty_read: sleeping(ubuf)\n");
1811 current->timeout = 0;
1812 current->state = TASK_INTERRUPTIBLE;
1815 if (current->signal & ~current->blocked)
1820 * Before we attempt to write the frame to the user, ensure that the
1821 * user has access to the pages for the total buffer length.
1823 indx = verify_area (VERIFY_WRITE, buf, nr);
1827 * Fetch the length of the buffer from the first two bytes.
1829 if (ppp->ubuf->head == ppp->ubuf->tail)
1838 * If there is no length then wait for the data to arrive.
1842 clear_bit (0, &ppp->ubuf->locked);
1843 if (file->f_flags & O_NONBLOCK)
1845 current->timeout = 0;
1847 if (ppp->flags & SC_DEBUG)
1849 "ppp_tty_read: sleeping(read_wait)\n");
1851 interruptible_sleep_on (&ppp->read_wait);
1852 if (current->signal & ~current->blocked)
1857 * Ensure that the frame will fit within the caller's buffer. If not, then
1858 * discard the frame from the input buffer.
1861 /* Can't copy it, update us_rbuff_head */
1863 if (ppp->flags & SC_DEBUG)
1865 "ppp: read of %u bytes too small for %d "
1866 "frame\n", nr, len + 2);
1867 ppp->ubuf->tail += len;
1868 ppp->ubuf->tail &= ppp->ubuf->size;
1869 clear_bit (0, &ppp->ubuf->locked);
1870 ppp->stats.ppp_ierrors++;
1874 * Before we attempt to write the frame to the user, ensure that the
1875 * page tables are proper.
1877 indx = verify_area (VERIFY_WRITE, buf, len + 2);
1879 ppp->ubuf->tail += len;
1880 ppp->ubuf->tail &= ppp->ubuf->size;
1881 clear_bit (0, &ppp->ubuf->locked);
1885 * Fake the insertion of the ADDRESS and CONTROL information because these
1886 * were not saved in the buffer.
1888 PUT_USER (error, (u_char) PPP_ALLSTATIONS, buf);
1890 PUT_USER (error, (u_char) PPP_UI, buf);
1895 * Copy the received data from the buffer to the caller's area.
1897 while (indx-- > 0) {
1899 PUT_USER (error, c, buf);
1903 clear_bit (0, &ppp->ubuf->locked);
1904 len += 2; /* Account for ADDRESS and CONTROL bytes */
1905 if (ppp->flags & SC_DEBUG)
1907 "ppp_tty_read: passing %d bytes up\n", len);
1913 /* stuff a character into the transmit buffer, using PPP's way of escaping
1915 also, update fcs to take account of new character */
1918 ppp_stuff_char (struct ppp *ppp, register struct ppp_buffer *buf,
1922 * The buffer should not be full.
1924 if (ppp->flags & SC_DEBUG) {
1925 if ((buf->count < 0) || (buf->count > 3000))
1926 printk (KERN_DEBUG "ppp_stuff_char: %d %x\n",
1927 (unsigned int) buf->count,
1928 (unsigned int) chr);
1931 * Update the FCS and if the character needs to be escaped, do it.
1933 buf->fcs = PPP_FCS (buf->fcs, chr);
1934 if (in_xmap (ppp, chr)) {
1936 ins_char (buf, PPP_ESCAPE);
1939 * Add the character to the buffer.
1941 ins_char (buf, chr);
1945 * Procedure to encode the data with the proper escaping and send the
1946 * data to the remote system.
1950 ppp_dev_xmit_lower (struct ppp *ppp, struct ppp_buffer *buf,
1951 __u8 *data, int count, int non_ip)
1954 int address, control;
1957 ++ppp->stats.ppp_opackets;
1958 ppp->stats.ppp_ooctects += count;
1961 * Insert the leading FLAG character
1965 if (non_ip || flag_time == 0)
1966 ins_char (buf, PPP_FLAG);
1968 if (jiffies - ppp->last_xmit > flag_time)
1969 ins_char (buf, PPP_FLAG);
1971 ppp->last_xmit = jiffies;
1972 buf->fcs = PPP_INITFCS;
1974 * Emit the address/control information if needed
1976 address = PPP_ADDRESS (data);
1977 control = PPP_CONTROL (data);
1978 proto = PPP_PROTOCOL (data);
1980 if (address != PPP_ALLSTATIONS ||
1981 control != PPP_UI ||
1982 (ppp->flags & SC_COMP_AC) == 0) {
1983 ppp_stuff_char (ppp, buf, address);
1984 ppp_stuff_char (ppp, buf, control);
1987 * Emit the protocol (compressed if possible)
1989 if ((ppp->flags & SC_COMP_PROT) == 0 || (proto & 0xFF00))
1990 ppp_stuff_char (ppp, buf, proto >> 8);
1992 ppp_stuff_char (ppp, buf, proto);
2000 ppp_stuff_char (ppp, buf, *data++);
2002 * Add the trailing CRC and the final flag character
2004 write_fcs = buf->fcs ^ 0xFFFF;
2005 ppp_stuff_char (ppp, buf, write_fcs);
2006 ppp_stuff_char (ppp, buf, write_fcs >> 8);
2008 * Add the trailing flag character
2010 ins_char (buf, PPP_FLAG);
2014 if (ppp->flags & SC_LOG_FLUSH)
2015 ppp_print_buffer ("ppp flush", buf_base (buf),
2018 * Send the block to the tty driver.
2020 ppp->stats.ppp_obytes += buf->count;
2021 ppp_kick_tty (ppp, buf);
2025 * Send an frame to the remote with the proper bsd compression.
2027 * Return 0 if frame was queued for transmission.
2028 * 1 if frame must be re-queued for later driver support.
2032 ppp_dev_xmit_frame (struct ppp *ppp, struct ppp_buffer *buf,
2033 __u8 *data, int count)
2036 int address, control;
2042 if (ppp->flags & SC_LOG_OUTPKT)
2043 ppp_print_buffer ("write frame", data, count);
2045 * Determine if the frame may be compressed. Attempt to compress the
2046 * frame if possible.
2048 proto = PPP_PROTOCOL (data);
2049 address = PPP_ADDRESS (data);
2050 control = PPP_CONTROL (data);
2052 if (((ppp->flags & SC_COMP_RUN) != 0) &&
2053 (ppp->sc_xc_state != (void *) 0) &&
2054 (address == PPP_ALLSTATIONS) &&
2055 (control == PPP_UI) &&
2056 (proto != PPP_LCP) &&
2057 (proto != PPP_CCP)) {
2058 new_data = kmalloc (count, GFP_ATOMIC);
2059 if (new_data == NULL) {
2060 if (ppp->flags & SC_DEBUG)
2062 "ppp_dev_xmit_frame: no memory\n");
2066 new_count = (*ppp->sc_xcomp->compress)
2067 (ppp->sc_xc_state, data, new_data, count, count);
2069 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2070 ppp_dev_xmit_lower (ppp, buf, new_data, new_count, 0);
2075 * The frame could not be compressed, or it could not be sent in
2076 * compressed form because CCP is not yet up.
2081 * Go to the escape encoding
2083 ppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
2088 * Revise the tty frame for specific protocols.
2092 send_revise_frame (register struct ppp *ppp, __u8 *data, int len)
2096 switch (PPP_PROTOCOL (data)) {
2098 * Update the LQR frame with the current MIB information. This saves having
2099 * the daemon read old MIB data from the driver.
2102 len = 48; /* total size of this frame */
2103 p = (__u8 *) &data [40]; /* Point to last two items. */
2104 p = store_long (p, ppp->stats.ppp_opackets + 1);
2105 p = store_long (p, ppp->stats.ppp_ooctects + len);
2108 * Outbound compression frames
2112 data + PPP_HARD_HDR_LEN,
2113 len - PPP_HARD_HDR_LEN,
2125 * write a frame with NR chars from BUF to TTY
2126 * we have to put the FCS field on ourselves
2130 ppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
2133 struct ppp *ppp = tty2ppp (tty);
2137 * Verify the pointers.
2142 if (ppp->magic != PPP_MAGIC)
2147 * Ensure that the caller does not wish to send too much.
2149 if (count > PPP_MTU + PPP_HDRLEN) {
2150 if (ppp->flags & SC_DEBUG)
2151 printk (KERN_WARNING
2152 "ppp_tty_write: truncating user packet "
2153 "from %u to mtu %d\n", count,
2154 PPP_MTU + PPP_HDRLEN);
2155 count = PPP_MTU + PPP_HDRLEN;
2158 * Allocate a buffer for the data and fetch it from the user space.
2160 new_data = kmalloc (count, GFP_KERNEL);
2161 if (new_data == NULL) {
2162 if (ppp->flags & SC_DEBUG)
2164 "ppp_tty_write: no memory\n");
2168 * lock this PPP unit so we will be the only writer;
2169 * sleep if necessary
2171 while (lock_buffer (ppp->tbuf) != 0) {
2172 current->timeout = 0;
2173 if (ppp->flags & SC_DEBUG)
2174 printk (KERN_DEBUG "ppp_tty_write: sleeping\n");
2175 interruptible_sleep_on (&ppp->write_wait);
2177 ppp = tty2ppp (tty);
2178 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
2179 || tty != ppp->tty) {
2184 if (current->signal & ~current->blocked) {
2190 * Retrieve the user's buffer
2192 COPY_FROM_USER (status,
2199 ppp->tbuf->locked = 0;
2203 * Change the LQR frame
2205 count = send_revise_frame (ppp, new_data, count);
2209 ppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
2215 * Process the BSD compression IOCTL event for the tty device.
2219 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
2221 struct compressor *cp;
2222 struct ppp_option_data data;
2226 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
2228 * Fetch the compression parameters
2230 COPY_FROM_USER (error,
2240 if ((__u32) nb >= (__u32)CCP_MAX_OPTION_LENGTH)
2241 nb = CCP_MAX_OPTION_LENGTH;
2243 COPY_FROM_USER (error,
2251 if (ccp_option[1] < 2) /* preliminary check on the length byte */
2254 cp = find_compressor ((int) (unsigned int) (__u8) ccp_option[0]);
2255 if (cp != (struct compressor *) 0) {
2257 * Found a handler for the protocol - try to allocate
2258 * a compressor or decompressor.
2261 if (data.transmit) {
2262 if (ppp->sc_xc_state != NULL)
2263 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2266 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2268 if (ppp->sc_xc_state == NULL) {
2269 if (ppp->flags & SC_DEBUG)
2270 printk("ppp%ld: comp_alloc failed\n",
2271 ppp2dev (ppp)->base_addr);
2274 ppp->flags &= ~SC_COMP_RUN;
2276 if (ppp->sc_rc_state != NULL)
2277 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2279 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2280 if (ppp->sc_rc_state == NULL) {
2281 if (ppp->flags & SC_DEBUG)
2282 printk("ppp%ld: decomp_alloc failed\n",
2283 ppp2dev (ppp)->base_addr);
2286 ppp->flags &= ~SC_DECOMP_RUN;
2291 if (ppp->flags & SC_DEBUG)
2292 printk(KERN_DEBUG "ppp%ld: no compressor for [%x %x %x], %x\n",
2293 ppp2dev (ppp)->base_addr, ccp_option[0], ccp_option[1],
2295 return (-EINVAL); /* no handler found */
2299 * Process the IOCTL event for the tty device.
2303 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
2304 unsigned int param2, unsigned long param3)
2306 struct ppp *ppp = tty2ppp (tty);
2307 register int temp_i = 0;
2310 * Verify the status of the PPP device.
2315 if (ppp->magic != PPP_MAGIC)
2320 * The user must have an euid of root to do these requests.
2329 GET_USER (error, temp_i, (int *) param3);
2331 if (ppp->flags & SC_DEBUG)
2333 "ppp_tty_ioctl: set mru to %x\n", temp_i);
2335 if (ppp->mru != temp_i)
2336 ppp_changedmtu (ppp, ppp2dev (ppp)->mtu, temp_i);
2343 temp_i = (ppp->flags & SC_MASK);
2344 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
2345 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
2346 SC_RCV_ODDP | SC_RCV_EVNP;
2348 PUT_USER (error, temp_i, (int *) param3);
2351 * Set the flags for the various options
2354 GET_USER (error, temp_i, (int *) param3);
2357 temp_i |= (ppp->flags & ~SC_MASK);
2359 if ((ppp->flags & SC_CCP_OPEN) &&
2360 (temp_i & SC_CCP_OPEN) == 0)
2361 ppp_ccp_closed (ppp);
2363 if ((ppp->flags | temp_i) & SC_DEBUG)
2365 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2366 ppp->flags = temp_i;
2370 * Set the compression mode
2372 case PPPIOCSCOMPRESS:
2373 error = ppp_set_compression (ppp,
2374 (struct ppp_option_data *) param3);
2377 * Retrieve the transmit async map
2379 case PPPIOCGASYNCMAP:
2380 PUT_USER (error, ppp->xmit_async_map[0], (int *) param3);
2383 * Set the transmit async map
2385 case PPPIOCSASYNCMAP:
2386 GET_USER (error, temp_i, (int *) param3);
2388 ppp->xmit_async_map[0] = temp_i;
2389 if (ppp->flags & SC_DEBUG)
2391 "ppp_tty_ioctl: set xmit asyncmap %x\n",
2392 ppp->xmit_async_map[0]);
2396 * Set the receive async map
2398 case PPPIOCSRASYNCMAP:
2399 GET_USER (error, temp_i, (int *) param3);
2401 ppp->recv_async_map = temp_i;
2402 if (ppp->flags & SC_DEBUG)
2404 "ppp_tty_ioctl: set rcv asyncmap %x\n",
2405 ppp->recv_async_map);
2409 * Obtain the unit number for this device.
2412 PUT_USER (error, ppp2dev (ppp)->base_addr, (int *) param3);
2414 if (ppp->flags & SC_DEBUG)
2416 "ppp_tty_ioctl: get unit: %ld\n",
2417 ppp2dev (ppp)->base_addr);
2421 * Set the debug level
2424 GET_USER (error, temp_i, (int *) param3);
2426 temp_i = (temp_i & 0x1F) << 16;
2427 temp_i |= (ppp->flags & ~0x1F0000);
2429 if ((ppp->flags | temp_i) & SC_DEBUG)
2431 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2432 ppp->flags = temp_i;
2436 * Get the debug level
2439 temp_i = (ppp->flags >> 16) & 0x1F;
2440 PUT_USER (error, temp_i, (int *) param3);
2443 * Get the times since the last send/receive frame operation
2447 struct ppp_idle cur_ddinfo;
2448 __u32 cur_jiffies = jiffies;
2450 /* change absolute times to relative times. */
2451 cur_ddinfo.xmit_idle = (cur_jiffies - ppp->ddinfo.xmit_idle) / HZ;
2452 cur_ddinfo.recv_idle = (cur_jiffies - ppp->ddinfo.recv_idle) / HZ;
2453 COPY_TO_USER (error,
2456 sizeof (cur_ddinfo));
2460 * Retrieve the extended async map
2462 case PPPIOCGXASYNCMAP:
2463 COPY_TO_USER (error,
2465 ppp->xmit_async_map,
2466 sizeof (ppp->xmit_async_map));
2469 * Set the async extended map
2471 case PPPIOCSXASYNCMAP:
2475 COPY_FROM_USER (error,
2481 temp_tbl[1] = 0x00000000;
2482 temp_tbl[2] &= ~0x40000000;
2483 temp_tbl[3] |= 0x60000000;
2485 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
2486 (temp_tbl[4] & temp_tbl[5]) != 0 ||
2487 (temp_tbl[6] & temp_tbl[7]) != 0)
2490 memcpy (ppp->xmit_async_map,
2492 sizeof (ppp->xmit_async_map));
2494 if (ppp->flags & SC_DEBUG)
2496 "ppp_tty_ioctl: set xasyncmap\n");
2502 * Set the maximum VJ header compression slot number.
2505 GET_USER (error, temp_i, (int *) param3);
2507 temp_i = (temp_i & 255) + 1;
2508 if (ppp->flags & SC_DEBUG)
2510 "ppp_tty_ioctl: set maxcid to %d\n",
2512 if (ppp->slcomp != NULL)
2513 slhc_free (ppp->slcomp);
2514 ppp->slcomp = slhc_init (16, temp_i);
2516 if (ppp->slcomp == NULL) {
2517 if (ppp->flags & SC_DEBUG)
2519 "ppp: no space for compression buffers!\n");
2526 case PPPIOCXFERUNIT:
2527 ppp->backup_tty = tty;
2528 ppp->sc_xfer = current->pid;
2535 COPY_FROM_USER (error,
2543 switch (npi.protocol) {
2545 npi.protocol = NP_IP;
2548 if (ppp->flags & SC_DEBUG)
2549 printk(KERN_DEBUG "pppioc[gs]npmode: "
2550 "invalid proto %d\n", npi.protocol);
2557 if (param2 == PPPIOCGNPMODE) {
2558 npi.mode = ppp->sc_npmode[npi.protocol];
2560 COPY_TO_USER (error,
2567 if (npi.mode != ppp->sc_npmode[npi.protocol]) {
2568 ppp->sc_npmode[npi.protocol] = npi.mode;
2569 if (npi.mode != NPMODE_QUEUE) {
2570 /* ppp_requeue(ppp); maybe needed */
2571 ppp_tty_wakeup (ppp2tty(ppp));
2577 * Allow users to read, but not set, the serial port parameters
2581 error = n_tty_ioctl (tty, file, param2, param3);
2586 int count = ppp->ubuf->tail - ppp->ubuf->head;
2588 count += (ppp->ubuf->size + 1);
2589 PUT_USER (error, count, (int *) param3);
2593 * All other ioctl() events will come here.
2596 if (ppp->flags & SC_DEBUG)
2598 "ppp_tty_ioctl: invalid ioctl: %x, addr %lx\n",
2602 error = -ENOIOCTLCMD;
2611 * Process the select() (or poll()) statement for the PPP device.
2614 #if LINUX_VERSION_CODE < VERSION(2,1,23)
2616 ppp_tty_select (struct tty_struct *tty, struct inode *inode,
2617 struct file *filp, int sel_type, select_table * wait)
2619 struct ppp *ppp = tty2ppp (tty);
2622 * Verify the status of the PPP device.
2627 if (ppp->magic != PPP_MAGIC || tty != ppp->tty)
2632 * Branch on the type of select mode. A read request must lock the user
2637 if (test_and_set_bit (0, &ppp->ubuf->locked) == 0) {
2638 /* Test for the presence of data in the queue */
2639 if (ppp->ubuf->head != ppp->ubuf->tail) {
2640 clear_bit (0, &ppp->ubuf->locked);
2643 clear_bit (0, &ppp->ubuf->locked);
2644 } /* fall through */
2646 * Exceptions or read errors.
2649 /* Is this a pty link and the remote disconnected? */
2650 if (tty->flags & (1 << TTY_OTHER_CLOSED))
2653 /* Is this a local link and the modem disconnected? */
2654 if (tty_hung_up_p (filp))
2657 select_wait (&ppp->read_wait, wait);
2661 * Write mode. A write is allowed if there is no current transmission.
2664 if (ppp->tbuf->locked != 0) {
2665 select_wait (&ppp->write_wait, wait);
2673 #else /* 2.1.23 or later */
2676 ppp_tty_poll (struct tty_struct *tty, struct file *filp, poll_table * wait)
2678 struct ppp *ppp = tty2ppp (tty);
2679 unsigned int mask = 0;
2681 if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
2684 poll_wait(&ppp->read_wait, wait);
2685 poll_wait(&ppp->write_wait, wait);
2687 /* Must lock the user buffer area while checking. */
2688 if(test_and_set_bit(0, &ppp->ubuf->locked) == 0) {
2689 if(ppp->ubuf->head != ppp->ubuf->tail)
2690 mask |= POLLIN | POLLRDNORM;
2691 clear_bit(0, &ppp->ubuf->locked);
2693 if(tty->flags & (1 << TTY_OTHER_CLOSED))
2695 if(tty_hung_up_p(filp))
2697 if(ppp->tbuf->locked == 0)
2698 mask |= POLLOUT | POLLWRNORM;
2705 /*************************************************************
2707 * This routine accepts requests from the network layer
2708 * and attempts to deliver the packets.
2709 * It also includes various routines we are compelled to
2710 * have to make the network layer work (arp, etc...).
2711 *************************************************************/
2714 * Callback from the network layer when the device goes up.
2718 ppp_dev_open (struct device *dev)
2720 struct ppp *ppp = dev2ppp (dev);
2722 /* reset POINTOPOINT every time, since dev_close zaps it! */
2723 dev->flags |= IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2725 if (ppp2tty (ppp) == NULL) {
2726 if (ppp->flags & SC_DEBUG)
2728 "ppp: %s not connected to a TTY! can't go open!\n",
2733 if (ppp->flags & SC_DEBUG)
2735 "ppp: channel %s going up for IP packets!\n",
2743 * Callback from the network layer when the ppp device goes down.
2747 ppp_dev_close (struct device *dev)
2749 struct ppp *ppp = dev2ppp (dev);
2751 if (ppp2tty (ppp) == NULL) {
2755 * We don't do anything about the device going down. It is not important
2758 if (ppp->flags & SC_DEBUG)
2760 "ppp: channel %s going down for IP packets!\n",
2767 * IOCTL operation to read the version of the driver.
2771 ppp_dev_ioctl_version (struct ppp *ppp, struct ifreq *ifr)
2774 char *result = (char *) ifr->ifr_ifru.ifru_data;
2775 int len = strlen (szVersion) + 1;
2777 * Move the version data
2779 COPY_TO_USER (error,
2788 * IOCTL to read the statistics for the pppstats program.
2792 ppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2794 struct ppp_stats *result, temp;
2797 * Supply the information for the caller. First move the version data
2798 * then move the ppp stats; and finally the vj stats.
2800 memset (&temp, 0, sizeof(temp));
2801 if (dev->flags & IFF_UP) {
2802 memcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
2803 if (ppp->slcomp != NULL) {
2804 temp.vj.vjs_packets = ppp->slcomp->sls_o_compressed+
2805 ppp->slcomp->sls_o_uncompressed;
2806 temp.vj.vjs_compressed = ppp->slcomp->sls_o_compressed;
2807 temp.vj.vjs_searches = ppp->slcomp->sls_o_searches;
2808 temp.vj.vjs_misses = ppp->slcomp->sls_o_misses;
2809 temp.vj.vjs_errorin = ppp->slcomp->sls_i_error;
2810 temp.vj.vjs_tossed = ppp->slcomp->sls_i_tossed;
2811 temp.vj.vjs_uncompressedin = ppp->slcomp->sls_i_uncompressed;
2812 temp.vj.vjs_compressedin = ppp->slcomp->sls_i_compressed;
2816 result = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
2818 COPY_TO_USER (error,
2827 * IOCTL to read the compression statistics for the pppstats program.
2831 ppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2833 struct ppp_comp_stats *result, temp;
2836 * Supply the information for the caller.
2838 memset (&temp, 0, sizeof(temp));
2839 if (dev->flags & IFF_UP) {
2840 if (ppp->sc_xc_state != NULL)
2841 (*ppp->sc_xcomp->comp_stat) (ppp->sc_xc_state,
2844 if (ppp->sc_rc_state != NULL)
2845 (*ppp->sc_rcomp->decomp_stat) (ppp->sc_rc_state,
2849 * Move the data to the caller's buffer
2851 result = (struct ppp_comp_stats *) ifr->ifr_ifru.ifru_data;
2853 COPY_TO_USER (error,
2862 * Callback from the network layer to process the sockioctl functions.
2866 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
2868 struct ppp *ppp = dev2ppp (dev);
2871 * Process the requests
2875 error = ppp_dev_ioctl_stats (ppp, ifr, dev);
2878 case SIOCGPPPCSTATS:
2879 error = ppp_dev_ioctl_comp_stats (ppp, ifr, dev);
2883 error = ppp_dev_ioctl_version (ppp, ifr);
2894 * Send an IP frame to the remote with vj header compression.
2896 * Return 0 if frame was queued for transmission.
2897 * 1 if frame must be re-queued for later driver support.
2901 ppp_dev_xmit_ip (struct device *dev, struct ppp *ppp, __u8 *data)
2905 struct ppp_hdr *hdr;
2906 struct tty_struct *tty = ppp2tty (ppp);
2908 * Obtain the length from the IP header.
2910 len = ((struct iphdr *)data) -> tot_len;
2913 * Validate the tty interface
2916 if (ppp->flags & SC_DEBUG)
2918 "ppp_dev_xmit: %s not connected to a TTY!\n",
2923 * Ensure that the PPP device is still up
2925 if (!(dev->flags & IFF_UP)) {
2926 if (ppp->flags & SC_DEBUG)
2927 printk (KERN_WARNING
2928 "ppp_dev_xmit: packet sent on interface %s,"
2929 " which is down for IP\n",
2934 * Branch on the type of processing for the IP frame.
2936 switch (ppp->sc_npmode[NP_IP]) {
2942 if (ppp->flags & SC_DEBUG)
2944 "ppp_dev_xmit: npmode = %d on %s\n",
2945 ppp->sc_npmode[NP_IP], dev->name);
2952 if (ppp->flags & SC_DEBUG)
2953 printk (KERN_WARNING
2954 "ppp_dev_xmit: unknown npmode %d on %s\n",
2955 ppp->sc_npmode[NP_IP],
2960 * Detect a change in the transfer size
2962 if (ppp->mtu != ppp2dev (ppp)->mtu) {
2963 ppp_changedmtu (ppp,
2968 * Acquire the lock on the transmission buffer. If the buffer was busy then
2969 * mark the device as busy.
2971 if (lock_buffer (ppp->wbuf) != 0) {
2976 * Print the frame being sent
2978 if (ppp->flags & SC_LOG_OUTPKT)
2979 ppp_print_buffer ("ppp outpkt", data, len);
2981 * At this point, the buffer will be transmitted. There is no other exit.
2983 * Try to compress the header.
2985 if (ppp->flags & SC_COMP_TCP) {
2986 len = slhc_compress (ppp->slcomp, data, len,
2987 buf_base (ppp->cbuf) + PPP_HARD_HDR_LEN,
2989 (ppp->flags & SC_NO_TCP_CCID) == 0);
2991 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2992 proto = PPP_VJC_COMP;
2993 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2995 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2996 proto = PPP_VJC_UNCOMP;
2997 data[0] = (data[0] & 0x0f) | 0x40;
3003 len += PPP_HARD_HDR_LEN;
3004 hdr = &((struct ppp_hdr *) data)[-1];
3006 hdr->address = PPP_ALLSTATIONS;
3007 hdr->control = PPP_UI;
3008 hdr->protocol[0] = 0;
3009 hdr->protocol[1] = proto;
3011 return ppp_dev_xmit_frame (ppp, ppp->wbuf, (__u8 *) hdr, len);
3015 * Send an IPX (or any other non-IP) frame to the remote.
3017 * Return 0 if frame was queued for transmission.
3018 * 1 if frame must be re-queued for later driver support.
3021 ppp_dev_xmit_ipx (struct device *dev, struct ppp *ppp,
3022 __u8 *data, int len, int proto)
3024 struct tty_struct *tty = ppp2tty (ppp);
3025 struct ppp_hdr *hdr;
3027 * Validate the tty interface
3030 if (ppp->flags & SC_DEBUG)
3032 "ppp_dev_xmit: %s not connected to a TTY!\n",
3037 * Ensure that the PPP device is still up
3039 if (!(dev->flags & IFF_UP)) {
3040 if (ppp->flags & SC_DEBUG)
3041 printk (KERN_WARNING
3042 "ppp_dev_xmit: packet sent on interface %s,"
3048 * Detect a change in the transfer size
3050 if (ppp->mtu != ppp2dev (ppp)->mtu) {
3051 ppp_changedmtu (ppp,
3056 * Acquire the lock on the transmission buffer. If the buffer was busy then
3057 * mark the device as busy.
3059 if (lock_buffer (ppp->wbuf) != 0) {
3064 * Print the frame being sent
3066 if (ppp->flags & SC_LOG_OUTPKT)
3067 ppp_print_buffer ("ppp outpkt", data, len);
3071 len += PPP_HARD_HDR_LEN;
3072 hdr = &((struct ppp_hdr *) data)[-1];
3074 hdr->address = PPP_ALLSTATIONS;
3075 hdr->control = PPP_UI;
3076 hdr->protocol[0] = proto >> 8;
3077 hdr->protocol[1] = proto;
3079 return ppp_dev_xmit_frame (ppp, ppp->wbuf, (__u8 *) 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);
3110 * Validate the tty interface
3113 if (ppp->flags & SC_DEBUG)
3115 "ppp_dev_xmit: %s not connected to a TTY!\n",
3117 dev_kfree_skb (skb, FREE_WRITE);
3121 * Fetch the pointer to the data
3124 data = skb_data(skb);
3126 if (data == (__u8 *) 0) {
3127 if (ppp->flags & SC_DEBUG)
3128 printk (KERN_CRIT "ppp_dev_xmit: %s Null skb data\n",
3130 dev_kfree_skb (skb, FREE_WRITE);
3134 * Look at the protocol in the skb to determine the difference between
3135 * an IP frame and an IPX frame.
3137 switch (ntohs (skb->protocol)) {
3139 answer = ppp_dev_xmit_ipx (dev, ppp, data, len, PPP_IPX);
3143 answer = ppp_dev_xmit_ip (dev, ppp, data);
3146 default: /* All others have no support at this time. */
3147 dev_kfree_skb (skb, FREE_WRITE);
3151 * This is the end of the transmission. Release the buffer if it was sent.
3154 dev_kfree_skb (skb, FREE_WRITE);
3155 ppp->ddinfo.xmit_idle = jiffies;
3161 * Generate the statistic information for the /proc/net/dev listing.
3164 static struct enet_statistics *
3165 ppp_dev_stats (struct device *dev)
3167 struct ppp *ppp = dev2ppp (dev);
3169 ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
3170 ppp->estats.rx_errors = ppp->stats.ppp_ierrors;
3171 ppp->estats.tx_packets = ppp->stats.ppp_opackets;
3172 ppp->estats.tx_errors = ppp->stats.ppp_oerrors;
3174 return &ppp->estats;
3177 #if LINUX_VERSION_CODE < VERSION(2,1,15)
3178 static int ppp_dev_header (sk_buff *skb, struct device *dev,
3179 __u16 type, void *daddr,
3180 void *saddr, unsigned int len)
3186 ppp_dev_rebuild (void *eth, struct device *dev,
3187 unsigned long raddr, struct sk_buff *skb)
3193 /*************************************************************
3195 * Miscellany called by various functions above.
3196 *************************************************************/
3198 /* Locate the previous instance of the PPP channel */
3200 ppp_find (int pid_value)
3206 /* try to find the exact same free device which we had before */
3211 ppp = ctl2ppp (ctl);
3212 if (ppp->sc_xfer == pid_value) {
3213 set_bit(0, &ppp->inuse);
3218 if (++if_num == max_dev)
3224 /* allocate or create a PPP channel */
3234 /* try to find an free device */
3239 ppp = ctl2ppp (ctl);
3240 if (!test_and_set_bit(0, &ppp->inuse))
3243 if (++if_num == max_dev)
3247 * There are no available items. Allocate a device from the system pool
3249 ctl = (ppp_ctrl_t *) kmalloc (sizeof(ppp_ctrl_t), GFP_KERNEL);
3251 (void) memset(ctl, 0, sizeof(ppp_ctrl_t));
3252 ppp = ctl2ppp (ctl);
3253 dev = ctl2dev (ctl);
3255 /* initialize channel control data */
3256 set_bit(0, &ppp->inuse);
3260 ppp->backup_tty = NULL;
3264 dev->init = ppp_init_dev;
3265 dev->name = ctl->name;
3266 dev->base_addr = (__u32) if_num;
3267 dev->priv = (void *) ppp;
3269 sprintf (dev->name, "ppp%d", if_num);
3271 /* link in the new channel */
3272 ctl->next = ppp_list;
3275 /* register device so that we can be ifconfig'd */
3276 /* ppp_init_dev() will be called as a side-effect */
3278 status = register_netdev (dev);
3280 printk (KERN_INFO "registered device %s\n", dev->name);
3285 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3287 /* This one will forever be busy as it is not initialized */
3293 * Utility procedures to print a buffer in hex/ascii
3297 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3299 register __u8 next_ch;
3300 static char hex[] = "0123456789ABCDEF";
3302 while (count-- > 0) {
3304 *out++ = hex[(next_ch >> 4) & 0x0F];
3305 *out++ = hex[next_ch & 0x0F];
3311 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3313 register __u8 next_ch;
3315 while (count-- > 0) {
3318 if (next_ch < 0x20 || next_ch > 0x7e)
3322 if (next_ch == '%') /* printk/syslogd has a bug !! */
3330 ppp_print_buffer (const __u8 * name, const __u8 * buf, int count)
3334 if (name != (__u8 *) NULL)
3335 printk (KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3338 memset (line, 32, 44);
3339 ppp_print_hex (line, buf, 8);
3340 ppp_print_char (&line[8 * 3], buf, 8);
3341 printk (KERN_DEBUG "%s\n", line);
3347 memset (line, 32, 44);
3348 ppp_print_hex (line, buf, count);
3349 ppp_print_char (&line[8 * 3], buf, count);
3350 printk (KERN_DEBUG "%s\n", line);
3354 /*************************************************************
3355 * Compressor module interface
3356 *************************************************************/
3358 struct compressor_link {
3359 struct compressor_link *next;
3360 struct compressor *comp;
3363 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3365 static struct compressor *find_compressor (int type)
3367 struct compressor_link *lnk;
3368 unsigned long flags;
3373 lnk = ppp_compressors;
3374 while (lnk != (struct compressor_link *) 0) {
3375 if ((int) (__u8) lnk->comp->compress_proto == type) {
3376 restore_flags(flags);
3382 restore_flags(flags);
3383 return (struct compressor *) 0;
3386 static int ppp_register_compressor (struct compressor *cp)
3388 struct compressor_link *new;
3389 unsigned long flags;
3391 new = (struct compressor_link *) kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3393 if (new == (struct compressor_link *) 0)
3399 if (find_compressor (cp->compress_proto)) {
3400 restore_flags(flags);
3405 new->next = ppp_compressors;
3407 ppp_compressors = new;
3409 restore_flags(flags);
3413 static void ppp_unregister_compressor (struct compressor *cp)
3415 struct compressor_link *prev = (struct compressor_link *) 0;
3416 struct compressor_link *lnk;
3417 unsigned long flags;
3422 lnk = ppp_compressors;
3423 while (lnk != (struct compressor_link *) 0) {
3424 if (lnk->comp == cp) {
3426 prev->next = lnk->next;
3428 ppp_compressors = lnk->next;
3435 restore_flags(flags);
3438 /*************************************************************
3439 * Module support routines
3440 *************************************************************/
3448 /* register our line disciplines */
3449 status = ppp_first_time();
3452 "PPP: ppp_init() failure %d\n", status);
3453 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3455 (void) register_symtab (&ppp_syms);
3461 cleanup_module(void)
3464 ppp_ctrl_t *ctl, *next_ctl;
3469 * Ensure that the devices are not in operation.
3473 ppp = ctl2ppp (ctl);
3474 if (ppp->inuse && ppp->tty != NULL) {
3479 dev = ctl2dev (ctl);
3480 if (dev->start || dev->flags & IFF_UP) {
3487 * Ensure that there are no compressor modules registered
3489 if (ppp_compressors != NULL)
3494 "PPP: device busy, remove delayed\n");
3498 * Release the tty registration of the line discipline so that no new entries
3501 status = tty_register_ldisc (N_PPP, NULL);
3504 "PPP: Unable to unregister ppp line discipline "
3505 "(err = %d)\n", status);
3508 "PPP: ppp line discipline successfully unregistered\n");
3510 * De-register the devices so that there is no problem with them
3512 next_ctl = ppp_list;
3515 next_ctl = ctl->next;
3516 ppp = ctl2ppp (ctl);
3517 dev = ctl2dev (ctl);
3520 unregister_netdev (dev);