899c4a2112c9f7ff1cb5f8e8f5ed953ff71f1582
[linux-2.6.git] / drivers / net / slip.c
1 /*
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.
5  *
6  * Version:     @(#)slip.c      0.8.3   12/24/94
7  *
8  * Authors:     Laurence Culhane, <loz@holmes.demon.co.uk>
9  *              Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
10  *
11  * Fixes:
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
35  *                                      correctly.
36  *                                      Modularization.
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
48  *                                      at module cleanup.
49  *                                      With MODULE-loading ``insmod'', user
50  *                                      can issue parameter:  slip_maxdev=1024
51  *                                      (Or how much he/she wants.. Default
52  *                                      is 256)
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
57  *                                      Linux SLIP driver.
58  *      Vitaly E. Lavrov        :       Sane behaviour on tty hangup.
59  *      Alexey Kuznetsov        :       Cleanup interfaces to tty & netdevice
60  *                                      modules.
61  */
62
63 #define SL_CHECK_TRANSMIT
64 #include <linux/module.h>
65 #include <linux/moduleparam.h>
66
67 #include <asm/system.h>
68 #include <asm/uaccess.h>
69 #include <linux/bitops.h>
70 #include <linux/string.h>
71 #include <linux/mm.h>
72 #include <linux/interrupt.h>
73 #include <linux/in.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>
84 #include "slip.h"
85 #ifdef CONFIG_INET
86 #include <linux/ip.h>
87 #include <linux/tcp.h>
88 #include <net/slhc_vj.h>
89 #endif
90
91 #define SLIP_VERSION    "0.8.4-NET3.019-NEWTTY"
92
93 static struct net_device **slip_devs;
94
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");
98
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);
104 #endif
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);
109 #endif
110
111 /********************************
112 *  Buffer administration routines:
113 *       sl_alloc_bufs()
114 *       sl_free_bufs()
115 *       sl_realloc_bufs()
116 *
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 *********************************/
121
122 /*
123    Allocate channel buffers.
124  */
125
126 static int sl_alloc_bufs(struct slip *sl, int mtu)
127 {
128         int err = -ENOBUFS;
129         unsigned long len;
130         char *rbuff = NULL;
131         char *xbuff = NULL;
132 #ifdef SL_INCLUDE_CSLIP
133         char *cbuff = NULL;
134         struct slcompress *slcomp = NULL;
135 #endif
136
137         /*
138          * Allocate the SLIP frame buffers:
139          *
140          * rbuff        Receive buffer.
141          * xbuff        Transmit buffer.
142          * cbuff        Temporary compression buffer.
143          */
144         len = mtu * 2;
145
146         /*
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
149          * an MSS of 128
150          */
151         if (len < 576 * 2)
152                 len = 576 * 2;
153         rbuff = kmalloc(len + 4, GFP_KERNEL);
154         if (rbuff == NULL)
155                 goto err_exit;
156         xbuff = kmalloc(len + 4, GFP_KERNEL);
157         if (xbuff == NULL)
158                 goto err_exit;
159 #ifdef SL_INCLUDE_CSLIP
160         cbuff = kmalloc(len + 4, GFP_KERNEL);
161         if (cbuff == NULL)
162                 goto err_exit;
163         slcomp = slhc_init(16, 16);
164         if (slcomp == NULL)
165                 goto err_exit;
166 #endif
167         spin_lock_bh(&sl->lock);
168         if (sl->tty == NULL) {
169                 spin_unlock_bh(&sl->lock);
170                 err = -ENODEV;
171                 goto err_exit;
172         }
173         sl->mtu      = mtu;
174         sl->buffsize = len;
175         sl->rcount   = 0;
176         sl->xleft    = 0;
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
183         sl->xdata    = 0;
184         sl->xbits    = 0;
185 #endif
186 #endif
187         spin_unlock_bh(&sl->lock);
188         err = 0;
189
190         /* Cleanup */
191 err_exit:
192 #ifdef SL_INCLUDE_CSLIP
193         kfree(cbuff);
194         if (slcomp)
195                 slhc_free(slcomp);
196 #endif
197         kfree(xbuff);
198         kfree(rbuff);
199         return err;
200 }
201
202 /* Free a SLIP channel buffers. */
203 static void sl_free_bufs(struct slip *sl)
204 {
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));
211 #endif
212 }
213
214 /*
215    Reallocate slip channel buffers.
216  */
217
218 static int sl_realloc_bufs(struct slip *sl, int mtu)
219 {
220         int err = 0;
221         struct net_device *dev = sl->dev;
222         unsigned char *xbuff, *rbuff;
223 #ifdef SL_INCLUDE_CSLIP
224         unsigned char *cbuff;
225 #endif
226         int len = mtu * 2;
227
228 /*
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
231  * an MSS of 128
232  */
233         if (len < 576 * 2)
234                 len = 576 * 2;
235
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);
240 #endif
241
242
243 #ifdef SL_INCLUDE_CSLIP
244         if (xbuff == NULL || rbuff == NULL || cbuff == NULL)  {
245 #else
246         if (xbuff == NULL || rbuff == NULL)  {
247 #endif
248                 if (mtu >= sl->mtu) {
249                         printk(KERN_WARNING "%s: unable to grow slip buffers, MTU change cancelled.\n",
250                                dev->name);
251                         err = -ENOBUFS;
252                 }
253                 goto done;
254         }
255         spin_lock_bh(&sl->lock);
256
257         err = -ENODEV;
258         if (sl->tty == NULL)
259                 goto done_on_bh;
260
261         xbuff    = xchg(&sl->xbuff, xbuff);
262         rbuff    = xchg(&sl->rbuff, rbuff);
263 #ifdef SL_INCLUDE_CSLIP
264         cbuff    = xchg(&sl->cbuff, cbuff);
265 #endif
266         if (sl->xleft)  {
267                 if (sl->xleft <= len)  {
268                         memcpy(sl->xbuff, sl->xhead, sl->xleft);
269                 } else  {
270                         sl->xleft = 0;
271                         sl->tx_dropped++;
272                 }
273         }
274         sl->xhead = sl->xbuff;
275
276         if (sl->rcount)  {
277                 if (sl->rcount <= len) {
278                         memcpy(sl->rbuff, rbuff, sl->rcount);
279                 } else  {
280                         sl->rcount = 0;
281                         sl->rx_over_errors++;
282                         set_bit(SLF_ERROR, &sl->flags);
283                 }
284         }
285         sl->mtu      = mtu;
286         dev->mtu      = mtu;
287         sl->buffsize = len;
288         err = 0;
289
290 done_on_bh:
291         spin_unlock_bh(&sl->lock);
292
293 done:
294         kfree(xbuff);
295         kfree(rbuff);
296 #ifdef SL_INCLUDE_CSLIP
297         kfree(cbuff);
298 #endif
299         return err;
300 }
301
302
303 /* Set the "sending" flag.  This must be atomic hence the set_bit. */
304 static inline void sl_lock(struct slip *sl)
305 {
306         netif_stop_queue(sl->dev);
307 }
308
309
310 /* Clear the "sending" flag.  This must be atomic, hence the ASM. */
311 static inline void sl_unlock(struct slip *sl)
312 {
313         netif_wake_queue(sl->dev);
314 }
315
316 /* Send one completely decapsulated IP datagram to the IP layer. */
317 static void sl_bump(struct slip *sl)
318 {
319         struct sk_buff *skb;
320         int count;
321
322         count = sl->rcount;
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);
330                                 return;
331                         }
332                         /* make sure we've reserved enough space for uncompress
333                            to use */
334                         if (count + 80 > sl->buffsize) {
335                                 sl->rx_over_errors++;
336                                 return;
337                         }
338                         count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
339                         if (count <= 0)
340                                 return;
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);
347                         }
348                         sl->rbuff[0] &= 0x4f;
349                         if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0)
350                                 return;
351                 }
352         }
353 #endif  /* SL_INCLUDE_CSLIP */
354
355         sl->rx_bytes += count;
356
357         skb = dev_alloc_skb(count);
358         if (skb == NULL) {
359                 printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n", sl->dev->name);
360                 sl->rx_dropped++;
361                 return;
362         }
363         skb->dev = sl->dev;
364         memcpy(skb_put(skb, count), sl->rbuff, count);
365         skb_reset_mac_header(skb);
366         skb->protocol = htons(ETH_P_IP);
367         netif_rx(skb);
368         sl->rx_packets++;
369 }
370
371 /* Encapsulate one IP datagram and stuff into a TTY queue. */
372 static void sl_encaps(struct slip *sl, unsigned char *icp, int len)
373 {
374         unsigned char *p;
375         int actual, count;
376
377         if (len > sl->mtu) {            /* Sigh, shouldn't occur BUT ... */
378                 printk(KERN_WARNING "%s: truncating oversized transmit packet!\n", sl->dev->name);
379                 sl->tx_dropped++;
380                 sl_unlock(sl);
381                 return;
382         }
383
384         p = icp;
385 #ifdef SL_INCLUDE_CSLIP
386         if (sl->mode & SL_MODE_CSLIP)
387                 len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
388 #endif
389 #ifdef CONFIG_SLIP_MODE_SLIP6
390         if (sl->mode & SL_MODE_SLIP6)
391                 count = slip_esc6(p, (unsigned char *) sl->xbuff, len);
392         else
393 #endif
394                 count = slip_esc(p, (unsigned char *) sl->xbuff, len);
395
396         /* Order of next two lines is *very* important.
397          * When we are sending a little amount of data,
398          * the transfer may be completed inside the ops->write()
399          * routine, because it's running with interrupts enabled.
400          * In this case we *never* got WRITE_WAKEUP event,
401          * if we did not request it before write operation.
402          *       14 Oct 1994  Dmitry Gorodchanin.
403          */
404         set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
405         actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
406 #ifdef SL_CHECK_TRANSMIT
407         sl->dev->trans_start = jiffies;
408 #endif
409         sl->xleft = count - actual;
410         sl->xhead = sl->xbuff + actual;
411 #ifdef CONFIG_SLIP_SMART
412         /* VSV */
413         clear_bit(SLF_OUTWAIT, &sl->flags);     /* reset outfill flag */
414 #endif
415 }
416
417 /*
418  * Called by the driver when there's room for more data.  If we have
419  * more packets to send, we send them here.
420  */
421 static void slip_write_wakeup(struct tty_struct *tty)
422 {
423         int actual;
424         struct slip *sl = tty->disc_data;
425
426         /* First make sure we're connected. */
427         if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
428                 return;
429
430         if (sl->xleft <= 0)  {
431                 /* Now serial buffer is almost free & we can start
432                  * transmission of another packet */
433                 sl->tx_packets++;
434                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
435                 sl_unlock(sl);
436                 return;
437         }
438
439         actual = tty->ops->write(tty, sl->xhead, sl->xleft);
440         sl->xleft -= actual;
441         sl->xhead += actual;
442 }
443
444 static void sl_tx_timeout(struct net_device *dev)
445 {
446         struct slip *sl = netdev_priv(dev);
447
448         spin_lock(&sl->lock);
449
450         if (netif_queue_stopped(dev)) {
451                 if (!netif_running(dev))
452                         goto out;
453
454                 /* May be we must check transmitter timeout here ?
455                  *      14 Oct 1994 Dmitry Gorodchanin.
456                  */
457 #ifdef SL_CHECK_TRANSMIT
458                 if (time_before(jiffies, dev->trans_start + 20 * HZ))  {
459                         /* 20 sec timeout not reached */
460                         goto out;
461                 }
462                 printk(KERN_WARNING "%s: transmit timed out, %s?\n",
463                         dev->name,
464                         (tty_chars_in_buffer(sl->tty) || sl->xleft) ?
465                                 "bad line quality" : "driver error");
466                 sl->xleft = 0;
467                 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
468                 sl_unlock(sl);
469 #endif
470         }
471 out:
472         spin_unlock(&sl->lock);
473 }
474
475
476 /* Encapsulate an IP datagram and kick it into a TTY queue. */
477 static int
478 sl_xmit(struct sk_buff *skb, struct net_device *dev)
479 {
480         struct slip *sl = netdev_priv(dev);
481
482         spin_lock(&sl->lock);
483         if (!netif_running(dev)) {
484                 spin_unlock(&sl->lock);
485                 printk(KERN_WARNING "%s: xmit call when iface is down\n", dev->name);
486                 dev_kfree_skb(skb);
487                 return NETDEV_TX_OK;
488         }
489         if (sl->tty == NULL) {
490                 spin_unlock(&sl->lock);
491                 dev_kfree_skb(skb);
492                 return NETDEV_TX_OK;
493         }
494
495         sl_lock(sl);
496         sl->tx_bytes += skb->len;
497         sl_encaps(sl, skb->data, skb->len);
498         spin_unlock(&sl->lock);
499
500         dev_kfree_skb(skb);
501         return NETDEV_TX_OK;
502 }
503
504
505 /******************************************
506  *   Routines looking at netdevice side.
507  ******************************************/
508
509 /* Netdevice UP -> DOWN routine */
510
511 static int
512 sl_close(struct net_device *dev)
513 {
514         struct slip *sl = netdev_priv(dev);
515
516         spin_lock_bh(&sl->lock);
517         if (sl->tty)
518                 /* TTY discipline is running. */
519                 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
520         netif_stop_queue(dev);
521         sl->rcount   = 0;
522         sl->xleft    = 0;
523         spin_unlock_bh(&sl->lock);
524
525         return 0;
526 }
527
528 /* Netdevice DOWN -> UP routine */
529
530 static int sl_open(struct net_device *dev)
531 {
532         struct slip *sl = netdev_priv(dev);
533
534         if (sl->tty == NULL)
535                 return -ENODEV;
536
537         sl->flags &= (1 << SLF_INUSE);
538         netif_start_queue(dev);
539         return 0;
540 }
541
542 /* Netdevice change MTU request */
543
544 static int sl_change_mtu(struct net_device *dev, int new_mtu)
545 {
546         struct slip *sl = netdev_priv(dev);
547
548         if (new_mtu < 68 || new_mtu > 65534)
549                 return -EINVAL;
550
551         if (new_mtu != dev->mtu)
552                 return sl_realloc_bufs(sl, new_mtu);
553         return 0;
554 }
555
556 /* Netdevice get statistics request */
557
558 static struct net_device_stats *
559 sl_get_stats(struct net_device *dev)
560 {
561         static struct net_device_stats stats;
562         struct slip *sl = netdev_priv(dev);
563 #ifdef SL_INCLUDE_CSLIP
564         struct slcompress *comp;
565 #endif
566
567         memset(&stats, 0, sizeof(struct net_device_stats));
568
569         stats.rx_packets     = sl->rx_packets;
570         stats.tx_packets     = sl->tx_packets;
571         stats.rx_bytes       = sl->rx_bytes;
572         stats.tx_bytes       = sl->tx_bytes;
573         stats.rx_dropped     = sl->rx_dropped;
574         stats.tx_dropped     = sl->tx_dropped;
575         stats.tx_errors      = sl->tx_errors;
576         stats.rx_errors      = sl->rx_errors;
577         stats.rx_over_errors = sl->rx_over_errors;
578 #ifdef SL_INCLUDE_CSLIP
579         stats.rx_fifo_errors = sl->rx_compressed;
580         stats.tx_fifo_errors = sl->tx_compressed;
581         stats.collisions     = sl->tx_misses;
582         comp = sl->slcomp;
583         if (comp) {
584                 stats.rx_fifo_errors += comp->sls_i_compressed;
585                 stats.rx_dropped     += comp->sls_i_tossed;
586                 stats.tx_fifo_errors += comp->sls_o_compressed;
587                 stats.collisions     += comp->sls_o_misses;
588         }
589 #endif /* CONFIG_INET */
590         return (&stats);
591 }
592
593 /* Netdevice register callback */
594
595 static int sl_init(struct net_device *dev)
596 {
597         struct slip *sl = netdev_priv(dev);
598
599         /*
600          *      Finish setting up the DEVICE info.
601          */
602
603         dev->mtu                = sl->mtu;
604         dev->type               = ARPHRD_SLIP + sl->mode;
605 #ifdef SL_CHECK_TRANSMIT
606         dev->watchdog_timeo     = 20*HZ;
607 #endif
608         return 0;
609 }
610
611
612 static void sl_uninit(struct net_device *dev)
613 {
614         struct slip *sl = netdev_priv(dev);
615
616         sl_free_bufs(sl);
617 }
618
619 static const struct net_device_ops sl_netdev_ops = {
620         .ndo_init               = sl_init,
621         .ndo_uninit             = sl_uninit,
622         .ndo_open               = sl_open,
623         .ndo_stop               = sl_close,
624         .ndo_start_xmit         = sl_xmit,
625         .ndo_get_stats          = sl_get_stats,
626         .ndo_change_mtu         = sl_change_mtu,
627         .ndo_tx_timeout         = sl_tx_timeout,
628 #ifdef CONFIG_SLIP_SMART
629         .ndo_do_ioctl           = sl_ioctl,
630 #endif
631 };
632
633
634 static void sl_setup(struct net_device *dev)
635 {
636         dev->netdev_ops         = &sl_netdev_ops;
637         dev->destructor         = free_netdev;
638
639         dev->hard_header_len    = 0;
640         dev->addr_len           = 0;
641         dev->tx_queue_len       = 10;
642
643         /* New-style flags. */
644         dev->flags              = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
645 }
646
647 /******************************************
648   Routines looking at TTY side.
649  ******************************************/
650
651
652 /*
653  * Handle the 'receiver data ready' interrupt.
654  * This function is called by the 'tty_io' module in the kernel when
655  * a block of SLIP data has been received, which can now be decapsulated
656  * and sent on to some IP layer for further processing. This will not
657  * be re-entered while running but other ldisc functions may be called
658  * in parallel
659  */
660
661 static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
662                                                         char *fp, int count)
663 {
664         struct slip *sl = tty->disc_data;
665
666         if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
667                 return;
668
669         /* Read the characters out of the buffer */
670         while (count--) {
671                 if (fp && *fp++) {
672                         if (!test_and_set_bit(SLF_ERROR, &sl->flags))
673                                 sl->rx_errors++;
674                         cp++;
675                         continue;
676                 }
677 #ifdef CONFIG_SLIP_MODE_SLIP6
678                 if (sl->mode & SL_MODE_SLIP6)
679                         slip_unesc6(sl, *cp++);
680                 else
681 #endif
682                         slip_unesc(sl, *cp++);
683         }
684 }
685
686 /************************************
687  *  slip_open helper routines.
688  ************************************/
689
690 /* Collect hanged up channels */
691 static void sl_sync(void)
692 {
693         int i;
694         struct net_device *dev;
695         struct slip       *sl;
696
697         for (i = 0; i < slip_maxdev; i++) {
698                 dev = slip_devs[i];
699                 if (dev == NULL)
700                         break;
701
702                 sl = netdev_priv(dev);
703                 if (sl->tty || sl->leased)
704                         continue;
705                 if (dev->flags & IFF_UP)
706                         dev_close(dev);
707         }
708 }
709
710
711 /* Find a free SLIP channel, and link in this `tty' line. */
712 static struct slip *sl_alloc(dev_t line)
713 {
714         int i;
715         int sel = -1;
716         int score = -1;
717         struct net_device *dev = NULL;
718         struct slip       *sl;
719
720         if (slip_devs == NULL)
721                 return NULL;    /* Master array missing ! */
722
723         for (i = 0; i < slip_maxdev; i++) {
724                 dev = slip_devs[i];
725                 if (dev == NULL)
726                         break;
727
728                 sl = netdev_priv(dev);
729                 if (sl->leased) {
730                         if (sl->line != line)
731                                 continue;
732                         if (sl->tty)
733                                 return NULL;
734
735                         /* Clear ESCAPE & ERROR flags */
736                         sl->flags &= (1 << SLF_INUSE);
737                         return sl;
738                 }
739
740                 if (sl->tty)
741                         continue;
742
743                 if (current->pid == sl->pid) {
744                         if (sl->line == line && score < 3) {
745                                 sel = i;
746                                 score = 3;
747                                 continue;
748                         }
749                         if (score < 2) {
750                                 sel = i;
751                                 score = 2;
752                         }
753                         continue;
754                 }
755                 if (sl->line == line && score < 1) {
756                         sel = i;
757                         score = 1;
758                         continue;
759                 }
760                 if (score < 0) {
761                         sel = i;
762                         score = 0;
763                 }
764         }
765
766         if (sel >= 0) {
767                 i = sel;
768                 dev = slip_devs[i];
769                 if (score > 1) {
770                         sl = netdev_priv(dev);
771                         sl->flags &= (1 << SLF_INUSE);
772                         return sl;
773                 }
774         }
775
776         /* Sorry, too many, all slots in use */
777         if (i >= slip_maxdev)
778                 return NULL;
779
780         if (dev) {
781                 sl = netdev_priv(dev);
782                 if (test_bit(SLF_INUSE, &sl->flags)) {
783                         unregister_netdevice(dev);
784                         dev = NULL;
785                         slip_devs[i] = NULL;
786                 }
787         }
788
789         if (!dev) {
790                 char name[IFNAMSIZ];
791                 sprintf(name, "sl%d", i);
792
793                 dev = alloc_netdev(sizeof(*sl), name, sl_setup);
794                 if (!dev)
795                         return NULL;
796                 dev->base_addr  = i;
797         }
798
799         sl = netdev_priv(dev);
800
801         /* Initialize channel control data */
802         sl->magic       = SLIP_MAGIC;
803         sl->dev         = dev;
804         spin_lock_init(&sl->lock);
805         sl->mode        = SL_MODE_DEFAULT;
806 #ifdef CONFIG_SLIP_SMART
807         /* initialize timer_list struct */
808         init_timer(&sl->keepalive_timer);
809         sl->keepalive_timer.data = (unsigned long)sl;
810         sl->keepalive_timer.function = sl_keepalive;
811         init_timer(&sl->outfill_timer);
812         sl->outfill_timer.data = (unsigned long)sl;
813         sl->outfill_timer.function = sl_outfill;
814 #endif
815         slip_devs[i] = dev;
816         return sl;
817 }
818
819 /*
820  * Open the high-level part of the SLIP channel.
821  * This function is called by the TTY module when the
822  * SLIP line discipline is called for.  Because we are
823  * sure the tty line exists, we only have to link it to
824  * a free SLIP channel...
825  *
826  * Called in process context serialized from other ldisc calls.
827  */
828
829 static int slip_open(struct tty_struct *tty)
830 {
831         struct slip *sl;
832         int err;
833
834         if (!capable(CAP_NET_ADMIN))
835                 return -EPERM;
836
837         if (tty->ops->write == NULL)
838                 return -EOPNOTSUPP;
839
840         /* RTnetlink lock is misused here to serialize concurrent
841            opens of slip channels. There are better ways, but it is
842            the simplest one.
843          */
844         rtnl_lock();
845
846         /* Collect hanged up channels. */
847         sl_sync();
848
849         sl = tty->disc_data;
850
851         err = -EEXIST;
852         /* First make sure we're not already connected. */
853         if (sl && sl->magic == SLIP_MAGIC)
854                 goto err_exit;
855
856         /* OK.  Find a free SLIP channel to use. */
857         err = -ENFILE;
858         sl = sl_alloc(tty_devnum(tty));
859         if (sl == NULL)
860                 goto err_exit;
861
862         sl->tty = tty;
863         tty->disc_data = sl;
864         sl->line = tty_devnum(tty);
865         sl->pid = current->pid;
866
867         if (!test_bit(SLF_INUSE, &sl->flags)) {
868                 /* Perform the low-level SLIP initialization. */
869                 err = sl_alloc_bufs(sl, SL_MTU);
870                 if (err)
871                         goto err_free_chan;
872
873                 set_bit(SLF_INUSE, &sl->flags);
874
875                 err = register_netdevice(sl->dev);
876                 if (err)
877                         goto err_free_bufs;
878         }
879
880 #ifdef CONFIG_SLIP_SMART
881         if (sl->keepalive) {
882                 sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
883                 add_timer(&sl->keepalive_timer);
884         }
885         if (sl->outfill) {
886                 sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
887                 add_timer(&sl->outfill_timer);
888         }
889 #endif
890
891         /* Done.  We have linked the TTY line to a channel. */
892         rtnl_unlock();
893         tty->receive_room = 65536;      /* We don't flow control */
894         return sl->dev->base_addr;
895
896 err_free_bufs:
897         sl_free_bufs(sl);
898
899 err_free_chan:
900         sl->tty = NULL;
901         tty->disc_data = NULL;
902         clear_bit(SLF_INUSE, &sl->flags);
903
904 err_exit:
905         rtnl_unlock();
906
907         /* Count references from TTY module */
908         return err;
909 }
910
911 /*
912
913   FIXME: 1,2 are fixed 3 was never true anyway.
914
915    Let me to blame a bit.
916    1. TTY module calls this funstion on soft interrupt.
917    2. TTY module calls this function WITH MASKED INTERRUPTS!
918    3. TTY module does not notify us about line discipline
919       shutdown,
920
921    Seems, now it is clean. The solution is to consider netdevice and
922    line discipline sides as two independent threads.
923
924    By-product (not desired): sl? does not feel hangups and remains open.
925    It is supposed, that user level program (dip, diald, slattach...)
926    will catch SIGHUP and make the rest of work.
927
928    I see no way to make more with current tty code. --ANK
929  */
930
931 /*
932  * Close down a SLIP channel.
933  * This means flushing out any pending queues, and then returning. This
934  * call is serialized against other ldisc functions.
935  */
936 static void slip_close(struct tty_struct *tty)
937 {
938         struct slip *sl = tty->disc_data;
939
940         /* First make sure we're connected. */
941         if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
942                 return;
943
944         tty->disc_data = NULL;
945         sl->tty = NULL;
946         if (!sl->leased)
947                 sl->line = 0;
948
949         /* VSV = very important to remove timers */
950 #ifdef CONFIG_SLIP_SMART
951         del_timer_sync(&sl->keepalive_timer);
952         del_timer_sync(&sl->outfill_timer);
953 #endif
954
955         /* Count references from TTY module */
956 }
957
958  /************************************************************************
959   *                     STANDARD SLIP ENCAPSULATION                      *
960   ************************************************************************/
961
962 static int slip_esc(unsigned char *s, unsigned char *d, int len)
963 {
964         unsigned char *ptr = d;
965         unsigned char c;
966
967         /*
968          * Send an initial END character to flush out any
969          * data that may have accumulated in the receiver
970          * due to line noise.
971          */
972
973         *ptr++ = END;
974
975         /*
976          * For each byte in the packet, send the appropriate
977          * character sequence, according to the SLIP protocol.
978          */
979
980         while (len-- > 0) {
981                 switch (c = *s++) {
982                 case END:
983                         *ptr++ = ESC;
984                         *ptr++ = ESC_END;
985                         break;
986                 case ESC:
987                         *ptr++ = ESC;
988                         *ptr++ = ESC_ESC;
989                         break;
990                 default:
991                         *ptr++ = c;
992                         break;
993                 }
994         }
995         *ptr++ = END;
996         return (ptr - d);
997 }
998
999 static void slip_unesc(struct slip *sl, unsigned char s)
1000 {
1001
1002         switch (s) {
1003         case END:
1004 #ifdef CONFIG_SLIP_SMART
1005                 /* drop keeptest bit = VSV */
1006                 if (test_bit(SLF_KEEPTEST, &sl->flags))
1007                         clear_bit(SLF_KEEPTEST, &sl->flags);
1008 #endif
1009
1010                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1011                                                         && (sl->rcount > 2))
1012                         sl_bump(sl);
1013                 clear_bit(SLF_ESCAPE, &sl->flags);
1014                 sl->rcount = 0;
1015                 return;
1016
1017         case ESC:
1018                 set_bit(SLF_ESCAPE, &sl->flags);
1019                 return;
1020         case ESC_ESC:
1021                 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
1022                         s = ESC;
1023                 break;
1024         case ESC_END:
1025                 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
1026                         s = END;
1027                 break;
1028         }
1029         if (!test_bit(SLF_ERROR, &sl->flags))  {
1030                 if (sl->rcount < sl->buffsize)  {
1031                         sl->rbuff[sl->rcount++] = s;
1032                         return;
1033                 }
1034                 sl->rx_over_errors++;
1035                 set_bit(SLF_ERROR, &sl->flags);
1036         }
1037 }
1038
1039
1040 #ifdef CONFIG_SLIP_MODE_SLIP6
1041 /************************************************************************
1042  *                       6 BIT SLIP ENCAPSULATION                       *
1043  ************************************************************************/
1044
1045 static int slip_esc6(unsigned char *s, unsigned char *d, int len)
1046 {
1047         unsigned char *ptr = d;
1048         unsigned char c;
1049         int i;
1050         unsigned short v = 0;
1051         short bits = 0;
1052
1053         /*
1054          * Send an initial END character to flush out any
1055          * data that may have accumulated in the receiver
1056          * due to line noise.
1057          */
1058
1059         *ptr++ = 0x70;
1060
1061         /*
1062          * Encode the packet into printable ascii characters
1063          */
1064
1065         for (i = 0; i < len; ++i) {
1066                 v = (v << 8) | s[i];
1067                 bits += 8;
1068                 while (bits >= 6) {
1069                         bits -= 6;
1070                         c = 0x30 + ((v >> bits) & 0x3F);
1071                         *ptr++ = c;
1072                 }
1073         }
1074         if (bits) {
1075                 c = 0x30 + ((v << (6 - bits)) & 0x3F);
1076                 *ptr++ = c;
1077         }
1078         *ptr++ = 0x70;
1079         return ptr - d;
1080 }
1081
1082 static void slip_unesc6(struct slip *sl, unsigned char s)
1083 {
1084         unsigned char c;
1085
1086         if (s == 0x70) {
1087 #ifdef CONFIG_SLIP_SMART
1088                 /* drop keeptest bit = VSV */
1089                 if (test_bit(SLF_KEEPTEST, &sl->flags))
1090                         clear_bit(SLF_KEEPTEST, &sl->flags);
1091 #endif
1092
1093                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1094                                                         && (sl->rcount > 2))
1095                         sl_bump(sl);
1096                 sl->rcount = 0;
1097                 sl->xbits = 0;
1098                 sl->xdata = 0;
1099         } else if (s >= 0x30 && s < 0x70) {
1100                 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1101                 sl->xbits += 6;
1102                 if (sl->xbits >= 8) {
1103                         sl->xbits -= 8;
1104                         c = (unsigned char)(sl->xdata >> sl->xbits);
1105                         if (!test_bit(SLF_ERROR, &sl->flags))  {
1106                                 if (sl->rcount < sl->buffsize)  {
1107                                         sl->rbuff[sl->rcount++] = c;
1108                                         return;
1109                                 }
1110                                 sl->rx_over_errors++;
1111                                 set_bit(SLF_ERROR, &sl->flags);
1112                         }
1113                 }
1114         }
1115 }
1116 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1117
1118 /* Perform I/O control on an active SLIP channel. */
1119 static int slip_ioctl(struct tty_struct *tty, struct file *file,
1120                                         unsigned int cmd, unsigned long arg)
1121 {
1122         struct slip *sl = tty->disc_data;
1123         unsigned int tmp;
1124         int __user *p = (int __user *)arg;
1125
1126         /* First make sure we're connected. */
1127         if (!sl || sl->magic != SLIP_MAGIC)
1128                 return -EINVAL;
1129
1130         switch (cmd) {
1131         case SIOCGIFNAME:
1132                 tmp = strlen(sl->dev->name) + 1;
1133                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1134                         return -EFAULT;
1135                 return 0;
1136
1137         case SIOCGIFENCAP:
1138                 if (put_user(sl->mode, p))
1139                         return -EFAULT;
1140                 return 0;
1141
1142         case SIOCSIFENCAP:
1143                 if (get_user(tmp, p))
1144                         return -EFAULT;
1145 #ifndef SL_INCLUDE_CSLIP
1146                 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
1147                         return -EINVAL;
1148 #else
1149                 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1150                     (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
1151                         /* return -EINVAL; */
1152                         tmp &= ~SL_MODE_ADAPTIVE;
1153 #endif
1154 #ifndef CONFIG_SLIP_MODE_SLIP6
1155                 if (tmp & SL_MODE_SLIP6)
1156                         return -EINVAL;
1157 #endif
1158                 sl->mode = tmp;
1159                 sl->dev->type = ARPHRD_SLIP + sl->mode;
1160                 return 0;
1161
1162         case SIOCSIFHWADDR:
1163                 return -EINVAL;
1164
1165 #ifdef CONFIG_SLIP_SMART
1166         /* VSV changes start here */
1167         case SIOCSKEEPALIVE:
1168                 if (get_user(tmp, p))
1169                         return -EFAULT;
1170                 if (tmp > 255) /* max for unchar */
1171                         return -EINVAL;
1172
1173                 spin_lock_bh(&sl->lock);
1174                 if (!sl->tty) {
1175                         spin_unlock_bh(&sl->lock);
1176                         return -ENODEV;
1177                 }
1178                 sl->keepalive = (u8)tmp;
1179                 if (sl->keepalive != 0) {
1180                         mod_timer(&sl->keepalive_timer,
1181                                         jiffies + sl->keepalive * HZ);
1182                         set_bit(SLF_KEEPTEST, &sl->flags);
1183                 } else
1184                         del_timer(&sl->keepalive_timer);
1185                 spin_unlock_bh(&sl->lock);
1186                 return 0;
1187
1188         case SIOCGKEEPALIVE:
1189                 if (put_user(sl->keepalive, p))
1190                         return -EFAULT;
1191                 return 0;
1192
1193         case SIOCSOUTFILL:
1194                 if (get_user(tmp, p))
1195                         return -EFAULT;
1196                 if (tmp > 255) /* max for unchar */
1197                         return -EINVAL;
1198                 spin_lock_bh(&sl->lock);
1199                 if (!sl->tty) {
1200                         spin_unlock_bh(&sl->lock);
1201                         return -ENODEV;
1202                 }
1203                 sl->outfill = (u8)tmp;
1204                 if (sl->outfill != 0) {
1205                         mod_timer(&sl->outfill_timer,
1206                                                 jiffies + sl->outfill * HZ);
1207                         set_bit(SLF_OUTWAIT, &sl->flags);
1208                 } else
1209                         del_timer(&sl->outfill_timer);
1210                 spin_unlock_bh(&sl->lock);
1211                 return 0;
1212
1213         case SIOCGOUTFILL:
1214                 if (put_user(sl->outfill, p))
1215                         return -EFAULT;
1216                 return 0;
1217         /* VSV changes end */
1218 #endif
1219         default:
1220                 return tty_mode_ioctl(tty, file, cmd, arg);
1221         }
1222 }
1223
1224 /* VSV changes start here */
1225 #ifdef CONFIG_SLIP_SMART
1226 /* function do_ioctl called from net/core/dev.c
1227    to allow get/set outfill/keepalive parameter
1228    by ifconfig                                 */
1229
1230 static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1231 {
1232         struct slip *sl = netdev_priv(dev);
1233         unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1234
1235         if (sl == NULL)         /* Allocation failed ?? */
1236                 return -ENODEV;
1237
1238         spin_lock_bh(&sl->lock);
1239
1240         if (!sl->tty) {
1241                 spin_unlock_bh(&sl->lock);
1242                 return -ENODEV;
1243         }
1244
1245         switch (cmd) {
1246         case SIOCSKEEPALIVE:
1247                 /* max for unchar */
1248                 if ((unsigned)*p > 255) {
1249                         spin_unlock_bh(&sl->lock);
1250                         return -EINVAL;
1251                 }
1252                 sl->keepalive = (u8)*p;
1253                 if (sl->keepalive != 0) {
1254                         sl->keepalive_timer.expires =
1255                                                 jiffies + sl->keepalive * HZ;
1256                         mod_timer(&sl->keepalive_timer,
1257                                                 jiffies + sl->keepalive * HZ);
1258                         set_bit(SLF_KEEPTEST, &sl->flags);
1259                 } else
1260                         del_timer(&sl->keepalive_timer);
1261                 break;
1262
1263         case SIOCGKEEPALIVE:
1264                 *p = sl->keepalive;
1265                 break;
1266
1267         case SIOCSOUTFILL:
1268                 if ((unsigned)*p > 255) { /* max for unchar */
1269                         spin_unlock_bh(&sl->lock);
1270                         return -EINVAL;
1271                 }
1272                 sl->outfill = (u8)*p;
1273                 if (sl->outfill != 0) {
1274                         mod_timer(&sl->outfill_timer,
1275                                                 jiffies + sl->outfill * HZ);
1276                         set_bit(SLF_OUTWAIT, &sl->flags);
1277                 } else
1278                         del_timer(&sl->outfill_timer);
1279                 break;
1280
1281         case SIOCGOUTFILL:
1282                 *p = sl->outfill;
1283                 break;
1284
1285         case SIOCSLEASE:
1286                 /* Resolve race condition, when ioctl'ing hanged up
1287                    and opened by another process device.
1288                  */
1289                 if (sl->tty != current->signal->tty &&
1290                                                 sl->pid != current->pid) {
1291                         spin_unlock_bh(&sl->lock);
1292                         return -EPERM;
1293                 }
1294                 sl->leased = 0;
1295                 if (*p)
1296                         sl->leased = 1;
1297                 break;
1298
1299         case SIOCGLEASE:
1300                 *p = sl->leased;
1301         };
1302         spin_unlock_bh(&sl->lock);
1303         return 0;
1304 }
1305 #endif
1306 /* VSV changes end */
1307
1308 static struct tty_ldisc_ops sl_ldisc = {
1309         .owner          = THIS_MODULE,
1310         .magic          = TTY_LDISC_MAGIC,
1311         .name           = "slip",
1312         .open           = slip_open,
1313         .close          = slip_close,
1314         .ioctl          = slip_ioctl,
1315         .receive_buf    = slip_receive_buf,
1316         .write_wakeup   = slip_write_wakeup,
1317 };
1318
1319 static int __init slip_init(void)
1320 {
1321         int status;
1322
1323         if (slip_maxdev < 4)
1324                 slip_maxdev = 4; /* Sanity */
1325
1326         printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1327 #ifdef CONFIG_SLIP_MODE_SLIP6
1328                " (6 bit encapsulation enabled)"
1329 #endif
1330                ".\n",
1331                SLIP_VERSION, slip_maxdev);
1332 #if defined(SL_INCLUDE_CSLIP)
1333         printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1334 #endif
1335 #ifdef CONFIG_SLIP_SMART
1336         printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1337 #endif
1338
1339         slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
1340                                                                 GFP_KERNEL);
1341         if (!slip_devs) {
1342                 printk(KERN_ERR "SLIP: Can't allocate slip devices array.\n");
1343                 return -ENOMEM;
1344         }
1345
1346         /* Fill in our line protocol discipline, and register it */
1347         status = tty_register_ldisc(N_SLIP, &sl_ldisc);
1348         if (status != 0) {
1349                 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1350                 kfree(slip_devs);
1351         }
1352         return status;
1353 }
1354
1355 static void __exit slip_exit(void)
1356 {
1357         int i;
1358         struct net_device *dev;
1359         struct slip *sl;
1360         unsigned long timeout = jiffies + HZ;
1361         int busy = 0;
1362
1363         if (slip_devs == NULL)
1364                 return;
1365
1366         /* First of all: check for active disciplines and hangup them.
1367          */
1368         do {
1369                 if (busy)
1370                         msleep_interruptible(100);
1371
1372                 busy = 0;
1373                 for (i = 0; i < slip_maxdev; i++) {
1374                         dev = slip_devs[i];
1375                         if (!dev)
1376                                 continue;
1377                         sl = netdev_priv(dev);
1378                         spin_lock_bh(&sl->lock);
1379                         if (sl->tty) {
1380                                 busy++;
1381                                 tty_hangup(sl->tty);
1382                         }
1383                         spin_unlock_bh(&sl->lock);
1384                 }
1385         } while (busy && time_before(jiffies, timeout));
1386
1387
1388         for (i = 0; i < slip_maxdev; i++) {
1389                 dev = slip_devs[i];
1390                 if (!dev)
1391                         continue;
1392                 slip_devs[i] = NULL;
1393
1394                 sl = netdev_priv(dev);
1395                 if (sl->tty) {
1396                         printk(KERN_ERR "%s: tty discipline still running\n",
1397                                dev->name);
1398                         /* Intentionally leak the control block. */
1399                         dev->destructor = NULL;
1400                 }
1401
1402                 unregister_netdev(dev);
1403         }
1404
1405         kfree(slip_devs);
1406         slip_devs = NULL;
1407
1408         i = tty_unregister_ldisc(N_SLIP);
1409         if (i != 0)
1410                 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
1411 }
1412
1413 module_init(slip_init);
1414 module_exit(slip_exit);
1415
1416 #ifdef CONFIG_SLIP_SMART
1417 /*
1418  * This is start of the code for multislip style line checking
1419  * added by Stanislav Voronyi. All changes before marked VSV
1420  */
1421
1422 static void sl_outfill(unsigned long sls)
1423 {
1424         struct slip *sl = (struct slip *)sls;
1425
1426         spin_lock(&sl->lock);
1427
1428         if (sl->tty == NULL)
1429                 goto out;
1430
1431         if (sl->outfill) {
1432                 if (test_bit(SLF_OUTWAIT, &sl->flags)) {
1433                         /* no packets were transmitted, do outfill */
1434 #ifdef CONFIG_SLIP_MODE_SLIP6
1435                         unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1436 #else
1437                         unsigned char s = END;
1438 #endif
1439                         /* put END into tty queue. Is it right ??? */
1440                         if (!netif_queue_stopped(sl->dev)) {
1441                                 /* if device busy no outfill */
1442                                 sl->tty->ops->write(sl->tty, &s, 1);
1443                         }
1444                 } else
1445                         set_bit(SLF_OUTWAIT, &sl->flags);
1446
1447                 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1448         }
1449 out:
1450         spin_unlock(&sl->lock);
1451 }
1452
1453 static void sl_keepalive(unsigned long sls)
1454 {
1455         struct slip *sl = (struct slip *)sls;
1456
1457         spin_lock(&sl->lock);
1458
1459         if (sl->tty == NULL)
1460                 goto out;
1461
1462         if (sl->keepalive) {
1463                 if (test_bit(SLF_KEEPTEST, &sl->flags)) {
1464                         /* keepalive still high :(, we must hangup */
1465                         if (sl->outfill)
1466                                 /* outfill timer must be deleted too */
1467                                 (void)del_timer(&sl->outfill_timer);
1468                         printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1469                         /* this must hangup tty & close slip */
1470                         tty_hangup(sl->tty);
1471                         /* I think we need not something else */
1472                         goto out;
1473                 } else
1474                         set_bit(SLF_KEEPTEST, &sl->flags);
1475
1476                 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1477         }
1478 out:
1479         spin_unlock(&sl->lock);
1480 }
1481
1482 #endif
1483 MODULE_LICENSE("GPL");
1484 MODULE_ALIAS_LDISC(N_SLIP);