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 /* From: ppp.c,v 1.5 1995/06/12 11:36:53 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>
81 #include <linux/netdevice.h>
83 #include <linux/if_ether.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.
1052 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1053 char *flags, int count)
1055 register struct ppp *ppp = tty2ppp (tty);
1056 register struct ppp_buffer *buf = NULL;
1059 * Fetch the pointer to the buffer. Be careful about race conditions.
1067 * Verify the table pointer and ensure that the line is
1068 * still in PPP discipline.
1070 if (ppp->magic != PPP_MAGIC) {
1071 if (ppp->flags & SC_DEBUG)
1073 "PPP: handler called but couldn't find "
1079 * Print the buffer if desired
1081 if (ppp->flags & SC_LOG_RAWIN)
1082 ppp_print_buffer ("receive buffer", data, count);
1084 * Collect the character and error condition for the character. Set the toss
1085 * flag for the first character error.
1087 while (count-- > 0) {
1091 if (*flags && ppp->toss == 0)
1096 * Set the flags for 8 data bits and no parity.
1098 * Actually, it sets the flags for d7 being 0/1 and parity being even/odd
1099 * so that the normal processing would have all flags set at the end of the
1100 * session. A missing flag bit would denote an error condition.
1103 #ifdef CHECK_CHARACTERS
1105 ppp->flags |= SC_RCV_B7_1;
1107 ppp->flags |= SC_RCV_B7_0;
1109 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1110 ppp->flags |= SC_RCV_ODDP;
1112 ppp->flags |= SC_RCV_EVNP;
1115 * Branch on the character. Process the escape character. The sequence ESC ESC
1116 * is defined to be ESC.
1119 case PPP_ESCAPE: /* PPP_ESCAPE: invert bit in next character */
1120 ppp->escape = PPP_TRANS;
1123 * FLAG. This is the end of the block. If the block terminated by ESC FLAG,
1124 * then the block is to be ignored. In addition, characters before the very
1125 * first FLAG are also tossed by this procedure.
1127 case PPP_FLAG: /* PPP_FLAG: end of frame */
1128 ppp->stats.ppp_ibytes += ppp->rbuf->count;
1132 * Process frames which are not to be ignored. If the processing failed,
1133 * then clean up the VJ tables.
1135 if ((ppp->toss & 0x80) != 0 ||
1136 ppp_doframe (ppp) == 0) {
1137 slhc_toss (ppp->slcomp);
1140 * Reset all indicators for the new frame to follow.
1143 buf->fcs = PPP_INITFCS;
1148 * All other characters in the data come here. If the character is in the
1149 * receive mask then ignore the character.
1152 if (in_rmap (ppp, chr))
1155 * Adjust the character and if the frame is to be discarded then simply
1156 * ignore the character until the ending FLAG is received.
1164 * If the count sent is within reason then store the character, bump the
1165 * count, and update the FCS for the character.
1167 if (buf->count < buf->size) {
1168 buf_base (buf)[buf->count++] = chr;
1169 buf->fcs = PPP_FCS (buf->fcs, chr);
1173 * The peer sent too much data. Set the flags to discard the current frame
1174 * and wait for the re-synchronization FLAG to be sent.
1176 ppp->stats.ppp_ierrors++;
1184 * Put the input frame into the networking system for the indicated protocol
1188 ppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1190 sk_buff *skb = dev_alloc_skb (count);
1192 * Generate a skb buffer for the new frame.
1195 if (ppp->flags & SC_DEBUG)
1197 "ppp_do_ip: packet dropped on %s (no memory)!\n",
1198 ppp2dev (ppp)->name);
1202 * Move the received data from the input buffer to the skb buffer.
1204 skb->dev = ppp2dev (ppp); /* We are the device */
1205 skb->protocol = proto;
1206 skb->mac.raw = skb_data(skb);
1207 memcpy (skb_put(skb,count), data, count); /* move data */
1209 * Tag the frame and kick it to the proper receive routine
1212 ppp->ddinfo.recv_idle = jiffies;
1218 * Process the receipt of an IP frame
1222 rcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1224 if ((ppp2dev (ppp)->flags & IFF_UP) && (count > 0))
1225 if (ppp->sc_npmode[NP_IP] == NPMODE_PASS)
1226 return ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
1231 * Process the receipt of an IPX frame
1235 rcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
1237 if (((ppp2dev (ppp)->flags & IFF_UP) != 0) && (count > 0))
1238 return ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
1243 * Process the receipt of an VJ Compressed frame
1247 rcv_proto_vjc_comp (struct ppp *ppp, __u16 proto,
1248 __u8 *data, int count)
1250 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1251 int new_count = slhc_uncompress (ppp->slcomp, data, count);
1252 if (new_count >= 0) {
1253 return rcv_proto_ip (ppp, PPP_IP, data, new_count);
1255 if (ppp->flags & SC_DEBUG)
1257 "ppp: error in VJ decompression\n");
1263 * Process the receipt of an VJ Un-compressed frame
1267 rcv_proto_vjc_uncomp (struct ppp *ppp, __u16 proto,
1268 __u8 *data, int count)
1270 if ((ppp->flags & SC_REJ_COMP_TCP) == 0) {
1271 if (slhc_remember (ppp->slcomp, data, count) > 0) {
1272 return rcv_proto_ip (ppp, PPP_IP, data, count);
1274 if (ppp->flags & SC_DEBUG)
1276 "ppp: error in VJ memorizing\n");
1282 * Receive all unclassified protocols.
1286 rcv_proto_unknown (struct ppp *ppp, __u16 proto,
1287 __u8 *data, int len)
1290 register int current_idx;
1294 buf_base (ppp->ubuf) [current_idx++] = (__u8) (c); \
1295 current_idx &= ppp->ubuf->size; \
1296 if (current_idx == ppp->ubuf->tail) \
1301 * The total length includes the protocol data.
1302 * Lock the user information buffer.
1304 if (set_bit (0, &ppp->ubuf->locked)) {
1305 if (ppp->flags & SC_DEBUG)
1307 "ppp_us_queue: can't get lock\n");
1309 current_idx = ppp->ubuf->head;
1311 * Insert the buffer length (not counted), the protocol, and the data
1321 while (totlen-- > 0) {
1326 * The frame is complete. Update the head pointer and wakeup the pppd
1329 ppp->ubuf->head = current_idx;
1331 clear_bit (0, &ppp->ubuf->locked);
1332 wake_up_interruptible (&ppp->read_wait);
1333 if (ppp->tty->fasync != NULL)
1334 kill_fasync (ppp->tty->fasync, SIGIO);
1336 if (ppp->flags & SC_DEBUG)
1338 "ppp: successfully queued %d bytes, flags = %x\n",
1339 len + 2, ppp->flags);
1343 * The buffer is full. Unlock the header
1346 clear_bit (0, &ppp->ubuf->locked);
1347 if (ppp->flags & SC_DEBUG)
1349 "ppp_us_queue: ran out of buffer space.\n");
1352 * Discard the frame. There are no takers for this protocol.
1354 if (ppp->flags & SC_DEBUG)
1355 printk (KERN_WARNING
1356 "ppp: dropping packet on the floor.\n");
1357 slhc_toss (ppp->slcomp);
1362 * Handle a CCP packet.
1364 * The CCP packet is passed along to the pppd process just like any
1365 * other PPP frame. The difference is that some processing needs to be
1366 * immediate or the compressors will become confused on the peer.
1369 static void ppp_proto_ccp (struct ppp *ppp, __u8 *dp, int len, int rcvd)
1371 int slen = CCP_LENGTH(dp);
1372 __u8 *opt = dp + CCP_HDRLEN;
1373 int opt_len = slen - CCP_HDRLEN;
1378 switch (CCP_CODE(dp)) {
1383 * CCP must be going down - disable compression
1385 if (ppp->flags & SC_CCP_UP) {
1386 ppp->flags &= ~(SC_CCP_UP |
1393 if ((ppp->flags & SC_CCP_OPEN) == 0)
1395 if (ppp->flags & SC_CCP_UP)
1397 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1399 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1402 * we're agreeing to send compressed packets.
1405 if (ppp->sc_xc_state == NULL)
1408 if ((*ppp->sc_xcomp->comp_init)
1412 ppp2dev (ppp)->base_addr,
1415 ppp->flags |= SC_COMP_RUN;
1419 * peer is agreeing to send compressed packets.
1421 if (ppp->sc_rc_state == NULL)
1424 if ((*ppp->sc_rcomp->decomp_init)
1428 ppp2dev (ppp)->base_addr,
1432 ppp->flags |= SC_DECOMP_RUN;
1433 ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1437 * The protocol sequence is complete at this end
1440 if ((ppp->flags & SC_CCP_UP) == 0)
1444 if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN))
1445 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1447 if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1448 (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1449 ppp->flags &= ~SC_DC_ERROR;
1457 rcv_proto_ccp (struct ppp *ppp, __u16 proto, __u8 *dp, int len)
1459 ppp_proto_ccp (ppp, dp, len, 1);
1460 return rcv_proto_unknown (ppp, proto, dp, len);
1464 * Handle a LQR packet.
1468 rcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
1470 return rcv_proto_unknown (ppp, proto, data, len);
1473 /* on entry, a received frame is in ppp->rbuf.bufr
1474 check it and dispose as appropriate */
1476 static void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
1478 __u16 proto = PPP_PROTOCOL (data);
1479 ppp_proto_type *proto_ptr;
1481 * Ignore empty frames
1486 * Count the frame and print it
1488 ++ppp->stats.ppp_ipackets;
1489 if (ppp->flags & SC_LOG_INPKT)
1490 ppp_print_buffer ("receive frame", data, count);
1492 * Find the procedure to handle this protocol. The last one is marked
1493 * as a protocol 0 which is the 'catch-all' to feed it to the pppd daemon.
1495 proto_ptr = proto_list;
1496 while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
1499 * Update the appropriate statistic counter.
1501 if ((*proto_ptr->func) (ppp, proto,
1502 &data[PPP_HARD_HDR_LEN],
1503 count - PPP_HARD_HDR_LEN))
1504 ppp->stats.ppp_ioctects += count;
1506 ++ppp->stats.ppp_discards;
1509 /* on entry, a received frame is in ppp->rbuf.bufr
1510 check it and dispose as appropriate */
1513 ppp_doframe (struct ppp *ppp)
1515 __u8 *data = buf_base (ppp->rbuf);
1516 int count = ppp->rbuf->count;
1517 int addr, ctrl, proto;
1521 * If there is a pending error from the receiver then log it and discard
1522 * the damaged frame.
1525 if (ppp->flags & SC_DEBUG)
1526 printk (KERN_WARNING
1527 "ppp_toss: tossing frame, reason = %d\n",
1529 ppp->stats.ppp_ierrors++;
1533 * An empty frame is ignored. This occurs if the FLAG sequence precedes and
1534 * follows each frame.
1539 * Generate an error if the frame is too small.
1541 if (count < PPP_HARD_HDR_LEN) {
1542 if (ppp->flags & SC_DEBUG)
1543 printk (KERN_WARNING
1544 "ppp: got runt ppp frame, %d chars\n", count);
1545 slhc_toss (ppp->slcomp);
1546 ppp->stats.ppp_ierrors++;
1550 * Verify the CRC of the frame and discard the CRC characters from the
1551 * end of the buffer.
1553 if (ppp->rbuf->fcs != PPP_GOODFCS) {
1554 if (ppp->flags & SC_DEBUG)
1555 printk (KERN_WARNING
1556 "ppp: frame with bad fcs, excess = %x\n",
1557 ppp->rbuf->fcs ^ PPP_GOODFCS);
1558 ppp->stats.ppp_ierrors++;
1561 count -= 2; /* ignore the fcs characters */
1563 * Ignore the leading ADDRESS and CONTROL fields in the frame.
1565 addr = PPP_ALLSTATIONS;
1568 if ((data[0] == PPP_ALLSTATIONS) && (data[1] == PPP_UI)) {
1573 * Obtain the protocol from the frame
1575 proto = (__u16) *data++;
1576 if ((proto & 1) == 0) {
1577 proto = (proto << 8) | (__u16) *data++;
1581 * Rewrite the header with the full information. This may encroach upon
1582 * the 'filler' area in the buffer header. This is the purpose for the
1586 *(--data) = proto >> 8;
1591 * Process the active decompressor.
1593 if ((ppp->sc_rc_state != (void *) 0) &&
1594 (ppp->flags & SC_DECOMP_RUN) &&
1595 ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
1596 if (proto == PPP_COMP) {
1598 * If the frame is compressed then decompress it.
1600 new_data = kmalloc (ppp->mru + 4, GFP_ATOMIC);
1601 if (new_data == NULL) {
1602 if (ppp->flags & SC_DEBUG)
1604 "ppp_doframe: no memory\n");
1605 slhc_toss (ppp->slcomp);
1606 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1612 * Decompress the frame
1614 new_count = bsd_decompress (ppp->sc_rc_state,
1619 switch (new_count) {
1621 ppp_doframe_lower (ppp, new_data, new_count);
1629 ppp->flags |= SC_DC_ERROR;
1632 case DECOMP_FATALERROR:
1633 ppp->flags |= SC_DC_FERROR;
1637 * Log the error condition and discard the frame.
1639 if (ppp->flags & SC_DEBUG)
1642 "decompress err %d\n", new_count);
1644 slhc_toss (ppp->slcomp);
1648 * The frame is not special. Pass it through the compressor without
1649 * actually compressing the data
1651 (*ppp->sc_rcomp->incomp) (ppp->sc_rc_state,
1656 * Process the uncompressed frame.
1658 ppp_doframe_lower (ppp, data, count);
1662 /*************************************************************
1663 * LINE DISCIPLINE SUPPORT
1664 * The following functions form support user programs
1665 * which read and write data on a TTY with the PPP line
1666 * discipline. Reading is done from a circular queue,
1667 * filled by the lower TTY levels.
1668 *************************************************************/
1670 /* read a PPP frame from the us_rbuff circular buffer,
1671 waiting if necessary
1675 ppp_tty_read (struct tty_struct *tty, struct file *file, __u8 * buf,
1678 struct ppp *ppp = tty2ppp (tty);
1684 c = buf_base (ppp->ubuf) [ppp->ubuf->tail++]; \
1685 ppp->ubuf->tail &= ppp->ubuf->size; \
1689 * Validate the pointers
1694 if (ppp->magic != PPP_MAGIC)
1699 if (ppp->flags & SC_DEBUG)
1701 "ppp_tty_read: called buf=%p nr=%u\n",
1704 * Acquire the read lock.
1707 ppp = tty2ppp (tty);
1708 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
1711 if (set_bit (0, &ppp->ubuf->locked) != 0) {
1712 if (ppp->flags & SC_DEBUG)
1714 "ppp_tty_read: sleeping(ubuf)\n");
1716 current->timeout = 0;
1717 current->state = TASK_INTERRUPTIBLE;
1720 if (current->signal & ~current->blocked)
1725 * Before we attempt to write the frame to the user, ensure that the
1726 * user has access to the pages for the total buffer length.
1728 indx = verify_area (VERIFY_WRITE, buf, nr);
1732 * Fetch the length of the buffer from the first two bytes.
1734 if (ppp->ubuf->head == ppp->ubuf->tail)
1743 * If there is no length then wait for the data to arrive.
1747 clear_bit (0, &ppp->ubuf->locked);
1748 if (file->f_flags & O_NONBLOCK) {
1749 if (ppp->flags & SC_DEBUG)
1751 "ppp_tty_read: no data "
1755 current->timeout = 0;
1757 if (ppp->flags & SC_DEBUG)
1759 "ppp_tty_read: sleeping(read_wait)\n");
1761 interruptible_sleep_on (&ppp->read_wait);
1762 if (current->signal & ~current->blocked)
1767 * Reset the time of the last read operation.
1769 if (ppp->flags & SC_DEBUG)
1770 printk (KERN_DEBUG "ppp_tty_read: len = %d\n", len);
1772 * Ensure that the frame will fit within the caller's buffer. If not, then
1773 * discard the frame from the input buffer.
1776 /* Can't copy it, update us_rbuff_head */
1778 if (ppp->flags & SC_DEBUG)
1780 "ppp: read of %u bytes too small for %d "
1781 "frame\n", nr, len + 2);
1782 ppp->ubuf->tail += len;
1783 ppp->ubuf->tail &= ppp->ubuf->size;
1784 clear_bit (0, &ppp->ubuf->locked);
1785 ppp->stats.ppp_ierrors++;
1789 * Before we attempt to write the frame to the user, ensure that the
1790 * page tables are proper.
1792 indx = verify_area (VERIFY_WRITE, buf, len + 2);
1794 ppp->ubuf->tail += len;
1795 ppp->ubuf->tail &= ppp->ubuf->size;
1796 clear_bit (0, &ppp->ubuf->locked);
1800 * Fake the insertion of the ADDRESS and CONTROL information because these
1801 * were not saved in the buffer.
1803 put_user (PPP_ALLSTATIONS, buf++);
1804 put_user (PPP_UI, buf++);
1808 * Copy the received data from the buffer to the caller's area.
1810 while (indx-- > 0) {
1816 clear_bit (0, &ppp->ubuf->locked);
1817 len += 2; /* Account for ADDRESS and CONTROL bytes */
1818 if (ppp->flags & SC_DEBUG)
1820 "ppp_tty_read: passing %d bytes up\n", len);
1826 /* stuff a character into the transmit buffer, using PPP's way of escaping
1828 also, update fcs to take account of new character */
1831 ppp_stuff_char (struct ppp *ppp, register struct ppp_buffer *buf,
1835 * The buffer should not be full.
1837 if (ppp->flags & SC_DEBUG) {
1838 if ((buf->count < 0) || (buf->count > 3000))
1839 printk (KERN_DEBUG "ppp_stuff_char: %x %d\n",
1840 (unsigned int) buf->count,
1841 (unsigned int) chr);
1844 * Update the FCS and if the character needs to be escaped, do it.
1846 buf->fcs = PPP_FCS (buf->fcs, chr);
1847 if (in_xmap (ppp, chr)) {
1849 ins_char (buf, PPP_ESCAPE);
1852 * Add the character to the buffer.
1854 ins_char (buf, chr);
1858 * Procedure to encode the data with the proper escaping and send the
1859 * data to the remote system.
1863 ppp_dev_xmit_lower (struct ppp *ppp, struct ppp_buffer *buf,
1864 __u8 *data, int count, int non_ip)
1867 int address, control;
1870 * Insert the leading FLAG character
1874 if (non_ip || flag_time == 0)
1875 ins_char (buf, PPP_FLAG);
1877 if (jiffies - ppp->last_xmit > flag_time)
1878 ins_char (buf, PPP_FLAG);
1880 ppp->last_xmit = jiffies;
1881 buf->fcs = PPP_INITFCS;
1883 * Emit the address/control information if needed
1885 address = PPP_ADDRESS (data);
1886 control = PPP_CONTROL (data);
1887 proto = PPP_PROTOCOL (data);
1889 if (address != PPP_ALLSTATIONS ||
1890 control != PPP_UI ||
1891 (ppp->flags & SC_COMP_AC) == 0) {
1892 ppp_stuff_char (ppp, buf, address);
1893 ppp_stuff_char (ppp, buf, control);
1896 * Emit the protocol (compressed if possible)
1898 if ((ppp->flags & SC_COMP_PROT) == 0 || (proto & 0xFF00))
1899 ppp_stuff_char (ppp, buf, proto >> 8);
1901 ppp_stuff_char (ppp, buf, proto);
1909 ppp_stuff_char (ppp, buf, *data++);
1911 * Add the trailing CRC and the final flag character
1913 write_fcs = buf->fcs ^ 0xFFFF;
1914 ppp_stuff_char (ppp, buf, write_fcs);
1915 ppp_stuff_char (ppp, buf, write_fcs >> 8);
1917 if (ppp->flags & SC_DEBUG)
1918 printk (KERN_DEBUG "ppp_dev_xmit_lower: fcs is %hx\n",
1921 * Add the trailing flag character
1923 ins_char (buf, PPP_FLAG);
1927 if (ppp->flags & SC_LOG_FLUSH)
1928 ppp_print_buffer ("ppp flush", buf_base (buf),
1931 if (ppp->flags & SC_DEBUG)
1933 "ppp_dev_xmit: writing %d chars\n",
1937 * Send the block to the tty driver.
1939 ppp->stats.ppp_obytes += buf->count;
1940 ppp_kick_tty (ppp, buf);
1944 * Send an frame to the remote with the proper bsd compression.
1946 * Return 0 if frame was queued for transmission.
1947 * 1 if frame must be re-queued for later driver support.
1951 ppp_dev_xmit_frame (struct ppp *ppp, struct ppp_buffer *buf,
1952 __u8 *data, int count)
1955 int address, control;
1961 if (ppp->flags & SC_LOG_OUTPKT)
1962 ppp_print_buffer ("write frame", data, count);
1964 * Determine if the frame may be compressed. Attempt to compress the
1965 * frame if possible.
1967 proto = PPP_PROTOCOL (data);
1968 address = PPP_ADDRESS (data);
1969 control = PPP_CONTROL (data);
1971 if (((ppp->flags & SC_COMP_RUN) != 0) &&
1972 (ppp->sc_xc_state != (void *) 0) &&
1973 (address == PPP_ALLSTATIONS) &&
1974 (control == PPP_UI) &&
1975 (proto != PPP_LCP) &&
1976 (proto != PPP_CCP)) {
1977 new_data = kmalloc (count, GFP_ATOMIC);
1978 if (new_data == NULL) {
1979 if (ppp->flags & SC_DEBUG)
1981 "ppp_dev_xmit_frame: no memory\n");
1985 new_count = bsd_compress (ppp->sc_xc_state,
1991 if (new_count > 0) {
1992 ++ppp->stats.ppp_opackets;
1993 ppp->stats.ppp_ooctects += new_count;
1995 ppp_dev_xmit_lower (ppp, buf, new_data,
2001 * The frame could not be compressed.
2006 * The frame may not be compressed. Update the statistics before the
2007 * count field is destroyed. The frame will be transmitted.
2009 ++ppp->stats.ppp_opackets;
2010 ppp->stats.ppp_ooctects += count;
2012 * Go to the escape encoding
2014 ppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
2019 * Revise the tty frame for specific protocols.
2023 send_revise_frame (register struct ppp *ppp, __u8 *data, int len)
2027 switch (PPP_PROTOCOL (data)) {
2029 * Update the LQR frame with the current MIB information. This saves having
2030 * the daemon read old MIB data from the driver.
2033 len = 48; /* total size of this frame */
2034 p = (__u8 *) &data [40]; /* Point to last two items. */
2035 p = store_long (p, ppp->stats.ppp_opackets + 1);
2036 p = store_long (p, ppp->stats.ppp_ooctects + len);
2039 * Outbound compression frames
2043 data + PPP_HARD_HDR_LEN,
2044 len - PPP_HARD_HDR_LEN,
2056 * write a frame with NR chars from BUF to TTY
2057 * we have to put the FCS field on ourselves
2061 ppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
2064 struct ppp *ppp = tty2ppp (tty);
2068 * Verify the pointers.
2073 if (ppp->magic != PPP_MAGIC)
2078 * Ensure that the caller does not wish to send too much.
2080 if (count > PPP_MTU) {
2081 if (ppp->flags & SC_DEBUG)
2082 printk (KERN_WARNING
2083 "ppp_tty_write: truncating user packet "
2084 "from %u to mtu %d\n", count, PPP_MTU);
2088 * Allocate a buffer for the data and fetch it from the user space.
2090 new_data = kmalloc (count, GFP_KERNEL);
2091 if (new_data == NULL) {
2092 if (ppp->flags & SC_DEBUG)
2094 "ppp_tty_write: no memory\n");
2098 * lock this PPP unit so we will be the only writer;
2099 * sleep if necessary
2101 while (lock_buffer (ppp->tbuf) != 0) {
2102 current->timeout = 0;
2103 if (ppp->flags & SC_DEBUG)
2104 printk (KERN_DEBUG "ppp_tty_write: sleeping\n");
2105 interruptible_sleep_on (&ppp->write_wait);
2107 ppp = tty2ppp (tty);
2108 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse) {
2113 if (current->signal & ~current->blocked) {
2119 * Ensure that the caller's buffer is valid.
2121 status = verify_area (VERIFY_READ, data, count);
2124 ppp->tbuf->locked = 0;
2128 memcpy_fromfs (new_data, data, count);
2130 * Change the LQR frame
2132 count = send_revise_frame (ppp, new_data, count);
2136 ppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
2142 * Process the BSD compression IOCTL event for the tty device.
2146 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
2148 struct compressor *cp;
2149 struct ppp_option_data data;
2153 __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
2155 * Fetch the compression parameters
2157 error = verify_area (VERIFY_READ, odp, sizeof (data));
2159 memcpy_fromfs (&data, odp, sizeof (data));
2162 if ((__u32) nb >= (__u32)CCP_MAX_OPTION_LENGTH)
2163 nb = CCP_MAX_OPTION_LENGTH;
2165 error = verify_area (VERIFY_READ, ptr, nb);
2171 memcpy_fromfs (ccp_option, ptr, nb);
2173 if (ccp_option[1] < 2) /* preliminary check on the length byte */
2176 cp = find_compressor ((int) (unsigned int) (__u8) ccp_option[0]);
2177 if (cp != (struct compressor *) 0) {
2179 * Found a handler for the protocol - try to allocate
2180 * a compressor or decompressor.
2183 if (data.transmit) {
2184 if (ppp->sc_xc_state != NULL)
2185 (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
2188 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
2190 if (ppp->sc_xc_state == NULL) {
2191 if (ppp->flags & SC_DEBUG)
2192 printk("ppp%ld: comp_alloc failed\n",
2193 ppp2dev (ppp)->base_addr);
2196 ppp->flags &= ~SC_COMP_RUN;
2198 if (ppp->sc_rc_state != NULL)
2199 (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
2201 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
2202 if (ppp->sc_rc_state == NULL) {
2203 if (ppp->flags & SC_DEBUG)
2204 printk("ppp%ld: decomp_alloc failed\n",
2205 ppp2dev (ppp)->base_addr);
2208 ppp->flags &= ~SC_DECOMP_RUN;
2213 if (ppp->flags & SC_DEBUG)
2214 printk(KERN_DEBUG "ppp%ld: no compressor for [%x %x %x], %x\n",
2215 ppp2dev (ppp)->base_addr, ccp_option[0], ccp_option[1],
2217 return (-EINVAL); /* no handler found */
2221 * Process the IOCTL event for the tty device.
2225 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
2226 unsigned int param2, unsigned long param3)
2228 struct ppp *ppp = tty2ppp (tty);
2229 register int temp_i = 0;
2232 * Verify the status of the PPP device.
2237 if (ppp->magic != PPP_MAGIC)
2242 * The user must have an euid of root to do these requests.
2251 error = verify_area (VERIFY_READ, (void *) param3,
2254 temp_i = get_user ((int *) param3);
2255 if (ppp->flags & SC_DEBUG)
2257 "ppp_tty_ioctl: set mru to %x\n", temp_i);
2259 if (ppp->mru != temp_i)
2260 ppp_changedmtu (ppp, ppp2dev (ppp)->mtu, temp_i);
2267 error = verify_area (VERIFY_WRITE, (void *) param3,
2270 temp_i = (ppp->flags & SC_MASK);
2271 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
2272 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
2273 SC_RCV_ODDP | SC_RCV_EVNP;
2275 put_user (temp_i, (int *) param3);
2276 if (ppp->flags & SC_DEBUG)
2278 "ppp_tty_ioctl: get flags: addr %lx flags "
2279 "%x\n", param3, temp_i);
2283 * Set the flags for the various options
2286 error = verify_area (VERIFY_READ, (void *) param3,
2289 temp_i = get_user ((int *) param3) & SC_MASK;
2290 temp_i |= (ppp->flags & ~SC_MASK);
2292 if ((ppp->flags & SC_CCP_OPEN) &&
2293 (temp_i & SC_CCP_OPEN) == 0)
2294 ppp_ccp_closed (ppp);
2296 if ((ppp->flags | temp_i) & SC_DEBUG)
2298 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2299 ppp->flags = temp_i;
2303 * Set the compression mode
2305 case PPPIOCSCOMPRESS:
2306 error = ppp_set_compression (ppp,
2307 (struct ppp_option_data *) param3);
2310 * Retrieve the transmit async map
2312 case PPPIOCGASYNCMAP:
2313 error = verify_area (VERIFY_WRITE, (void *) param3,
2316 put_user (ppp->xmit_async_map[0], (int *) param3);
2317 if (ppp->flags & SC_DEBUG)
2319 "ppp_tty_ioctl: get asyncmap: addr "
2320 "%lx asyncmap %x\n",
2322 ppp->xmit_async_map[0]);
2326 * Set the transmit async map
2328 case PPPIOCSASYNCMAP:
2329 error = verify_area (VERIFY_READ, (void *) param3,
2332 ppp->xmit_async_map[0] = get_user ((int *) param3);
2333 if (ppp->flags & SC_DEBUG)
2335 "ppp_tty_ioctl: set xmit asyncmap %x\n",
2336 ppp->xmit_async_map[0]);
2340 * Set the receive async map
2342 case PPPIOCSRASYNCMAP:
2343 error = verify_area (VERIFY_READ, (void *) param3,
2346 ppp->recv_async_map = get_user ((int *) param3);
2347 if (ppp->flags & SC_DEBUG)
2349 "ppp_tty_ioctl: set rcv asyncmap %x\n",
2350 ppp->recv_async_map);
2354 * Obtain the unit number for this device.
2357 error = verify_area (VERIFY_WRITE, (void *) param3,
2360 put_user (ppp2dev (ppp)->base_addr, (int *) param3);
2361 if (ppp->flags & SC_DEBUG)
2363 "ppp_tty_ioctl: get unit: %ld",
2364 ppp2dev (ppp)->base_addr);
2368 * Set the debug level
2371 error = verify_area (VERIFY_READ, (void *) param3,
2374 temp_i = (get_user ((int *) param3) & 0x1F) << 16;
2375 temp_i |= (ppp->flags & ~0x1F0000);
2377 if ((ppp->flags | temp_i) & SC_DEBUG)
2379 "ppp_tty_ioctl: set flags to %x\n", temp_i);
2380 ppp->flags = temp_i;
2384 * Get the debug level
2387 error = verify_area (VERIFY_WRITE, (void *) param3,
2390 temp_i = (ppp->flags >> 16) & 0x1F;
2391 put_user (temp_i, (int *) param3);
2393 if (ppp->flags & SC_DEBUG)
2395 "ppp_tty_ioctl: get debug level %d\n",
2400 * Get the times since the last send/receive frame operation
2403 error = verify_area (VERIFY_WRITE, (void *) param3,
2404 sizeof (struct ppp_idle));
2406 struct ppp_idle cur_ddinfo;
2407 __u32 cur_jiffies = jiffies;
2409 /* change absolute times to relative times. */
2410 cur_ddinfo.xmit_idle = (cur_jiffies - ppp->ddinfo.xmit_idle) / HZ;
2411 cur_ddinfo.recv_idle = (cur_jiffies - ppp->ddinfo.recv_idle) / HZ;
2412 memcpy_tofs ((void *) param3, &cur_ddinfo,
2413 sizeof (cur_ddinfo));
2414 if (ppp->flags & SC_DEBUG)
2416 "ppp_tty_ioctl: read demand dial info\n");
2420 * Retrieve the extended async map
2422 case PPPIOCGXASYNCMAP:
2423 error = verify_area (VERIFY_WRITE,
2425 sizeof (ppp->xmit_async_map));
2427 memcpy_tofs ((void *) param3,
2428 ppp->xmit_async_map,
2429 sizeof (ppp->xmit_async_map));
2431 if (ppp->flags & SC_DEBUG)
2433 "ppp_tty_ioctl: get xasyncmap: addr %lx\n",
2438 * Set the async extended map
2440 case PPPIOCSXASYNCMAP:
2441 error = verify_area (VERIFY_READ, (void *) param3,
2442 sizeof (ppp->xmit_async_map));
2446 memcpy_fromfs (temp_tbl, (void *) param3,
2447 sizeof (ppp->xmit_async_map));
2448 temp_tbl[1] = 0x00000000;
2449 temp_tbl[2] &= ~0x40000000;
2450 temp_tbl[3] |= 0x60000000;
2452 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
2453 (temp_tbl[4] & temp_tbl[5]) != 0 ||
2454 (temp_tbl[6] & temp_tbl[7]) != 0)
2457 memcpy (ppp->xmit_async_map, temp_tbl,
2458 sizeof (ppp->xmit_async_map));
2460 if (ppp->flags & SC_DEBUG)
2462 "ppp_tty_ioctl: set xasyncmap\n");
2467 * Set the maximum VJ header compression slot number.
2470 error = verify_area (VERIFY_READ, (void *) param3,
2473 temp_i = get_user ((int *) param3) + 1;
2474 if (ppp->flags & SC_DEBUG)
2476 "ppp_tty_ioctl: set maxcid to %d\n",
2478 if (ppp->slcomp != NULL)
2479 slhc_free (ppp->slcomp);
2480 ppp->slcomp = slhc_init (16, temp_i);
2482 if (ppp->slcomp == NULL) {
2483 if (ppp->flags & SC_DEBUG)
2485 "ppp: no space for compression buffers!\n");
2492 case PPPIOCXFERUNIT:
2493 ppp_tty_close_local (tty, current->pid);
2498 error = verify_area (VERIFY_READ, (void *) param3,
2499 sizeof (struct npioctl));
2502 memcpy_fromfs (&npi,
2506 switch (npi.protocol) {
2508 npi.protocol = NP_IP;
2517 if (param2 == PPPIOCGNPMODE) {
2518 npi.mode = ppp->sc_npmode[npi.protocol];
2519 error = verify_area (VERIFY_WRITE,
2525 memcpy_tofs ((void *) param3,
2531 if (npi.mode != ppp->sc_npmode[npi.protocol]) {
2532 ppp->sc_npmode[npi.protocol] = npi.mode;
2533 if (npi.mode != NPMODE_QUEUE) {
2534 /* ppp_requeue(ppp); maybe needed */
2535 ppp_tty_wakeup (ppp2tty(ppp));
2541 * Allow users to read, but not set, the serial port parameters
2545 error = n_tty_ioctl (tty, file, param2, param3);
2549 error = verify_area (VERIFY_WRITE,
2553 int count = ppp->ubuf->tail - ppp->ubuf->head;
2555 count += (ppp->ubuf->size + 1);
2557 put_user (count, (int *) param3);
2561 * All other ioctl() events will come here.
2564 if (ppp->flags & SC_DEBUG)
2566 "ppp_tty_ioctl: invalid ioctl: %x, addr %lx\n",
2570 error = -ENOIOCTLCMD;
2579 * Process the select() statement for the PPP device.
2583 ppp_tty_select (struct tty_struct *tty, struct inode *inode,
2584 struct file *filp, int sel_type, select_table * wait)
2586 struct ppp *ppp = tty2ppp (tty);
2589 * Verify the status of the PPP device.
2594 if (ppp->magic != PPP_MAGIC)
2599 * Branch on the type of select mode. A read request must lock the user
2604 if (set_bit (0, &ppp->ubuf->locked) == 0) {
2605 /* Test for the presence of data in the queue */
2606 if (ppp->ubuf->head != ppp->ubuf->tail) {
2607 clear_bit (0, &ppp->ubuf->locked);
2610 clear_bit (0, &ppp->ubuf->locked);
2611 } /* fall through */
2613 * Exceptions or read errors.
2616 /* Is this a pty link and the remote disconnected? */
2617 if (tty->flags & (1 << TTY_OTHER_CLOSED))
2620 /* Is this a local link and the modem disconnected? */
2621 if (tty_hung_up_p (filp))
2624 select_wait (&ppp->read_wait, wait);
2628 * Write mode. A write is allowed if there is no current transmission.
2631 if (ppp->tbuf->locked != 0) {
2632 select_wait (&ppp->write_wait, wait);
2640 /*************************************************************
2642 * This routine accepts requests from the network layer
2643 * and attempts to deliver the packets.
2644 * It also includes various routines we are compelled to
2645 * have to make the network layer work (arp, etc...).
2646 *************************************************************/
2649 * Callback from the network layer when the device goes up.
2653 ppp_dev_open (struct device *dev)
2655 struct ppp *ppp = dev2ppp (dev);
2657 /* reset POINTOPOINT every time, since dev_close zaps it! */
2658 dev->flags |= IFF_POINTOPOINT;
2660 if (ppp2tty (ppp) == NULL) {
2661 if (ppp->flags & SC_DEBUG)
2663 "ppp: %s not connected to a TTY! can't go open!\n",
2668 if (ppp->flags & SC_DEBUG)
2670 "ppp: channel %s going up for IP packets!\n",
2678 * Callback from the network layer when the ppp device goes down.
2682 ppp_dev_close (struct device *dev)
2684 struct ppp *ppp = dev2ppp (dev);
2686 if (ppp2tty (ppp) == NULL) {
2687 if (ppp->flags & SC_DEBUG)
2689 "ppp: %s not connected to a TTY! can't go down!\n",
2694 * We don't do anything about the device going down. It is not important
2697 if (ppp->flags & SC_DEBUG)
2699 "ppp: channel %s going down for IP packets!\n",
2706 * IOCTL operation to read the version of the driver.
2710 ppp_dev_ioctl_version (struct ppp *ppp, struct ifreq *ifr)
2716 * Must have write access to the buffer.
2718 result = (char *) ifr->ifr_ifru.ifru_data;
2719 len = strlen (szVersion) + 1;
2720 error = verify_area (VERIFY_WRITE, result, len);
2722 * Move the version data
2725 memcpy_tofs (result, szVersion, len);
2731 * IOCTL to read the statistics for the pppstats program.
2735 ppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2737 struct ppp_stats *result, temp;
2740 * Must have write access to the buffer.
2742 result = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
2743 error = verify_area (VERIFY_WRITE,
2747 * Supply the information for the caller. First move the version data
2748 * then move the ppp stats; and finally the vj stats.
2750 memset (&temp, 0, sizeof(temp));
2751 if (error == 0 && dev->flags & IFF_UP) {
2752 memcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
2753 if (ppp->slcomp != NULL) {
2754 temp.vj.vjs_packets = ppp->slcomp->sls_o_compressed+
2755 ppp->slcomp->sls_o_uncompressed;
2756 temp.vj.vjs_compressed = ppp->slcomp->sls_o_compressed;
2757 temp.vj.vjs_searches = ppp->slcomp->sls_o_searches;
2758 temp.vj.vjs_misses = ppp->slcomp->sls_o_misses;
2759 temp.vj.vjs_errorin = ppp->slcomp->sls_i_error;
2760 temp.vj.vjs_tossed = ppp->slcomp->sls_i_tossed;
2761 temp.vj.vjs_uncompressedin = ppp->slcomp->sls_i_uncompressed;
2762 temp.vj.vjs_compressedin = ppp->slcomp->sls_i_compressed;
2767 memcpy_tofs (result, &temp, sizeof (temp));
2772 * IOCTL to read the compression statistics for the pppstats program.
2776 ppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
2778 struct ppp_comp_stats *result, temp;
2781 * Must have write access to the buffer.
2783 result = (struct ppp_comp_stats *) ifr->ifr_ifru.ifru_data;
2784 error = verify_area (VERIFY_WRITE,
2788 * Supply the information for the caller.
2790 memset (&temp, 0, sizeof(temp));
2791 if (error == 0 && dev->flags & IFF_UP) {
2792 if (ppp->sc_xc_state != NULL)
2793 (*ppp->sc_xcomp->comp_stat) (ppp->sc_xc_state,
2796 if (ppp->sc_rc_state != NULL)
2797 (*ppp->sc_rcomp->decomp_stat) (ppp->sc_rc_state,
2801 * Move the data to the caller's buffer
2804 memcpy_tofs (result, &temp, sizeof (temp));
2809 * Callback from the network layer to process the sockioctl functions.
2813 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
2815 struct ppp *ppp = dev2ppp (dev);
2818 * Process the requests
2822 error = ppp_dev_ioctl_stats (ppp, ifr, dev);
2825 case SIOCGPPPCSTATS:
2826 error = ppp_dev_ioctl_comp_stats (ppp, ifr, dev);
2830 error = ppp_dev_ioctl_version (ppp, ifr);
2841 * Send an IP frame to the remote with vj header compression.
2843 * Return 0 if frame was queued for transmission.
2844 * 1 if frame must be re-queued for later driver support.
2848 ppp_dev_xmit_ip (struct device *dev, struct ppp *ppp, __u8 *data)
2852 struct ppp_hdr *hdr;
2853 struct tty_struct *tty = ppp2tty (ppp);
2855 * Obtain the length from the IP header.
2857 len = ((struct iphdr *)data) -> tot_len;
2860 * Validate the tty interface
2863 if (ppp->flags & SC_DEBUG)
2865 "ppp_dev_xmit: %s not connected to a TTY!\n",
2870 * Ensure that the PPP device is still up
2872 if (!(dev->flags & IFF_UP)) {
2873 if (ppp->flags & SC_DEBUG)
2874 printk (KERN_WARNING
2875 "ppp_dev_xmit: packet sent on interface %s,"
2876 " which is down for IP\n",
2881 * Branch on the type of processing for the IP frame.
2883 switch (ppp->sc_npmode[NP_IP]) {
2888 if (ppp->flags & SC_DEBUG)
2889 printk (KERN_WARNING
2890 "ppp_dev_xmit: npmode = NPMODE_ERROR on %s\n",
2895 if (ppp->flags & SC_DEBUG)
2896 printk (KERN_WARNING
2897 "ppp_dev_xmit: npmode = NPMODE_DROP on %s\n",
2905 if (ppp->flags & SC_DEBUG)
2906 printk (KERN_WARNING
2907 "ppp_dev_xmit: unknown npmode %d on %s\n",
2908 ppp->sc_npmode[NP_IP],
2913 * Detect a change in the transfer size
2915 if (ppp->mtu != ppp2dev (ppp)->mtu) {
2916 ppp_changedmtu (ppp,
2921 * Acquire the lock on the transmission buffer. If the buffer was busy then
2922 * mark the device as busy.
2924 if (lock_buffer (ppp->wbuf) != 0) {
2929 * Print the frame being sent
2931 if (ppp->flags & SC_LOG_OUTPKT)
2932 ppp_print_buffer ("ppp outpkt", data, len);
2934 * At this point, the buffer will be transmitted. There is no other exit.
2936 * Try to compress the header.
2938 if (ppp->flags & SC_COMP_TCP) {
2939 len = slhc_compress (ppp->slcomp, data, len,
2940 buf_base (ppp->cbuf) + PPP_HARD_HDR_LEN,
2942 (ppp->flags & SC_NO_TCP_CCID) == 0);
2944 if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2945 proto = PPP_VJC_COMP;
2946 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2948 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2949 proto = PPP_VJC_UNCOMP;
2950 data[0] = (data[0] & 0x0f) | 0x40;
2956 len += PPP_HARD_HDR_LEN;
2957 hdr = &((struct ppp_hdr *) data)[-1];
2959 hdr->address = PPP_ALLSTATIONS;
2960 hdr->control = PPP_UI;
2961 hdr->protocol[0] = 0;
2962 hdr->protocol[1] = proto;
2964 return ppp_dev_xmit_frame (ppp, ppp->wbuf, (__u8 *) hdr, len);
2968 * Send an IPX (or any other non-IP) frame to the remote.
2970 * Return 0 if frame was queued for transmission.
2971 * 1 if frame must be re-queued for later driver support.
2974 ppp_dev_xmit_ipx (struct device *dev, struct ppp *ppp,
2975 __u8 *data, int len, int proto)
2977 struct tty_struct *tty = ppp2tty (ppp);
2978 struct ppp_hdr *hdr;
2980 * Validate the tty interface
2983 if (ppp->flags & SC_DEBUG)
2985 "ppp_dev_xmit: %s not connected to a TTY!\n",
2990 * Ensure that the PPP device is still up
2992 if (!(dev->flags & IFF_UP)) {
2993 if (ppp->flags & SC_DEBUG)
2994 printk (KERN_WARNING
2995 "ppp_dev_xmit: packet sent on interface %s,"
3001 * Detect a change in the transfer size
3003 if (ppp->mtu != ppp2dev (ppp)->mtu) {
3004 ppp_changedmtu (ppp,
3009 * Acquire the lock on the transmission buffer. If the buffer was busy then
3010 * mark the device as busy.
3012 if (lock_buffer (ppp->wbuf) != 0) {
3017 * Print the frame being sent
3019 if (ppp->flags & SC_LOG_OUTPKT)
3020 ppp_print_buffer ("ppp outpkt", data, len);
3024 len += PPP_HARD_HDR_LEN;
3025 hdr = &((struct ppp_hdr *) data)[-1];
3027 hdr->address = PPP_ALLSTATIONS;
3028 hdr->control = PPP_UI;
3029 hdr->protocol[0] = proto >> 8;
3030 hdr->protocol[1] = proto;
3032 return ppp_dev_xmit_frame (ppp, ppp->wbuf, (__u8 *) hdr, len);
3036 * Send a frame to the remote.
3040 ppp_dev_xmit (sk_buff *skb, struct device *dev)
3044 struct ppp *ppp = dev2ppp (dev);
3045 struct tty_struct *tty = ppp2tty (ppp);
3047 * just a little sanity check.
3050 if (ppp->flags & SC_DEBUG)
3051 printk (KERN_WARNING "ppp_dev_xmit: null packet!\n");
3055 * Avoid timing problem should tty hangup while data is queued to be sent
3058 dev_kfree_skb (skb, FREE_WRITE);
3063 * Validate the tty linkage
3065 if (ppp->flags & SC_DEBUG)
3066 printk (KERN_DEBUG "ppp_dev_xmit [%s]: skb %p\n",
3069 * Validate the tty interface
3072 if (ppp->flags & SC_DEBUG)
3074 "ppp_dev_xmit: %s not connected to a TTY!\n",
3076 dev_kfree_skb (skb, FREE_WRITE);
3080 * Fetch the pointer to the data
3083 data = skb_data(skb);
3085 * Look at the protocol in the skb to determine the difference between
3086 * an IP frame and an IPX frame.
3088 switch (ntohs (skb->protocol)) {
3090 answer = ppp_dev_xmit_ipx (dev, ppp, data, len, PPP_IPX);
3094 answer = ppp_dev_xmit_ip (dev, ppp, data);
3097 default: /* All others have no support at this time. */
3098 dev_kfree_skb (skb, FREE_WRITE);
3102 * This is the end of the transmission. Release the buffer if it was sent.
3105 dev_kfree_skb (skb, FREE_WRITE);
3106 ppp->ddinfo.xmit_idle = jiffies;
3112 * Generate the statistic information for the /proc/net/dev listing.
3115 static struct enet_statistics *
3116 ppp_dev_stats (struct device *dev)
3118 struct ppp *ppp = dev2ppp (dev);
3119 static struct enet_statistics ppp_stats;
3121 ppp_stats.rx_packets = ppp->stats.ppp_ipackets;
3122 ppp_stats.rx_errors = ppp->stats.ppp_ierrors;
3123 ppp_stats.rx_dropped = ppp->stats.ppp_ierrors;
3124 ppp_stats.rx_fifo_errors = 0;
3125 ppp_stats.rx_length_errors = 0;
3126 ppp_stats.rx_over_errors = 0;
3127 ppp_stats.rx_crc_errors = 0;
3128 ppp_stats.rx_frame_errors = 0;
3129 ppp_stats.tx_packets = ppp->stats.ppp_opackets;
3130 ppp_stats.tx_errors = ppp->stats.ppp_oerrors;
3131 ppp_stats.tx_dropped = 0;
3132 ppp_stats.tx_fifo_errors = 0;
3133 ppp_stats.collisions = 0;
3134 ppp_stats.tx_carrier_errors = 0;
3135 ppp_stats.tx_aborted_errors = 0;
3136 ppp_stats.tx_window_errors = 0;
3137 ppp_stats.tx_heartbeat_errors = 0;
3139 if (ppp->flags & SC_DEBUG)
3140 printk (KERN_INFO "ppp_dev_stats called");
3144 static int ppp_dev_header (sk_buff *skb, struct device *dev,
3145 __u16 type, void *daddr,
3146 void *saddr, unsigned int len)
3152 ppp_dev_rebuild (void *eth, struct device *dev,
3153 unsigned long raddr, struct sk_buff *skb)
3158 /*************************************************************
3160 * Miscellany called by various functions above.
3161 *************************************************************/
3163 /* Locate the previous instance of the PPP channel */
3165 ppp_find (int pid_value)
3171 /* try to find the exact same free device which we had before */
3176 ppp = ctl2ppp (ctl);
3177 if (!set_bit(0, &ppp->inuse)) {
3178 if (ppp->sc_xfer == pid_value) {
3182 clear_bit (0, &ppp->inuse);
3185 if (++if_num == max_dev)
3191 /* allocate or create a PPP channel */
3201 /* try to find an free device */
3206 ppp = ctl2ppp (ctl);
3207 if (!set_bit(0, &ppp->inuse))
3210 if (++if_num == max_dev)
3214 * There are no available items. Allocate a device from the system pool
3216 ctl = (ppp_ctrl_t *) kmalloc (sizeof(ppp_ctrl_t), GFP_KERNEL);
3218 (void) memset(ctl, 0, sizeof(ppp_ctrl_t));
3219 ppp = ctl2ppp (ctl);
3220 dev = ctl2dev (ctl);
3222 /* initialize channel control data */
3223 set_bit(0, &ppp->inuse);
3230 dev->init = ppp_init_dev;
3231 dev->name = ctl->name;
3232 dev->base_addr = (__u32) if_num;
3233 dev->priv = (void *) ppp;
3235 sprintf (dev->name, "ppp%d", if_num);
3237 /* link in the new channel */
3238 ctl->next = ppp_list;
3241 /* register device so that we can be ifconfig'd */
3242 /* ppp_init_dev() will be called as a side-effect */
3244 status = register_netdev (dev);
3246 printk (KERN_INFO "registered device %s\n", dev->name);
3251 "ppp_alloc - register_netdev(%s) = %d failure.\n",
3253 /* This one will forever be busy as it is not initialized */
3259 * Utility procedures to print a buffer in hex/ascii
3263 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
3265 register __u8 next_ch;
3266 static char hex[] = "0123456789ABCDEF";
3268 while (count-- > 0) {
3270 *out++ = hex[(next_ch >> 4) & 0x0F];
3271 *out++ = hex[next_ch & 0x0F];
3277 ppp_print_char (register __u8 * out, const __u8 * in, int count)
3279 register __u8 next_ch;
3281 while (count-- > 0) {
3284 if (next_ch < 0x20 || next_ch > 0x7e)
3288 if (next_ch == '%') /* printk/syslogd has a bug !! */
3296 ppp_print_buffer (const __u8 * name, const __u8 * buf, int count)
3300 if (name != (__u8 *) NULL)
3301 printk (KERN_DEBUG "ppp: %s, count = %d\n", name, count);
3304 memset (line, 32, 44);
3305 ppp_print_hex (line, buf, 8);
3306 ppp_print_char (&line[8 * 3], buf, 8);
3307 printk (KERN_DEBUG "%s\n", line);
3313 memset (line, 32, 44);
3314 ppp_print_hex (line, buf, count);
3315 ppp_print_char (&line[8 * 3], buf, count);
3316 printk (KERN_DEBUG "%s\n", line);
3320 /*************************************************************
3321 * Compressor module interface
3322 *************************************************************/
3324 struct compressor_link {
3325 struct compressor_link *next;
3326 struct compressor *comp;
3329 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
3331 static struct compressor *find_compressor (int type)
3333 struct compressor_link *lnk;
3339 lnk = ppp_compressors;
3340 while (lnk != (struct compressor_link *) 0) {
3341 if ((int) (__u8) lnk->comp->compress_proto == type) {
3342 restore_flags(flags);
3348 restore_flags(flags);
3349 return (struct compressor *) 0;
3352 static int ppp_register_compressor (struct compressor *cp)
3354 struct compressor_link *new;
3357 new = (struct compressor_link *) kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
3359 if (new == (struct compressor_link *) 0)
3365 if (find_compressor (cp->compress_proto)) {
3366 restore_flags(flags);
3371 new->next = ppp_compressors;
3373 ppp_compressors = new;
3375 restore_flags(flags);
3379 static void ppp_unregister_compressor (struct compressor *cp)
3381 struct compressor_link *prev = (struct compressor_link *) 0;
3382 struct compressor_link *lnk;
3388 lnk = ppp_compressors;
3389 while (lnk != (struct compressor_link *) 0) {
3390 if (lnk->comp == cp) {
3392 prev->next = lnk->next;
3394 ppp_compressors = lnk->next;
3401 restore_flags(flags);
3404 /*************************************************************
3405 * Module support routines
3406 *************************************************************/
3414 /* register our line disciplines */
3415 status = ppp_first_time();
3418 "PPP: ppp_init() failure %d\n", status);
3420 (void) register_symtab (&ppp_syms);
3425 cleanup_module(void)
3428 ppp_ctrl_t *ctl, *next_ctl;
3433 * Ensure that the devices are not in operation.
3437 ppp = ctl2ppp (ctl);
3438 if (ppp->inuse && ppp->tty != NULL) {
3443 dev = ctl2dev (ctl);
3444 if (dev->start || dev->flags & IFF_UP) {
3451 * Ensure that there are no compressor modules registered
3453 if (ppp_compressors != NULL)
3458 "PPP: device busy, remove delayed\n");
3462 * Release the tty registration of the line discipline so that no new entries
3465 status = tty_register_ldisc (N_PPP, NULL);
3468 "PPP: Unable to unregister ppp line discipline "
3469 "(err = %d)\n", status);
3472 "PPP: ppp line discipline successfully unregistered\n");
3474 * De-register the devices so that there is no problem with them
3476 next_ctl = ppp_list;
3479 next_ctl = ctl->next;
3480 ppp = ctl2ppp (ctl);
3481 dev = ctl2dev (ctl);
3484 unregister_netdev (dev);