2 * slip.c This module implements the SLIP protocol for kernel-based
3 * devices like TTY. It interfaces between a raw TTY, and the
4 * kernel's INET protocol layers.
6 * Version: @(#)slip.c 0.8.3 12/24/94
8 * Authors: Laurence Culhane, <loz@holmes.demon.co.uk>
9 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
12 * Alan Cox : Sanity checks and avoid tx overruns.
13 * Has a new sl->mtu field.
14 * Alan Cox : Found cause of overrun. ifconfig sl0
15 * mtu upwards. Driver now spots this
16 * and grows/shrinks its buffers(hack!).
17 * Memory leak if you run out of memory
18 * setting up a slip driver fixed.
19 * Matt Dillon : Printable slip (borrowed from NET2E)
20 * Pauline Middelink : Slip driver fixes.
21 * Alan Cox : Honours the old SL_COMPRESSED flag
22 * Alan Cox : KISS AX.25 and AXUI IP support
23 * Michael Riepe : Automatic CSLIP recognition added
24 * Charles Hedrick : CSLIP header length problem fix.
25 * Alan Cox : Corrected non-IP cases of the above.
26 * Alan Cox : Now uses hardware type as per FvK.
27 * Alan Cox : Default to 192.168.0.0 (RFC 1597)
28 * A.N.Kuznetsov : dev_tint() recursion fix.
29 * Dmitry Gorodchanin : SLIP memory leaks
30 * Dmitry Gorodchanin : Code cleanup. Reduce tty driver
31 * buffering from 4096 to 256 bytes.
32 * Improving SLIP response time.
33 * CONFIG_SLIP_MODE_SLIP6.
34 * ifconfig sl? up & down now works
37 * Alan Cox : Oops - fix AX.25 buffer lengths
38 * Dmitry Gorodchanin : Even more cleanups. Preserve CSLIP
39 * statistics. Include CSLIP code only
40 * if it really needed.
41 * Alan Cox : Free slhc buffers in the right place.
42 * Alan Cox : Allow for digipeated IP over AX.25
43 * Matti Aarnio : Dynamic SLIP devices, with ideas taken
44 * from Jim Freeman's <jfree@caldera.com>
45 * dynamic PPP devices. We do NOT kfree()
46 * device entries, just reg./unreg. them
47 * as they are needed. We kfree() them
49 * With MODULE-loading ``insmod'', user
50 * can issue parameter: slip_maxdev=1024
51 * (Or how much he/she wants.. Default
53 * Stanislav Voronyi : Slip line checking, with ideas taken
54 * from multislip BSDI driver which was
55 * written by Igor Chechik, RELCOM Corp.
56 * Only algorithms have been ported to
58 * Vitaly E. Lavrov : Sane behaviour on tty hangup.
59 * Alexey Kuznetsov : Cleanup interfaces to tty & netdevice
63 #define SL_CHECK_TRANSMIT
64 #include <linux/module.h>
65 #include <linux/moduleparam.h>
67 #include <asm/system.h>
68 #include <asm/uaccess.h>
69 #include <linux/bitops.h>
70 #include <linux/string.h>
72 #include <linux/interrupt.h>
74 #include <linux/tty.h>
75 #include <linux/errno.h>
76 #include <linux/netdevice.h>
77 #include <linux/etherdevice.h>
78 #include <linux/skbuff.h>
79 #include <linux/rtnetlink.h>
80 #include <linux/if_arp.h>
81 #include <linux/if_slip.h>
82 #include <linux/delay.h>
83 #include <linux/init.h>
87 #include <linux/tcp.h>
88 #include <net/slhc_vj.h>
91 #define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
93 static struct net_device
**slip_devs
;
95 static int slip_maxdev
= SL_NRUNIT
;
96 module_param(slip_maxdev
, int, 0);
97 MODULE_PARM_DESC(slip_maxdev
, "Maximum number of slip devices");
99 static int slip_esc(unsigned char *p
, unsigned char *d
, int len
);
100 static void slip_unesc(struct slip
*sl
, unsigned char c
);
101 #ifdef CONFIG_SLIP_MODE_SLIP6
102 static int slip_esc6(unsigned char *p
, unsigned char *d
, int len
);
103 static void slip_unesc6(struct slip
*sl
, unsigned char c
);
105 #ifdef CONFIG_SLIP_SMART
106 static void sl_keepalive(unsigned long sls
);
107 static void sl_outfill(unsigned long sls
);
108 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
111 /********************************
112 * Buffer administration routines:
117 * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
118 * sl_realloc_bufs provides strong atomicity and reallocation
119 * on actively running device.
120 *********************************/
123 Allocate channel buffers.
126 static int sl_alloc_bufs(struct slip
*sl
, int mtu
)
132 #ifdef SL_INCLUDE_CSLIP
134 struct slcompress
*slcomp
= NULL
;
138 * Allocate the SLIP frame buffers:
140 * rbuff Receive buffer.
141 * xbuff Transmit buffer.
142 * cbuff Temporary compression buffer.
147 * allow for arrival of larger UDP packets, even if we say not to
148 * also fixes a bug in which SunOS sends 512-byte packets even with
153 rbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
156 xbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
159 #ifdef SL_INCLUDE_CSLIP
160 cbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
163 slcomp
= slhc_init(16, 16);
167 spin_lock_bh(&sl
->lock
);
168 if (sl
->tty
== NULL
) {
169 spin_unlock_bh(&sl
->lock
);
177 rbuff
= xchg(&sl
->rbuff
, rbuff
);
178 xbuff
= xchg(&sl
->xbuff
, xbuff
);
179 #ifdef SL_INCLUDE_CSLIP
180 cbuff
= xchg(&sl
->cbuff
, cbuff
);
181 slcomp
= xchg(&sl
->slcomp
, slcomp
);
182 #ifdef CONFIG_SLIP_MODE_SLIP6
187 spin_unlock_bh(&sl
->lock
);
192 #ifdef SL_INCLUDE_CSLIP
202 /* Free a SLIP channel buffers. */
203 static void sl_free_bufs(struct slip
*sl
)
205 /* Free all SLIP frame buffers. */
206 kfree(xchg(&sl
->rbuff
, NULL
));
207 kfree(xchg(&sl
->xbuff
, NULL
));
208 #ifdef SL_INCLUDE_CSLIP
209 kfree(xchg(&sl
->cbuff
, NULL
));
210 slhc_free(xchg(&sl
->slcomp
, NULL
));
215 Reallocate slip channel buffers.
218 static int sl_realloc_bufs(struct slip
*sl
, int mtu
)
221 struct net_device
*dev
= sl
->dev
;
222 unsigned char *xbuff
, *rbuff
;
223 #ifdef SL_INCLUDE_CSLIP
224 unsigned char *cbuff
;
229 * allow for arrival of larger UDP packets, even if we say not to
230 * also fixes a bug in which SunOS sends 512-byte packets even with
236 xbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
237 rbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
238 #ifdef SL_INCLUDE_CSLIP
239 cbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
243 #ifdef SL_INCLUDE_CSLIP
244 if (xbuff
== NULL
|| rbuff
== NULL
|| cbuff
== NULL
) {
246 if (xbuff
== NULL
|| rbuff
== NULL
) {
248 if (mtu
>= sl
->mtu
) {
249 printk(KERN_WARNING
"%s: unable to grow slip buffers, MTU change cancelled.\n",
255 spin_lock_bh(&sl
->lock
);
261 xbuff
= xchg(&sl
->xbuff
, xbuff
);
262 rbuff
= xchg(&sl
->rbuff
, rbuff
);
263 #ifdef SL_INCLUDE_CSLIP
264 cbuff
= xchg(&sl
->cbuff
, cbuff
);
267 if (sl
->xleft
<= len
) {
268 memcpy(sl
->xbuff
, sl
->xhead
, sl
->xleft
);
274 sl
->xhead
= sl
->xbuff
;
277 if (sl
->rcount
<= len
) {
278 memcpy(sl
->rbuff
, rbuff
, sl
->rcount
);
281 sl
->rx_over_errors
++;
282 set_bit(SLF_ERROR
, &sl
->flags
);
291 spin_unlock_bh(&sl
->lock
);
296 #ifdef SL_INCLUDE_CSLIP
303 /* Set the "sending" flag. This must be atomic hence the set_bit. */
304 static inline void sl_lock(struct slip
*sl
)
306 netif_stop_queue(sl
->dev
);
310 /* Clear the "sending" flag. This must be atomic, hence the ASM. */
311 static inline void sl_unlock(struct slip
*sl
)
313 netif_wake_queue(sl
->dev
);
316 /* Send one completely decapsulated IP datagram to the IP layer. */
317 static void sl_bump(struct slip
*sl
)
323 #ifdef SL_INCLUDE_CSLIP
324 if (sl
->mode
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) {
325 unsigned char c
= sl
->rbuff
[0];
326 if (c
& SL_TYPE_COMPRESSED_TCP
) {
327 /* ignore compressed packets when CSLIP is off */
328 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
329 printk(KERN_WARNING
"%s: compressed packet ignored\n", sl
->dev
->name
);
332 /* make sure we've reserved enough space for uncompress
334 if (count
+ 80 > sl
->buffsize
) {
335 sl
->rx_over_errors
++;
338 count
= slhc_uncompress(sl
->slcomp
, sl
->rbuff
, count
);
341 } else if (c
>= SL_TYPE_UNCOMPRESSED_TCP
) {
342 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
343 /* turn on header compression */
344 sl
->mode
|= SL_MODE_CSLIP
;
345 sl
->mode
&= ~SL_MODE_ADAPTIVE
;
346 printk(KERN_INFO
"%s: header compression turned on\n", sl
->dev
->name
);
348 sl
->rbuff
[0] &= 0x4f;
349 if (slhc_remember(sl
->slcomp
, sl
->rbuff
, count
) <= 0)
353 #endif /* SL_INCLUDE_CSLIP */
355 sl
->rx_bytes
+= count
;
357 skb
= dev_alloc_skb(count
);
359 printk(KERN_WARNING
"%s: memory squeeze, dropping packet.\n", sl
->dev
->name
);
364 memcpy(skb_put(skb
, count
), sl
->rbuff
, count
);
365 skb_reset_mac_header(skb
);
366 skb
->protocol
= htons(ETH_P_IP
);
368 sl
->dev
->last_rx
= jiffies
;
372 /* Encapsulate one IP datagram and stuff into a TTY queue. */
373 static void sl_encaps(struct slip
*sl
, unsigned char *icp
, int len
)
378 if (len
> sl
->mtu
) { /* Sigh, shouldn't occur BUT ... */
379 printk(KERN_WARNING
"%s: truncating oversized transmit packet!\n", sl
->dev
->name
);
386 #ifdef SL_INCLUDE_CSLIP
387 if (sl
->mode
& SL_MODE_CSLIP
)
388 len
= slhc_compress(sl
->slcomp
, p
, len
, sl
->cbuff
, &p
, 1);
390 #ifdef CONFIG_SLIP_MODE_SLIP6
391 if (sl
->mode
& SL_MODE_SLIP6
)
392 count
= slip_esc6(p
, (unsigned char *) sl
->xbuff
, len
);
395 count
= slip_esc(p
, (unsigned char *) sl
->xbuff
, len
);
397 /* Order of next two lines is *very* important.
398 * When we are sending a little amount of data,
399 * the transfer may be completed inside the ops->write()
400 * routine, because it's running with interrupts enabled.
401 * In this case we *never* got WRITE_WAKEUP event,
402 * if we did not request it before write operation.
403 * 14 Oct 1994 Dmitry Gorodchanin.
405 sl
->tty
->flags
|= (1 << TTY_DO_WRITE_WAKEUP
);
406 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xbuff
, count
);
407 #ifdef SL_CHECK_TRANSMIT
408 sl
->dev
->trans_start
= jiffies
;
410 sl
->xleft
= count
- actual
;
411 sl
->xhead
= sl
->xbuff
+ actual
;
412 #ifdef CONFIG_SLIP_SMART
414 clear_bit(SLF_OUTWAIT
, &sl
->flags
); /* reset outfill flag */
419 * Called by the driver when there's room for more data. If we have
420 * more packets to send, we send them here.
422 static void slip_write_wakeup(struct tty_struct
*tty
)
425 struct slip
*sl
= tty
->disc_data
;
427 /* First make sure we're connected. */
428 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
431 if (sl
->xleft
<= 0) {
432 /* Now serial buffer is almost free & we can start
433 * transmission of another packet */
435 tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
440 actual
= tty
->ops
->write(tty
, sl
->xhead
, sl
->xleft
);
445 static void sl_tx_timeout(struct net_device
*dev
)
447 struct slip
*sl
= netdev_priv(dev
);
449 spin_lock(&sl
->lock
);
451 if (netif_queue_stopped(dev
)) {
452 if (!netif_running(dev
))
455 /* May be we must check transmitter timeout here ?
456 * 14 Oct 1994 Dmitry Gorodchanin.
458 #ifdef SL_CHECK_TRANSMIT
459 if (time_before(jiffies
, dev
->trans_start
+ 20 * HZ
)) {
460 /* 20 sec timeout not reached */
463 printk(KERN_WARNING
"%s: transmit timed out, %s?\n",
465 (tty_chars_in_buffer(sl
->tty
) || sl
->xleft
) ?
466 "bad line quality" : "driver error");
468 sl
->tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
473 spin_unlock(&sl
->lock
);
477 /* Encapsulate an IP datagram and kick it into a TTY queue. */
479 sl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
481 struct slip
*sl
= netdev_priv(dev
);
483 spin_lock(&sl
->lock
);
484 if (!netif_running(dev
)) {
485 spin_unlock(&sl
->lock
);
486 printk(KERN_WARNING
"%s: xmit call when iface is down\n", dev
->name
);
490 if (sl
->tty
== NULL
) {
491 spin_unlock(&sl
->lock
);
497 sl
->tx_bytes
+= skb
->len
;
498 sl_encaps(sl
, skb
->data
, skb
->len
);
499 spin_unlock(&sl
->lock
);
506 /******************************************
507 * Routines looking at netdevice side.
508 ******************************************/
510 /* Netdevice UP -> DOWN routine */
513 sl_close(struct net_device
*dev
)
515 struct slip
*sl
= netdev_priv(dev
);
517 spin_lock_bh(&sl
->lock
);
519 /* TTY discipline is running. */
520 sl
->tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
522 netif_stop_queue(dev
);
525 spin_unlock_bh(&sl
->lock
);
530 /* Netdevice DOWN -> UP routine */
532 static int sl_open(struct net_device
*dev
)
534 struct slip
*sl
= netdev_priv(dev
);
539 sl
->flags
&= (1 << SLF_INUSE
);
540 netif_start_queue(dev
);
544 /* Netdevice change MTU request */
546 static int sl_change_mtu(struct net_device
*dev
, int new_mtu
)
548 struct slip
*sl
= netdev_priv(dev
);
550 if (new_mtu
< 68 || new_mtu
> 65534)
553 if (new_mtu
!= dev
->mtu
)
554 return sl_realloc_bufs(sl
, new_mtu
);
558 /* Netdevice get statistics request */
560 static struct net_device_stats
*
561 sl_get_stats(struct net_device
*dev
)
563 static struct net_device_stats stats
;
564 struct slip
*sl
= netdev_priv(dev
);
565 #ifdef SL_INCLUDE_CSLIP
566 struct slcompress
*comp
;
569 memset(&stats
, 0, sizeof(struct net_device_stats
));
571 stats
.rx_packets
= sl
->rx_packets
;
572 stats
.tx_packets
= sl
->tx_packets
;
573 stats
.rx_bytes
= sl
->rx_bytes
;
574 stats
.tx_bytes
= sl
->tx_bytes
;
575 stats
.rx_dropped
= sl
->rx_dropped
;
576 stats
.tx_dropped
= sl
->tx_dropped
;
577 stats
.tx_errors
= sl
->tx_errors
;
578 stats
.rx_errors
= sl
->rx_errors
;
579 stats
.rx_over_errors
= sl
->rx_over_errors
;
580 #ifdef SL_INCLUDE_CSLIP
581 stats
.rx_fifo_errors
= sl
->rx_compressed
;
582 stats
.tx_fifo_errors
= sl
->tx_compressed
;
583 stats
.collisions
= sl
->tx_misses
;
586 stats
.rx_fifo_errors
+= comp
->sls_i_compressed
;
587 stats
.rx_dropped
+= comp
->sls_i_tossed
;
588 stats
.tx_fifo_errors
+= comp
->sls_o_compressed
;
589 stats
.collisions
+= comp
->sls_o_misses
;
591 #endif /* CONFIG_INET */
595 /* Netdevice register callback */
597 static int sl_init(struct net_device
*dev
)
599 struct slip
*sl
= netdev_priv(dev
);
602 * Finish setting up the DEVICE info.
606 dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
607 #ifdef SL_CHECK_TRANSMIT
608 dev
->tx_timeout
= sl_tx_timeout
;
609 dev
->watchdog_timeo
= 20*HZ
;
615 static void sl_uninit(struct net_device
*dev
)
617 struct slip
*sl
= netdev_priv(dev
);
622 static void sl_setup(struct net_device
*dev
)
625 dev
->uninit
= sl_uninit
;
627 dev
->destructor
= free_netdev
;
628 dev
->stop
= sl_close
;
629 dev
->get_stats
= sl_get_stats
;
630 dev
->change_mtu
= sl_change_mtu
;
631 dev
->hard_start_xmit
= sl_xmit
;
632 #ifdef CONFIG_SLIP_SMART
633 dev
->do_ioctl
= sl_ioctl
;
635 dev
->hard_header_len
= 0;
637 dev
->tx_queue_len
= 10;
639 /* New-style flags. */
640 dev
->flags
= IFF_NOARP
|IFF_POINTOPOINT
|IFF_MULTICAST
;
643 /******************************************
644 Routines looking at TTY side.
645 ******************************************/
649 * Handle the 'receiver data ready' interrupt.
650 * This function is called by the 'tty_io' module in the kernel when
651 * a block of SLIP data has been received, which can now be decapsulated
652 * and sent on to some IP layer for further processing. This will not
653 * be re-entered while running but other ldisc functions may be called
657 static void slip_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
660 struct slip
*sl
= tty
->disc_data
;
662 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
665 /* Read the characters out of the buffer */
668 if (!test_and_set_bit(SLF_ERROR
, &sl
->flags
))
673 #ifdef CONFIG_SLIP_MODE_SLIP6
674 if (sl
->mode
& SL_MODE_SLIP6
)
675 slip_unesc6(sl
, *cp
++);
678 slip_unesc(sl
, *cp
++);
682 /************************************
683 * slip_open helper routines.
684 ************************************/
686 /* Collect hanged up channels */
687 static void sl_sync(void)
690 struct net_device
*dev
;
693 for (i
= 0; i
< slip_maxdev
; i
++) {
698 sl
= netdev_priv(dev
);
699 if (sl
->tty
|| sl
->leased
)
701 if (dev
->flags
& IFF_UP
)
707 /* Find a free SLIP channel, and link in this `tty' line. */
708 static struct slip
*sl_alloc(dev_t line
)
713 struct net_device
*dev
= NULL
;
716 if (slip_devs
== NULL
)
717 return NULL
; /* Master array missing ! */
719 for (i
= 0; i
< slip_maxdev
; i
++) {
724 sl
= netdev_priv(dev
);
726 if (sl
->line
!= line
)
731 /* Clear ESCAPE & ERROR flags */
732 sl
->flags
&= (1 << SLF_INUSE
);
739 if (current
->pid
== sl
->pid
) {
740 if (sl
->line
== line
&& score
< 3) {
751 if (sl
->line
== line
&& score
< 1) {
766 sl
= netdev_priv(dev
);
767 sl
->flags
&= (1 << SLF_INUSE
);
772 /* Sorry, too many, all slots in use */
773 if (i
>= slip_maxdev
)
777 sl
= netdev_priv(dev
);
778 if (test_bit(SLF_INUSE
, &sl
->flags
)) {
779 unregister_netdevice(dev
);
787 sprintf(name
, "sl%d", i
);
789 dev
= alloc_netdev(sizeof(*sl
), name
, sl_setup
);
795 sl
= netdev_priv(dev
);
797 /* Initialize channel control data */
798 sl
->magic
= SLIP_MAGIC
;
800 spin_lock_init(&sl
->lock
);
801 sl
->mode
= SL_MODE_DEFAULT
;
802 #ifdef CONFIG_SLIP_SMART
803 /* initialize timer_list struct */
804 init_timer(&sl
->keepalive_timer
);
805 sl
->keepalive_timer
.data
= (unsigned long)sl
;
806 sl
->keepalive_timer
.function
= sl_keepalive
;
807 init_timer(&sl
->outfill_timer
);
808 sl
->outfill_timer
.data
= (unsigned long)sl
;
809 sl
->outfill_timer
.function
= sl_outfill
;
816 * Open the high-level part of the SLIP channel.
817 * This function is called by the TTY module when the
818 * SLIP line discipline is called for. Because we are
819 * sure the tty line exists, we only have to link it to
820 * a free SLIP channel...
822 * Called in process context serialized from other ldisc calls.
825 static int slip_open(struct tty_struct
*tty
)
830 if (!capable(CAP_NET_ADMIN
))
833 if (tty
->ops
->write
== NULL
)
836 /* RTnetlink lock is misused here to serialize concurrent
837 opens of slip channels. There are better ways, but it is
842 /* Collect hanged up channels. */
848 /* First make sure we're not already connected. */
849 if (sl
&& sl
->magic
== SLIP_MAGIC
)
852 /* OK. Find a free SLIP channel to use. */
854 sl
= sl_alloc(tty_devnum(tty
));
860 sl
->line
= tty_devnum(tty
);
861 sl
->pid
= current
->pid
;
863 if (!test_bit(SLF_INUSE
, &sl
->flags
)) {
864 /* Perform the low-level SLIP initialization. */
865 err
= sl_alloc_bufs(sl
, SL_MTU
);
869 set_bit(SLF_INUSE
, &sl
->flags
);
871 err
= register_netdevice(sl
->dev
);
876 #ifdef CONFIG_SLIP_SMART
878 sl
->keepalive_timer
.expires
= jiffies
+ sl
->keepalive
* HZ
;
879 add_timer(&sl
->keepalive_timer
);
882 sl
->outfill_timer
.expires
= jiffies
+ sl
->outfill
* HZ
;
883 add_timer(&sl
->outfill_timer
);
887 /* Done. We have linked the TTY line to a channel. */
889 tty
->receive_room
= 65536; /* We don't flow control */
890 return sl
->dev
->base_addr
;
897 tty
->disc_data
= NULL
;
898 clear_bit(SLF_INUSE
, &sl
->flags
);
903 /* Count references from TTY module */
909 FIXME: 1,2 are fixed 3 was never true anyway.
911 Let me to blame a bit.
912 1. TTY module calls this funstion on soft interrupt.
913 2. TTY module calls this function WITH MASKED INTERRUPTS!
914 3. TTY module does not notify us about line discipline
917 Seems, now it is clean. The solution is to consider netdevice and
918 line discipline sides as two independent threads.
920 By-product (not desired): sl? does not feel hangups and remains open.
921 It is supposed, that user level program (dip, diald, slattach...)
922 will catch SIGHUP and make the rest of work.
924 I see no way to make more with current tty code. --ANK
928 * Close down a SLIP channel.
929 * This means flushing out any pending queues, and then returning. This
930 * call is serialized against other ldisc functions.
932 static void slip_close(struct tty_struct
*tty
)
934 struct slip
*sl
= tty
->disc_data
;
936 /* First make sure we're connected. */
937 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| sl
->tty
!= tty
)
940 tty
->disc_data
= NULL
;
945 /* VSV = very important to remove timers */
946 #ifdef CONFIG_SLIP_SMART
947 del_timer_sync(&sl
->keepalive_timer
);
948 del_timer_sync(&sl
->outfill_timer
);
951 /* Count references from TTY module */
954 /************************************************************************
955 * STANDARD SLIP ENCAPSULATION *
956 ************************************************************************/
958 static int slip_esc(unsigned char *s
, unsigned char *d
, int len
)
960 unsigned char *ptr
= d
;
964 * Send an initial END character to flush out any
965 * data that may have accumulated in the receiver
972 * For each byte in the packet, send the appropriate
973 * character sequence, according to the SLIP protocol.
995 static void slip_unesc(struct slip
*sl
, unsigned char s
)
1000 #ifdef CONFIG_SLIP_SMART
1001 /* drop keeptest bit = VSV */
1002 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1003 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1006 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
)
1007 && (sl
->rcount
> 2))
1009 clear_bit(SLF_ESCAPE
, &sl
->flags
);
1014 set_bit(SLF_ESCAPE
, &sl
->flags
);
1017 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
1021 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
1025 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1026 if (sl
->rcount
< sl
->buffsize
) {
1027 sl
->rbuff
[sl
->rcount
++] = s
;
1030 sl
->rx_over_errors
++;
1031 set_bit(SLF_ERROR
, &sl
->flags
);
1036 #ifdef CONFIG_SLIP_MODE_SLIP6
1037 /************************************************************************
1038 * 6 BIT SLIP ENCAPSULATION *
1039 ************************************************************************/
1041 static int slip_esc6(unsigned char *s
, unsigned char *d
, int len
)
1043 unsigned char *ptr
= d
;
1046 unsigned short v
= 0;
1050 * Send an initial END character to flush out any
1051 * data that may have accumulated in the receiver
1052 * due to line noise.
1058 * Encode the packet into printable ascii characters
1061 for (i
= 0; i
< len
; ++i
) {
1062 v
= (v
<< 8) | s
[i
];
1066 c
= 0x30 + ((v
>> bits
) & 0x3F);
1071 c
= 0x30 + ((v
<< (6 - bits
)) & 0x3F);
1078 static void slip_unesc6(struct slip
*sl
, unsigned char s
)
1083 #ifdef CONFIG_SLIP_SMART
1084 /* drop keeptest bit = VSV */
1085 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1086 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1089 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
)
1090 && (sl
->rcount
> 2))
1095 } else if (s
>= 0x30 && s
< 0x70) {
1096 sl
->xdata
= (sl
->xdata
<< 6) | ((s
- 0x30) & 0x3F);
1098 if (sl
->xbits
>= 8) {
1100 c
= (unsigned char)(sl
->xdata
>> sl
->xbits
);
1101 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1102 if (sl
->rcount
< sl
->buffsize
) {
1103 sl
->rbuff
[sl
->rcount
++] = c
;
1106 sl
->rx_over_errors
++;
1107 set_bit(SLF_ERROR
, &sl
->flags
);
1112 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1114 /* Perform I/O control on an active SLIP channel. */
1115 static int slip_ioctl(struct tty_struct
*tty
, struct file
*file
,
1116 unsigned int cmd
, unsigned long arg
)
1118 struct slip
*sl
= tty
->disc_data
;
1120 int __user
*p
= (int __user
*)arg
;
1122 /* First make sure we're connected. */
1123 if (!sl
|| sl
->magic
!= SLIP_MAGIC
)
1128 tmp
= strlen(sl
->dev
->name
) + 1;
1129 if (copy_to_user((void __user
*)arg
, sl
->dev
->name
, tmp
))
1134 if (put_user(sl
->mode
, p
))
1139 if (get_user(tmp
, p
))
1141 #ifndef SL_INCLUDE_CSLIP
1142 if (tmp
& (SL_MODE_CSLIP
|SL_MODE_ADAPTIVE
))
1145 if ((tmp
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) ==
1146 (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
))
1147 /* return -EINVAL; */
1148 tmp
&= ~SL_MODE_ADAPTIVE
;
1150 #ifndef CONFIG_SLIP_MODE_SLIP6
1151 if (tmp
& SL_MODE_SLIP6
)
1155 sl
->dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
1161 #ifdef CONFIG_SLIP_SMART
1162 /* VSV changes start here */
1163 case SIOCSKEEPALIVE
:
1164 if (get_user(tmp
, p
))
1166 if (tmp
> 255) /* max for unchar */
1169 spin_lock_bh(&sl
->lock
);
1171 spin_unlock_bh(&sl
->lock
);
1174 sl
->keepalive
= (u8
)tmp
;
1175 if (sl
->keepalive
!= 0) {
1176 mod_timer(&sl
->keepalive_timer
,
1177 jiffies
+ sl
->keepalive
* HZ
);
1178 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1180 del_timer(&sl
->keepalive_timer
);
1181 spin_unlock_bh(&sl
->lock
);
1184 case SIOCGKEEPALIVE
:
1185 if (put_user(sl
->keepalive
, p
))
1190 if (get_user(tmp
, p
))
1192 if (tmp
> 255) /* max for unchar */
1194 spin_lock_bh(&sl
->lock
);
1196 spin_unlock_bh(&sl
->lock
);
1199 sl
->outfill
= (u8
)tmp
;
1200 if (sl
->outfill
!= 0) {
1201 mod_timer(&sl
->outfill_timer
,
1202 jiffies
+ sl
->outfill
* HZ
);
1203 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1205 del_timer(&sl
->outfill_timer
);
1206 spin_unlock_bh(&sl
->lock
);
1210 if (put_user(sl
->outfill
, p
))
1213 /* VSV changes end */
1216 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1220 /* VSV changes start here */
1221 #ifdef CONFIG_SLIP_SMART
1222 /* function do_ioctl called from net/core/dev.c
1223 to allow get/set outfill/keepalive parameter
1226 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1228 struct slip
*sl
= netdev_priv(dev
);
1229 unsigned long *p
= (unsigned long *)&rq
->ifr_ifru
;
1231 if (sl
== NULL
) /* Allocation failed ?? */
1234 spin_lock_bh(&sl
->lock
);
1237 spin_unlock_bh(&sl
->lock
);
1242 case SIOCSKEEPALIVE
:
1243 /* max for unchar */
1244 if ((unsigned)*p
> 255) {
1245 spin_unlock_bh(&sl
->lock
);
1248 sl
->keepalive
= (u8
)*p
;
1249 if (sl
->keepalive
!= 0) {
1250 sl
->keepalive_timer
.expires
=
1251 jiffies
+ sl
->keepalive
* HZ
;
1252 mod_timer(&sl
->keepalive_timer
,
1253 jiffies
+ sl
->keepalive
* HZ
);
1254 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1256 del_timer(&sl
->keepalive_timer
);
1259 case SIOCGKEEPALIVE
:
1264 if ((unsigned)*p
> 255) { /* max for unchar */
1265 spin_unlock_bh(&sl
->lock
);
1268 sl
->outfill
= (u8
)*p
;
1269 if (sl
->outfill
!= 0) {
1270 mod_timer(&sl
->outfill_timer
,
1271 jiffies
+ sl
->outfill
* HZ
);
1272 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1274 del_timer(&sl
->outfill_timer
);
1282 /* Resolve race condition, when ioctl'ing hanged up
1283 and opened by another process device.
1285 if (sl
->tty
!= current
->signal
->tty
&&
1286 sl
->pid
!= current
->pid
) {
1287 spin_unlock_bh(&sl
->lock
);
1298 spin_unlock_bh(&sl
->lock
);
1302 /* VSV changes end */
1304 static struct tty_ldisc sl_ldisc
= {
1305 .owner
= THIS_MODULE
,
1306 .magic
= TTY_LDISC_MAGIC
,
1309 .close
= slip_close
,
1310 .ioctl
= slip_ioctl
,
1311 .receive_buf
= slip_receive_buf
,
1312 .write_wakeup
= slip_write_wakeup
,
1315 static int __init
slip_init(void)
1319 if (slip_maxdev
< 4)
1320 slip_maxdev
= 4; /* Sanity */
1322 printk(KERN_INFO
"SLIP: version %s (dynamic channels, max=%d)"
1323 #ifdef CONFIG_SLIP_MODE_SLIP6
1324 " (6 bit encapsulation enabled)"
1327 SLIP_VERSION
, slip_maxdev
);
1328 #if defined(SL_INCLUDE_CSLIP)
1329 printk(KERN_INFO
"CSLIP: code copyright 1989 Regents of the University of California.\n");
1331 #ifdef CONFIG_SLIP_SMART
1332 printk(KERN_INFO
"SLIP linefill/keepalive option.\n");
1335 slip_devs
= kzalloc(sizeof(struct net_device
*)*slip_maxdev
,
1338 printk(KERN_ERR
"SLIP: Can't allocate slip devices array.\n");
1342 /* Fill in our line protocol discipline, and register it */
1343 status
= tty_register_ldisc(N_SLIP
, &sl_ldisc
);
1345 printk(KERN_ERR
"SLIP: can't register line discipline (err = %d)\n", status
);
1351 static void __exit
slip_exit(void)
1354 struct net_device
*dev
;
1356 unsigned long timeout
= jiffies
+ HZ
;
1359 if (slip_devs
== NULL
)
1362 /* First of all: check for active disciplines and hangup them.
1366 msleep_interruptible(100);
1369 for (i
= 0; i
< slip_maxdev
; i
++) {
1373 sl
= netdev_priv(dev
);
1374 spin_lock_bh(&sl
->lock
);
1377 tty_hangup(sl
->tty
);
1379 spin_unlock_bh(&sl
->lock
);
1381 } while (busy
&& time_before(jiffies
, timeout
));
1384 for (i
= 0; i
< slip_maxdev
; i
++) {
1388 slip_devs
[i
] = NULL
;
1390 sl
= netdev_priv(dev
);
1392 printk(KERN_ERR
"%s: tty discipline still running\n",
1394 /* Intentionally leak the control block. */
1395 dev
->destructor
= NULL
;
1398 unregister_netdev(dev
);
1404 i
= tty_unregister_ldisc(N_SLIP
);
1406 printk(KERN_ERR
"SLIP: can't unregister line discipline (err = %d)\n", i
);
1409 module_init(slip_init
);
1410 module_exit(slip_exit
);
1412 #ifdef CONFIG_SLIP_SMART
1414 * This is start of the code for multislip style line checking
1415 * added by Stanislav Voronyi. All changes before marked VSV
1418 static void sl_outfill(unsigned long sls
)
1420 struct slip
*sl
= (struct slip
*)sls
;
1422 spin_lock(&sl
->lock
);
1424 if (sl
->tty
== NULL
)
1428 if (test_bit(SLF_OUTWAIT
, &sl
->flags
)) {
1429 /* no packets were transmitted, do outfill */
1430 #ifdef CONFIG_SLIP_MODE_SLIP6
1431 unsigned char s
= (sl
->mode
& SL_MODE_SLIP6
)?0x70:END
;
1433 unsigned char s
= END
;
1435 /* put END into tty queue. Is it right ??? */
1436 if (!netif_queue_stopped(sl
->dev
)) {
1437 /* if device busy no outfill */
1438 sl
->tty
->ops
->write(sl
->tty
, &s
, 1);
1441 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1443 mod_timer(&sl
->outfill_timer
, jiffies
+sl
->outfill
*HZ
);
1446 spin_unlock(&sl
->lock
);
1449 static void sl_keepalive(unsigned long sls
)
1451 struct slip
*sl
= (struct slip
*)sls
;
1453 spin_lock(&sl
->lock
);
1455 if (sl
->tty
== NULL
)
1458 if (sl
->keepalive
) {
1459 if (test_bit(SLF_KEEPTEST
, &sl
->flags
)) {
1460 /* keepalive still high :(, we must hangup */
1462 /* outfill timer must be deleted too */
1463 (void)del_timer(&sl
->outfill_timer
);
1464 printk(KERN_DEBUG
"%s: no packets received during keepalive timeout, hangup.\n", sl
->dev
->name
);
1465 /* this must hangup tty & close slip */
1466 tty_hangup(sl
->tty
);
1467 /* I think we need not something else */
1470 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1472 mod_timer(&sl
->keepalive_timer
, jiffies
+sl
->keepalive
*HZ
);
1475 spin_unlock(&sl
->lock
);
1479 MODULE_LICENSE("GPL");
1480 MODULE_ALIAS_LDISC(N_SLIP
);
This page took 0.060202 seconds and 5 git commands to generate.