4 $Id: ppp.c,v 1.1 1994/05/27 00:55:25 paulus Exp $
12 RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
13 Multi-protocol Datagrams over Point-to-Point Links
19 Flags for this module (any combination is acceptable for testing.):
21 NET02D - Define if using Net-2-Debugged in kernels earler
24 NEW_TTY_DRIVERS - Define if using new Ted Ts'o's alpha TTY drivers
25 from tsx-11.mit.edu. From Ted Ts'o.
27 OPTIMIZE_FLAG_TIME - Number of jiffies to force sending of leading flag
28 character. This is normally set to ((HZ * 3) / 2).
29 This is 1.5 seconds. If not defined then the leading
33 /* #define NET02D /* */
34 /* #define NEW_TTY_DRIVERS /* */
35 #define OPTIMIZE_FLAG_TIME ((HZ * 3)/2) /* */
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/types.h>
40 #include <linux/fcntl.h>
41 #include <linux/interrupt.h>
42 #include <linux/ptrace.h>
43 #include <linux/ioport.h>
45 #include <linux/malloc.h>
46 #include <linux/tty.h>
47 #include <linux/errno.h>
48 #include <linux/sched.h> /* to get the struct task_struct */
49 #include <linux/string.h> /* used in new tty drivers */
50 #include <linux/signal.h> /* used in new tty drivers */
51 #include <asm/system.h>
52 #include <asm/bitops.h>
53 #include <asm/segment.h>
55 #ifdef NET02D /* v1.1.4 net code and earlier */
58 #define skb_queue_head_init(buf) *(buf) = NULL
59 #else /* v1.1.5 and later */
60 #include <linux/netdevice.h>
61 #include <linux/skbuff.h>
64 #include <linux/ppp.h>
71 #include <linux/if_arp.h>
76 #define PRINTK(p) printk p ;
77 #define ASSERT(p) if (!p) PRINTK ((KERN_CRIT "assertion failed: " # p))
78 #define PRINTKN(n,p) {if (ppp_debug >= n) PRINTK (p)}
79 #define CHECK_PPP(a) if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return a;}
80 #define CHECK_PPP_VOID() if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return;}
82 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
83 #define in_rmap(ppp,c) ((((unsigned int) (unsigned char) (c)) < 0x20) && \
84 ppp->recv_async_map & (1 << (c)))
86 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
89 int ppp_debug_netpackets = 0;
91 /* Define this string only once for all macro envocations */
92 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
94 int ppp_init(struct device *);
95 static void ppp_init_ctrl_blk(struct ppp *);
96 static int ppp_dev_open(struct device *);
97 static int ppp_dev_close(struct device *);
98 static void ppp_kick_tty(struct ppp *);
100 #ifdef NEW_TTY_DRIVERS
101 #define ppp_find(tty) ((struct ppp *) tty->disc_data)
103 static void ppp_output_done(void *);
104 static void ppp_unesc(struct ppp *ppp, unsigned char *c, int n);
105 static struct ppp *ppp_find(struct tty_struct *);
108 static void ppp_doframe(struct ppp *);
109 static int ppp_do_ip(struct ppp *, unsigned short, unsigned char *, int);
110 static int ppp_us_queue(struct ppp *, unsigned short, unsigned char *, int);
111 static int ppp_xmit(struct sk_buff *, struct device *);
112 static unsigned short ppp_type_trans(struct sk_buff *, struct device *);
115 static int ppp_header(unsigned char *buff, struct device *dev,
116 unsigned short type, unsigned long daddr,
117 unsigned long saddr, unsigned len);
118 static int ppp_rebuild_header(void *buff, struct device *dev);
119 static void ppp_add_arp(unsigned long addr, struct sk_buff *skb,
122 static int ppp_header(unsigned char *, struct device *, unsigned short,
123 void *, void *, unsigned, struct sk_buff *);
124 static int ppp_rebuild_header(void *, struct device *, unsigned long,
128 static struct enet_statistics *ppp_get_stats (struct device *);
129 static struct ppp *ppp_alloc(void);
130 static int ppp_lock(struct ppp *);
131 static void ppp_unlock(struct ppp *);
132 static void ppp_add_fcs(struct ppp *);
133 static int ppp_check_fcs(struct ppp *);
134 static void ppp_print_buffer(const char *,char *,int,int);
136 static int ppp_read(struct tty_struct *, struct file *, unsigned char *,
138 static int ppp_write(struct tty_struct *, struct file *, unsigned char *,
140 static int ppp_ioctl(struct tty_struct *, struct file *, unsigned int,
142 static int ppp_select(struct tty_struct *tty, struct inode * inode,
143 struct file * filp, int sel_type, select_table * wait);
144 static int ppp_open(struct tty_struct *);
145 static void ppp_close(struct tty_struct *);
147 #ifdef NEW_TTY_DRIVERS
148 static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
149 char *fp, int count);
150 static void ppp_write_wakeup(struct tty_struct *tty);
152 static void ppp_tty_input_ready(struct tty_struct *);
155 /* FCS table from RFC1331 */
157 static unsigned short fcstab[256] = {
158 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
159 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
160 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
161 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
162 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
163 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
164 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
165 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
166 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
167 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
168 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
169 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
170 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
171 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
172 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
173 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
174 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
175 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
176 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
177 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
178 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
179 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
180 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
181 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
182 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
183 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
184 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
185 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
186 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
187 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
188 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
189 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
192 struct tty_ldisc ppp_ldisc;
194 static struct ppp ppp_ctrl[PPP_NRUNIT];
196 /*************************************************************
198 *************************************************************/
200 static int first_time = 1;
202 /* called at boot time for each ppp device */
205 ppp_init(struct device *dev)
210 ppp = &ppp_ctrl[dev->base_addr];
215 printk (KERN_INFO "PPP: version %s (%d channels)"
219 #ifdef NEW_TTY_DRIVERS
222 #ifdef OPTIMIZE_FLAG_TIME
225 "\n", PPP_VERSION, PPP_NRUNIT);
228 "TCP compression code copyright 1989 Regents of the "
229 "University of California\n");
231 (void) memset(&ppp_ldisc, 0, sizeof(ppp_ldisc));
232 ppp_ldisc.open = ppp_open;
233 ppp_ldisc.close = ppp_close;
234 ppp_ldisc.read = ppp_read;
235 ppp_ldisc.write = ppp_write;
236 ppp_ldisc.ioctl = ppp_ioctl;
237 ppp_ldisc.select = ppp_select;
239 #ifdef NEW_TTY_DRIVERS
240 ppp_ldisc.magic = TTY_LDISC_MAGIC;
241 ppp_ldisc.receive_buf = ppp_receive_buf;
242 ppp_ldisc.write_wakeup = ppp_write_wakeup;
244 ppp_ldisc.handler = ppp_tty_input_ready;
247 if ((i = tty_register_ldisc(N_PPP, &ppp_ldisc)) == 0)
248 printk(KERN_INFO "PPP line discipline registered.\n");
250 printk(KERN_ERR "error registering line discipline: %d\n", i);
253 /* initialize PPP control block */
254 ppp_init_ctrl_blk (ppp);
256 ppp->line = dev->base_addr;
260 /* clear statistics */
261 memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
265 dev->hard_start_xmit = ppp_xmit;
266 dev->open = ppp_dev_open;
267 dev->stop = ppp_dev_close;
268 dev->get_stats = ppp_get_stats;
269 dev->hard_header = ppp_header;
270 dev->type_trans = ppp_type_trans;
271 dev->rebuild_header = ppp_rebuild_header;
272 dev->hard_header_len = 0;
274 dev->type = ARPHRD_PPP;
277 dev->add_arp = ppp_add_arp;
278 dev->queue_xmit = dev_queue_xmit;
281 for (i = 0; i < DEV_NUMBUFFS; i++)
282 skb_queue_head_init(&dev->buffs[i]); /* = NULL if NET02D */
284 /* New-style flags */
285 dev->flags = IFF_POINTOPOINT;
286 dev->family = AF_INET;
290 dev->pa_alen = sizeof(unsigned long);
296 ppp_init_ctrl_blk(struct ppp *ppp)
298 ppp->magic = PPP_MAGIC;
308 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
309 ppp->xmit_async_map[0] = 0xffffffff;
310 ppp->xmit_async_map[3] = 0x60000000;
311 ppp->recv_async_map = 0x00000000;
324 ppp->us_rbuff = NULL;
325 ppp->us_rbuff_end = NULL;
326 ppp->us_rbuff_head = NULL;
327 ppp->us_rbuff_tail = NULL;
328 ppp->read_wait = NULL;
329 ppp->write_wait = NULL;
330 ppp->us_rbuff_lock = 0;
332 ppp->inp_sig_pid = 0;
334 #ifdef OPTIMIZE_FLAG_TIME /* ensure flag will always be sent first time */
335 ppp->last_xmit = jiffies - OPTIMIZE_FLAG_TIME;
340 /* clear statistics */
341 memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
343 /* Reset the demand dial information */
344 ppp->ddinfo.ip_sjiffies =
345 ppp->ddinfo.ip_rjiffies =
346 ppp->ddinfo.nip_sjiffies =
347 ppp->ddinfo.nip_rjiffies = jiffies;
351 * MTU has been changed by the IP layer. Unfortunately we are not told
352 * about this, but we spot it ourselves and fix things up. We could be
353 * in an upcall from the tty driver, or in an ip packet queue.
357 ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
360 unsigned char *new_rbuff, *new_xbuff, *new_cbuff;
361 unsigned char *old_rbuff, *old_xbuff, *old_cbuff;
364 * Allocate the buffer from the kernel for the data
370 /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
374 mtu = (mtu * 2) + 20;
375 mru = (mru * 2) + 20;
377 PRINTKN (2,(KERN_INFO "ppp: channel %s mtu = %d, mru = %d\n",
378 dev->name, new_mtu, new_mru));
380 new_xbuff = (unsigned char *) kmalloc(mtu + 4, GFP_KERNEL);
381 new_rbuff = (unsigned char *) kmalloc(mru + 4, GFP_KERNEL);
382 new_cbuff = (unsigned char *) kmalloc(mru + 4, GFP_KERNEL);
384 * If the buffers failed to allocate then complain.
386 if (new_xbuff == NULL || new_rbuff == NULL || new_cbuff == NULL)
388 PRINTKN (2,(KERN_ERR "ppp: failed to allocate new buffers\n"));
390 * Release new buffer pointers if the updates were not performed
392 if (new_rbuff != NULL)
395 if (new_xbuff != NULL)
398 if (new_cbuff != NULL)
402 * Update the pointers to the new buffer structures.
407 old_xbuff = ppp->xbuff;
408 old_rbuff = ppp->rbuff;
409 old_cbuff = ppp->cbuff;
411 ppp->xbuff = new_xbuff;
412 ppp->rbuff = new_rbuff;
413 ppp->cbuff = new_cbuff;
415 dev->mem_start = (unsigned long) new_xbuff;
416 dev->mem_end = (unsigned long) (dev->mem_start + mtu);
418 dev->rmem_start = (unsigned long) new_rbuff;
419 ppp->rend = (unsigned char *)
420 dev->rmem_end = (unsigned long) (dev->rmem_start + mru);
422 ppp->rhead = new_rbuff;
424 * Update the parameters for the new buffer sizes
438 * Release old buffer pointers
440 if (old_rbuff != NULL)
443 if (old_xbuff != NULL)
446 if (old_cbuff != NULL)
451 /* called when we abandon the PPP line discipline */
454 ppp_release(struct ppp *ppp)
456 #ifdef NEW_TTY_DRIVERS
457 if (ppp->tty != NULL && ppp->tty->disc_data == ppp)
458 ppp->tty->disc_data = NULL; /* Break the tty->ppp link */
462 ppp->dev->flags &= ~IFF_UP; /* down the device */
463 ppp->dev->flags |= IFF_POINTOPOINT;
469 kfree (ppp->us_rbuff);
474 ppp->us_rbuff = NULL;
477 slhc_free(ppp->slcomp);
486 ppp_close(struct tty_struct *tty)
488 struct ppp *ppp = ppp_find(tty);
490 if (ppp == NULL || ppp->magic != PPP_MAGIC) {
491 PRINTKN (1,(KERN_WARNING "ppp: trying to close unopened tty!\n"));
496 PRINTKN (2,(KERN_INFO "ppp: channel %s closing.\n", ppp->dev->name));
500 /* called when PPP line discipline is selected on a tty */
502 ppp_open(struct tty_struct *tty)
504 struct ppp *ppp = ppp_find(tty);
507 PRINTKN (1,(KERN_ERR "ppp_open: gack! tty already associated to %s!\n",
508 ppp->magic == PPP_MAGIC ? ppp->dev->name : "unknown"));
514 PRINTKN (1,(KERN_ERR "ppp_open: couldn't allocate ppp channel\n"));
518 /* make sure the channel is actually open */
519 ppp_init_ctrl_blk (ppp);
523 #ifdef NEW_TTY_DRIVERS
524 tty->disc_data = ppp;
525 if (tty->driver.flush_buffer)
526 tty->driver.flush_buffer(tty);
527 if (tty->ldisc.flush_buffer)
528 tty->ldisc.flush_buffer(tty);
530 tty_read_flush (tty);
531 tty_write_flush (tty);
534 if ((ppp->slcomp = slhc_init(16, 16)) == NULL) {
535 PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
540 /* Define the buffers for operation */
541 ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
542 if (ppp->rbuff == NULL) {
547 /* Allocate a user-level receive buffer */
548 ppp->us_rbuff = kmalloc (RBUFSIZE, GFP_KERNEL);
549 if (ppp->us_rbuff == NULL) {
550 PRINTKN (1,(KERN_ERR "ppp: no space for user receive buffer\n"));
556 ppp->us_rbuff_tail = ppp->us_rbuff;
557 ppp->us_rbuff_end = ppp->us_rbuff + RBUFSIZE;
559 PRINTKN (2,(KERN_INFO "ppp: channel %s open\n", ppp->dev->name));
561 #ifdef NEW_TTY_DRIVERS
568 /* called when ppp interface goes "up". here this just means we start
569 passing IP packets */
571 ppp_dev_open(struct device *dev)
573 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
575 /* reset POINTOPOINT every time, since dev_close zaps it! */
576 dev->flags |= IFF_POINTOPOINT;
578 if (ppp->tty == NULL) {
579 PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go open!\n",
584 PRINTKN (2,(KERN_INFO "ppp: channel %s going up for IP packets!\n",
592 ppp_dev_close(struct device *dev)
594 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
596 if (ppp->tty == NULL) {
597 PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go down!\n",
602 PRINTKN (2,(KERN_INFO "ppp: channel %s going down for IP packets!\n",
608 /*************************************************************
610 * The following function delivers a fully-formed PPP
611 * frame in ppp->xbuff to the TTY for output.
612 *************************************************************/
614 #ifdef NEW_TTY_DRIVERS
619 ppp_output_done (void *ppp)
621 /* unlock the transmitter queue */
622 ppp_unlock ((struct ppp *) ppp);
624 /* If the device is still up then enable the transmitter of the
626 if (((struct ppp *) ppp)->dev->flags & IFF_UP)
627 dev_tint (((struct ppp *) ppp)->dev);
629 /* enable any blocked process pending transmission */
630 wake_up_interruptible (&((struct ppp *) ppp)->write_wait);
633 #ifndef NEW_TTY_DRIVERS
635 ppp_kick_tty (struct ppp *ppp)
637 register int count = ppp->xhead - ppp->xbuff;
640 ppp->stats.sbytes += count;
642 answer = tty_write_data (ppp->tty,
649 ppp_output_done (ppp); /* Should not happen */
652 ppp->stats.serrors++;
653 ppp_output_done (ppp); /* unlock the transmitter */
660 ppp_kick_tty (struct ppp *ppp)
662 register int count, actual;
664 count = ppp->xhead - ppp->xbuff;
666 actual = ppp->tty->driver.write(ppp->tty, 0, ppp->xbuff, count);
667 ppp->stats.sbytes += actual;
668 if (actual == count) {
669 ppp_output_done(ppp);
671 ppp->xtail = ppp->xbuff + actual;
672 ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
676 static void ppp_write_wakeup(struct tty_struct *tty)
678 register int count, actual;
679 struct ppp *ppp = ppp_find(tty);
681 if (!ppp || ppp->magic != PPP_MAGIC) {
683 (KERN_ERR "PPP: write_wakeup called but couldn't "
684 "find PPP struct.\n"));
688 if (!ppp->xtail || (ppp->flags & SC_XMIT_BUSY))
692 if (ppp->flags & SC_XMIT_BUSY)
694 ppp->flags |= SC_XMIT_BUSY;
697 count = ppp->xhead - ppp->xtail;
699 actual = tty->driver.write(tty, 0, ppp->xtail, count);
700 ppp->stats.sbytes += actual;
701 if (actual == count) {
703 tty->flags &= ~TTY_DO_WRITE_WAKEUP;
705 ppp_output_done(ppp);
707 ppp->xtail += actual;
709 ppp->flags &= ~SC_XMIT_BUSY;
713 /*************************************************************
715 * The following functions handle input that arrives from
716 * the TTY. It recognizes PPP frames and either hands them
717 * to the network layer or queues them for delivery to a
718 * user process reading this TTY.
719 *************************************************************/
721 /* stuff a single character into the receive buffer */
724 ppp_enqueue(struct ppp *ppp, unsigned char c)
730 if (ppp->rhead < ppp->rend) {
735 ppp->stats.roverrun++;
736 restore_flags(flags);
739 #ifdef CHECK_CHARACTERS
740 static unsigned paritytab[8] = {
741 0x96696996, 0x69969669, 0x69969669, 0x96696996,
742 0x69969669, 0x96696996, 0x96696996, 0x69969669
746 #ifndef NEW_TTY_DRIVERS
748 ppp_dump_inqueue(struct tty_struct *tty)
750 int head = tty->read_q.head,
751 tail = tty->read_q.tail,
755 PRINTK ((KERN_DEBUG "INQUEUE: head %d tail %d imode %x:\n", head, tail,
756 (unsigned int) tty->termios->c_iflag))
762 buffer [count] = tty->read_q.buf[i];
764 ppp_print_buffer (NULL, buffer, 8, KERNEL_DS);
767 i = (i + 1) & (TTY_BUF_SIZE - 1);
769 ppp_print_buffer (NULL, buffer, count, KERNEL_DS);
772 /* called by lower levels of TTY driver when data becomes available.
773 all incoming data comes through this function. */
775 void ppp_tty_input_ready(struct tty_struct *tty)
777 struct ppp *ppp = ppp_find(tty);
779 unsigned char buff[128];
781 /* PRINTK( (KERN_DEBUG "PPP: handler called.\n") ) */
782 if (!ppp || ppp->magic != PPP_MAGIC) {
784 (KERN_ERR "PPP: handler called but couldn't find PPP struct.\n"));
792 ppp_dump_inqueue(ppp->tty);
795 n = tty_read_raw_data(tty, buff, 128);
796 if ( n == 0 ) /* nothing there */
800 ppp_print_buffer ("receive buffer", buff, n > 0 ? n : -n, KERNEL_DS);
803 /* Last character is error flag.
804 Process the previous characters, then set toss flag. */
808 ppp->stats.rbytes += n;
809 ppp_unesc(ppp,buff,n);
815 /* recover frame by undoing PPP escape mechanism;
816 copies N chars of input data from C into PPP->rbuff
817 calls ppp_doframe to dispose of any frames it finds
821 ppp_unesc(struct ppp *ppp, unsigned char *c, int n)
825 for (i = 0; i < n; i++, c++) {
826 PRINTKN (6,(KERN_DEBUG "(%x)", (unsigned int) *c));
828 #ifdef CHECK_CHARACTERS
830 sc->sc_flags |= SC_RCV_B7_1;
832 sc->sc_flags |= SC_RCV_B7_0;
834 if (paritytab[*c >> 5] & (1 << (*c & 0x1F)))
835 sc->sc_flags |= SC_RCV_ODDP;
837 sc->sc_flags |= SC_RCV_EVNP;
841 case PPP_ESC: /* PPP_ESC: invert 0x20 in next character */
842 ppp->escape = PPP_TRANS;
845 case PPP_FLAG: /* PPP_FLAG: end of frame */
846 if (ppp->escape) /* PPP_ESC just before PPP_FLAG is illegal */
849 if ((ppp->toss & 0x80) == 0)
850 ppp_doframe(ppp); /* pass frame on to next layers */
853 ppp->rhead = ppp->rbuff;
858 default: /* regular character */
859 if (!in_rmap (ppp, *c)) {
861 ppp_enqueue (ppp, *c ^ ppp->escape);
870 static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
873 register struct ppp *ppp = ppp_find (tty);
876 /* PRINTK( ("PPP: handler called.\n") ); */
878 if (!ppp || ppp->magic != PPP_MAGIC) {
879 PRINTKN (1,("PPP: handler called but couldn't find "
886 if (ppp_debug >= 5) {
887 ppp_print_buffer ("receive buffer", cp, count, KERNEL_DS);
890 while (count-- > 0) {
894 if (*fp && ppp->toss == 0)
899 #ifdef CHECK_CHARACTERS
901 sc->sc_flags |= SC_RCV_B7_1;
903 sc->sc_flags |= SC_RCV_B7_0;
905 if (paritytab[c >> 5] & (1 << (c & 0x1F)))
906 sc->sc_flags |= SC_RCV_ODDP;
908 sc->sc_flags |= SC_RCV_EVNP;
912 case PPP_ESC: /* PPP_ESC: invert 0x20 in next character */
913 ppp->escape = PPP_TRANS;
916 case PPP_FLAG: /* PPP_FLAG: end of frame */
917 if (ppp->escape) /* PPP_ESC just before PPP_FLAG is "cancel"*/
920 if ((ppp->toss & 0x80) == 0)
921 ppp_doframe(ppp); /* pass frame on to next layers */
924 ppp->rhead = ppp->rbuff;
929 default: /* regular character */
930 if (!in_rmap (ppp, c)) {
932 ppp_enqueue (ppp, c ^ ppp->escape);
940 /* on entry, a received frame is in ppp->rbuff
941 check it and dispose as appropriate */
943 ppp_doframe(struct ppp *ppp)
945 u_char *c = ppp->rbuff;
947 int count = ppp->rcount;
949 /* forget it if we've already noticed an error */
951 PRINTKN (1, (KERN_WARNING "ppp_toss: tossing frame, reason = %d\n",
953 ppp->stats.rerrors++;
957 /* do this before printing buffer to avoid generating copious output */
962 ppp_print_buffer ("receive frame", c, count, KERNEL_DS);
965 PRINTKN (1,(KERN_WARNING "ppp: got runt ppp frame, %d chars\n", count));
970 /* check PPP error detection field */
971 if (!ppp_check_fcs(ppp)) {
972 PRINTKN (1,(KERN_WARNING "ppp: frame with bad fcs\n"));
973 ppp->stats.rerrors++;
977 count -= 2; /* ignore last two characters */
979 /* now we have a good frame */
980 /* figure out the protocol field */
981 if ((c[0] == PPP_ADDRESS) && (c[1] == PPP_CONTROL)) {
982 c = c + 2; /* ADDR/CTRL not compressed, so skip */
986 proto = (u_short) *c++; /* PROTO compressed */
990 proto = (proto << 8) | (u_short) *c++; /* PROTO uncompressed */
994 /* Send the frame to the network if the ppp device is up */
995 if ((ppp->dev->flags & IFF_UP) && ppp_do_ip(ppp, proto, c, count)) {
996 ppp->ddinfo.ip_rjiffies = jiffies;
1000 /* If we got here, it has to go to a user process doing a read,
1003 User process expects to get whole frame (for some reason), so
1004 use count+2 so as to include FCS field. */
1006 if (ppp_us_queue (ppp, proto, c, count+2)) {
1007 ppp->ddinfo.nip_rjiffies = jiffies;
1008 ppp->stats.rothers++;
1012 /* couldn't cope. */
1013 PRINTKN (1,(KERN_WARNING
1014 "ppp: dropping packet on the floor: nobody could take it.\n"));
1015 ppp->stats.tossed++;
1018 /* Examine packet at C, attempt to pass up to net layer.
1019 PROTO is the protocol field from the PPP frame.
1020 Return 1 if could handle it, 0 otherwise. */
1023 ppp_do_ip (struct ppp *ppp, unsigned short proto, unsigned char *c,
1028 PRINTKN (4,(KERN_DEBUG "ppp_do_ip: proto %x len %d first byte %x\n",
1029 (int) proto, count, c[0]));
1031 if (ppp_debug_netpackets) {
1032 PRINTK (("KERN_DEBUG %s <-- proto %x len %d\n", ppp->dev->name,
1033 (int) proto, count));
1036 if (proto == PROTO_IP) {
1037 ppp->stats.runcomp++;
1041 if ((proto == PROTO_VJCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
1042 /* get space for uncompressing the header */
1046 if ((ppp->rhead + 80) < ppp->rend) {
1051 restore_flags(flags);
1054 PRINTKN (1,(KERN_NOTICE
1055 "ppp: no space to decompress VJ compressed TCP header.\n"));
1056 ppp->stats.roverrun++;
1060 count = slhc_uncompress(ppp->slcomp, c, count);
1062 ppp->stats.rerrors++;
1063 PRINTKN (1,(KERN_NOTICE "ppp: error in VJ decompression\n"));
1070 if ((proto == PROTO_VJUNCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
1071 if (slhc_remember(ppp->slcomp, c, count) <= 0) {
1072 ppp->stats.rerrors++;
1073 PRINTKN (1,(KERN_NOTICE "ppp: error in VJ memorizing\n"));
1076 ppp->stats.runcomp++;
1084 if (ppp_debug_netpackets) {
1085 struct iphdr *iph = (struct iphdr *) c;
1086 PRINTK ((KERN_INFO "%s <-- src %lx dst %lx len %d\n", ppp->dev->name,
1087 iph->saddr, iph->daddr, count))
1090 /* receive the frame through the network software */
1091 while ((dev_rint(c, count, 0, ppp->dev) & ~1) != 0)
1097 /* stuff packet at BUF, length LEN, into the us_rbuff buffer
1098 prepend PROTO information */
1100 #define PUTC(c,label) *ppp->us_rbuff_head++ = c; \
1101 if (ppp->us_rbuff_head == ppp->us_rbuff_end) \
1102 ppp->us_rbuff_head = ppp->us_rbuff; \
1103 if (ppp->us_rbuff_head == ppp->us_rbuff_tail) \
1105 #define GETC(c) c = *ppp->us_rbuff_tail++; \
1106 if (ppp->us_rbuff_tail == ppp->us_rbuff_end) \
1107 ppp->us_rbuff_tail = ppp->us_rbuff;
1110 ppp_us_queue(struct ppp *ppp, unsigned short proto,
1111 unsigned char *buf, int len)
1114 unsigned char *saved_head;
1116 totlen = len+2; /* including protocol */
1118 if (set_bit(1, &ppp->us_rbuff_lock)) {
1119 PRINTKN (1, (KERN_NOTICE "ppp_us_queue: can't get lock\n"));
1122 saved_head = ppp->us_rbuff_head;
1124 PUTC((totlen & 0xff00) >> 8, failure);
1125 PUTC(totlen & 0x00ff, failure);
1126 PUTC((proto & 0xff00) >> 8, failure);
1127 PUTC(proto & 0x00ff, failure);
1130 PUTC(*buf++, failure);
1133 PRINTKN (3, (KERN_INFO "ppp: successfully queued %d bytes\n", totlen));
1134 clear_bit(1, &ppp->us_rbuff_lock);
1135 wake_up_interruptible (&ppp->read_wait);
1137 #ifdef NEW_TTY_DRIVERS
1138 kill_fasync(ppp->tty->fasync, SIGIO);
1141 if (ppp->inp_sig && ppp->inp_sig_pid)
1142 if (kill_proc (ppp->inp_sig_pid, ppp->inp_sig, 1) != 0) {
1143 /* process is gone */
1144 PRINTKN (2,(KERN_NOTICE
1145 "ppp: process that requested notification is gone\n"));
1147 ppp->inp_sig_pid = 0;
1152 ppp->us_rbuff_head = saved_head;
1153 clear_bit(1, &ppp->us_rbuff_lock);
1155 PRINTKN (1, (KERN_NOTICE "ppp_us_queue: ran out of buffer space.\n"));
1160 /*************************************************************
1161 * LINE DISCIPLINE SUPPORT
1162 * The following functions form support user programs
1163 * which read and write data on a TTY with the PPP line
1164 * discipline. Reading is done from a circular queue,
1165 * filled by the lower TTY levels.
1166 *************************************************************/
1168 /* read a PPP frame from the us_rbuff circular buffer,
1169 waiting if necessary
1173 ppp_read(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
1175 struct ppp *ppp = ppp_find(tty);
1179 if (!ppp || ppp->magic != PPP_MAGIC) {
1180 PRINTKN (1,(KERN_ERR "ppp_read: cannnot find ppp channel\n"));
1186 PRINTKN (4,(KERN_DEBUG "ppp_read: called %x num %u\n",
1191 /* try to acquire read lock */
1192 if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
1194 if (ppp->us_rbuff_head == ppp->us_rbuff_tail) {
1196 PRINTKN (4,(KERN_DEBUG "ppp_read: no data\n"));
1197 clear_bit(0, &ppp->us_rbuff_lock);
1199 PRINTKN (4,(KERN_DEBUG "ppp_read: EWOULDBLOCK\n"));
1200 return -EWOULDBLOCK;
1204 /* reset the time of the last read operation */
1205 ppp->ddinfo.nip_rjiffies = jiffies;
1207 GETC (c); len = c << 8; GETC (c); len += c;
1209 PRINTKN (4,(KERN_DEBUG "ppp_read: len = %d\n", len));
1212 /* frame too big; can't copy it, but do update us_rbuff_head */
1213 PRINTKN (1,(KERN_DEBUG
1214 "ppp: read of %u bytes too small for %d frame\n",
1216 ppp->us_rbuff_head += len;
1217 if (ppp->us_rbuff_head > ppp->us_rbuff_end)
1218 ppp->us_rbuff_head += - (ppp->us_rbuff_end - ppp->us_rbuff);
1219 clear_bit(0, &ppp->us_rbuff_lock);
1220 wake_up_interruptible (&ppp->read_wait);
1221 ppp->stats.rgiants++;
1222 return -EOVERFLOW; /* ZZZ; HACK! */
1224 /* have the space: copy the packet, faking the first two bytes */
1225 put_fs_byte (PPP_ADDRESS, buf++);
1226 put_fs_byte (PPP_CONTROL, buf++);
1230 put_fs_byte (c, buf++);
1234 clear_bit(0, &ppp->us_rbuff_lock);
1235 PRINTKN (3,(KERN_DEBUG "ppp_read: passing %d bytes up\n", len + 2));
1236 ppp->stats.rothers++;
1242 current->timeout = 0;
1243 PRINTKN (3,(KERN_DEBUG "ppp_read: sleeping\n"));
1244 interruptible_sleep_on (&ppp->read_wait);
1245 if (current->signal & ~current->blocked)
1250 /* stuff a character into the transmit buffer, using PPP's way of escaping
1252 also, update ppp->fcs to take account of new character */
1254 ppp_stuff_char(struct ppp *ppp, unsigned char c)
1256 int curpt = ppp->xhead - ppp->xbuff;
1257 if ((curpt < 0) || (curpt > 3000)) {
1258 PRINTK ((KERN_DEBUG "ppp_stuff_char: %x %x %d\n",
1259 (unsigned int) ppp->xbuff, (unsigned int) ppp->xhead, curpt))
1261 if (in_xmap (ppp, c)) {
1262 *ppp->xhead++ = PPP_ESC;
1263 *ppp->xhead++ = c ^ PPP_TRANS;
1266 ppp->fcs = (ppp->fcs >> 8) ^ fcstab[(ppp->fcs ^ c) & 0xff];
1269 /* write a frame with NR chars from BUF to TTY
1270 we have to put the FCS field on ourselves
1274 ppp_write(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
1276 struct ppp *ppp = ppp_find(tty);
1279 if (!ppp || ppp->magic != PPP_MAGIC) {
1280 PRINTKN (1,(KERN_ERR "ppp_write: cannot find ppp unit\n"));
1286 if (ppp->mtu != ppp->dev->mtu) /* Someone has been ifconfigging */
1287 ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
1289 if (nr > ppp->mtu) {
1290 PRINTKN (1,(KERN_WARNING
1291 "ppp_write: truncating user packet from %u to mtu %d\n",
1297 ppp_print_buffer ("write frame", buf, nr, USER_DS);
1299 /* lock this PPP unit so we will be the only writer;
1300 sleep if necessary */
1301 while ((ppp->sending == 1) || !ppp_lock(ppp)) {
1302 current->timeout = 0;
1303 PRINTKN (3,(KERN_DEBUG "ppp_write: sleeping\n"));
1304 interruptible_sleep_on(&ppp->write_wait);
1305 if (current->signal & ~current->blocked)
1309 /* OK, locked. Stuff the given bytes into the buffer. */
1311 PRINTKN(4,(KERN_DEBUG "ppp_write: acquired write lock\n"));
1312 ppp->xhead = ppp->xbuff;
1314 #ifdef OPTIMIZE_FLAG_TIME
1315 if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
1316 *ppp->xhead++ = PPP_FLAG;
1317 ppp->last_xmit = jiffies;
1319 *ppp->xhead++ = PPP_FLAG;
1322 ppp->fcs = PPP_FCS_INIT;
1325 ppp_stuff_char(ppp,get_fs_byte(buf++));
1327 ppp_add_fcs(ppp); /* concatenate FCS at end */
1329 *ppp->xhead++ = PPP_FLAG;
1331 /* reset the time of the last write operation */
1332 ppp->ddinfo.nip_sjiffies = jiffies;
1335 ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
1337 PRINTKN (4,(KERN_DEBUG
1338 "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
1341 /* packet is ready-to-go */
1342 ++ppp->stats.sothers;
1349 ppp_ioctl(struct tty_struct *tty, struct file *file, unsigned int i,
1352 struct ppp *ppp = ppp_find(tty);
1353 register int temp_i = 0;
1356 if (!ppp || ppp->magic != PPP_MAGIC) {
1357 PRINTK ((KERN_ERR "ppp_ioctl: can't find PPP block from tty!\n"))
1363 /* This must be root user */
1369 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1371 PRINTKN (3,(KERN_INFO "ppp_ioctl: set mru to %x\n", temp_i));
1372 temp_i = (int) get_fs_long (l);
1373 if (ppp->mru != temp_i)
1374 ppp_changedmtu (ppp, ppp->mtu, temp_i);
1379 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1381 temp_i = (ppp->flags & SC_MASK);
1382 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
1383 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP;
1385 put_fs_long ((long) temp_i, l);
1386 PRINTKN (3,(KERN_DEBUG "ppp_ioctl: get flags: addr %lx flags %x\n",
1393 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1395 temp_i = (int) get_fs_long (l);
1396 ppp->flags ^= ((ppp->flags ^ temp_i) & SC_MASK);
1397 PRINTKN (3,(KERN_INFO "ppp_ioctl: set flags to %x\n", temp_i));
1401 case PPPIOCGASYNCMAP:
1402 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1404 put_fs_long (ppp->xmit_async_map[0], l);
1405 PRINTKN (3,(KERN_INFO "ppp_ioctl: get asyncmap: addr %lx asyncmap %lx\n",
1406 l, ppp->xmit_async_map[0]));
1410 case PPPIOCSASYNCMAP:
1411 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1413 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
1414 ppp->xmit_async_map[0] = get_fs_long (l);
1415 bset (ppp->xmit_async_map, PPP_FLAG);
1416 bset (ppp->xmit_async_map, PPP_ESC);
1417 PRINTKN (3,(KERN_INFO "ppp_ioctl: set xmit asyncmap %lx\n",
1418 ppp->xmit_async_map[0]));
1422 case PPPIOCRASYNCMAP:
1423 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1425 ppp->recv_async_map = get_fs_long (l);
1426 PRINTKN (3,(KERN_INFO "ppp_ioctl: set recv asyncmap %lx\n",
1427 ppp->recv_async_map));
1432 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1434 put_fs_long (ppp->dev->base_addr, l);
1435 PRINTKN (3,(KERN_INFO "ppp_ioctl: get unit: %d", ppp->dev->base_addr));
1440 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1442 ppp->inp_sig = (int) get_fs_long (l);
1443 ppp->inp_sig_pid = current->pid;
1444 PRINTKN (3,(KERN_INFO "ppp_ioctl: set input signal %d\n", ppp->inp_sig));
1449 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1451 ppp_debug = (int) get_fs_long (l);
1452 ppp_debug_netpackets = (ppp_debug & 0xff00) >> 8;
1454 PRINTKN (1, (KERN_INFO "ppp_ioctl: set debug level %d, netpacket %d\n",
1455 ppp_debug, ppp_debug_netpackets));
1460 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1462 put_fs_long ((long) (ppp_debug | (ppp_debug_netpackets << 8)), l);
1463 PRINTKN (3,(KERN_INFO "ppp_ioctl: get debug level %d\n",
1464 ppp_debug | (ppp_debug_netpackets << 8)));
1469 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_stats));
1471 memcpy_tofs ((void *) l, &ppp->stats, sizeof (struct ppp_stats));
1472 PRINTKN (3,(KERN_INFO "ppp_ioctl: read statistics\n"));
1477 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_ddinfo));
1479 struct ppp_ddinfo cur_ddinfo;
1480 unsigned long cur_jiffies = jiffies;
1482 /* change absolute times to relative times. */
1483 cur_ddinfo.ip_sjiffies = cur_jiffies - ppp->ddinfo.ip_sjiffies;
1484 cur_ddinfo.ip_rjiffies = cur_jiffies - ppp->ddinfo.ip_rjiffies;
1485 cur_ddinfo.nip_sjiffies = cur_jiffies - ppp->ddinfo.nip_sjiffies;
1486 cur_ddinfo.nip_rjiffies = cur_jiffies - ppp->ddinfo.nip_rjiffies;
1488 memcpy_tofs ((void *) l, &cur_ddinfo, sizeof (struct ppp_ddinfo));
1489 PRINTKN (3,(KERN_INFO "ppp_ioctl: read demand dial info\n"));
1493 case PPPIOCGXASYNCMAP:
1494 error = verify_area (VERIFY_WRITE,
1496 sizeof (ppp->xmit_async_map));
1498 memcpy_tofs ((void *) l,
1499 ppp->xmit_async_map,
1500 sizeof (ppp->xmit_async_map));
1501 PRINTKN (3,(KERN_INFO "ppp_ioctl: get xasyncmap: addr %lx\n", l));
1505 case PPPIOCSXASYNCMAP:
1506 error = verify_area (VERIFY_READ, (void *) l,
1507 sizeof (ppp->xmit_async_map));
1509 unsigned long temp_tbl [8];
1511 memcpy_fromfs (temp_tbl, (void *) l, sizeof (ppp->xmit_async_map));
1512 temp_tbl[1] = 0x00000000; /* must not escape 0x20 - 0x3f */
1513 temp_tbl[2] &= ~0x40000000; /* must not escape 0x5e */
1514 temp_tbl[3] |= 0x60000000; /* must escape 0x7d and 0x7e */
1516 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
1517 (temp_tbl[4] & temp_tbl[5]) != 0 ||
1518 (temp_tbl[6] & temp_tbl[7]) != 0)
1521 memcpy (ppp->xmit_async_map, temp_tbl, sizeof (ppp->xmit_async_map));
1522 PRINTKN (3,(KERN_INFO "ppp_ioctl: set xasyncmap\n"));
1528 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1530 temp_i = (int) get_fs_long (l) + 1;
1531 PRINTKN (3,(KERN_INFO "ppp_ioctl: set maxcid to %d\n", temp_i));
1532 if (ppp->slcomp != NULL)
1533 slhc_free (ppp->slcomp);
1535 ppp->slcomp = slhc_init (temp_i, temp_i);
1537 if (ppp->slcomp == NULL) {
1538 PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
1545 #ifdef NEW_TTY_DRIVERS
1546 /* Allow stty to read, but not set, the serial port */
1549 error = n_tty_ioctl(tty, file, i, l);
1554 * All other ioctl() events will come here.
1558 PRINTKN (1,(KERN_ERR "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
1561 #ifdef NEW_TTY_DRIVERS
1562 error = -ENOIOCTLCMD;
1572 ppp_select (struct tty_struct *tty, struct inode * inode,
1573 struct file * filp, int sel_type, select_table * wait)
1575 struct ppp *ppp = ppp_find (tty);
1577 if (!ppp || ppp->magic != PPP_MAGIC) {
1578 PRINTK ((KERN_ERR "ppp_select: can't find PPP block from tty!\n"))
1582 /* If the PPP protocol is no longer active, return false */
1585 /* Process the request based upon the type desired */
1588 if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
1589 /* Test for the presence of data in the queue */
1590 if (ppp->us_rbuff_head != ppp->us_rbuff_tail) {
1591 clear_bit (0, &ppp->us_rbuff_lock);
1594 clear_bit (0, &ppp->us_rbuff_lock);
1595 } /* fall through */
1598 /* Is there a pending error condition? */
1599 if (tty->packet && tty->link->ctrl_status)
1603 if (tty->flags & (1 << TTY_SLAVE_CLOSED))
1606 /* If the tty is disconnected, then this is an exception too */
1607 if (tty_hung_up_p(filp))
1610 select_wait (&ppp->read_wait, wait);
1614 if (ppp_lock (ppp)) {
1615 if (ppp->sending == 0) {
1621 select_wait (&ppp->write_wait, wait);
1627 /*************************************************************
1629 * This routine accepts requests from the network layer
1630 * and attempts to deliver the packets.
1631 * It also includes various routines we are compelled to
1632 * have to make the network layer work (arp, etc...).
1633 *************************************************************/
1636 ppp_xmit(struct sk_buff *skb, struct device *dev)
1638 struct tty_struct *tty;
1641 unsigned short proto;
1644 /* just a little sanity check. */
1646 PRINTKN(3,(KERN_WARNING "ppp_xmit: null packet!\n"));
1650 /* Get pointers to the various components */
1651 ppp = &ppp_ctrl[dev->base_addr];
1653 p = (unsigned char *) (skb + 1);
1657 PRINTKN(4,(KERN_DEBUG "ppp_xmit [%s]: skb %lX busy %d\n", dev->name,
1658 (unsigned long int) skb, ppp->sending));
1663 PRINTKN(1,(KERN_ERR "ppp_xmit: %s not connected to a TTY!\n", dev->name));
1667 if (!(dev->flags & IFF_UP)) {
1668 PRINTKN(1,(KERN_WARNING
1669 "ppp_xmit: packet sent on interface %s, which is down for IP\n",
1674 /* get length from IP header as per Alan Cox bugfix for slip.c */
1675 if (len < sizeof(struct iphdr)) {
1676 PRINTKN(0,(KERN_ERR "ppp_xmit: given runt packet, ignoring\n"));
1679 len = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
1681 /* If doing demand dial then divert the first frame to pppd. */
1682 if (ppp->flags & SC_IP_DOWN) {
1683 if (ppp->flags & SC_IP_FLUSH == 0) {
1684 if (ppp_us_queue (ppp, proto, p, len))
1685 ppp->flags |= SC_IP_FLUSH;
1690 /* Attempt to acquire send lock */
1691 if (ppp->sending || !ppp_lock(ppp)) {
1692 PRINTKN(3,(KERN_WARNING "ppp_xmit: busy\n"));
1697 ppp->xhead = ppp->xbuff;
1699 /* try to compress, if VJ compression mode is on */
1700 if (ppp->flags & SC_COMP_TCP) {
1701 /* NOTE: last 0 argument says never to compress connection ID */
1702 len = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p, 0);
1703 if (p[0] & SL_TYPE_COMPRESSED_TCP)
1704 proto = PROTO_VJCOMP;
1706 if (p[0] >= SL_TYPE_UNCOMPRESSED_TCP) {
1707 proto = PROTO_VJUNCOMP;
1708 p[0] = (p[0] & 0x0f) | 0x40;
1713 /* increment appropriate counter */
1714 if (proto == PROTO_VJCOMP)
1717 ++ppp->stats.suncomp;
1719 if (ppp_debug_netpackets) {
1720 struct iphdr *iph = (struct iphdr *) (skb + 1);
1721 PRINTK ((KERN_DEBUG "%s ==> proto %x len %d src %x dst %x proto %d\n",
1722 dev->name, (int) proto, (int) len, (int) iph->saddr,
1723 (int) iph->daddr, (int) iph->protocol))
1726 /* start of frame: FLAG ALL_STATIONS CONTROL <protohi> <protolo> */
1727 #ifdef OPTIMIZE_FLAG_TIME
1728 if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
1729 *ppp->xhead++ = PPP_FLAG;
1730 ppp->last_xmit = jiffies;
1732 *ppp->xhead++ = PPP_FLAG;
1735 ppp->fcs = PPP_FCS_INIT;
1736 if (!(ppp->flags & SC_COMP_AC)) {
1737 ppp_stuff_char(ppp, PPP_ADDRESS);
1738 ppp_stuff_char(ppp, PPP_CONTROL);
1741 if (!(ppp->flags & SC_COMP_PROT) || (proto & 0xff00))
1742 ppp_stuff_char(ppp, proto>>8);
1743 ppp_stuff_char(ppp, proto&0xff);
1747 ppp_stuff_char(ppp, *p++);
1751 *ppp->xhead++ = PPP_FLAG;
1753 /* update the time for demand dial function */
1754 ppp->ddinfo.ip_sjiffies = jiffies;
1758 ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
1760 PRINTKN (4,(KERN_DEBUG
1761 "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
1768 kfree_skb(skb, FREE_WRITE);
1772 static unsigned short
1773 ppp_type_trans (struct sk_buff *skb, struct device *dev)
1775 return(htons(ETH_P_IP));
1780 ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
1781 unsigned long daddr, unsigned long saddr, unsigned len)
1787 ppp_rebuild_header(void *buff, struct device *dev)
1793 ppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
1800 ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
1801 void *daddr, void *saddr, unsigned len, struct sk_buff *skb)
1807 ppp_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
1808 struct sk_buff *skb)
1814 static struct enet_statistics *
1815 ppp_get_stats (struct device *dev)
1817 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
1818 static struct enet_statistics ppp_stats;
1820 ppp_stats.rx_packets = ppp->stats.rcomp + ppp->stats.runcomp;
1821 ppp_stats.rx_errors = ppp->stats.rerrors;
1822 ppp_stats.rx_dropped = ppp->stats.tossed;
1823 ppp_stats.rx_fifo_errors = 0;
1824 ppp_stats.rx_length_errors = ppp->stats.runts;
1825 ppp_stats.rx_over_errors = ppp->stats.roverrun;
1826 ppp_stats.rx_crc_errors = 0;
1827 ppp_stats.rx_frame_errors = 0;
1828 ppp_stats.tx_packets = ppp->stats.scomp + ppp->stats.suncomp;
1829 ppp_stats.tx_errors = ppp->stats.serrors;
1830 ppp_stats.tx_dropped = 0;
1831 ppp_stats.tx_fifo_errors = 0;
1832 ppp_stats.collisions = ppp->stats.sbusy;
1833 ppp_stats.tx_carrier_errors = 0;
1834 ppp_stats.tx_aborted_errors = 0;
1835 ppp_stats.tx_window_errors = 0;
1836 ppp_stats.tx_heartbeat_errors = 0;
1838 PRINTKN (3, (KERN_INFO "ppp_get_stats called"));
1842 /*************************************************************
1844 * Miscellany called by various functions above.
1845 *************************************************************/
1847 #ifndef NEW_TTY_DRIVERS
1848 /* find a PPP channel given a TTY */
1850 ppp_find(struct tty_struct *tty)
1853 for (i = 0; i < PPP_NRUNIT; i++)
1854 if (ppp_ctrl[i].inuse && (ppp_ctrl[i].tty == tty)) return &ppp_ctrl[i];
1860 /* allocate a PPP channel */
1865 for (i = 0; i < PPP_NRUNIT; i++)
1866 if (!set_bit(0, &ppp_ctrl[i].inuse)) return &ppp_ctrl[i];
1871 /* marks a PPP interface 'busy'. user processes will wait, if
1872 they try to write, and the network code will refrain from sending
1873 return nonzero if succeeded in acquiring lock
1877 ppp_lock(struct ppp *ppp)
1882 locked = ppp->sending;
1884 if (ppp->dev->flags & IFF_UP)
1885 ppp->dev->tbusy = 1;
1886 restore_flags(flags);
1891 ppp_unlock(struct ppp *ppp)
1897 if (ppp->dev->flags & IFF_UP)
1898 ppp->dev->tbusy = 0;
1899 restore_flags(flags);
1902 /* FCS support functions */
1905 ppp_add_fcs(struct ppp *ppp)
1907 unsigned short fcs = ppp->fcs;
1910 ppp_stuff_char(ppp, fcs & 0x00ff);
1911 ppp_stuff_char(ppp, (fcs & 0xff00) >> 8);
1912 ASSERT (ppp->fcs == PPP_FCS_GOOD);
1913 PRINTKN (4,(KERN_DEBUG "ppp_add_fcs: fcs is %lx\n",
1914 (long) (unsigned long) fcs));
1918 ppp_check_fcs(struct ppp *ppp)
1920 unsigned short fcs = PPP_FCS_INIT, msgfcs;
1921 unsigned char *c = ppp->rbuff;
1924 for (i = 0; i < ppp->rcount - 2; i++, c++)
1925 fcs = (fcs >> 8) ^ fcstab[(fcs ^ *c) & 0xff];
1928 msgfcs = (c[1] << 8) + c[0];
1929 PRINTKN (4,(KERN_INFO "ppp_check_fcs: got %lx want %lx\n",
1930 (unsigned long) msgfcs, (unsigned long) fcs));
1931 return fcs == msgfcs;
1934 static char hex[] = "0123456789ABCDEF";
1936 inline void ppp_print_hex (register char *out, char *in, int count);
1937 inline void ppp_print_hex (register char *out, char *in, int count)
1939 register unsigned char next_ch;
1941 while (count-- > 0) {
1942 next_ch = (unsigned char) get_fs_byte (in);
1944 *out++ = hex[(next_ch >> 4) & 0x0F];
1945 *out++ = hex[next_ch & 0x0F];
1951 inline void ppp_print_char (register char *out, char *in, int count);
1952 inline void ppp_print_char (register char *out, char *in, int count)
1954 register unsigned char next_ch;
1956 while (count-- > 0) {
1957 next_ch = (unsigned char) get_fs_byte (in);
1959 if (next_ch < 0x20 || next_ch > 0x7e)
1963 if (next_ch == '%') /* printk/syslogd has a bug !! */
1971 static void ppp_print_buffer(const char *name, char *buf, int count, int seg)
1974 int old_fs = get_fs();
1978 if (name != (char *) NULL)
1979 PRINTK ((KERN_DEBUG "ppp: %s, count = %d\n", name, count));
1982 memset (line, ' ', sizeof (line));
1983 ppp_print_hex (line, buf, 8);
1984 ppp_print_char (&line[8 * 3], buf, 8);
1985 PRINTK ((KERN_DEBUG "%s\n", line));
1991 memset (line, ' ', sizeof (line));
1992 ppp_print_hex (line, buf, count);
1993 ppp_print_char (&line[8 * 3], buf, count);
1994 PRINTK ((KERN_DEBUG "%s\n", line));