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 960528==
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.8 1996/09/14 05:37:07 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/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>
70 #include <linux/ioport.h>
72 #include <linux/malloc.h>
73 #include <linux/tty.h>
74 #include <linux/errno.h>
75 #include <linux/sched.h> /* to get the struct task_struct */
76 #include <linux/string.h> /* used in new tty drivers */
77 #include <linux/signal.h> /* used in new tty drivers */
78 #include <asm/system.h>
79 #include <asm/bitops.h>
80 #include <asm/segment.h>
82 #include <linux/if_ether.h>
83 #include <linux/netdevice.h>
84 #include <linux/skbuff.h>
85 #include <linux/inet.h>
86 #include <linux/ioctl.h>
88 typedef struct sk_buff sk_buff;
89 #define skb_data(skb) ((__u8 *) (skb)->data)
92 #include <linux/tcp.h>
93 #include <linux/if_arp.h>
94 #include <net/slhc_vj.h>
96 #define fcstab ppp_crc16_table /* Name of the table in the kernel */
97 #include <linux/ppp_defs.h>
99 #include <linux/socket.h>
100 #include <linux/if_ppp.h>
101 #include <linux/if_pppvar.h>
105 #include <linux/ppp-comp.h>
108 #define bsd_decompress (*ppp->sc_rcomp->decompress)
109 #define bsd_compress (*ppp->sc_xcomp->compress)
112 #define PPP_IPX 0x2b /* IPX protocol over PPP */
116 #define PPP_LQR 0xc025 /* Link Quality Reporting Protocol */
119 static int ppp_register_compressor (struct compressor *cp);
120 static void ppp_unregister_compressor (struct compressor *cp);
126 static struct compressor *find_compressor (int type);
127 static void ppp_init_ctrl_blk (register struct ppp *);
128 static void ppp_kick_tty (struct ppp *, struct ppp_buffer *bfr);
129 static int ppp_doframe (struct ppp *);
130 static struct ppp *ppp_alloc (void);
131 static struct ppp *ppp_find (int pid_value);
132 static void ppp_print_buffer (const __u8 *, const __u8 *, int);
133 extern inline void ppp_stuff_char (struct ppp *ppp,
134 register struct ppp_buffer *buf,
136 extern inline int lock_buffer (register struct ppp_buffer *buf);
138 static int rcv_proto_ip (struct ppp *, __u16, __u8 *, int);
139 static int rcv_proto_ipx (struct ppp *, __u16, __u8 *, int);
140 static int rcv_proto_vjc_comp (struct ppp *, __u16, __u8 *, int);
141 static int rcv_proto_vjc_uncomp (struct ppp *, __u16, __u8 *, int);
142 static int rcv_proto_unknown (struct ppp *, __u16, __u8 *, int);
143 static int rcv_proto_lqr (struct ppp *, __u16, __u8 *, int);
144 static void ppp_doframe_lower (struct ppp *, __u8 *, int);
145 static int ppp_doframe (struct ppp *);
147 extern int ppp_bsd_compressor_init(void);
148 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd);
149 static int rcv_proto_ccp (struct ppp *, __u16, __u8 *, int);
151 #define ins_char(pbuf,c) (buf_base(pbuf) [(pbuf)->count++] = (__u8)(c))
153 #ifndef OPTIMIZE_FLAG_TIME
154 #define OPTIMIZE_FLAG_TIME 0
158 #define PPP_MAX_DEV 256
162 * Parameters which may be changed via insmod.
165 static int flag_time = OPTIMIZE_FLAG_TIME;
166 static int max_dev = PPP_MAX_DEV;
169 * The "main" procedure to the ppp device
172 int ppp_init (struct device *);
175 * Network device driver callback routines
178 static int ppp_dev_open (struct device *);
179 static int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
180 static int ppp_dev_close (struct device *);
181 static int ppp_dev_xmit (sk_buff *, struct device *);
182 static struct enet_statistics *ppp_dev_stats (struct device *);
183 static int ppp_dev_header (sk_buff *, struct device *, __u16,
184 void *, void *, unsigned int);
185 static int ppp_dev_rebuild (void *eth, struct device *dev,
186 unsigned long raddr, struct sk_buff *skb);
191 static int ppp_tty_read (struct tty_struct *, struct file *, __u8 *,
193 static int ppp_tty_write (struct tty_struct *, struct file *, const __u8 *,
195 static int ppp_tty_ioctl (struct tty_struct *, struct file *, unsigned int,
197 static int ppp_tty_select (struct tty_struct *tty, struct inode *inode,
198 struct file *filp, int sel_type, select_table * wait);
199 static int ppp_tty_open (struct tty_struct *);
200 static void ppp_tty_close (struct tty_struct *);
201 static int ppp_tty_room (struct tty_struct *tty);
202 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
203 char *fp, int count);
204 static void ppp_tty_wakeup (struct tty_struct *tty);
206 #define CHECK_PPP(a) if (!ppp->inuse) { printk (ppp_warning, __LINE__); return a;}
207 #define CHECK_PPP_VOID() if (!ppp->inuse) { printk (ppp_warning, __LINE__); return;}
209 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
210 #define in_rmap(ppp,c) ((((unsigned int) (__u8) (c)) < 0x20) && \
211 ppp->recv_async_map & (1 << (c)))
213 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
215 #define tty2ppp(tty) ((struct ppp *) (tty->disc_data))
216 #define dev2ppp(dev) ((struct ppp *) (dev->priv))
217 #define ppp2tty(ppp) ((struct tty_struct *) ppp->tty)
218 #define ppp2dev(ppp) ((struct device *) ppp->dev)
226 #define PPP_HARD_HDR_LEN (sizeof (struct ppp_hdr))
228 typedef struct ppp_ctrl {
229 struct ppp_ctrl *next; /* Next structure in the list */
230 char name [8]; /* Name of the device */
231 struct ppp ppp; /* PPP control table */
232 struct device dev; /* Device information table */
235 static ppp_ctrl_t *ppp_list = NULL;
237 #define ctl2ppp(ctl) (struct ppp *) &ctl->ppp
238 #define ctl2dev(ctl) (struct device *) &ctl->dev
242 #define BUFFER_TYPE_DEV_RD 0 /* ppp read buffer */
243 #define BUFFER_TYPE_TTY_WR 1 /* tty write buffer */
244 #define BUFFER_TYPE_DEV_WR 2 /* ppp write buffer */
245 #define BUFFER_TYPE_TTY_RD 3 /* tty read buffer */
246 #define BUFFER_TYPE_VJ 4 /* vj compression buffer */
248 /* Define this string only once for all macro invocations */
249 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
251 static char szVersion[] = PPP_VERSION;
254 * Information for the protocol decoder
257 typedef int (*pfn_proto) (struct ppp *, __u16, __u8 *, int);
259 typedef struct ppp_proto_struct {
265 ppp_proto_type proto_list[] = {
266 { PPP_IP, rcv_proto_ip },
267 { PPP_IPX, rcv_proto_ipx },
268 { PPP_VJC_COMP, rcv_proto_vjc_comp },
269 { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
270 { PPP_LQR, rcv_proto_lqr },
271 { PPP_CCP, rcv_proto_ccp },
272 { 0, rcv_proto_unknown } /* !!! MUST BE LAST !!! */
275 __u16 ppp_crc16_table[256] =
277 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
278 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
279 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
280 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
281 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
282 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
283 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
284 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
285 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
286 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
287 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
288 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
289 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
290 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
291 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
292 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
293 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
294 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
295 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
296 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
297 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
298 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
299 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
300 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
301 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
302 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
303 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
304 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
305 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
306 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
307 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
308 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
311 #ifdef CHECK_CHARACTERS
312 static __u32 paritytab[8] =
314 0x96696996, 0x69969669, 0x69969669, 0x96696996,
315 0x69969669, 0x96696996, 0x96696996, 0x69969669
319 /* local function to store a value into the LQR frame */
320 extern inline __u8 * store_long (register __u8 *p, register int value) {
321 *p++ = (__u8) (value >> 24);
322 *p++ = (__u8) (value >> 16);
323 *p++ = (__u8) (value >> 8);
328 /*************************************************************
330 *************************************************************/
332 /* This procedure is called once and once only to define who we are to
333 * the operating system and the various procedures that it may use in
334 * accessing the ppp protocol.
338 ppp_first_time (void)
340 static struct tty_ldisc ppp_ldisc;
344 "PPP: version %s (dynamic channel allocation)"
347 #ifndef MODULE /* slhc module logic has its own copyright announcement */
349 "TCP compression code copyright 1989 Regents of the "
350 "University of California\n");
354 "PPP Dynamic channel allocation code copyright 1995 "
357 * Register the tty discipline
359 (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
360 ppp_ldisc.magic = TTY_LDISC_MAGIC;
361 ppp_ldisc.open = ppp_tty_open;
362 ppp_ldisc.close = ppp_tty_close;
363 ppp_ldisc.read = ppp_tty_read;
364 ppp_ldisc.write = ppp_tty_write;
365 ppp_ldisc.ioctl = ppp_tty_ioctl;
366 ppp_ldisc.select = ppp_tty_select;
367 ppp_ldisc.receive_room = ppp_tty_room;
368 ppp_ldisc.receive_buf = ppp_tty_receive;
369 ppp_ldisc.write_wakeup = ppp_tty_wakeup;
371 status = tty_register_ldisc (N_PPP, &ppp_ldisc);
373 printk (KERN_INFO "PPP line discipline registered.\n");
375 printk (KERN_ERR "error registering line discipline: %d\n",
380 /*************************************************************
382 *************************************************************/
384 /* called when the device is actually created */
387 ppp_init_dev (struct device *dev)
391 dev->hard_header = ppp_dev_header;
392 dev->rebuild_header = ppp_dev_rebuild;
393 dev->hard_header_len = PPP_HARD_HDR_LEN;
397 dev->hard_start_xmit = ppp_dev_xmit;
398 dev->open = ppp_dev_open;
399 dev->stop = ppp_dev_close;
400 dev->get_stats = ppp_dev_stats;
401 dev->do_ioctl = ppp_dev_ioctl;
403 dev->tx_queue_len = 10;
404 dev->type = ARPHRD_PPP;
406 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
407 skb_queue_head_init (&dev->buffs[indx]);
409 /* New-style flags */
410 dev->flags = IFF_POINTOPOINT;
411 dev->family = AF_INET;
415 dev->pa_alen = 4; /* sizeof (__u32) */
421 * Local procedure to initialize the ppp structure
425 ppp_init_ctrl_blk (register struct ppp *ppp)
427 ppp->magic = PPP_MAGIC;
435 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
436 ppp->xmit_async_map[0] = 0xffffffff;
437 ppp->xmit_async_map[3] = 0x60000000;
438 ppp->recv_async_map = 0x00000000;
445 ppp->read_wait = NULL;
446 ppp->write_wait = NULL;
447 ppp->last_xmit = jiffies - flag_time;
449 /* clear statistics */
450 memset (&ppp->stats, '\0', sizeof (struct pppstat));
452 /* Reset the demand dial information */
453 ppp->ddinfo.xmit_idle= /* time since last NP packet sent */
454 ppp->ddinfo.recv_idle=jiffies; /* time since last NP packet received */
456 /* PPP compression data */
458 ppp->sc_rc_state = NULL;
461 static struct symbol_table ppp_syms = {
462 #include <linux/symtab_begin.h>
463 X(ppp_register_compressor),
464 X(ppp_unregister_compressor),
466 #include <linux/symtab_end.h>
469 /* called at boot/load time for each ppp device defined in the kernel */
473 ppp_init (struct device *dev)
475 static int first_time = 1;
480 answer = ppp_first_time();
482 (void) register_symtab (&ppp_syms);
491 * Routine to allocate a buffer for later use by the driver.
494 static struct ppp_buffer *
495 ppp_alloc_buf (int size, int type)
497 struct ppp_buffer *buf;
499 buf = (struct ppp_buffer *) kmalloc (size + sizeof (struct ppp_buffer),
503 buf->size = size - 1; /* Mask for the buffer size */
509 buf->fcs = PPP_INITFCS;
516 * Routine to release the allocated buffer.
520 ppp_free_buf (struct ppp_buffer *ptr)
527 * Lock the indicated transmit buffer
531 lock_buffer (register struct ppp_buffer *buf)
536 * Save the current state and if free then set it to the "busy" state
544 restore_flags (flags);
549 * MTU has been changed by the IP layer. Unfortunately we are not told
550 * about this, but we spot it ourselves and fix things up. We could be
551 * in an upcall from the tty driver, or in an ip packet queue.
555 ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
559 struct ppp_buffer *new_rbuf;
560 struct ppp_buffer *new_wbuf;
561 struct ppp_buffer *new_cbuf;
562 struct ppp_buffer *new_tbuf;
564 struct ppp_buffer *old_rbuf;
565 struct ppp_buffer *old_wbuf;
566 struct ppp_buffer *old_cbuf;
567 struct ppp_buffer *old_tbuf;
571 * Allocate the buffer from the kernel for the data
575 /* allow for possible escaping of every character */
576 mtu = (new_mtu * 2) + 20;
578 /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
584 if (ppp->flags & SC_DEBUG)
585 printk (KERN_INFO "ppp: channel %s mtu = %d, mru = %d\n",
586 dev->name, new_mtu, new_mru);
588 new_wbuf = ppp_alloc_buf (mtu+PPP_HARD_HDR_LEN, BUFFER_TYPE_DEV_WR);
589 new_tbuf = ppp_alloc_buf ((PPP_MTU * 2) + 24, BUFFER_TYPE_TTY_WR);
590 new_rbuf = ppp_alloc_buf (mru + 84, BUFFER_TYPE_DEV_RD);
591 new_cbuf = ppp_alloc_buf (mru+PPP_HARD_HDR_LEN, BUFFER_TYPE_VJ);
593 * If the buffers failed to allocate then complain and release the partial
596 if (new_wbuf == NULL || new_tbuf == NULL ||
597 new_rbuf == NULL || new_cbuf == NULL) {
598 if (ppp->flags & SC_DEBUG)
600 "ppp: failed to allocate new buffers\n");
602 ppp_free_buf (new_wbuf);
603 ppp_free_buf (new_tbuf);
604 ppp_free_buf (new_rbuf);
605 ppp_free_buf (new_cbuf);
609 * Update the pointers to the new buffer structures.
612 old_wbuf = ppp->wbuf;
613 old_rbuf = ppp->rbuf;
614 old_cbuf = ppp->cbuf;
615 old_tbuf = ppp->tbuf;
617 ppp->wbuf = new_wbuf;
618 ppp->rbuf = new_rbuf;
619 ppp->cbuf = new_cbuf;
620 ppp->tbuf = new_tbuf;
622 ppp->rbuf->size -= 80; /* reserve space for vj header expansion */
624 dev->mem_start = (unsigned long) buf_base (new_wbuf);
625 dev->mem_end = (unsigned long) (dev->mem_start + mtu);
626 dev->rmem_start = (unsigned long) buf_base (new_rbuf);
627 dev->rmem_end = (unsigned long) (dev->rmem_start + mru);
629 * Update the parameters for the new buffer sizes
631 ppp->toss = 0xE0; /* To ignore characters until new FLAG */
632 ppp->escape = 0; /* No pending escape character */
642 ppp->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
643 ppp->flags &= ~SC_XMIT_BUSY;
647 * Release old buffer pointers
649 ppp_free_buf (old_rbuf);
650 ppp_free_buf (old_wbuf);
651 ppp_free_buf (old_cbuf);
652 ppp_free_buf (old_tbuf);
657 * CCP is down; free (de)compressor state if necessary.
661 ppp_ccp_closed (struct ppp *ppp)
663 if (ppp->sc_xc_state) {
664 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
665 ppp->sc_xc_state = NULL;
668 if (ppp->sc_rc_state) {
669 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
670 ppp->sc_rc_state = NULL;
675 * Called to release all of the information in the current PPP structure.
677 * It is called when the ppp device goes down or if it is unable to go
682 ppp_release (struct ppp *ppp)
684 struct tty_struct *tty;
690 ppp_ccp_closed (ppp);
692 /* Ensure that the pppd process is not hanging on select() */
693 wake_up_interruptible (&ppp->read_wait);
694 wake_up_interruptible (&ppp->write_wait);
696 if (tty != NULL && tty->disc_data == ppp)
697 tty->disc_data = NULL; /* Break the tty->ppp link */
699 if (dev && dev->flags & IFF_UP) {
700 dev_close (dev); /* close the device properly */
701 dev->flags = 0; /* prevent recursion */
704 ppp_free_buf (ppp->rbuf);
705 ppp_free_buf (ppp->wbuf);
706 ppp_free_buf (ppp->cbuf);
707 ppp_free_buf (ppp->ubuf);
708 ppp_free_buf (ppp->tbuf);
720 slhc_free (ppp->slcomp);
731 * Called when the PPP device goes down in response to an ifconfig request.
735 ppp_tty_close_local (struct tty_struct *tty, int sc_xfer)
737 struct ppp *ppp = tty2ppp (tty);
740 if (ppp->magic != PPP_MAGIC) {
741 if (ppp->flags & SC_DEBUG)
743 "ppp: trying to close unopened tty!\n");
746 ppp->sc_xfer = sc_xfer;
747 if (ppp->flags & SC_DEBUG)
748 printk (KERN_INFO "ppp: channel %s closing.\n",
749 ppp2dev(ppp) -> name);
757 ppp_tty_close (struct tty_struct *tty)
759 ppp_tty_close_local (tty, 0);
765 * Called when the tty discipline is switched to PPP.
769 ppp_tty_open (struct tty_struct *tty)
771 struct ppp *ppp = tty2ppp (tty);
774 * There should not be an existing table for this slot.
777 if (ppp->flags & SC_DEBUG)
779 "ppp_tty_open: gack! tty already associated to %s!\n",
780 ppp->magic == PPP_MAGIC ? ppp2dev(ppp)->name
785 * Allocate the structure from the system
787 ppp = ppp_find(current->pid);
795 if (ppp->flags & SC_DEBUG)
797 "ppp_tty_open: couldn't allocate ppp channel\n");
801 * Initialize the control block
803 ppp_init_ctrl_blk (ppp);
805 tty->disc_data = ppp;
807 * Flush any pending characters in the driver and discipline.
809 if (tty->ldisc.flush_buffer)
810 tty->ldisc.flush_buffer (tty);
812 if (tty->driver.flush_buffer)
813 tty->driver.flush_buffer (tty);
815 * Allocate space for the default VJ header compression slots
817 ppp->slcomp = slhc_init (16, 16);
818 if (ppp->slcomp == NULL) {
819 if (ppp->flags & SC_DEBUG)
821 "ppp_tty_open: no space for compression buffers!\n");
826 * Allocate space for the MTU and MRU buffers
828 if (ppp_changedmtu (ppp, ppp2dev(ppp)->mtu, ppp->mru) == 0) {
833 * Allocate space for a user level buffer
835 ppp->ubuf = ppp_alloc_buf (RBUFSIZE, BUFFER_TYPE_TTY_RD);
836 if (ppp->ubuf == NULL) {
837 if (ppp->flags & SC_DEBUG)
839 "ppp_tty_open: no space for user receive buffer\n");
844 if (ppp->flags & SC_DEBUG)
845 printk (KERN_INFO "ppp: channel %s open\n",
848 for (indx = 0; indx < NUM_NP; ++indx)
849 ppp->sc_npmode[indx] = NPMODE_PASS;
856 * Local function to send the next portion of the buffer.
858 * Called by the tty driver's tty_wakeup function should it be entered
859 * because the partial buffer was transmitted.
861 * Called by kick_tty to send the initial portion of the buffer.
863 * Completion processing of the buffer transmission is handled here.
867 ppp_tty_wakeup_code (struct ppp *ppp, struct tty_struct *tty,
868 struct ppp_buffer *xbuf)
870 register int count, actual;
872 * Prevent re-entrancy by ensuring that this routine is called only once.
875 if (ppp->flags & SC_XMIT_BUSY) {
879 ppp->flags |= SC_XMIT_BUSY;
882 * Send the next block of data to the modem
884 count = xbuf->count - xbuf->tail;
885 actual = tty->driver.write (tty, 0,
886 buf_base (xbuf) + xbuf->tail, count);
888 * Terminate transmission of any block which may have an error.
889 * This could occur should the carrier drop.
892 ppp->stats.ppp_oerrors++;
895 ppp->bytes_sent += actual;
897 * If the buffer has been transmitted then clear the indicators.
899 xbuf->tail += actual;
900 if (actual == count) {
902 ppp->flags &= ~SC_XMIT_BUSY;
904 * Complete the transmission on the current buffer.
908 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
912 * If the completed buffer came from the device write, then complete the
913 * transmission block.
915 if (ppp2dev (ppp) -> flags & IFF_UP) {
916 if (xbuf->type == BUFFER_TYPE_DEV_WR)
917 ppp2dev (ppp)->tbusy = 0;
921 * Wake up the transmission queue for all completion events.
923 wake_up_interruptible (&ppp->write_wait);
925 * Look at the priorities. Choose a daemon write over the device driver.
936 * If there is a pending buffer then transmit it now.
939 ppp->flags &= ~SC_XMIT_BUSY;
940 ppp_kick_tty (ppp, xbuf);
946 * Clear the re-entry flag
948 ppp->flags &= ~SC_XMIT_BUSY;
952 * This function is called by the tty driver when the transmit buffer has
953 * additional space. It is used by the ppp code to continue to transmit
954 * the current buffer should the buffer have been partially sent.
956 * In addition, it is used to send the first part of the buffer since the
957 * logic and the inter-locking would be identical.
961 ppp_tty_wakeup (struct tty_struct *tty)
963 struct ppp_buffer *xbuf;
964 struct ppp *ppp = tty2ppp (tty);
969 if (ppp->magic != PPP_MAGIC)
972 * Ensure that there is a transmission pending. Clear the re-entry flag if
973 * there is no pending buffer. Otherwise, send the buffer.
977 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
979 ppp_tty_wakeup_code (ppp, tty, xbuf);
983 * This function is called to transmit a buffer to the remote. The buffer
984 * is placed on the pending queue if there is presently a buffer being
985 * sent or it is transmitted with the aid of ppp_tty_wakeup.
989 ppp_kick_tty (struct ppp *ppp, struct ppp_buffer *xbuf)
998 * Control the flags which are best performed with the interrupts masked.
1003 * If the transmitter is busy then place the buffer on the appropriate
1006 if (ppp->xbuf != NULL) {
1007 if (xbuf->type == BUFFER_TYPE_TTY_WR)
1011 restore_flags (flags);
1015 * If the transmitter is not busy then this is the highest priority frame
1017 ppp->flags &= ~SC_XMIT_BUSY;
1018 ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
1020 restore_flags (flags);
1022 * Do the "tty wakeup_code" to actually send this buffer.
1024 ppp_tty_wakeup_code (ppp, ppp2tty (ppp), xbuf);
1027 /*************************************************************
1029 * The following functions handle input that arrives from
1030 * the TTY. It recognizes PPP frames and either hands them
1031 * to the network layer or queues them for delivery to a
1032 * user process reading this TTY.
1033 *************************************************************/
1036 * Callback function from tty driver. Return the amount of space left
1037 * in the receiver's buffer to decide if remote transmitter is to be
1042 ppp_tty_room (struct tty_struct *tty)
1044 return 65536; /* We can handle an infinite amount of data. :-) */
1048 * Callback function when data is available at the tty driver.
1051 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1052 char *flags, int count)
1054 register struct ppp *ppp = tty2ppp (tty);
1055 register struct ppp_buffer *buf = NULL;
1058 if (count >= TTY_FLIPBUF_SIZE)
1059 printk(KERN_WARNING "ppp_tty_receive: got %d chars\n", count);
1062 * Fetch the pointer to the buffer. Be careful about race conditions.
1070 * Verify the table pointer and ensure that the line is
1071 * still in PPP discipline.
1073 if (ppp->magic != PPP_MAGIC) {
1074 if (ppp->flags & SC_DEBUG)
1076 "PPP: handler called but couldn't find "
1082 * Print the buffer if desired
1084 if (ppp->flags & SC_LOG_RAWIN)
1085 ppp_print_buffer ("receive buffer", data, count);
1087 * Collect the character and error condition for the character. Set the toss
1088 * flag for the first character error.
1090 while (count-- > 0) {
1094 if (*flags && ppp->toss == 0)
1099 * Set the flags for 8 data bits and no parity.
1101 * Actually, it sets the flags for d7 being 0/1 and parity being even/odd
1102 * so that the normal processing would have all flags set at the end of the
1103 * session. A missing flag bit would denote an error condition.
1106 #ifdef CHECK_CHARACTERS
1108 ppp->flags |= SC_RCV_B7_1;
1110 ppp->flags |= SC_RCV_B7_0;
1112 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1113 ppp->flags |= SC_RCV_ODDP;
1115 ppp->flags |= SC_RCV_EVNP;
1118 * Branch on the character.
1122 * FLAG. This is the end of the block. If the block terminated by ESC FLAG,
1123 * then the block is to be ignored. In addition, characters before the very
1124 * first FLAG are also tossed by this procedure.
1126 case PPP_FLAG: /* PPP_FLAG: end of frame */
1127 ppp->stats.ppp_ibytes += ppp->rbuf->count;
1131 * Process frames which are not to be ignored. If the processing failed,
1132 * then clean up the VJ tables.
1134 if (ppp_doframe (ppp) == 0) {
1135 slhc_toss (ppp->slcomp);
1138 * Reset all indicators for the new frame to follow.
1141 buf->fcs = PPP_INITFCS;
1146 * All other characters in the data come here. If the character is in the
1147 * receive mask then ignore the character.
1150 /* If we're tossing, look no further. */
1154 /* If this is a control char to be ignored, do so */
1155 if (in_rmap (ppp, chr)) {
1156 if (ppp->flags & SC_DEBUG)
1157 printk(KERN_DEBUG "ignoring control char %x\n", chr);
1162 * Modify the next character if preceded by escape.
1163 * The escape character (0x7d) could be an escaped
1164 * 0x5d, if it follows an escape :-)
1169 } else if (chr == PPP_ESCAPE) {
1170 ppp->escape = PPP_TRANS;
1175 * If the count sent is within reason then store the character, bump the
1176 * count, and update the FCS for the character.
1178 if (buf->count < buf->size) {
1179 buf_base (buf)[buf->count++] = chr;
1180 buf->fcs = PPP_FCS (buf->fcs, chr);
1184 * The peer sent too much data. Set the flags to discard the current frame
1185 * and wait for the re-synchronization FLAG to be sent.
1187 ppp->stats.ppp_ierrors++;
1195 * Put the input frame into the networking system for the indicated protocol
1199 ppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1201 sk_buff *skb = dev_alloc_skb (count);
1203 * Generate a skb buffer for the new frame.
1206 if (ppp->flags & SC_DEBUG)
1208 "ppp_do_ip: packet dropped on %s (no memory)!\n",
1209 ppp2dev (ppp)->name);
1213 * Move the received data from the input buffer to the skb buffer.
1215 skb->dev = ppp2dev (ppp); /* We are the device */
1216 skb->protocol = proto;
1217 skb->mac.raw = skb_data(skb);
1218 memcpy (skb_put(skb,count), data, count); /* move data */
1220 * Tag the frame and kick it to the proper receive routine
1223 ppp->ddinfo.recv_idle = jiffies;
1229 * Process the receipt of an IP frame
1233 rcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1235 if ((ppp2dev (ppp)->flags & IFF_UP) && (count > 0))
1236 if (ppp->sc_npmode[NP_IP] == NPMODE_PASS)
1237 return ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
1242 * Process the receipt of an IPX frame
1246 rcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1248 if (((ppp2dev (ppp)->flags & IFF_UP) != 0) && (count > 0))
1249 return ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
1254 * Process the receipt of an VJ Compressed frame
1258 rcv_proto_vjc_comp (struct ppp *ppp, __u16 proto,
1259 __u8 *data, int count)
1261 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1262 int new_count = slhc_uncompress (ppp->slcomp, data, count);
1263 if (new_count >= 0) {
1264 return rcv_proto_ip (ppp, PPP_IP, data, new_count);
1266 if (ppp->flags & SC_DEBUG)
1268 "ppp: error in VJ decompression\n");
1274 * Process the receipt of an VJ Un-compressed frame
1278 rcv_proto_vjc_uncomp (struct ppp *ppp, __u16 proto,
1279 __u8 *data, int count)
1281 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1282 if (slhc_remember (ppp->slcomp, data, count) > 0) {
1283 return rcv_proto_ip (ppp, PPP_IP, data, count);
1285 if (ppp->flags & SC_DEBUG)
1287 "ppp: error in VJ memorizing\n");
1293 * Receive all unclassified protocols.
1297 rcv_proto_unknown (struct ppp *ppp, __u16 proto,
1298 __u8 *data, int len)
1301 register int current_idx;
1305 buf_base (ppp->ubuf) [current_idx++] = (__u8) (c); \
1306 current_idx &= ppp->ubuf->size; \
1307 if (current_idx == ppp->ubuf->tail) \
1312 * The total length includes the protocol data.
1313 * Lock the user information buffer.
1315 if (set_bit (0, &ppp->ubuf->locked)) {
1316 if (ppp->flags & SC_DEBUG)
1318 "ppp_us_queue: can't get lock\n");
1320 current_idx = ppp->ubuf->head;
1322 * Insert the buffer length (not counted), the protocol, and the data
1332 while (totlen-- > 0) {
1337 * The frame is complete. Update the head pointer and wakeup the pppd
1340 ppp->ubuf->head = current_idx;
1342 clear_bit (0, &ppp->ubuf->locked);
1343 wake_up_interruptible (&ppp->read_wait);
1344 if (ppp->tty->fasync != NULL)
1345 kill_fasync (ppp->tty->fasync, SIGIO);
1347 if (ppp->flags & SC_DEBUG)
1349 "ppp: successfully queued %d bytes, flags = %x\n",
1350 len + 2, ppp->flags);
1354 * The buffer is full. Unlock the header
1357 clear_bit (0, &ppp->ubuf->locked);
1358 if (ppp->flags & SC_DEBUG)
1360 "ppp_us_queue: ran out of buffer space.\n");
1363 * Discard the frame. There are no takers for this protocol.
1365 if (ppp->flags & SC_DEBUG)
1366 printk (KERN_WARNING
1367 "ppp: dropping packet on the floor.\n");
1368 slhc_toss (ppp->slcomp);
1373 * Handle a CCP packet.
1375 * The CCP packet is passed along to the pppd process just like any
1376 * other PPP frame. The difference is that some processing needs to be
1377 * immediate or the compressors will become confused on the peer.
1380 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd)
1382 int slen = CCP_LENGTH(dp);
1383 __u8 *opt = dp + CCP_HDRLEN;
1384 int opt_len = slen - CCP_HDRLEN;
1389 switch (CCP_CODE(dp)) {
1394 * CCP must be going down - disable compression
1396 if (ppp->flags & SC_CCP_UP) {
1397 ppp->flags &= ~(SC_CCP_UP |
1404 if ((ppp->flags & SC_CCP_OPEN) == 0)
1406 if (ppp->flags & SC_CCP_UP)
1408 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1410 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1413 * we're agreeing to send compressed packets.
1416 if (ppp->sc_xc_state == NULL)
1419 if ((*ppp->sc_xcomp->comp_init)
1423 ppp2dev (ppp)->base_addr,
1426 ppp->flags |= SC_COMP_RUN;
1430 * peer is agreeing to send compressed packets.
1432 if (ppp->sc_rc_state == NULL)
1435 if ((*ppp->sc_rcomp->decomp_init)
1439 ppp2dev (ppp)->base_addr,
1443 ppp->flags |= SC_DECOMP_RUN;
1444 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1448 * The protocol sequence is complete at this end
1451 if ((ppp->flags & SC_CCP_UP) == 0)
1455 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN))
1456 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1458 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1459 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1460 ppp->flags &= ~SC_DC_ERROR;
1468 rcv_proto_ccp (struct ppp *ppp, __u16 proto, __u8 *dp, int len)
1470 ppp_proto_ccp (ppp, dp, len, 1);
1471 return rcv_proto_unknown (ppp, proto, dp, len);
1475 * Handle a LQR packet.
1479 rcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
1481 return rcv_proto_unknown (ppp, proto, data, len);
1484 /* on entry, a received frame is in ppp->rbuf.bufr
1485 check it and dispose as appropriate */
1487 static void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
1489 __u16 proto = PPP_PROTOCOL (data);
1490 ppp_proto_type *proto_ptr;
1492 * Ignore empty frames
1497 * Count the frame and print it
1499 ++ppp->stats.ppp_ipackets;
1500 if (ppp->flags & SC_LOG_INPKT)
1501 ppp_print_buffer ("receive frame", data, count);
1503 * Find the procedure to handle this protocol. The last one is marked
1504 * as a protocol 0 which is the 'catch-all' to feed it to the pppd daemon.
1506 proto_ptr = proto_list;
1507 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
1510 * Update the appropriate statistic counter.
1512 if ((*proto_ptr->func) (ppp, proto,
1513 &data[PPP_HARD_HDR_LEN],
1514 count - PPP_HARD_HDR_LEN))
1515 ppp->stats.ppp_ioctects += count;
1517 ++ppp->stats.ppp_discards;
1520 /* on entry, a received frame is in ppp->rbuf.bufr
1521 check it and dispose as appropriate */
1524 ppp_doframe (struct ppp *ppp)
1526 __u8 *data = buf_base (ppp->rbuf);
1527 int count = ppp->rbuf->count;
1528 int addr, ctrl, proto;
1532 * If there is a pending error from the receiver then log it and discard
1533 * the damaged frame.
1536 if (ppp->flags & SC_DEBUG)
1538 "ppp_toss: tossing frame, reason = %x\n",
1540 ppp->stats.ppp_ierrors++;
1544 * An empty frame is ignored. This occurs if the FLAG sequence precedes and
1545 * follows each frame.
1550 * Generate an error if the frame is too small.
1552 if (count < PPP_HARD_HDR_LEN) {
1553 if (ppp->flags & SC_DEBUG)
1554 printk (KERN_WARNING
1555 "ppp: got runt ppp frame, %d chars\n", count);
1556 slhc_toss (ppp->slcomp);
1557 ppp->stats.ppp_ierrors++;
1561 * Verify the CRC of the frame and discard the CRC characters from the
1562 * end of the buffer.
1564 if (ppp->rbuf->fcs != PPP_GOODFCS) {
1565 if (ppp->flags & SC_DEBUG) {
1566 printk (KERN_WARNING
1567 "ppp: frame with bad fcs, excess = %x, length = %d\n",
1568 ppp->rbuf->fcs ^ PPP_GOODFCS, count);
1569 ppp_print_buffer("bad frame", data, count);
1571 ppp->stats.ppp_ierrors++;
1574 count -= 2; /* ignore the fcs characters */
1576 * Ignore the leading ADDRESS and CONTROL fields in the frame.
1578 addr = PPP_ALLSTATIONS;
1581 if ((data[0] == PPP_ALLSTATIONS) && (data[1] == PPP_UI)) {
1586 * Obtain the protocol from the frame
1588 proto = (__u16) *data++;
1589 if ((proto & 1) == 0) {
1590 proto = (proto << 8) | (__u16) *data++;
1594 * Rewrite the header with the full information. This may encroach upon
1595 * the 'filler' area in the buffer header. This is the purpose for the
1599 *(--data) = proto >> 8;
1604 * Process the active decompressor.
1606 if ((ppp->sc_rc_state != (void *) 0) &&
1607 (ppp->flags & SC_DECOMP_RUN) &&
1608 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
1609 if (proto == PPP_COMP) {
1611 * If the frame is compressed then decompress it.
1613 new_data = kmalloc (ppp->mru + 4, GFP_ATOMIC);
1614 if (new_data == NULL) {
1615 if (ppp->flags & SC_DEBUG)
1617 "ppp_doframe: no memory\n");
1618 slhc_toss (ppp->slcomp);
1619 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1625 * Decompress the frame
1627 new_count = bsd_decompress (ppp->sc_rc_state,
1632 switch (new_count) {
1634 ppp_doframe_lower (ppp, new_data, new_count);
1642 ppp->flags |= SC_DC_ERROR;
1645 case DECOMP_FATALERROR:
1646 ppp->flags |= SC_DC_FERROR;
1650 * Log the error condition and discard the frame.
1652 if (ppp->flags & SC_DEBUG)
1655 "decompress err %d\n", new_count);
1657 slhc_toss (ppp->slcomp);
1661 * The frame is not special. Pass it through the compressor without
1662 * actually compressing the data
1664 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1669 * Process the uncompressed frame.
1671 ppp_doframe_lower (ppp, data, count);
1675 /*************************************************************
1676 * LINE DISCIPLINE SUPPORT
1677 * The following functions form support user programs
1678 * which read and write data on a TTY with the PPP line
1679 * discipline. Reading is done from a circular queue,
1680 * filled by the lower TTY levels.
1681 *************************************************************/
1683 /* read a PPP frame from the us_rbuff circular buffer,
1684 waiting if necessary
1688 ppp_tty_read (struct tty_struct *tty, struct file *file, __u8 * buf,
1691 struct ppp *ppp = tty2ppp (tty);
1697 c = buf_base (ppp->ubuf) [ppp->ubuf->tail++]; \
1698 ppp->ubuf->tail &= ppp->ubuf->size; \
1702 * Validate the pointers
1707 if (ppp->magic != PPP_MAGIC)
1712 if (ppp->flags & SC_DEBUG)
1714 "ppp_tty_read: called buf=%p nr=%u\n",
1717 * Acquire the read lock.
1720 ppp = tty2ppp (tty);
1721 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
1724 if (set_bit (0, &ppp->ubuf->locked) != 0) {
1725 if (ppp->flags & SC_DEBUG)
1727 "ppp_tty_read: sleeping(ubuf)\n");
1729 current->timeout = 0;
1730 current->state = TASK_INTERRUPTIBLE;
1733 if (current->signal & ~current->blocked)
1738 * Before we attempt to write the frame to the user, ensure that the
1739 * user has access to the pages for the total buffer length.
1741 indx = verify_area (VERIFY_WRITE, buf, nr);
1745 * Fetch the length of the buffer from the first two bytes.
1747 if (ppp->ubuf->head == ppp->ubuf->tail)
1756 * If there is no length then wait for the data to arrive.
1760 clear_bit (0, &ppp->ubuf->locked);
1761 if (file->f_flags & O_NONBLOCK) {
1762 if (ppp->flags & SC_DEBUG)
1764 "ppp_tty_read: no data "
1768 current->timeout = 0;
1770 if (ppp->flags & SC_DEBUG)
1772 "ppp_tty_read: sleeping(read_wait)\n");
1774 interruptible_sleep_on (&ppp->read_wait);
1775 if (current->signal & ~current->blocked)
1780 * Reset the time of the last read operation.
1782 if (ppp->flags & SC_DEBUG)
1783 printk (KERN_DEBUG "ppp_tty_read: len = %d\n", len);
1785 * Ensure that the frame will fit within the caller's buffer. If not, then
1786 * discard the frame from the input buffer.
1789 /* Can't copy it, update us_rbuff_head */
1791 if (ppp->flags & SC_DEBUG)
1793 "ppp: read of %u bytes too small for %d "
1794 "frame\n", nr, len + 2);
1795 ppp->ubuf->tail += len;
1796 ppp->ubuf->tail &= ppp->ubuf->size;
1797 clear_bit (0, &ppp->ubuf->locked);
1798 ppp->stats.ppp_ierrors++;
1802 * Before we attempt to write the frame to the user, ensure that the
1803 * page tables are proper.
1805 indx = verify_area (VERIFY_WRITE, buf, len + 2);
1807 ppp->ubuf->tail += len;
1808 ppp->ubuf->tail &= ppp->ubuf->size;
1809 clear_bit (0, &ppp->ubuf->locked);
1813 * Fake the insertion of the ADDRESS and CONTROL information because these
1814 * were not saved in the buffer.
1816 put_user (PPP_ALLSTATIONS, buf++);
1817 put_user (PPP_UI, buf++);
1821 * Copy the received data from the buffer to the caller's area.
1823 while (indx-- > 0) {
1829 clear_bit (0, &ppp->ubuf->locked);
1830 len += 2; /* Account for ADDRESS and CONTROL bytes */
1831 if (ppp->flags & SC_DEBUG)
1833 "ppp_tty_read: passing %d bytes up\n", len);
1839 /* stuff a character into the transmit buffer, using PPP's way of escaping
1841 also, update fcs to take account of new character */
1844 ppp_stuff_char (struct ppp *ppp, register struct ppp_buffer *buf,
1848 * The buffer should not be full.
1850 if (ppp->flags & SC_DEBUG) {
1851 if ((buf->count < 0) || (buf->count > 3000))
1852 printk (KERN_DEBUG "ppp_stuff_char: %x %d\n",
1853 (unsigned int) buf->count,
1854 (unsigned int) chr);
1857 * Update the FCS and if the character needs to be escaped, do it.
1859 buf->fcs = PPP_FCS (buf->fcs, chr);
1860 if (in_xmap (ppp, chr)) {
1862 ins_char (buf, PPP_ESCAPE);
1865 * Add the character to the buffer.
1867 ins_char (buf, chr);
1871 * Procedure to encode the data with the proper escaping and send the
1872 * data to the remote system.
1876 ppp_dev_xmit_lower (struct ppp *ppp, struct ppp_buffer *buf,
1877 __u8 *data, int count, int non_ip)
1880 int address, control;
1883 * Insert the leading FLAG character
1887 if (non_ip || flag_time == 0)
1888 ins_char (buf, PPP_FLAG);
1890 if (jiffies - ppp->last_xmit > flag_time)
1891 ins_char (buf, PPP_FLAG);
1893 ppp->last_xmit = jiffies;
1894 buf->fcs = PPP_INITFCS;
1896 * Emit the address/control information if needed
1898 address = PPP_ADDRESS (data);
1899 control = PPP_CONTROL (data);
1900 proto = PPP_PROTOCOL (data);
1902 if (address != PPP_ALLSTATIONS ||
1903 control != PPP_UI ||
1904 (ppp->flags & SC_COMP_AC) == 0) {
1905 ppp_stuff_char (ppp, buf, address);
1906 ppp_stuff_char (ppp, buf, control);
1909 * Emit the protocol (compressed if possible)
1911 if ((ppp->flags & SC_COMP_PROT) == 0 || (proto & 0xFF00))
1912 ppp_stuff_char (ppp, buf, proto >> 8);
1914 ppp_stuff_char (ppp, buf, proto);
1922 ppp_stuff_char (ppp, buf, *data++);
1924 * Add the trailing CRC and the final flag character
1926 write_fcs = buf->fcs ^ 0xFFFF;
1927 ppp_stuff_char (ppp, buf, write_fcs);
1928 ppp_stuff_char (ppp, buf, write_fcs >> 8);
1930 * Add the trailing flag character
1932 ins_char (buf, PPP_FLAG);
1936 if (ppp->flags & SC_LOG_FLUSH)
1937 ppp_print_buffer ("ppp flush", buf_base (buf),
1940 * Send the block to the tty driver.
1942 ppp->stats.ppp_obytes += buf->count;
1943 ppp_kick_tty (ppp, buf);
1947 * Send an frame to the remote with the proper bsd compression.
1949 * Return 0 if frame was queued for transmission.
1950 * 1 if frame must be re-queued for later driver support.
1954 ppp_dev_xmit_frame (struct ppp *ppp, struct ppp_buffer *buf,
1955 __u8 *data, int count)
1958 int address, control;
1964 if (ppp->flags & SC_LOG_OUTPKT)
1965 ppp_print_buffer ("write frame", data, count);
1967 * Determine if the frame may be compressed. Attempt to compress the
1968 * frame if possible.
1970 proto = PPP_PROTOCOL (data);
1971 address = PPP_ADDRESS (data);
1972 control = PPP_CONTROL (data);
1974 if (((ppp->flags & SC_COMP_RUN) != 0) &&
1975 (ppp->sc_xc_state != (void *) 0) &&
1976 (address == PPP_ALLSTATIONS) &&
1977 (control == PPP_UI) &&
1978 (proto != PPP_LCP) &&
1979 (proto != PPP_CCP)) {
1980 new_data = kmalloc (count, GFP_ATOMIC);
1981 if (new_data == NULL) {
1982 if (ppp->flags & SC_DEBUG)
1984 "ppp_dev_xmit_frame: no memory\n");
1988 new_count = bsd_compress (ppp->sc_xc_state,
1994 if (new_count > 0) {
1995 ++ppp->stats.ppp_opackets;
1996 ppp->stats.ppp_ooctects += new_count;
1998 ppp_dev_xmit_lower (ppp, buf, new_data,
2004 * The frame could not be compressed.
2009 * The frame may not be compressed. Update the statistics before the
2010 * count field is destroyed. The frame will be transmitted.
2012 ++ppp->stats.ppp_opackets;
2013 ppp->stats.ppp_ooctects += count;
2015 * Go to the escape encoding
2017 ppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
2022 * Revise the tty frame for specific protocols.
2026 send_revise_frame (register struct ppp *ppp, __u8 *data, int len)
2030 switch (PPP_PROTOCOL (data)) {
2032 * Update the LQR frame with the current MIB information. This saves having
2033 * the daemon read old MIB data from the driver.
2036 len = 48; /* total size of this frame */
2037 p = (__u8 *) &data [40]; /* Point to last two items. */
2038 p = store_long (p, ppp->stats.ppp_opackets + 1);
2039 p = store_long (p, ppp->stats.ppp_ooctects + len);
2042 * Outbound compression frames
2046 data + PPP_HARD_HDR_LEN,
2047 len - PPP_HARD_HDR_LEN,
2059 * write a frame with NR chars from BUF to TTY
2060 * we have to put the FCS field on ourselves
2064 ppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
2067 struct ppp *ppp = tty2ppp (tty);
2071 * Verify the pointers.
2076 if (ppp->magic != PPP_MAGIC)
2081 * Ensure that the caller does not wish to send too much.
2083 if (count > PPP_MTU) {
2084 if (ppp->flags & SC_DEBUG)
2085 printk (KERN_WARNING
2086 "ppp_tty_write: truncating user packet "
2087 "from %u to mtu %d\n", count, PPP_MTU);
2091 * Allocate a buffer for the data and fetch it from the user space.
2093 new_data = kmalloc (count, GFP_KERNEL);
2094 if (new_data == NULL) {
2095 if (ppp->flags & SC_DEBUG)
2097 "ppp_tty_write: no memory\n");
2101 * lock this PPP unit so we will be the only writer;
2102 * sleep if necessary
2104 while (lock_buffer (ppp->tbuf) != 0) {
2105 current->timeout = 0;
2106 if (ppp->flags & SC_DEBUG)
2107 printk (KERN_DEBUG "ppp_tty_write: sleeping\n");
2108 interruptible_sleep_on (&ppp->write_wait);
2110 ppp = tty2ppp (tty);
2111 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse) {
2116 if (current->signal & ~current->blocked) {
2122 * Ensure that the caller's buffer is valid.
2124 status = verify_area (VERIFY_READ, data, count);
2127 ppp->tbuf->locked = 0;
2131 memcpy_fromfs (new_data, data, count);
2133 * Change the LQR frame
2135 count = send_revise_frame (ppp, new_data, count);
2139 ppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
2145 * Process the BSD compression IOCTL event for the tty device.
2149 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
2151 struct compressor *cp;
2152 struct ppp_option_data data;
2156 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
2158 * Fetch the compression parameters
2160 error = verify_area (VERIFY_READ, odp, sizeof (data));
2162 memcpy_fromfs (&data, odp, sizeof (data));
2165 if ((__u32) nb >= (__u32)CCP_MAX_OPTION_LENGTH)
2166 nb = CCP_MAX_OPTION_LENGTH;
2168 error = verify_area (VERIFY_READ, ptr, nb);
2174 memcpy_fromfs (ccp_option, ptr, nb);
2176 if (ccp_option[1] < 2) /* preliminary check on the length byte */
2179 cp = find_compressor ((int) (unsigned int) (__u8) ccp_option[0]);
2180 if (cp != (struct compressor *) 0) {
2182 * Found a handler for the protocol - try to allocate
2183 * a compressor or decompressor.
2186 if (data.transmit) {
2187 if (ppp->sc_xc_state != NULL)
2188 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2191 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2193 if (ppp->sc_xc_state == NULL) {
2194 if (ppp->flags & SC_DEBUG)
2195 printk("ppp%ld: comp_alloc failed\n",
2196 ppp2dev (ppp)->base_addr);
2199 ppp->flags &= ~SC_COMP_RUN;
2201 if (ppp->sc_rc_state != NULL)
2202 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2204 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2205 if (ppp->sc_rc_state == NULL) {
2206 if (ppp->flags & SC_DEBUG)
2207 printk("ppp%ld: decomp_alloc failed\n",
2208 ppp2dev (ppp)->base_addr);
2211 ppp->flags &= ~SC_DECOMP_RUN;
2216 if (ppp->flags & SC_DEBUG)
2217 printk(KERN_DEBUG "ppp%ld: no compressor for [%x %x %x], %x\n",
2218 ppp2dev (ppp)->base_addr, ccp_option[0], ccp_option[1],
2220 return (-EINVAL); /* no handler found */
2224 * Process the IOCTL event for the tty device.
2228 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
2229 unsigned int param2, unsigned long param3)
2231 struct ppp *ppp = tty2ppp (tty);
2232 register int temp_i = 0;
2235 * Verify the status of the PPP device.
2240 if (ppp->magic != PPP_MAGIC)
2245 * The user must have an euid of root to do these requests.
2254 error = verify_area (VERIFY_READ, (void *) param3,
2257 temp_i = get_user ((int *) param3);
2258 if (ppp->flags & SC_DEBUG)
2260 "ppp_tty_ioctl: set mru to %x\n", temp_i);
2262 if (ppp->mru != temp_i)
2263 ppp_changedmtu (ppp, ppp2dev (ppp)->mtu, temp_i);
2270 error = verify_area (VERIFY_WRITE, (void *) param3,
2273 temp_i = (ppp->flags & SC_MASK);
2274 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
2275 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
2276 SC_RCV_ODDP | SC_RCV_EVNP;
2278 put_user (temp_i, (int *) param3);
2279 if (ppp->flags & SC_DEBUG)
2281 "ppp_tty_ioctl: get flags: addr %lx flags "
2282 "%x\n", param3, temp_i);
2286 * Set the flags for the various options
2289 error = verify_area (VERIFY_READ, (void *) param3,
2292 temp_i = get_user ((int *) param3) & SC_MASK;
2293 temp_i |= (ppp->flags & ~SC_MASK);
2295 if ((ppp->flags & SC_CCP_OPEN) &&
2296 (temp_i & SC_CCP_OPEN) == 0)
2297 ppp_ccp_closed (ppp);
2299 if ((ppp->flags | temp_i) & SC_DEBUG)
2301 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2302 ppp->flags = temp_i;
2306 * Set the compression mode
2308 case PPPIOCSCOMPRESS:
2309 error = ppp_set_compression (ppp,
2310 (struct ppp_option_data *) param3);
2313 * Retrieve the transmit async map
2315 case PPPIOCGASYNCMAP:
2316 error = verify_area (VERIFY_WRITE, (void *) param3,
2319 put_user (ppp->xmit_async_map[0], (int *) param3);
2320 if (ppp->flags & SC_DEBUG)
2322 "ppp_tty_ioctl: get asyncmap: addr "
2323 "%lx asyncmap %x\n",
2325 ppp->xmit_async_map[0]);
2329 * Set the transmit async map
2331 case PPPIOCSASYNCMAP:
2332 error = verify_area (VERIFY_READ, (void *) param3,
2335 ppp->xmit_async_map[0] = get_user ((int *) param3);
2336 if (ppp->flags & SC_DEBUG)
2338 "ppp_tty_ioctl: set xmit asyncmap %x\n",
2339 ppp->xmit_async_map[0]);
2343 * Set the receive async map
2345 case PPPIOCSRASYNCMAP:
2346 error = verify_area (VERIFY_READ, (void *) param3,
2349 ppp->recv_async_map = get_user ((int *) param3);
2350 if (ppp->flags & SC_DEBUG)
2352 "ppp_tty_ioctl: set rcv asyncmap %x\n",
2353 ppp->recv_async_map);
2357 * Obtain the unit number for this device.
2360 error = verify_area (VERIFY_WRITE, (void *) param3,
2363 put_user (ppp2dev (ppp)->base_addr, (int *) param3);
2364 if (ppp->flags & SC_DEBUG)
2366 "ppp_tty_ioctl: get unit: %ld",
2367 ppp2dev (ppp)->base_addr);
2371 * Set the debug level
2374 error = verify_area (VERIFY_READ, (void *) param3,
2377 temp_i = (get_user ((int *) param3) & 0x1F) << 16;
2378 temp_i |= (ppp->flags & ~0x1F0000);
2380 if ((ppp->flags | temp_i) & SC_DEBUG)
2382 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2383 ppp->flags = temp_i;
2387 * Get the debug level
2390 error = verify_area (VERIFY_WRITE, (void *) param3,
2393 temp_i = (ppp->flags >> 16) & 0x1F;
2394 put_user (temp_i, (int *) param3);
2396 if (ppp->flags & SC_DEBUG)
2398 "ppp_tty_ioctl: get debug level %d\n",
2403 * Get the times since the last send/receive frame operation
2406 error = verify_area (VERIFY_WRITE, (void *) param3,
2407 sizeof (struct ppp_idle));
2409 struct ppp_idle cur_ddinfo;
2410 __u32 cur_jiffies = jiffies;
2412 /* change absolute times to relative times. */
2413 cur_ddinfo.xmit_idle = (cur_jiffies - ppp->ddinfo.xmit_idle) / HZ;
2414 cur_ddinfo.recv_idle = (cur_jiffies - ppp->ddinfo.recv_idle) / HZ;
2415 memcpy_tofs ((void *) param3, &cur_ddinfo,
2416 sizeof (cur_ddinfo));
2417 if (ppp->flags & SC_DEBUG)
2419 "ppp_tty_ioctl: read demand dial info\n");
2423 * Retrieve the extended async map
2425 case PPPIOCGXASYNCMAP:
2426 error = verify_area (VERIFY_WRITE,
2428 sizeof (ppp->xmit_async_map));
2430 memcpy_tofs ((void *) param3,
2431 ppp->xmit_async_map,
2432 sizeof (ppp->xmit_async_map));
2434 if (ppp->flags & SC_DEBUG)
2436 "ppp_tty_ioctl: get xasyncmap: addr %lx\n",
2441 * Set the async extended map
2443 case PPPIOCSXASYNCMAP:
2444 error = verify_area (VERIFY_READ, (void *) param3,
2445 sizeof (ppp->xmit_async_map));
2449 memcpy_fromfs (temp_tbl, (void *) param3,
2450 sizeof (ppp->xmit_async_map));
2451 temp_tbl[1] = 0x00000000;
2452 temp_tbl[2] &= ~0x40000000;
2453 temp_tbl[3] |= 0x60000000;
2455 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
2456 (temp_tbl[4] & temp_tbl[5]) != 0 ||
2457 (temp_tbl[6] & temp_tbl[7]) != 0)
2460 memcpy (ppp->xmit_async_map, temp_tbl,
2461 sizeof (ppp->xmit_async_map));
2463 if (ppp->flags & SC_DEBUG)
2465 "ppp_tty_ioctl: set xasyncmap\n");
2470 * Set the maximum VJ header compression slot number.
2473 error = verify_area (VERIFY_READ, (void *) param3,
2476 temp_i = get_user ((int *) param3) + 1;
2477 if (ppp->flags & SC_DEBUG)
2479 "ppp_tty_ioctl: set maxcid to %d\n",
2481 if (ppp->slcomp != NULL)
2482 slhc_free (ppp->slcomp);
2483 ppp->slcomp = slhc_init (16, temp_i);
2485 if (ppp->slcomp == NULL) {
2486 if (ppp->flags & SC_DEBUG)
2488 "ppp: no space for compression buffers!\n");
2495 case PPPIOCXFERUNIT:
2496 ppp_tty_close_local (tty, current->pid);
2501 error = verify_area (VERIFY_READ, (void *) param3,
2502 sizeof (struct npioctl));
2505 memcpy_fromfs (&npi,
2509 switch (npi.protocol) {
2511 npi.protocol = NP_IP;
2520 if (param2 == PPPIOCGNPMODE) {
2521 npi.mode = ppp->sc_npmode[npi.protocol];
2522 error = verify_area (VERIFY_WRITE,
2528 memcpy_tofs ((void *) param3,
2534 if (npi.mode != ppp->sc_npmode[npi.protocol]) {
2535 ppp->sc_npmode[npi.protocol] = npi.mode;
2536 if (npi.mode != NPMODE_QUEUE) {
2537 /* ppp_requeue(ppp); maybe needed */
2538 ppp_tty_wakeup (ppp2tty(ppp));
2544 * Allow users to read, but not set, the serial port parameters
2548 error = n_tty_ioctl (tty, file, param2, param3);
2552 error = verify_area (VERIFY_WRITE,
2556 int count = ppp->ubuf->tail - ppp->ubuf->head;
2558 count += (ppp->ubuf->size + 1);
2560 put_user (count, (int *) param3);
2564 * All other ioctl() events will come here.
2567 if (ppp->flags & SC_DEBUG)
2569 "ppp_tty_ioctl: invalid ioctl: %x, addr %lx\n",
2573 error = -ENOIOCTLCMD;
2582 * Process the select() statement for the PPP device.
2586 ppp_tty_select (struct tty_struct *tty, struct inode *inode,
2587 struct file *filp, int sel_type, select_table * wait)
2589 struct ppp *ppp = tty2ppp (tty);
2592 * Verify the status of the PPP device.
2597 if (ppp->magic != PPP_MAGIC)
2602 * Branch on the type of select mode. A read request must lock the user
2607 if (set_bit (0, &ppp->ubuf->locked) == 0) {
2608 /* Test for the presence of data in the queue */
2609 if (ppp->ubuf->head != ppp->ubuf->tail) {
2610 clear_bit (0, &ppp->ubuf->locked);
2613 clear_bit (0, &ppp->ubuf->locked);
2614 } /* fall through */
2616 * Exceptions or read errors.
2619 /* Is this a pty link and the remote disconnected? */
2620 if (tty->flags & (1 << TTY_OTHER_CLOSED))
2623 /* Is this a local link and the modem disconnected? */
2624 if (tty_hung_up_p (filp))
2627 select_wait (&ppp->read_wait, wait);
2631 * Write mode. A write is allowed if there is no current transmission.
2634 if (ppp->tbuf->locked != 0) {
2635 select_wait (&ppp->write_wait, wait);
2643 /*************************************************************
2645 * This routine accepts requests from the network layer
2646 * and attempts to deliver the packets.
2647 * It also includes various routines we are compelled to
2648 * have to make the network layer work (arp, etc...).
2649 *************************************************************/
2652 * Callback from the network layer when the device goes up.
2656 ppp_dev_open (struct device *dev)
2658 struct ppp *ppp = dev2ppp (dev);
2660 /* reset POINTOPOINT every time, since dev_close zaps it! */
2661 dev->flags |= IFF_POINTOPOINT;
2663 if (ppp2tty (ppp) == NULL) {
2664 if (ppp->flags & SC_DEBUG)
2666 "ppp: %s not connected to a TTY! can't go open!\n",
2671 if (ppp->flags & SC_DEBUG)
2673 "ppp: channel %s going up for IP packets!\n",
2681 * Callback from the network layer when the ppp device goes down.
2685 ppp_dev_close (struct device *dev)
2687 struct ppp *ppp = dev2ppp (dev);
2689 if (ppp2tty (ppp) == NULL) {
2690 if (ppp->flags & SC_DEBUG)
2692 "ppp: %s not connected to a TTY! can't go down!\n",
2697 * We don't do anything about the device going down. It is not important
2700 if (ppp->flags & SC_DEBUG)
2702 "ppp: channel %s going down for IP packets!\n",
2709 * IOCTL operation to read the version of the driver.
2713 ppp_dev_ioctl_version (struct ppp *ppp, struct ifreq *ifr)
2719 * Must have write access to the buffer.
2721 result = (char *) ifr->ifr_ifru.ifru_data;
2722 len = strlen (szVersion) + 1;
2723 error = verify_area (VERIFY_WRITE, result, len);
2725 * Move the version data
2728 memcpy_tofs (result, szVersion, len);
2734 * IOCTL to read the statistics for the pppstats program.
2738 ppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2740 struct ppp_stats *result, temp;
2743 * Must have write access to the buffer.
2745 result = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
2746 error = verify_area (VERIFY_WRITE,
2750 * Supply the information for the caller. First move the version data
2751 * then move the ppp stats; and finally the vj stats.
2753 memset (&temp, 0, sizeof(temp));
2754 if (error == 0 && dev->flags & IFF_UP) {
2755 memcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
2756 if (ppp->slcomp != NULL) {
2757 temp.vj.vjs_packets = ppp->slcomp->sls_o_compressed+
2758 ppp->slcomp->sls_o_uncompressed;
2759 temp.vj.vjs_compressed = ppp->slcomp->sls_o_compressed;
2760 temp.vj.vjs_searches = ppp->slcomp->sls_o_searches;
2761 temp.vj.vjs_misses = ppp->slcomp->sls_o_misses;
2762 temp.vj.vjs_errorin = ppp->slcomp->sls_i_error;
2763 temp.vj.vjs_tossed = ppp->slcomp->sls_i_tossed;
2764 temp.vj.vjs_uncompressedin = ppp->slcomp->sls_i_uncompressed;
2765 temp.vj.vjs_compressedin = ppp->slcomp->sls_i_compressed;
2770 memcpy_tofs (result, &temp, sizeof (temp));
2775 * IOCTL to read the compression statistics for the pppstats program.
2779 ppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2781 struct ppp_comp_stats *result, temp;
2784 * Must have write access to the buffer.
2786 result = (struct ppp_comp_stats *) ifr->ifr_ifru.ifru_data;
2787 error = verify_area (VERIFY_WRITE,
2791 * Supply the information for the caller.
2793 memset (&temp, 0, sizeof(temp));
2794 if (error == 0 && dev->flags & IFF_UP) {
2795 if (ppp->sc_xc_state != NULL)
2796 (*ppp->sc_xcomp->comp_stat) (ppp->sc_xc_state,
2799 if (ppp->sc_rc_state != NULL)
2800 (*ppp->sc_rcomp->decomp_stat) (ppp->sc_rc_state,
2804 * Move the data to the caller's buffer
2807 memcpy_tofs (result, &temp, sizeof (temp));
2812 * Callback from the network layer to process the sockioctl functions.
2816 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
2818 struct ppp *ppp = dev2ppp (dev);
2821 * Process the requests
2825 error = ppp_dev_ioctl_stats (ppp, ifr, dev);
2828 case SIOCGPPPCSTATS:
2829 error = ppp_dev_ioctl_comp_stats (ppp, ifr, dev);
2833 error = ppp_dev_ioctl_version (ppp, ifr);
2844 * Send an IP frame to the remote with vj header compression.
2846 * Return 0 if frame was queued for transmission.
2847 * 1 if frame must be re-queued for later driver support.
2851 ppp_dev_xmit_ip (struct device *dev, struct ppp *ppp, __u8 *data)
2855 struct ppp_hdr *hdr;
2856 struct tty_struct *tty = ppp2tty (ppp);
2858 * Obtain the length from the IP header.
2860 len = ((struct iphdr *)data) -> tot_len;
2863 * Validate the tty interface
2866 if (ppp->flags & SC_DEBUG)
2868 "ppp_dev_xmit: %s not connected to a TTY!\n",
2873 * Ensure that the PPP device is still up
2875 if (!(dev->flags & IFF_UP)) {
2876 if (ppp->flags & SC_DEBUG)
2877 printk (KERN_WARNING
2878 "ppp_dev_xmit: packet sent on interface %s,"
2879 " which is down for IP\n",
2884 * Branch on the type of processing for the IP frame.
2886 switch (ppp->sc_npmode[NP_IP]) {
2891 if (ppp->flags & SC_DEBUG)
2892 printk (KERN_WARNING
2893 "ppp_dev_xmit: npmode = NPMODE_ERROR on %s\n",
2898 if (ppp->flags & SC_DEBUG)
2899 printk (KERN_WARNING
2900 "ppp_dev_xmit: npmode = NPMODE_DROP on %s\n",
2908 if (ppp->flags & SC_DEBUG)
2909 printk (KERN_WARNING
2910 "ppp_dev_xmit: unknown npmode %d on %s\n",
2911 ppp->sc_npmode[NP_IP],
2916 * Detect a change in the transfer size
2918 if (ppp->mtu != ppp2dev (ppp)->mtu) {
2919 ppp_changedmtu (ppp,
2924 * Acquire the lock on the transmission buffer. If the buffer was busy then
2925 * mark the device as busy.
2927 if (lock_buffer (ppp->wbuf) != 0) {
2932 * Print the frame being sent
2934 if (ppp->flags & SC_LOG_OUTPKT)
2935 ppp_print_buffer ("ppp outpkt", data, len);
2937 * At this point, the buffer will be transmitted. There is no other exit.
2939 * Try to compress the header.
2941 if (ppp->flags & SC_COMP_TCP) {
2942 len = slhc_compress (ppp->slcomp, data, len,
2943 buf_base (ppp->cbuf) + PPP_HARD_HDR_LEN,
2945 (ppp->flags & SC_NO_TCP_CCID) == 0);
2947 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2948 proto = PPP_VJC_COMP;
2949 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2951 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2952 proto = PPP_VJC_UNCOMP;
2953 data[0] = (data[0] & 0x0f) | 0x40;
2959 len += PPP_HARD_HDR_LEN;
2960 hdr = &((struct ppp_hdr *) data)[-1];
2962 hdr->address = PPP_ALLSTATIONS;
2963 hdr->control = PPP_UI;
2964 hdr->protocol[0] = 0;
2965 hdr->protocol[1] = proto;
2967 return ppp_dev_xmit_frame (ppp, ppp->wbuf, (__u8 *) hdr, len);
2971 * Send an IPX (or any other non-IP) frame to the remote.
2973 * Return 0 if frame was queued for transmission.
2974 * 1 if frame must be re-queued for later driver support.
2977 ppp_dev_xmit_ipx (struct device *dev, struct ppp *ppp,
2978 __u8 *data, int len, int proto)
2980 struct tty_struct *tty = ppp2tty (ppp);
2981 struct ppp_hdr *hdr;
2983 * Validate the tty interface
2986 if (ppp->flags & SC_DEBUG)
2988 "ppp_dev_xmit: %s not connected to a TTY!\n",
2993 * Ensure that the PPP device is still up
2995 if (!(dev->flags & IFF_UP)) {
2996 if (ppp->flags & SC_DEBUG)
2997 printk (KERN_WARNING
2998 "ppp_dev_xmit: packet sent on interface %s,"
3004 * Detect a change in the transfer size
3006 if (ppp->mtu != ppp2dev (ppp)->mtu) {
3007 ppp_changedmtu (ppp,
3012 * Acquire the lock on the transmission buffer. If the buffer was busy then
3013 * mark the device as busy.
3015 if (lock_buffer (ppp->wbuf) != 0) {
3020 * Print the frame being sent
3022 if (ppp->flags & SC_LOG_OUTPKT)
3023 ppp_print_buffer ("ppp outpkt", data, len);
3027 len += PPP_HARD_HDR_LEN;
3028 hdr = &((struct ppp_hdr *) data)[-1];
3030 hdr->address = PPP_ALLSTATIONS;
3031 hdr->control = PPP_UI;
3032 hdr->protocol[0] = proto >> 8;
3033 hdr->protocol[1] = proto;
3035 return ppp_dev_xmit_frame (ppp, ppp->wbuf, (__u8 *) hdr, len);
3039 * Send a frame to the remote.
3043 ppp_dev_xmit (sk_buff *skb, struct device *dev)
3047 struct ppp *ppp = dev2ppp (dev);
3048 struct tty_struct *tty = ppp2tty (ppp);
3050 * just a little sanity check.
3053 if (ppp->flags & SC_DEBUG)
3054 printk (KERN_WARNING "ppp_dev_xmit: null packet!\n");
3058 * Avoid timing problem should tty hangup while data is queued to be sent
3061 dev_kfree_skb (skb, FREE_WRITE);
3066 * Validate the tty interface
3069 if (ppp->flags & SC_DEBUG)
3071 "ppp_dev_xmit: %s not connected to a TTY!\n",
3073 dev_kfree_skb (skb, FREE_WRITE);
3077 * Fetch the pointer to the data
3080 data = skb_data(skb);
3082 * Look at the protocol in the skb to determine the difference between
3083 * an IP frame and an IPX frame.
3085 switch (ntohs (skb->protocol)) {
3087 answer = ppp_dev_xmit_ipx (dev, ppp, data, len, PPP_IPX);
3091 answer = ppp_dev_xmit_ip (dev, ppp, data);
3094 default: /* All others have no support at this time. */
3095 dev_kfree_skb (skb, FREE_WRITE);
3099 * This is the end of the transmission. Release the buffer if it was sent.
3102 dev_kfree_skb (skb, FREE_WRITE);
3103 ppp->ddinfo.xmit_idle = jiffies;
3109 * Generate the statistic information for the /proc/net/dev listing.
3112 static struct enet_statistics *
3113 ppp_dev_stats (struct device *dev)
3115 struct ppp *ppp = dev2ppp (dev);
3116 static struct enet_statistics ppp_stats;
3118 ppp_stats.rx_packets = ppp->stats.ppp_ipackets;
3119 ppp_stats.rx_errors = ppp->stats.ppp_ierrors;
3120 ppp_stats.rx_dropped = ppp->stats.ppp_ierrors;
3121 ppp_stats.rx_fifo_errors = 0;
3122 ppp_stats.rx_length_errors = 0;
3123 ppp_stats.rx_over_errors = 0;
3124 ppp_stats.rx_crc_errors = 0;
3125 ppp_stats.rx_frame_errors = 0;
3126 ppp_stats.tx_packets = ppp->stats.ppp_opackets;
3127 ppp_stats.tx_errors = ppp->stats.ppp_oerrors;
3128 ppp_stats.tx_dropped = 0;
3129 ppp_stats.tx_fifo_errors = 0;
3130 ppp_stats.collisions = 0;
3131 ppp_stats.tx_carrier_errors = 0;
3132 ppp_stats.tx_aborted_errors = 0;
3133 ppp_stats.tx_window_errors = 0;
3134 ppp_stats.tx_heartbeat_errors = 0;
3136 if (ppp->flags & SC_DEBUG)
3137 printk (KERN_INFO "ppp_dev_stats called\n");
3141 static int ppp_dev_header (sk_buff *skb, struct device *dev,
3142 __u16 type, void *daddr,
3143 void *saddr, unsigned int len)
3149 ppp_dev_rebuild (void *eth, struct device *dev,
3150 unsigned long raddr, struct sk_buff *skb)
3155 /*************************************************************
3157 * Miscellany called by various functions above.
3158 *************************************************************/
3160 /* Locate the previous instance of the PPP channel */
3162 ppp_find (int pid_value)
3168 /* try to find the exact same free device which we had before */
3173 ppp = ctl2ppp (ctl);
3174 if (!set_bit(0, &ppp->inuse)) {
3175 if (ppp->sc_xfer == pid_value) {
3179 clear_bit (0, &ppp->inuse);
3182 if (++if_num == max_dev)
3188 /* allocate or create a PPP channel */
3198 /* try to find an free device */
3203 ppp = ctl2ppp (ctl);
3204 if (!set_bit(0, &ppp->inuse))
3207 if (++if_num == max_dev)
3211 * There are no available items. Allocate a device from the system pool
3213 ctl = (ppp_ctrl_t *) kmalloc (sizeof(ppp_ctrl_t), GFP_KERNEL);
3215 (void) memset(ctl, 0, sizeof(ppp_ctrl_t));
3216 ppp = ctl2ppp (ctl);
3217 dev = ctl2dev (ctl);
3219 /* initialize channel control data */
3220 set_bit(0, &ppp->inuse);
3227 dev->init = ppp_init_dev;
3228 dev->name = ctl->name;
3229 dev->base_addr = (__u32) if_num;
3230 dev->priv = (void *) ppp;
3232 sprintf (dev->name, "ppp%d", if_num);
3234 /* link in the new channel */
3235 ctl->next = ppp_list;
3238 /* register device so that we can be ifconfig'd */
3239 /* ppp_init_dev() will be called as a side-effect */
3241 status = register_netdev (dev);
3243 printk (KERN_INFO "registered device %s\n", dev->name);
3248 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3250 /* This one will forever be busy as it is not initialized */
3256 * Utility procedures to print a buffer in hex/ascii
3260 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3262 register __u8 next_ch;
3263 static char hex[] = "0123456789ABCDEF";
3265 while (count-- > 0) {
3267 *out++ = hex[(next_ch >> 4) & 0x0F];
3268 *out++ = hex[next_ch & 0x0F];
3274 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3276 register __u8 next_ch;
3278 while (count-- > 0) {
3281 if (next_ch < 0x20 || next_ch > 0x7e)
3285 if (next_ch == '%') /* printk/syslogd has a bug !! */
3293 ppp_print_buffer (const __u8 * name, const __u8 * buf, int count)
3297 if (name != (__u8 *) NULL)
3298 printk (KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3301 memset (line, 32, 44);
3302 ppp_print_hex (line, buf, 8);
3303 ppp_print_char (&line[8 * 3], buf, 8);
3304 printk (KERN_DEBUG "%s\n", line);
3310 memset (line, 32, 44);
3311 ppp_print_hex (line, buf, count);
3312 ppp_print_char (&line[8 * 3], buf, count);
3313 printk (KERN_DEBUG "%s\n", line);
3317 /*************************************************************
3318 * Compressor module interface
3319 *************************************************************/
3321 struct compressor_link {
3322 struct compressor_link *next;
3323 struct compressor *comp;
3326 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3328 static struct compressor *find_compressor (int type)
3330 struct compressor_link *lnk;
3331 unsigned long flags;
3336 lnk = ppp_compressors;
3337 while (lnk != (struct compressor_link *) 0) {
3338 if ((int) (__u8) lnk->comp->compress_proto == type) {
3339 restore_flags(flags);
3345 restore_flags(flags);
3346 return (struct compressor *) 0;
3349 static int ppp_register_compressor (struct compressor *cp)
3351 struct compressor_link *new;
3352 unsigned long flags;
3354 new = (struct compressor_link *) kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3356 if (new == (struct compressor_link *) 0)
3362 if (find_compressor (cp->compress_proto)) {
3363 restore_flags(flags);
3368 new->next = ppp_compressors;
3370 ppp_compressors = new;
3372 restore_flags(flags);
3376 static void ppp_unregister_compressor (struct compressor *cp)
3378 struct compressor_link *prev = (struct compressor_link *) 0;
3379 struct compressor_link *lnk;
3380 unsigned long flags;
3385 lnk = ppp_compressors;
3386 while (lnk != (struct compressor_link *) 0) {
3387 if (lnk->comp == cp) {
3389 prev->next = lnk->next;
3391 ppp_compressors = lnk->next;
3398 restore_flags(flags);
3401 /*************************************************************
3402 * Module support routines
3403 *************************************************************/
3411 /* register our line disciplines */
3412 status = ppp_first_time();
3415 "PPP: ppp_init() failure %d\n", status);
3417 (void) register_symtab (&ppp_syms);
3422 cleanup_module(void)
3425 ppp_ctrl_t *ctl, *next_ctl;
3430 * Ensure that the devices are not in operation.
3434 ppp = ctl2ppp (ctl);
3435 if (ppp->inuse && ppp->tty != NULL) {
3440 dev = ctl2dev (ctl);
3441 if (dev->start || dev->flags & IFF_UP) {
3448 * Ensure that there are no compressor modules registered
3450 if (ppp_compressors != NULL)
3455 "PPP: device busy, remove delayed\n");
3459 * Release the tty registration of the line discipline so that no new entries
3462 status = tty_register_ldisc (N_PPP, NULL);
3465 "PPP: Unable to unregister ppp line discipline "
3466 "(err = %d)\n", status);
3469 "PPP: ppp line discipline successfully unregistered\n");
3471 * De-register the devices so that there is no problem with them
3473 next_ctl = ppp_list;
3476 next_ctl = ctl->next;
3477 ppp = ctl2ppp (ctl);
3478 dev = ctl2dev (ctl);
3481 unregister_netdev (dev);