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 <linux/uaccess.h>
68 #include <linux/bitops.h>
69 #include <linux/sched/signal.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/compat.h>
83 #include <linux/delay.h>
84 #include <linux/init.h>
85 #include <linux/slab.h>
86 #include <linux/workqueue.h>
90 #include <linux/tcp.h>
91 #include <net/slhc_vj.h>
94 #define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
96 static struct net_device
**slip_devs
;
98 static int slip_maxdev
= SL_NRUNIT
;
99 module_param(slip_maxdev
, int, 0);
100 MODULE_PARM_DESC(slip_maxdev
, "Maximum number of slip devices");
102 static int slip_esc(unsigned char *p
, unsigned char *d
, int len
);
103 static void slip_unesc(struct slip
*sl
, unsigned char c
);
104 #ifdef CONFIG_SLIP_MODE_SLIP6
105 static int slip_esc6(unsigned char *p
, unsigned char *d
, int len
);
106 static void slip_unesc6(struct slip
*sl
, unsigned char c
);
108 #ifdef CONFIG_SLIP_SMART
109 static void sl_keepalive(struct timer_list
*t
);
110 static void sl_outfill(struct timer_list
*t
);
111 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
114 /********************************
115 * Buffer administration routines:
120 * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
121 * sl_realloc_bufs provides strong atomicity and reallocation
122 * on actively running device.
123 *********************************/
126 Allocate channel buffers.
129 static int sl_alloc_bufs(struct slip
*sl
, int mtu
)
135 #ifdef SL_INCLUDE_CSLIP
137 struct slcompress
*slcomp
= NULL
;
141 * Allocate the SLIP frame buffers:
143 * rbuff Receive buffer.
144 * xbuff Transmit buffer.
145 * cbuff Temporary compression buffer.
150 * allow for arrival of larger UDP packets, even if we say not to
151 * also fixes a bug in which SunOS sends 512-byte packets even with
156 rbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
159 xbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
162 #ifdef SL_INCLUDE_CSLIP
163 cbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
166 slcomp
= slhc_init(16, 16);
170 spin_lock_bh(&sl
->lock
);
171 if (sl
->tty
== NULL
) {
172 spin_unlock_bh(&sl
->lock
);
180 rbuff
= xchg(&sl
->rbuff
, rbuff
);
181 xbuff
= xchg(&sl
->xbuff
, xbuff
);
182 #ifdef SL_INCLUDE_CSLIP
183 cbuff
= xchg(&sl
->cbuff
, cbuff
);
184 slcomp
= xchg(&sl
->slcomp
, slcomp
);
186 #ifdef CONFIG_SLIP_MODE_SLIP6
190 spin_unlock_bh(&sl
->lock
);
195 #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
) {
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
);
273 dev
->stats
.tx_dropped
++;
276 sl
->xhead
= sl
->xbuff
;
279 if (sl
->rcount
<= len
) {
280 memcpy(sl
->rbuff
, rbuff
, sl
->rcount
);
283 dev
->stats
.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
)
321 struct net_device
*dev
= sl
->dev
;
326 #ifdef SL_INCLUDE_CSLIP
327 if (sl
->mode
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) {
328 unsigned char c
= sl
->rbuff
[0];
329 if (c
& SL_TYPE_COMPRESSED_TCP
) {
330 /* ignore compressed packets when CSLIP is off */
331 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
332 printk(KERN_WARNING
"%s: compressed packet ignored\n", dev
->name
);
335 /* make sure we've reserved enough space for uncompress
337 if (count
+ 80 > sl
->buffsize
) {
338 dev
->stats
.rx_over_errors
++;
341 count
= slhc_uncompress(sl
->slcomp
, sl
->rbuff
, count
);
344 } else if (c
>= SL_TYPE_UNCOMPRESSED_TCP
) {
345 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
346 /* turn on header compression */
347 sl
->mode
|= SL_MODE_CSLIP
;
348 sl
->mode
&= ~SL_MODE_ADAPTIVE
;
349 printk(KERN_INFO
"%s: header compression turned on\n", dev
->name
);
351 sl
->rbuff
[0] &= 0x4f;
352 if (slhc_remember(sl
->slcomp
, sl
->rbuff
, count
) <= 0)
356 #endif /* SL_INCLUDE_CSLIP */
358 dev
->stats
.rx_bytes
+= count
;
360 skb
= dev_alloc_skb(count
);
362 printk(KERN_WARNING
"%s: memory squeeze, dropping packet.\n", dev
->name
);
363 dev
->stats
.rx_dropped
++;
367 skb_put_data(skb
, sl
->rbuff
, count
);
368 skb_reset_mac_header(skb
);
369 skb
->protocol
= htons(ETH_P_IP
);
371 dev
->stats
.rx_packets
++;
374 /* Encapsulate one IP datagram and stuff into a TTY queue. */
375 static void sl_encaps(struct slip
*sl
, unsigned char *icp
, int len
)
380 if (len
> sl
->mtu
) { /* Sigh, shouldn't occur BUT ... */
381 printk(KERN_WARNING
"%s: truncating oversized transmit packet!\n", sl
->dev
->name
);
382 sl
->dev
->stats
.tx_dropped
++;
388 #ifdef SL_INCLUDE_CSLIP
389 if (sl
->mode
& SL_MODE_CSLIP
)
390 len
= slhc_compress(sl
->slcomp
, p
, len
, sl
->cbuff
, &p
, 1);
392 #ifdef CONFIG_SLIP_MODE_SLIP6
393 if (sl
->mode
& SL_MODE_SLIP6
)
394 count
= slip_esc6(p
, sl
->xbuff
, len
);
397 count
= slip_esc(p
, sl
->xbuff
, len
);
399 /* Order of next two lines is *very* important.
400 * When we are sending a little amount of data,
401 * the transfer may be completed inside the ops->write()
402 * routine, because it's running with interrupts enabled.
403 * In this case we *never* got WRITE_WAKEUP event,
404 * if we did not request it before write operation.
405 * 14 Oct 1994 Dmitry Gorodchanin.
407 set_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
408 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xbuff
, count
);
409 #ifdef SL_CHECK_TRANSMIT
410 netif_trans_update(sl
->dev
);
412 sl
->xleft
= count
- actual
;
413 sl
->xhead
= sl
->xbuff
+ actual
;
414 #ifdef CONFIG_SLIP_SMART
416 clear_bit(SLF_OUTWAIT
, &sl
->flags
); /* reset outfill flag */
420 /* Write out any remaining transmit buffer. Scheduled when tty is writable */
421 static void slip_transmit(struct work_struct
*work
)
423 struct slip
*sl
= container_of(work
, struct slip
, tx_work
);
426 spin_lock_bh(&sl
->lock
);
427 /* First make sure we're connected. */
428 if (!sl
->tty
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
)) {
429 spin_unlock_bh(&sl
->lock
);
433 if (sl
->xleft
<= 0) {
434 /* Now serial buffer is almost free & we can start
435 * transmission of another packet */
436 sl
->dev
->stats
.tx_packets
++;
437 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
438 spin_unlock_bh(&sl
->lock
);
443 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xhead
, sl
->xleft
);
446 spin_unlock_bh(&sl
->lock
);
450 * Called by the driver when there's room for more data.
451 * Schedule the transmit.
453 static void slip_write_wakeup(struct tty_struct
*tty
)
455 struct slip
*sl
= tty
->disc_data
;
457 schedule_work(&sl
->tx_work
);
460 static void sl_tx_timeout(struct net_device
*dev
)
462 struct slip
*sl
= netdev_priv(dev
);
464 spin_lock(&sl
->lock
);
466 if (netif_queue_stopped(dev
)) {
467 if (!netif_running(dev
))
470 /* May be we must check transmitter timeout here ?
471 * 14 Oct 1994 Dmitry Gorodchanin.
473 #ifdef SL_CHECK_TRANSMIT
474 if (time_before(jiffies
, dev_trans_start(dev
) + 20 * HZ
)) {
475 /* 20 sec timeout not reached */
478 printk(KERN_WARNING
"%s: transmit timed out, %s?\n",
480 (tty_chars_in_buffer(sl
->tty
) || sl
->xleft
) ?
481 "bad line quality" : "driver error");
483 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
488 spin_unlock(&sl
->lock
);
492 /* Encapsulate an IP datagram and kick it into a TTY queue. */
494 sl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
496 struct slip
*sl
= netdev_priv(dev
);
498 spin_lock(&sl
->lock
);
499 if (!netif_running(dev
)) {
500 spin_unlock(&sl
->lock
);
501 printk(KERN_WARNING
"%s: xmit call when iface is down\n", dev
->name
);
505 if (sl
->tty
== NULL
) {
506 spin_unlock(&sl
->lock
);
512 dev
->stats
.tx_bytes
+= skb
->len
;
513 sl_encaps(sl
, skb
->data
, skb
->len
);
514 spin_unlock(&sl
->lock
);
521 /******************************************
522 * Routines looking at netdevice side.
523 ******************************************/
525 /* Netdevice UP -> DOWN routine */
528 sl_close(struct net_device
*dev
)
530 struct slip
*sl
= netdev_priv(dev
);
532 spin_lock_bh(&sl
->lock
);
534 /* TTY discipline is running. */
535 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
536 netif_stop_queue(dev
);
539 spin_unlock_bh(&sl
->lock
);
544 /* Netdevice DOWN -> UP routine */
546 static int sl_open(struct net_device
*dev
)
548 struct slip
*sl
= netdev_priv(dev
);
553 sl
->flags
&= (1 << SLF_INUSE
);
554 netif_start_queue(dev
);
558 /* Netdevice change MTU request */
560 static int sl_change_mtu(struct net_device
*dev
, int new_mtu
)
562 struct slip
*sl
= netdev_priv(dev
);
564 return sl_realloc_bufs(sl
, new_mtu
);
567 /* Netdevice get statistics request */
570 sl_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
572 struct net_device_stats
*devstats
= &dev
->stats
;
573 #ifdef SL_INCLUDE_CSLIP
574 struct slip
*sl
= netdev_priv(dev
);
575 struct slcompress
*comp
= sl
->slcomp
;
577 stats
->rx_packets
= devstats
->rx_packets
;
578 stats
->tx_packets
= devstats
->tx_packets
;
579 stats
->rx_bytes
= devstats
->rx_bytes
;
580 stats
->tx_bytes
= devstats
->tx_bytes
;
581 stats
->rx_dropped
= devstats
->rx_dropped
;
582 stats
->tx_dropped
= devstats
->tx_dropped
;
583 stats
->tx_errors
= devstats
->tx_errors
;
584 stats
->rx_errors
= devstats
->rx_errors
;
585 stats
->rx_over_errors
= devstats
->rx_over_errors
;
587 #ifdef SL_INCLUDE_CSLIP
589 /* Generic compressed statistics */
590 stats
->rx_compressed
= comp
->sls_i_compressed
;
591 stats
->tx_compressed
= comp
->sls_o_compressed
;
593 /* Are we really still needs this? */
594 stats
->rx_fifo_errors
+= comp
->sls_i_compressed
;
595 stats
->rx_dropped
+= comp
->sls_i_tossed
;
596 stats
->tx_fifo_errors
+= comp
->sls_o_compressed
;
597 stats
->collisions
+= comp
->sls_o_misses
;
602 /* Netdevice register callback */
604 static int sl_init(struct net_device
*dev
)
606 struct slip
*sl
= netdev_priv(dev
);
609 * Finish setting up the DEVICE info.
613 dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
614 #ifdef SL_CHECK_TRANSMIT
615 dev
->watchdog_timeo
= 20*HZ
;
621 static void sl_uninit(struct net_device
*dev
)
623 struct slip
*sl
= netdev_priv(dev
);
628 /* Hook the destructor so we can free slip devices at the right point in time */
629 static void sl_free_netdev(struct net_device
*dev
)
631 int i
= dev
->base_addr
;
636 static const struct net_device_ops sl_netdev_ops
= {
638 .ndo_uninit
= sl_uninit
,
640 .ndo_stop
= sl_close
,
641 .ndo_start_xmit
= sl_xmit
,
642 .ndo_get_stats64
= sl_get_stats64
,
643 .ndo_change_mtu
= sl_change_mtu
,
644 .ndo_tx_timeout
= sl_tx_timeout
,
645 #ifdef CONFIG_SLIP_SMART
646 .ndo_do_ioctl
= sl_ioctl
,
651 static void sl_setup(struct net_device
*dev
)
653 dev
->netdev_ops
= &sl_netdev_ops
;
654 dev
->needs_free_netdev
= true;
655 dev
->priv_destructor
= sl_free_netdev
;
657 dev
->hard_header_len
= 0;
659 dev
->tx_queue_len
= 10;
661 /* MTU range: 68 - 65534 */
663 dev
->max_mtu
= 65534;
665 /* New-style flags. */
666 dev
->flags
= IFF_NOARP
|IFF_POINTOPOINT
|IFF_MULTICAST
;
669 /******************************************
670 Routines looking at TTY side.
671 ******************************************/
675 * Handle the 'receiver data ready' interrupt.
676 * This function is called by the 'tty_io' module in the kernel when
677 * a block of SLIP data has been received, which can now be decapsulated
678 * and sent on to some IP layer for further processing. This will not
679 * be re-entered while running but other ldisc functions may be called
683 static void slip_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
686 struct slip
*sl
= tty
->disc_data
;
688 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
691 /* Read the characters out of the buffer */
694 if (!test_and_set_bit(SLF_ERROR
, &sl
->flags
))
695 sl
->dev
->stats
.rx_errors
++;
699 #ifdef CONFIG_SLIP_MODE_SLIP6
700 if (sl
->mode
& SL_MODE_SLIP6
)
701 slip_unesc6(sl
, *cp
++);
704 slip_unesc(sl
, *cp
++);
708 /************************************
709 * slip_open helper routines.
710 ************************************/
712 /* Collect hanged up channels */
713 static void sl_sync(void)
716 struct net_device
*dev
;
719 for (i
= 0; i
< slip_maxdev
; i
++) {
724 sl
= netdev_priv(dev
);
725 if (sl
->tty
|| sl
->leased
)
727 if (dev
->flags
& IFF_UP
)
733 /* Find a free SLIP channel, and link in this `tty' line. */
734 static struct slip
*sl_alloc(void)
738 struct net_device
*dev
= NULL
;
741 for (i
= 0; i
< slip_maxdev
; i
++) {
746 /* Sorry, too many, all slots in use */
747 if (i
>= slip_maxdev
)
750 sprintf(name
, "sl%d", i
);
751 dev
= alloc_netdev(sizeof(*sl
), name
, NET_NAME_UNKNOWN
, sl_setup
);
756 sl
= netdev_priv(dev
);
758 /* Initialize channel control data */
759 sl
->magic
= SLIP_MAGIC
;
761 spin_lock_init(&sl
->lock
);
762 INIT_WORK(&sl
->tx_work
, slip_transmit
);
763 sl
->mode
= SL_MODE_DEFAULT
;
764 #ifdef CONFIG_SLIP_SMART
765 /* initialize timer_list struct */
766 timer_setup(&sl
->keepalive_timer
, sl_keepalive
, 0);
767 timer_setup(&sl
->outfill_timer
, sl_outfill
, 0);
774 * Open the high-level part of the SLIP channel.
775 * This function is called by the TTY module when the
776 * SLIP line discipline is called for. Because we are
777 * sure the tty line exists, we only have to link it to
778 * a free SLIP channel...
780 * Called in process context serialized from other ldisc calls.
783 static int slip_open(struct tty_struct
*tty
)
788 if (!capable(CAP_NET_ADMIN
))
791 if (tty
->ops
->write
== NULL
)
794 /* RTnetlink lock is misused here to serialize concurrent
795 opens of slip channels. There are better ways, but it is
800 /* Collect hanged up channels. */
806 /* First make sure we're not already connected. */
807 if (sl
&& sl
->magic
== SLIP_MAGIC
)
810 /* OK. Find a free SLIP channel to use. */
818 sl
->pid
= current
->pid
;
820 if (!test_bit(SLF_INUSE
, &sl
->flags
)) {
821 /* Perform the low-level SLIP initialization. */
822 err
= sl_alloc_bufs(sl
, SL_MTU
);
826 set_bit(SLF_INUSE
, &sl
->flags
);
828 err
= register_netdevice(sl
->dev
);
833 #ifdef CONFIG_SLIP_SMART
835 sl
->keepalive_timer
.expires
= jiffies
+ sl
->keepalive
* HZ
;
836 add_timer(&sl
->keepalive_timer
);
839 sl
->outfill_timer
.expires
= jiffies
+ sl
->outfill
* HZ
;
840 add_timer(&sl
->outfill_timer
);
844 /* Done. We have linked the TTY line to a channel. */
846 tty
->receive_room
= 65536; /* We don't flow control */
848 /* TTY layer expects 0 on success */
856 tty
->disc_data
= NULL
;
857 clear_bit(SLF_INUSE
, &sl
->flags
);
862 /* Count references from TTY module */
867 * Close down a SLIP channel.
868 * This means flushing out any pending queues, and then returning. This
869 * call is serialized against other ldisc functions.
871 * We also use this method fo a hangup event
874 static void slip_close(struct tty_struct
*tty
)
876 struct slip
*sl
= tty
->disc_data
;
878 /* First make sure we're connected. */
879 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| sl
->tty
!= tty
)
882 spin_lock_bh(&sl
->lock
);
883 tty
->disc_data
= NULL
;
885 spin_unlock_bh(&sl
->lock
);
887 flush_work(&sl
->tx_work
);
889 /* VSV = very important to remove timers */
890 #ifdef CONFIG_SLIP_SMART
891 del_timer_sync(&sl
->keepalive_timer
);
892 del_timer_sync(&sl
->outfill_timer
);
894 /* Flush network side */
895 unregister_netdev(sl
->dev
);
896 /* This will complete via sl_free_netdev */
899 static int slip_hangup(struct tty_struct
*tty
)
904 /************************************************************************
905 * STANDARD SLIP ENCAPSULATION *
906 ************************************************************************/
908 static int slip_esc(unsigned char *s
, unsigned char *d
, int len
)
910 unsigned char *ptr
= d
;
914 * Send an initial END character to flush out any
915 * data that may have accumulated in the receiver
922 * For each byte in the packet, send the appropriate
923 * character sequence, according to the SLIP protocol.
945 static void slip_unesc(struct slip
*sl
, unsigned char s
)
950 #ifdef CONFIG_SLIP_SMART
951 /* drop keeptest bit = VSV */
952 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
953 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
956 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
) &&
959 clear_bit(SLF_ESCAPE
, &sl
->flags
);
964 set_bit(SLF_ESCAPE
, &sl
->flags
);
967 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
971 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
975 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
976 if (sl
->rcount
< sl
->buffsize
) {
977 sl
->rbuff
[sl
->rcount
++] = s
;
980 sl
->dev
->stats
.rx_over_errors
++;
981 set_bit(SLF_ERROR
, &sl
->flags
);
986 #ifdef CONFIG_SLIP_MODE_SLIP6
987 /************************************************************************
988 * 6 BIT SLIP ENCAPSULATION *
989 ************************************************************************/
991 static int slip_esc6(unsigned char *s
, unsigned char *d
, int len
)
993 unsigned char *ptr
= d
;
996 unsigned short v
= 0;
1000 * Send an initial END character to flush out any
1001 * data that may have accumulated in the receiver
1002 * due to line noise.
1008 * Encode the packet into printable ascii characters
1011 for (i
= 0; i
< len
; ++i
) {
1012 v
= (v
<< 8) | s
[i
];
1016 c
= 0x30 + ((v
>> bits
) & 0x3F);
1021 c
= 0x30 + ((v
<< (6 - bits
)) & 0x3F);
1028 static void slip_unesc6(struct slip
*sl
, unsigned char s
)
1033 #ifdef CONFIG_SLIP_SMART
1034 /* drop keeptest bit = VSV */
1035 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1036 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1039 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
) &&
1045 } else if (s
>= 0x30 && s
< 0x70) {
1046 sl
->xdata
= (sl
->xdata
<< 6) | ((s
- 0x30) & 0x3F);
1048 if (sl
->xbits
>= 8) {
1050 c
= (unsigned char)(sl
->xdata
>> sl
->xbits
);
1051 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1052 if (sl
->rcount
< sl
->buffsize
) {
1053 sl
->rbuff
[sl
->rcount
++] = c
;
1056 sl
->dev
->stats
.rx_over_errors
++;
1057 set_bit(SLF_ERROR
, &sl
->flags
);
1062 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1064 /* Perform I/O control on an active SLIP channel. */
1065 static int slip_ioctl(struct tty_struct
*tty
, struct file
*file
,
1066 unsigned int cmd
, unsigned long arg
)
1068 struct slip
*sl
= tty
->disc_data
;
1070 int __user
*p
= (int __user
*)arg
;
1072 /* First make sure we're connected. */
1073 if (!sl
|| sl
->magic
!= SLIP_MAGIC
)
1078 tmp
= strlen(sl
->dev
->name
) + 1;
1079 if (copy_to_user((void __user
*)arg
, sl
->dev
->name
, tmp
))
1084 if (put_user(sl
->mode
, p
))
1089 if (get_user(tmp
, p
))
1091 #ifndef SL_INCLUDE_CSLIP
1092 if (tmp
& (SL_MODE_CSLIP
|SL_MODE_ADAPTIVE
))
1095 if ((tmp
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) ==
1096 (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
))
1097 /* return -EINVAL; */
1098 tmp
&= ~SL_MODE_ADAPTIVE
;
1100 #ifndef CONFIG_SLIP_MODE_SLIP6
1101 if (tmp
& SL_MODE_SLIP6
)
1105 sl
->dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
1111 #ifdef CONFIG_SLIP_SMART
1112 /* VSV changes start here */
1113 case SIOCSKEEPALIVE
:
1114 if (get_user(tmp
, p
))
1116 if (tmp
> 255) /* max for unchar */
1119 spin_lock_bh(&sl
->lock
);
1121 spin_unlock_bh(&sl
->lock
);
1124 sl
->keepalive
= (u8
)tmp
;
1125 if (sl
->keepalive
!= 0) {
1126 mod_timer(&sl
->keepalive_timer
,
1127 jiffies
+ sl
->keepalive
* HZ
);
1128 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1130 del_timer(&sl
->keepalive_timer
);
1131 spin_unlock_bh(&sl
->lock
);
1134 case SIOCGKEEPALIVE
:
1135 if (put_user(sl
->keepalive
, p
))
1140 if (get_user(tmp
, p
))
1142 if (tmp
> 255) /* max for unchar */
1144 spin_lock_bh(&sl
->lock
);
1146 spin_unlock_bh(&sl
->lock
);
1149 sl
->outfill
= (u8
)tmp
;
1150 if (sl
->outfill
!= 0) {
1151 mod_timer(&sl
->outfill_timer
,
1152 jiffies
+ sl
->outfill
* HZ
);
1153 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1155 del_timer(&sl
->outfill_timer
);
1156 spin_unlock_bh(&sl
->lock
);
1160 if (put_user(sl
->outfill
, p
))
1163 /* VSV changes end */
1166 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1170 #ifdef CONFIG_COMPAT
1171 static long slip_compat_ioctl(struct tty_struct
*tty
, struct file
*file
,
1172 unsigned int cmd
, unsigned long arg
)
1179 case SIOCSKEEPALIVE
:
1180 case SIOCGKEEPALIVE
:
1183 return slip_ioctl(tty
, file
, cmd
,
1184 (unsigned long)compat_ptr(arg
));
1187 return -ENOIOCTLCMD
;
1191 /* VSV changes start here */
1192 #ifdef CONFIG_SLIP_SMART
1193 /* function do_ioctl called from net/core/dev.c
1194 to allow get/set outfill/keepalive parameter
1197 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1199 struct slip
*sl
= netdev_priv(dev
);
1200 unsigned long *p
= (unsigned long *)&rq
->ifr_ifru
;
1202 if (sl
== NULL
) /* Allocation failed ?? */
1205 spin_lock_bh(&sl
->lock
);
1208 spin_unlock_bh(&sl
->lock
);
1213 case SIOCSKEEPALIVE
:
1214 /* max for unchar */
1215 if ((unsigned)*p
> 255) {
1216 spin_unlock_bh(&sl
->lock
);
1219 sl
->keepalive
= (u8
)*p
;
1220 if (sl
->keepalive
!= 0) {
1221 sl
->keepalive_timer
.expires
=
1222 jiffies
+ sl
->keepalive
* HZ
;
1223 mod_timer(&sl
->keepalive_timer
,
1224 jiffies
+ sl
->keepalive
* HZ
);
1225 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1227 del_timer(&sl
->keepalive_timer
);
1230 case SIOCGKEEPALIVE
:
1235 if ((unsigned)*p
> 255) { /* max for unchar */
1236 spin_unlock_bh(&sl
->lock
);
1239 sl
->outfill
= (u8
)*p
;
1240 if (sl
->outfill
!= 0) {
1241 mod_timer(&sl
->outfill_timer
,
1242 jiffies
+ sl
->outfill
* HZ
);
1243 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1245 del_timer(&sl
->outfill_timer
);
1253 /* Resolve race condition, when ioctl'ing hanged up
1254 and opened by another process device.
1256 if (sl
->tty
!= current
->signal
->tty
&&
1257 sl
->pid
!= current
->pid
) {
1258 spin_unlock_bh(&sl
->lock
);
1269 spin_unlock_bh(&sl
->lock
);
1273 /* VSV changes end */
1275 static struct tty_ldisc_ops sl_ldisc
= {
1276 .owner
= THIS_MODULE
,
1277 .magic
= TTY_LDISC_MAGIC
,
1280 .close
= slip_close
,
1281 .hangup
= slip_hangup
,
1282 .ioctl
= slip_ioctl
,
1283 #ifdef CONFIG_COMPAT
1284 .compat_ioctl
= slip_compat_ioctl
,
1286 .receive_buf
= slip_receive_buf
,
1287 .write_wakeup
= slip_write_wakeup
,
1290 static int __init
slip_init(void)
1294 if (slip_maxdev
< 4)
1295 slip_maxdev
= 4; /* Sanity */
1297 printk(KERN_INFO
"SLIP: version %s (dynamic channels, max=%d)"
1298 #ifdef CONFIG_SLIP_MODE_SLIP6
1299 " (6 bit encapsulation enabled)"
1302 SLIP_VERSION
, slip_maxdev
);
1303 #if defined(SL_INCLUDE_CSLIP)
1304 printk(KERN_INFO
"CSLIP: code copyright 1989 Regents of the University of California.\n");
1306 #ifdef CONFIG_SLIP_SMART
1307 printk(KERN_INFO
"SLIP linefill/keepalive option.\n");
1310 slip_devs
= kzalloc(sizeof(struct net_device
*)*slip_maxdev
,
1315 /* Fill in our line protocol discipline, and register it */
1316 status
= tty_register_ldisc(N_SLIP
, &sl_ldisc
);
1318 printk(KERN_ERR
"SLIP: can't register line discipline (err = %d)\n", status
);
1324 static void __exit
slip_exit(void)
1327 struct net_device
*dev
;
1329 unsigned long timeout
= jiffies
+ HZ
;
1332 if (slip_devs
== NULL
)
1335 /* First of all: check for active disciplines and hangup them.
1339 msleep_interruptible(100);
1342 for (i
= 0; i
< slip_maxdev
; i
++) {
1346 sl
= netdev_priv(dev
);
1347 spin_lock_bh(&sl
->lock
);
1350 tty_hangup(sl
->tty
);
1352 spin_unlock_bh(&sl
->lock
);
1354 } while (busy
&& time_before(jiffies
, timeout
));
1356 /* FIXME: hangup is async so we should wait when doing this second
1359 for (i
= 0; i
< slip_maxdev
; i
++) {
1363 slip_devs
[i
] = NULL
;
1365 sl
= netdev_priv(dev
);
1367 printk(KERN_ERR
"%s: tty discipline still running\n",
1371 unregister_netdev(dev
);
1377 i
= tty_unregister_ldisc(N_SLIP
);
1379 printk(KERN_ERR
"SLIP: can't unregister line discipline (err = %d)\n", i
);
1382 module_init(slip_init
);
1383 module_exit(slip_exit
);
1385 #ifdef CONFIG_SLIP_SMART
1387 * This is start of the code for multislip style line checking
1388 * added by Stanislav Voronyi. All changes before marked VSV
1391 static void sl_outfill(struct timer_list
*t
)
1393 struct slip
*sl
= from_timer(sl
, t
, outfill_timer
);
1395 spin_lock(&sl
->lock
);
1397 if (sl
->tty
== NULL
)
1401 if (test_bit(SLF_OUTWAIT
, &sl
->flags
)) {
1402 /* no packets were transmitted, do outfill */
1403 #ifdef CONFIG_SLIP_MODE_SLIP6
1404 unsigned char s
= (sl
->mode
& SL_MODE_SLIP6
)?0x70:END
;
1406 unsigned char s
= END
;
1408 /* put END into tty queue. Is it right ??? */
1409 if (!netif_queue_stopped(sl
->dev
)) {
1410 /* if device busy no outfill */
1411 sl
->tty
->ops
->write(sl
->tty
, &s
, 1);
1414 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1416 mod_timer(&sl
->outfill_timer
, jiffies
+sl
->outfill
*HZ
);
1419 spin_unlock(&sl
->lock
);
1422 static void sl_keepalive(struct timer_list
*t
)
1424 struct slip
*sl
= from_timer(sl
, t
, keepalive_timer
);
1426 spin_lock(&sl
->lock
);
1428 if (sl
->tty
== NULL
)
1431 if (sl
->keepalive
) {
1432 if (test_bit(SLF_KEEPTEST
, &sl
->flags
)) {
1433 /* keepalive still high :(, we must hangup */
1435 /* outfill timer must be deleted too */
1436 (void)del_timer(&sl
->outfill_timer
);
1437 printk(KERN_DEBUG
"%s: no packets received during keepalive timeout, hangup.\n", sl
->dev
->name
);
1438 /* this must hangup tty & close slip */
1439 tty_hangup(sl
->tty
);
1440 /* I think we need not something else */
1443 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1445 mod_timer(&sl
->keepalive_timer
, jiffies
+sl
->keepalive
*HZ
);
1448 spin_unlock(&sl
->lock
);
1452 MODULE_LICENSE("GPL");
1453 MODULE_ALIAS_LDISC(N_SLIP
);