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/sched.h>
71 #include <linux/string.h>
73 #include <linux/interrupt.h>
75 #include <linux/tty.h>
76 #include <linux/errno.h>
77 #include <linux/netdevice.h>
78 #include <linux/etherdevice.h>
79 #include <linux/skbuff.h>
80 #include <linux/rtnetlink.h>
81 #include <linux/if_arp.h>
82 #include <linux/if_slip.h>
83 #include <linux/compat.h>
84 #include <linux/delay.h>
85 #include <linux/init.h>
89 #include <linux/tcp.h>
90 #include <net/slhc_vj.h>
93 #define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
95 static struct net_device
**slip_devs
;
97 static int slip_maxdev
= SL_NRUNIT
;
98 module_param(slip_maxdev
, int, 0);
99 MODULE_PARM_DESC(slip_maxdev
, "Maximum number of slip devices");
101 static int slip_esc(unsigned char *p
, unsigned char *d
, int len
);
102 static void slip_unesc(struct slip
*sl
, unsigned char c
);
103 #ifdef CONFIG_SLIP_MODE_SLIP6
104 static int slip_esc6(unsigned char *p
, unsigned char *d
, int len
);
105 static void slip_unesc6(struct slip
*sl
, unsigned char c
);
107 #ifdef CONFIG_SLIP_SMART
108 static void sl_keepalive(unsigned long sls
);
109 static void sl_outfill(unsigned long sls
);
110 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
113 /********************************
114 * Buffer administration routines:
119 * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
120 * sl_realloc_bufs provides strong atomicity and reallocation
121 * on actively running device.
122 *********************************/
125 Allocate channel buffers.
128 static int sl_alloc_bufs(struct slip
*sl
, int mtu
)
134 #ifdef SL_INCLUDE_CSLIP
136 struct slcompress
*slcomp
= NULL
;
140 * Allocate the SLIP frame buffers:
142 * rbuff Receive buffer.
143 * xbuff Transmit buffer.
144 * cbuff Temporary compression buffer.
149 * allow for arrival of larger UDP packets, even if we say not to
150 * also fixes a bug in which SunOS sends 512-byte packets even with
155 rbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
158 xbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
161 #ifdef SL_INCLUDE_CSLIP
162 cbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
165 slcomp
= slhc_init(16, 16);
169 spin_lock_bh(&sl
->lock
);
170 if (sl
->tty
== NULL
) {
171 spin_unlock_bh(&sl
->lock
);
179 rbuff
= xchg(&sl
->rbuff
, rbuff
);
180 xbuff
= xchg(&sl
->xbuff
, xbuff
);
181 #ifdef SL_INCLUDE_CSLIP
182 cbuff
= xchg(&sl
->cbuff
, cbuff
);
183 slcomp
= xchg(&sl
->slcomp
, slcomp
);
184 #ifdef CONFIG_SLIP_MODE_SLIP6
189 spin_unlock_bh(&sl
->lock
);
194 #ifdef SL_INCLUDE_CSLIP
204 /* Free a SLIP channel buffers. */
205 static void sl_free_bufs(struct slip
*sl
)
207 /* Free all SLIP frame buffers. */
208 kfree(xchg(&sl
->rbuff
, NULL
));
209 kfree(xchg(&sl
->xbuff
, NULL
));
210 #ifdef SL_INCLUDE_CSLIP
211 kfree(xchg(&sl
->cbuff
, NULL
));
212 slhc_free(xchg(&sl
->slcomp
, NULL
));
217 Reallocate slip channel buffers.
220 static int sl_realloc_bufs(struct slip
*sl
, int mtu
)
223 struct net_device
*dev
= sl
->dev
;
224 unsigned char *xbuff
, *rbuff
;
225 #ifdef SL_INCLUDE_CSLIP
226 unsigned char *cbuff
;
231 * allow for arrival of larger UDP packets, even if we say not to
232 * also fixes a bug in which SunOS sends 512-byte packets even with
238 xbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
239 rbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
240 #ifdef SL_INCLUDE_CSLIP
241 cbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
245 #ifdef SL_INCLUDE_CSLIP
246 if (xbuff
== NULL
|| rbuff
== NULL
|| cbuff
== NULL
) {
248 if (xbuff
== NULL
|| rbuff
== NULL
) {
250 if (mtu
>= sl
->mtu
) {
251 printk(KERN_WARNING
"%s: unable to grow slip buffers, MTU change cancelled.\n",
257 spin_lock_bh(&sl
->lock
);
263 xbuff
= xchg(&sl
->xbuff
, xbuff
);
264 rbuff
= xchg(&sl
->rbuff
, rbuff
);
265 #ifdef SL_INCLUDE_CSLIP
266 cbuff
= xchg(&sl
->cbuff
, cbuff
);
269 if (sl
->xleft
<= len
) {
270 memcpy(sl
->xbuff
, sl
->xhead
, sl
->xleft
);
276 sl
->xhead
= sl
->xbuff
;
279 if (sl
->rcount
<= len
) {
280 memcpy(sl
->rbuff
, rbuff
, sl
->rcount
);
283 sl
->rx_over_errors
++;
284 set_bit(SLF_ERROR
, &sl
->flags
);
293 spin_unlock_bh(&sl
->lock
);
298 #ifdef SL_INCLUDE_CSLIP
305 /* Set the "sending" flag. This must be atomic hence the set_bit. */
306 static inline void sl_lock(struct slip
*sl
)
308 netif_stop_queue(sl
->dev
);
312 /* Clear the "sending" flag. This must be atomic, hence the ASM. */
313 static inline void sl_unlock(struct slip
*sl
)
315 netif_wake_queue(sl
->dev
);
318 /* Send one completely decapsulated IP datagram to the IP layer. */
319 static void sl_bump(struct slip
*sl
)
325 #ifdef SL_INCLUDE_CSLIP
326 if (sl
->mode
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) {
327 unsigned char c
= sl
->rbuff
[0];
328 if (c
& SL_TYPE_COMPRESSED_TCP
) {
329 /* ignore compressed packets when CSLIP is off */
330 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
331 printk(KERN_WARNING
"%s: compressed packet ignored\n", sl
->dev
->name
);
334 /* make sure we've reserved enough space for uncompress
336 if (count
+ 80 > sl
->buffsize
) {
337 sl
->rx_over_errors
++;
340 count
= slhc_uncompress(sl
->slcomp
, sl
->rbuff
, count
);
343 } else if (c
>= SL_TYPE_UNCOMPRESSED_TCP
) {
344 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
345 /* turn on header compression */
346 sl
->mode
|= SL_MODE_CSLIP
;
347 sl
->mode
&= ~SL_MODE_ADAPTIVE
;
348 printk(KERN_INFO
"%s: header compression turned on\n", sl
->dev
->name
);
350 sl
->rbuff
[0] &= 0x4f;
351 if (slhc_remember(sl
->slcomp
, sl
->rbuff
, count
) <= 0)
355 #endif /* SL_INCLUDE_CSLIP */
357 sl
->rx_bytes
+= count
;
359 skb
= dev_alloc_skb(count
);
361 printk(KERN_WARNING
"%s: memory squeeze, dropping packet.\n", sl
->dev
->name
);
366 memcpy(skb_put(skb
, count
), sl
->rbuff
, count
);
367 skb_reset_mac_header(skb
);
368 skb
->protocol
= htons(ETH_P_IP
);
373 /* Encapsulate one IP datagram and stuff into a TTY queue. */
374 static void sl_encaps(struct slip
*sl
, unsigned char *icp
, int len
)
379 if (len
> sl
->mtu
) { /* Sigh, shouldn't occur BUT ... */
380 printk(KERN_WARNING
"%s: truncating oversized transmit packet!\n", sl
->dev
->name
);
387 #ifdef SL_INCLUDE_CSLIP
388 if (sl
->mode
& SL_MODE_CSLIP
)
389 len
= slhc_compress(sl
->slcomp
, p
, len
, sl
->cbuff
, &p
, 1);
391 #ifdef CONFIG_SLIP_MODE_SLIP6
392 if (sl
->mode
& SL_MODE_SLIP6
)
393 count
= slip_esc6(p
, (unsigned char *) sl
->xbuff
, len
);
396 count
= slip_esc(p
, (unsigned char *) sl
->xbuff
, len
);
398 /* Order of next two lines is *very* important.
399 * When we are sending a little amount of data,
400 * the transfer may be completed inside the ops->write()
401 * routine, because it's running with interrupts enabled.
402 * In this case we *never* got WRITE_WAKEUP event,
403 * if we did not request it before write operation.
404 * 14 Oct 1994 Dmitry Gorodchanin.
406 set_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
407 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xbuff
, count
);
408 #ifdef SL_CHECK_TRANSMIT
409 sl
->dev
->trans_start
= jiffies
;
411 sl
->xleft
= count
- actual
;
412 sl
->xhead
= sl
->xbuff
+ actual
;
413 #ifdef CONFIG_SLIP_SMART
415 clear_bit(SLF_OUTWAIT
, &sl
->flags
); /* reset outfill flag */
420 * Called by the driver when there's room for more data. If we have
421 * more packets to send, we send them here.
423 static void slip_write_wakeup(struct tty_struct
*tty
)
426 struct slip
*sl
= tty
->disc_data
;
428 /* First make sure we're connected. */
429 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
432 if (sl
->xleft
<= 0) {
433 /* Now serial buffer is almost free & we can start
434 * transmission of another packet */
436 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
441 actual
= tty
->ops
->write(tty
, sl
->xhead
, sl
->xleft
);
446 static void sl_tx_timeout(struct net_device
*dev
)
448 struct slip
*sl
= netdev_priv(dev
);
450 spin_lock(&sl
->lock
);
452 if (netif_queue_stopped(dev
)) {
453 if (!netif_running(dev
))
456 /* May be we must check transmitter timeout here ?
457 * 14 Oct 1994 Dmitry Gorodchanin.
459 #ifdef SL_CHECK_TRANSMIT
460 if (time_before(jiffies
, dev
->trans_start
+ 20 * HZ
)) {
461 /* 20 sec timeout not reached */
464 printk(KERN_WARNING
"%s: transmit timed out, %s?\n",
466 (tty_chars_in_buffer(sl
->tty
) || sl
->xleft
) ?
467 "bad line quality" : "driver error");
469 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
474 spin_unlock(&sl
->lock
);
478 /* Encapsulate an IP datagram and kick it into a TTY queue. */
480 sl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
482 struct slip
*sl
= netdev_priv(dev
);
484 spin_lock(&sl
->lock
);
485 if (!netif_running(dev
)) {
486 spin_unlock(&sl
->lock
);
487 printk(KERN_WARNING
"%s: xmit call when iface is down\n", dev
->name
);
491 if (sl
->tty
== NULL
) {
492 spin_unlock(&sl
->lock
);
498 sl
->tx_bytes
+= skb
->len
;
499 sl_encaps(sl
, skb
->data
, skb
->len
);
500 spin_unlock(&sl
->lock
);
507 /******************************************
508 * Routines looking at netdevice side.
509 ******************************************/
511 /* Netdevice UP -> DOWN routine */
514 sl_close(struct net_device
*dev
)
516 struct slip
*sl
= netdev_priv(dev
);
518 spin_lock_bh(&sl
->lock
);
520 /* TTY discipline is running. */
521 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
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
->watchdog_timeo
= 20*HZ
;
614 static void sl_uninit(struct net_device
*dev
)
616 struct slip
*sl
= netdev_priv(dev
);
621 /* Hook the destructor so we can free slip devices at the right point in time */
622 static void sl_free_netdev(struct net_device
*dev
)
624 int i
= dev
->base_addr
;
629 static const struct net_device_ops sl_netdev_ops
= {
631 .ndo_uninit
= sl_uninit
,
633 .ndo_stop
= sl_close
,
634 .ndo_start_xmit
= sl_xmit
,
635 .ndo_get_stats
= sl_get_stats
,
636 .ndo_change_mtu
= sl_change_mtu
,
637 .ndo_tx_timeout
= sl_tx_timeout
,
638 #ifdef CONFIG_SLIP_SMART
639 .ndo_do_ioctl
= sl_ioctl
,
644 static void sl_setup(struct net_device
*dev
)
646 dev
->netdev_ops
= &sl_netdev_ops
;
647 dev
->destructor
= sl_free_netdev
;
649 dev
->hard_header_len
= 0;
651 dev
->tx_queue_len
= 10;
653 /* New-style flags. */
654 dev
->flags
= IFF_NOARP
|IFF_POINTOPOINT
|IFF_MULTICAST
;
657 /******************************************
658 Routines looking at TTY side.
659 ******************************************/
663 * Handle the 'receiver data ready' interrupt.
664 * This function is called by the 'tty_io' module in the kernel when
665 * a block of SLIP data has been received, which can now be decapsulated
666 * and sent on to some IP layer for further processing. This will not
667 * be re-entered while running but other ldisc functions may be called
671 static void slip_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
674 struct slip
*sl
= tty
->disc_data
;
676 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
679 /* Read the characters out of the buffer */
682 if (!test_and_set_bit(SLF_ERROR
, &sl
->flags
))
687 #ifdef CONFIG_SLIP_MODE_SLIP6
688 if (sl
->mode
& SL_MODE_SLIP6
)
689 slip_unesc6(sl
, *cp
++);
692 slip_unesc(sl
, *cp
++);
696 /************************************
697 * slip_open helper routines.
698 ************************************/
700 /* Collect hanged up channels */
701 static void sl_sync(void)
704 struct net_device
*dev
;
707 for (i
= 0; i
< slip_maxdev
; i
++) {
712 sl
= netdev_priv(dev
);
713 if (sl
->tty
|| sl
->leased
)
715 if (dev
->flags
& IFF_UP
)
721 /* Find a free SLIP channel, and link in this `tty' line. */
722 static struct slip
*sl_alloc(dev_t line
)
725 struct net_device
*dev
= NULL
;
728 if (slip_devs
== NULL
)
729 return NULL
; /* Master array missing ! */
731 for (i
= 0; i
< slip_maxdev
; i
++) {
736 /* Sorry, too many, all slots in use */
737 if (i
>= slip_maxdev
)
741 sl
= netdev_priv(dev
);
742 if (test_bit(SLF_INUSE
, &sl
->flags
)) {
743 unregister_netdevice(dev
);
751 sprintf(name
, "sl%d", i
);
753 dev
= alloc_netdev(sizeof(*sl
), name
, sl_setup
);
759 sl
= netdev_priv(dev
);
761 /* Initialize channel control data */
762 sl
->magic
= SLIP_MAGIC
;
764 spin_lock_init(&sl
->lock
);
765 sl
->mode
= SL_MODE_DEFAULT
;
766 #ifdef CONFIG_SLIP_SMART
767 /* initialize timer_list struct */
768 init_timer(&sl
->keepalive_timer
);
769 sl
->keepalive_timer
.data
= (unsigned long)sl
;
770 sl
->keepalive_timer
.function
= sl_keepalive
;
771 init_timer(&sl
->outfill_timer
);
772 sl
->outfill_timer
.data
= (unsigned long)sl
;
773 sl
->outfill_timer
.function
= sl_outfill
;
780 * Open the high-level part of the SLIP channel.
781 * This function is called by the TTY module when the
782 * SLIP line discipline is called for. Because we are
783 * sure the tty line exists, we only have to link it to
784 * a free SLIP channel...
786 * Called in process context serialized from other ldisc calls.
789 static int slip_open(struct tty_struct
*tty
)
794 if (!capable(CAP_NET_ADMIN
))
797 if (tty
->ops
->write
== NULL
)
800 /* RTnetlink lock is misused here to serialize concurrent
801 opens of slip channels. There are better ways, but it is
806 /* Collect hanged up channels. */
812 /* First make sure we're not already connected. */
813 if (sl
&& sl
->magic
== SLIP_MAGIC
)
816 /* OK. Find a free SLIP channel to use. */
818 sl
= sl_alloc(tty_devnum(tty
));
824 sl
->line
= tty_devnum(tty
);
825 sl
->pid
= current
->pid
;
827 if (!test_bit(SLF_INUSE
, &sl
->flags
)) {
828 /* Perform the low-level SLIP initialization. */
829 err
= sl_alloc_bufs(sl
, SL_MTU
);
833 set_bit(SLF_INUSE
, &sl
->flags
);
835 err
= register_netdevice(sl
->dev
);
840 #ifdef CONFIG_SLIP_SMART
842 sl
->keepalive_timer
.expires
= jiffies
+ sl
->keepalive
* HZ
;
843 add_timer(&sl
->keepalive_timer
);
846 sl
->outfill_timer
.expires
= jiffies
+ sl
->outfill
* HZ
;
847 add_timer(&sl
->outfill_timer
);
851 /* Done. We have linked the TTY line to a channel. */
853 tty
->receive_room
= 65536; /* We don't flow control */
854 return sl
->dev
->base_addr
;
861 tty
->disc_data
= NULL
;
862 clear_bit(SLF_INUSE
, &sl
->flags
);
867 /* Count references from TTY module */
872 * Close down a SLIP channel.
873 * This means flushing out any pending queues, and then returning. This
874 * call is serialized against other ldisc functions.
876 * We also use this method fo a hangup event
879 static void slip_close(struct tty_struct
*tty
)
881 struct slip
*sl
= tty
->disc_data
;
883 /* First make sure we're connected. */
884 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| sl
->tty
!= tty
)
887 tty
->disc_data
= NULL
;
892 /* VSV = very important to remove timers */
893 #ifdef CONFIG_SLIP_SMART
894 del_timer_sync(&sl
->keepalive_timer
);
895 del_timer_sync(&sl
->outfill_timer
);
897 /* Flush network side */
898 unregister_netdev(sl
->dev
);
899 /* This will complete via sl_free_netdev */
902 static int slip_hangup(struct tty_struct
*tty
)
907 /************************************************************************
908 * STANDARD SLIP ENCAPSULATION *
909 ************************************************************************/
911 static int slip_esc(unsigned char *s
, unsigned char *d
, int len
)
913 unsigned char *ptr
= d
;
917 * Send an initial END character to flush out any
918 * data that may have accumulated in the receiver
925 * For each byte in the packet, send the appropriate
926 * character sequence, according to the SLIP protocol.
948 static void slip_unesc(struct slip
*sl
, unsigned char s
)
953 #ifdef CONFIG_SLIP_SMART
954 /* drop keeptest bit = VSV */
955 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
956 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
959 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
) &&
962 clear_bit(SLF_ESCAPE
, &sl
->flags
);
967 set_bit(SLF_ESCAPE
, &sl
->flags
);
970 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
974 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
978 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
979 if (sl
->rcount
< sl
->buffsize
) {
980 sl
->rbuff
[sl
->rcount
++] = s
;
983 sl
->rx_over_errors
++;
984 set_bit(SLF_ERROR
, &sl
->flags
);
989 #ifdef CONFIG_SLIP_MODE_SLIP6
990 /************************************************************************
991 * 6 BIT SLIP ENCAPSULATION *
992 ************************************************************************/
994 static int slip_esc6(unsigned char *s
, unsigned char *d
, int len
)
996 unsigned char *ptr
= d
;
999 unsigned short v
= 0;
1003 * Send an initial END character to flush out any
1004 * data that may have accumulated in the receiver
1005 * due to line noise.
1011 * Encode the packet into printable ascii characters
1014 for (i
= 0; i
< len
; ++i
) {
1015 v
= (v
<< 8) | s
[i
];
1019 c
= 0x30 + ((v
>> bits
) & 0x3F);
1024 c
= 0x30 + ((v
<< (6 - bits
)) & 0x3F);
1031 static void slip_unesc6(struct slip
*sl
, unsigned char s
)
1036 #ifdef CONFIG_SLIP_SMART
1037 /* drop keeptest bit = VSV */
1038 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1039 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1042 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
) &&
1048 } else if (s
>= 0x30 && s
< 0x70) {
1049 sl
->xdata
= (sl
->xdata
<< 6) | ((s
- 0x30) & 0x3F);
1051 if (sl
->xbits
>= 8) {
1053 c
= (unsigned char)(sl
->xdata
>> sl
->xbits
);
1054 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1055 if (sl
->rcount
< sl
->buffsize
) {
1056 sl
->rbuff
[sl
->rcount
++] = c
;
1059 sl
->rx_over_errors
++;
1060 set_bit(SLF_ERROR
, &sl
->flags
);
1065 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1067 /* Perform I/O control on an active SLIP channel. */
1068 static int slip_ioctl(struct tty_struct
*tty
, struct file
*file
,
1069 unsigned int cmd
, unsigned long arg
)
1071 struct slip
*sl
= tty
->disc_data
;
1073 int __user
*p
= (int __user
*)arg
;
1075 /* First make sure we're connected. */
1076 if (!sl
|| sl
->magic
!= SLIP_MAGIC
)
1081 tmp
= strlen(sl
->dev
->name
) + 1;
1082 if (copy_to_user((void __user
*)arg
, sl
->dev
->name
, tmp
))
1087 if (put_user(sl
->mode
, p
))
1092 if (get_user(tmp
, p
))
1094 #ifndef SL_INCLUDE_CSLIP
1095 if (tmp
& (SL_MODE_CSLIP
|SL_MODE_ADAPTIVE
))
1098 if ((tmp
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) ==
1099 (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
))
1100 /* return -EINVAL; */
1101 tmp
&= ~SL_MODE_ADAPTIVE
;
1103 #ifndef CONFIG_SLIP_MODE_SLIP6
1104 if (tmp
& SL_MODE_SLIP6
)
1108 sl
->dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
1114 #ifdef CONFIG_SLIP_SMART
1115 /* VSV changes start here */
1116 case SIOCSKEEPALIVE
:
1117 if (get_user(tmp
, p
))
1119 if (tmp
> 255) /* max for unchar */
1122 spin_lock_bh(&sl
->lock
);
1124 spin_unlock_bh(&sl
->lock
);
1127 sl
->keepalive
= (u8
)tmp
;
1128 if (sl
->keepalive
!= 0) {
1129 mod_timer(&sl
->keepalive_timer
,
1130 jiffies
+ sl
->keepalive
* HZ
);
1131 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1133 del_timer(&sl
->keepalive_timer
);
1134 spin_unlock_bh(&sl
->lock
);
1137 case SIOCGKEEPALIVE
:
1138 if (put_user(sl
->keepalive
, p
))
1143 if (get_user(tmp
, p
))
1145 if (tmp
> 255) /* max for unchar */
1147 spin_lock_bh(&sl
->lock
);
1149 spin_unlock_bh(&sl
->lock
);
1152 sl
->outfill
= (u8
)tmp
;
1153 if (sl
->outfill
!= 0) {
1154 mod_timer(&sl
->outfill_timer
,
1155 jiffies
+ sl
->outfill
* HZ
);
1156 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1158 del_timer(&sl
->outfill_timer
);
1159 spin_unlock_bh(&sl
->lock
);
1163 if (put_user(sl
->outfill
, p
))
1166 /* VSV changes end */
1169 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1173 #ifdef CONFIG_COMPAT
1174 static long slip_compat_ioctl(struct tty_struct
*tty
, struct file
*file
,
1175 unsigned int cmd
, unsigned long arg
)
1182 case SIOCSKEEPALIVE
:
1183 case SIOCGKEEPALIVE
:
1186 return slip_ioctl(tty
, file
, cmd
,
1187 (unsigned long)compat_ptr(arg
));
1190 return -ENOIOCTLCMD
;
1194 /* VSV changes start here */
1195 #ifdef CONFIG_SLIP_SMART
1196 /* function do_ioctl called from net/core/dev.c
1197 to allow get/set outfill/keepalive parameter
1200 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1202 struct slip
*sl
= netdev_priv(dev
);
1203 unsigned long *p
= (unsigned long *)&rq
->ifr_ifru
;
1205 if (sl
== NULL
) /* Allocation failed ?? */
1208 spin_lock_bh(&sl
->lock
);
1211 spin_unlock_bh(&sl
->lock
);
1216 case SIOCSKEEPALIVE
:
1217 /* max for unchar */
1218 if ((unsigned)*p
> 255) {
1219 spin_unlock_bh(&sl
->lock
);
1222 sl
->keepalive
= (u8
)*p
;
1223 if (sl
->keepalive
!= 0) {
1224 sl
->keepalive_timer
.expires
=
1225 jiffies
+ sl
->keepalive
* HZ
;
1226 mod_timer(&sl
->keepalive_timer
,
1227 jiffies
+ sl
->keepalive
* HZ
);
1228 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1230 del_timer(&sl
->keepalive_timer
);
1233 case SIOCGKEEPALIVE
:
1238 if ((unsigned)*p
> 255) { /* max for unchar */
1239 spin_unlock_bh(&sl
->lock
);
1242 sl
->outfill
= (u8
)*p
;
1243 if (sl
->outfill
!= 0) {
1244 mod_timer(&sl
->outfill_timer
,
1245 jiffies
+ sl
->outfill
* HZ
);
1246 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1248 del_timer(&sl
->outfill_timer
);
1256 /* Resolve race condition, when ioctl'ing hanged up
1257 and opened by another process device.
1259 if (sl
->tty
!= current
->signal
->tty
&&
1260 sl
->pid
!= current
->pid
) {
1261 spin_unlock_bh(&sl
->lock
);
1272 spin_unlock_bh(&sl
->lock
);
1276 /* VSV changes end */
1278 static struct tty_ldisc_ops sl_ldisc
= {
1279 .owner
= THIS_MODULE
,
1280 .magic
= TTY_LDISC_MAGIC
,
1283 .close
= slip_close
,
1284 .hangup
= slip_hangup
,
1285 .ioctl
= slip_ioctl
,
1286 #ifdef CONFIG_COMPAT
1287 .compat_ioctl
= slip_compat_ioctl
,
1289 .receive_buf
= slip_receive_buf
,
1290 .write_wakeup
= slip_write_wakeup
,
1293 static int __init
slip_init(void)
1297 if (slip_maxdev
< 4)
1298 slip_maxdev
= 4; /* Sanity */
1300 printk(KERN_INFO
"SLIP: version %s (dynamic channels, max=%d)"
1301 #ifdef CONFIG_SLIP_MODE_SLIP6
1302 " (6 bit encapsulation enabled)"
1305 SLIP_VERSION
, slip_maxdev
);
1306 #if defined(SL_INCLUDE_CSLIP)
1307 printk(KERN_INFO
"CSLIP: code copyright 1989 Regents of the University of California.\n");
1309 #ifdef CONFIG_SLIP_SMART
1310 printk(KERN_INFO
"SLIP linefill/keepalive option.\n");
1313 slip_devs
= kzalloc(sizeof(struct net_device
*)*slip_maxdev
,
1316 printk(KERN_ERR
"SLIP: Can't allocate slip devices array.\n");
1320 /* Fill in our line protocol discipline, and register it */
1321 status
= tty_register_ldisc(N_SLIP
, &sl_ldisc
);
1323 printk(KERN_ERR
"SLIP: can't register line discipline (err = %d)\n", status
);
1329 static void __exit
slip_exit(void)
1332 struct net_device
*dev
;
1334 unsigned long timeout
= jiffies
+ HZ
;
1337 if (slip_devs
== NULL
)
1340 /* First of all: check for active disciplines and hangup them.
1344 msleep_interruptible(100);
1347 for (i
= 0; i
< slip_maxdev
; i
++) {
1351 sl
= netdev_priv(dev
);
1352 spin_lock_bh(&sl
->lock
);
1355 tty_hangup(sl
->tty
);
1357 spin_unlock_bh(&sl
->lock
);
1359 } while (busy
&& time_before(jiffies
, timeout
));
1361 /* FIXME: hangup is async so we should wait when doing this second
1364 for (i
= 0; i
< slip_maxdev
; i
++) {
1368 slip_devs
[i
] = NULL
;
1370 sl
= netdev_priv(dev
);
1372 printk(KERN_ERR
"%s: tty discipline still running\n",
1374 /* Intentionally leak the control block. */
1375 dev
->destructor
= NULL
;
1378 unregister_netdev(dev
);
1384 i
= tty_unregister_ldisc(N_SLIP
);
1386 printk(KERN_ERR
"SLIP: can't unregister line discipline (err = %d)\n", i
);
1389 module_init(slip_init
);
1390 module_exit(slip_exit
);
1392 #ifdef CONFIG_SLIP_SMART
1394 * This is start of the code for multislip style line checking
1395 * added by Stanislav Voronyi. All changes before marked VSV
1398 static void sl_outfill(unsigned long sls
)
1400 struct slip
*sl
= (struct slip
*)sls
;
1402 spin_lock(&sl
->lock
);
1404 if (sl
->tty
== NULL
)
1408 if (test_bit(SLF_OUTWAIT
, &sl
->flags
)) {
1409 /* no packets were transmitted, do outfill */
1410 #ifdef CONFIG_SLIP_MODE_SLIP6
1411 unsigned char s
= (sl
->mode
& SL_MODE_SLIP6
)?0x70:END
;
1413 unsigned char s
= END
;
1415 /* put END into tty queue. Is it right ??? */
1416 if (!netif_queue_stopped(sl
->dev
)) {
1417 /* if device busy no outfill */
1418 sl
->tty
->ops
->write(sl
->tty
, &s
, 1);
1421 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1423 mod_timer(&sl
->outfill_timer
, jiffies
+sl
->outfill
*HZ
);
1426 spin_unlock(&sl
->lock
);
1429 static void sl_keepalive(unsigned long sls
)
1431 struct slip
*sl
= (struct slip
*)sls
;
1433 spin_lock(&sl
->lock
);
1435 if (sl
->tty
== NULL
)
1438 if (sl
->keepalive
) {
1439 if (test_bit(SLF_KEEPTEST
, &sl
->flags
)) {
1440 /* keepalive still high :(, we must hangup */
1442 /* outfill timer must be deleted too */
1443 (void)del_timer(&sl
->outfill_timer
);
1444 printk(KERN_DEBUG
"%s: no packets received during keepalive timeout, hangup.\n", sl
->dev
->name
);
1445 /* this must hangup tty & close slip */
1446 tty_hangup(sl
->tty
);
1447 /* I think we need not something else */
1450 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1452 mod_timer(&sl
->keepalive_timer
, jiffies
+sl
->keepalive
*HZ
);
1455 spin_unlock(&sl
->lock
);
1459 MODULE_LICENSE("GPL");
1460 MODULE_ALIAS_LDISC(N_SLIP
);