Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * slip.c   This module implements the SLIP protocol for kernel-based
0004  *      devices like TTY.  It interfaces between a raw TTY, and the
0005  *      kernel's INET protocol layers.
0006  *
0007  * Version: @(#)slip.c  0.8.3   12/24/94
0008  *
0009  * Authors: Laurence Culhane, <loz@holmes.demon.co.uk>
0010  *      Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
0011  *
0012  * Fixes:
0013  *      Alan Cox    :   Sanity checks and avoid tx overruns.
0014  *                  Has a new sl->mtu field.
0015  *      Alan Cox    :   Found cause of overrun. ifconfig sl0
0016  *                  mtu upwards. Driver now spots this
0017  *                  and grows/shrinks its buffers(hack!).
0018  *                  Memory leak if you run out of memory
0019  *                  setting up a slip driver fixed.
0020  *      Matt Dillon :   Printable slip (borrowed from NET2E)
0021  *  Pauline Middelink   :   Slip driver fixes.
0022  *      Alan Cox    :   Honours the old SL_COMPRESSED flag
0023  *      Alan Cox    :   KISS AX.25 and AXUI IP support
0024  *      Michael Riepe   :   Automatic CSLIP recognition added
0025  *      Charles Hedrick :   CSLIP header length problem fix.
0026  *      Alan Cox    :   Corrected non-IP cases of the above.
0027  *      Alan Cox    :   Now uses hardware type as per FvK.
0028  *      Alan Cox    :   Default to 192.168.0.0 (RFC 1597)
0029  *      A.N.Kuznetsov   :   dev_tint() recursion fix.
0030  *  Dmitry Gorodchanin  :   SLIP memory leaks
0031  *      Dmitry Gorodchanin      :       Code cleanup. Reduce tty driver
0032  *                                      buffering from 4096 to 256 bytes.
0033  *                                      Improving SLIP response time.
0034  *                                      CONFIG_SLIP_MODE_SLIP6.
0035  *                                      ifconfig sl? up & down now works
0036  *                  correctly.
0037  *                  Modularization.
0038  *              Alan Cox        :       Oops - fix AX.25 buffer lengths
0039  *      Dmitry Gorodchanin      :       Even more cleanups. Preserve CSLIP
0040  *                                      statistics. Include CSLIP code only
0041  *                                      if it really needed.
0042  *      Alan Cox    :   Free slhc buffers in the right place.
0043  *      Alan Cox    :   Allow for digipeated IP over AX.25
0044  *      Matti Aarnio    :   Dynamic SLIP devices, with ideas taken
0045  *                  from Jim Freeman's <jfree@caldera.com>
0046  *                  dynamic PPP devices.  We do NOT kfree()
0047  *                  device entries, just reg./unreg. them
0048  *                  as they are needed.  We kfree() them
0049  *                  at module cleanup.
0050  *                  With MODULE-loading ``insmod'', user
0051  *                  can issue parameter:  slip_maxdev=1024
0052  *                  (Or how much he/she wants.. Default
0053  *                  is 256)
0054  *  Stanislav Voronyi   :   Slip line checking, with ideas taken
0055  *                  from multislip BSDI driver which was
0056  *                  written by Igor Chechik, RELCOM Corp.
0057  *                  Only algorithms have been ported to
0058  *                  Linux SLIP driver.
0059  *  Vitaly E. Lavrov    :   Sane behaviour on tty hangup.
0060  *  Alexey Kuznetsov    :   Cleanup interfaces to tty & netdevice
0061  *                  modules.
0062  */
0063 
0064 #define SL_CHECK_TRANSMIT
0065 #include <linux/compat.h>
0066 #include <linux/module.h>
0067 #include <linux/moduleparam.h>
0068 
0069 #include <linux/uaccess.h>
0070 #include <linux/bitops.h>
0071 #include <linux/sched/signal.h>
0072 #include <linux/string.h>
0073 #include <linux/mm.h>
0074 #include <linux/interrupt.h>
0075 #include <linux/in.h>
0076 #include <linux/tty.h>
0077 #include <linux/errno.h>
0078 #include <linux/netdevice.h>
0079 #include <linux/etherdevice.h>
0080 #include <linux/skbuff.h>
0081 #include <linux/rtnetlink.h>
0082 #include <linux/if_arp.h>
0083 #include <linux/if_slip.h>
0084 #include <linux/delay.h>
0085 #include <linux/init.h>
0086 #include <linux/slab.h>
0087 #include <linux/workqueue.h>
0088 #include "slip.h"
0089 #ifdef CONFIG_INET
0090 #include <linux/ip.h>
0091 #include <linux/tcp.h>
0092 #include <net/slhc_vj.h>
0093 #endif
0094 
0095 #define SLIP_VERSION    "0.8.4-NET3.019-NEWTTY"
0096 
0097 static struct net_device **slip_devs;
0098 
0099 static int slip_maxdev = SL_NRUNIT;
0100 module_param(slip_maxdev, int, 0);
0101 MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices");
0102 
0103 static int slip_esc(unsigned char *p, unsigned char *d, int len);
0104 static void slip_unesc(struct slip *sl, unsigned char c);
0105 #ifdef CONFIG_SLIP_MODE_SLIP6
0106 static int slip_esc6(unsigned char *p, unsigned char *d, int len);
0107 static void slip_unesc6(struct slip *sl, unsigned char c);
0108 #endif
0109 #ifdef CONFIG_SLIP_SMART
0110 static void sl_keepalive(struct timer_list *t);
0111 static void sl_outfill(struct timer_list *t);
0112 static int sl_siocdevprivate(struct net_device *dev, struct ifreq *rq, void __user *data, int cmd);
0113 #endif
0114 
0115 /********************************
0116 *  Buffer administration routines:
0117 *   sl_alloc_bufs()
0118 *   sl_free_bufs()
0119 *   sl_realloc_bufs()
0120 *
0121 * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
0122 *   sl_realloc_bufs provides strong atomicity and reallocation
0123 *   on actively running device.
0124 *********************************/
0125 
0126 /*
0127    Allocate channel buffers.
0128  */
0129 
0130 static int sl_alloc_bufs(struct slip *sl, int mtu)
0131 {
0132     int err = -ENOBUFS;
0133     unsigned long len;
0134     char *rbuff = NULL;
0135     char *xbuff = NULL;
0136 #ifdef SL_INCLUDE_CSLIP
0137     char *cbuff = NULL;
0138     struct slcompress *slcomp = NULL;
0139 #endif
0140 
0141     /*
0142      * Allocate the SLIP frame buffers:
0143      *
0144      * rbuff    Receive buffer.
0145      * xbuff    Transmit buffer.
0146      * cbuff        Temporary compression buffer.
0147      */
0148     len = mtu * 2;
0149 
0150     /*
0151      * allow for arrival of larger UDP packets, even if we say not to
0152      * also fixes a bug in which SunOS sends 512-byte packets even with
0153      * an MSS of 128
0154      */
0155     if (len < 576 * 2)
0156         len = 576 * 2;
0157     rbuff = kmalloc(len + 4, GFP_KERNEL);
0158     if (rbuff == NULL)
0159         goto err_exit;
0160     xbuff = kmalloc(len + 4, GFP_KERNEL);
0161     if (xbuff == NULL)
0162         goto err_exit;
0163 #ifdef SL_INCLUDE_CSLIP
0164     cbuff = kmalloc(len + 4, GFP_KERNEL);
0165     if (cbuff == NULL)
0166         goto err_exit;
0167     slcomp = slhc_init(16, 16);
0168     if (IS_ERR(slcomp))
0169         goto err_exit;
0170 #endif
0171     spin_lock_bh(&sl->lock);
0172     if (sl->tty == NULL) {
0173         spin_unlock_bh(&sl->lock);
0174         err = -ENODEV;
0175         goto err_exit;
0176     }
0177     sl->mtu      = mtu;
0178     sl->buffsize = len;
0179     sl->rcount   = 0;
0180     sl->xleft    = 0;
0181     rbuff = xchg(&sl->rbuff, rbuff);
0182     xbuff = xchg(&sl->xbuff, xbuff);
0183 #ifdef SL_INCLUDE_CSLIP
0184     cbuff = xchg(&sl->cbuff, cbuff);
0185     slcomp = xchg(&sl->slcomp, slcomp);
0186 #endif
0187 #ifdef CONFIG_SLIP_MODE_SLIP6
0188     sl->xdata    = 0;
0189     sl->xbits    = 0;
0190 #endif
0191     spin_unlock_bh(&sl->lock);
0192     err = 0;
0193 
0194     /* Cleanup */
0195 err_exit:
0196 #ifdef SL_INCLUDE_CSLIP
0197     kfree(cbuff);
0198     slhc_free(slcomp);
0199 #endif
0200     kfree(xbuff);
0201     kfree(rbuff);
0202     return err;
0203 }
0204 
0205 /* Free a SLIP channel buffers. */
0206 static void sl_free_bufs(struct slip *sl)
0207 {
0208     /* Free all SLIP frame buffers. */
0209     kfree(xchg(&sl->rbuff, NULL));
0210     kfree(xchg(&sl->xbuff, NULL));
0211 #ifdef SL_INCLUDE_CSLIP
0212     kfree(xchg(&sl->cbuff, NULL));
0213     slhc_free(xchg(&sl->slcomp, NULL));
0214 #endif
0215 }
0216 
0217 /*
0218    Reallocate slip channel buffers.
0219  */
0220 
0221 static int sl_realloc_bufs(struct slip *sl, int mtu)
0222 {
0223     int err = 0;
0224     struct net_device *dev = sl->dev;
0225     unsigned char *xbuff, *rbuff;
0226 #ifdef SL_INCLUDE_CSLIP
0227     unsigned char *cbuff;
0228 #endif
0229     int len = mtu * 2;
0230 
0231 /*
0232  * allow for arrival of larger UDP packets, even if we say not to
0233  * also fixes a bug in which SunOS sends 512-byte packets even with
0234  * an MSS of 128
0235  */
0236     if (len < 576 * 2)
0237         len = 576 * 2;
0238 
0239     xbuff = kmalloc(len + 4, GFP_ATOMIC);
0240     rbuff = kmalloc(len + 4, GFP_ATOMIC);
0241 #ifdef SL_INCLUDE_CSLIP
0242     cbuff = kmalloc(len + 4, GFP_ATOMIC);
0243 #endif
0244 
0245 
0246 #ifdef SL_INCLUDE_CSLIP
0247     if (xbuff == NULL || rbuff == NULL || cbuff == NULL)  {
0248 #else
0249     if (xbuff == NULL || rbuff == NULL)  {
0250 #endif
0251         if (mtu > sl->mtu) {
0252             printk(KERN_WARNING "%s: unable to grow slip buffers, MTU change cancelled.\n",
0253                    dev->name);
0254             err = -ENOBUFS;
0255         }
0256         goto done;
0257     }
0258     spin_lock_bh(&sl->lock);
0259 
0260     err = -ENODEV;
0261     if (sl->tty == NULL)
0262         goto done_on_bh;
0263 
0264     xbuff    = xchg(&sl->xbuff, xbuff);
0265     rbuff    = xchg(&sl->rbuff, rbuff);
0266 #ifdef SL_INCLUDE_CSLIP
0267     cbuff    = xchg(&sl->cbuff, cbuff);
0268 #endif
0269     if (sl->xleft)  {
0270         if (sl->xleft <= len)  {
0271             memcpy(sl->xbuff, sl->xhead, sl->xleft);
0272         } else  {
0273             sl->xleft = 0;
0274             dev->stats.tx_dropped++;
0275         }
0276     }
0277     sl->xhead = sl->xbuff;
0278 
0279     if (sl->rcount)  {
0280         if (sl->rcount <= len) {
0281             memcpy(sl->rbuff, rbuff, sl->rcount);
0282         } else  {
0283             sl->rcount = 0;
0284             dev->stats.rx_over_errors++;
0285             set_bit(SLF_ERROR, &sl->flags);
0286         }
0287     }
0288     sl->mtu      = mtu;
0289     dev->mtu      = mtu;
0290     sl->buffsize = len;
0291     err = 0;
0292 
0293 done_on_bh:
0294     spin_unlock_bh(&sl->lock);
0295 
0296 done:
0297     kfree(xbuff);
0298     kfree(rbuff);
0299 #ifdef SL_INCLUDE_CSLIP
0300     kfree(cbuff);
0301 #endif
0302     return err;
0303 }
0304 
0305 
0306 /* Set the "sending" flag.  This must be atomic hence the set_bit. */
0307 static inline void sl_lock(struct slip *sl)
0308 {
0309     netif_stop_queue(sl->dev);
0310 }
0311 
0312 
0313 /* Clear the "sending" flag.  This must be atomic, hence the ASM. */
0314 static inline void sl_unlock(struct slip *sl)
0315 {
0316     netif_wake_queue(sl->dev);
0317 }
0318 
0319 /* Send one completely decapsulated IP datagram to the IP layer. */
0320 static void sl_bump(struct slip *sl)
0321 {
0322     struct net_device *dev = sl->dev;
0323     struct sk_buff *skb;
0324     int count;
0325 
0326     count = sl->rcount;
0327 #ifdef SL_INCLUDE_CSLIP
0328     if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
0329         unsigned char c = sl->rbuff[0];
0330         if (c & SL_TYPE_COMPRESSED_TCP) {
0331             /* ignore compressed packets when CSLIP is off */
0332             if (!(sl->mode & SL_MODE_CSLIP)) {
0333                 printk(KERN_WARNING "%s: compressed packet ignored\n", dev->name);
0334                 return;
0335             }
0336             /* make sure we've reserved enough space for uncompress
0337                to use */
0338             if (count + 80 > sl->buffsize) {
0339                 dev->stats.rx_over_errors++;
0340                 return;
0341             }
0342             count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
0343             if (count <= 0)
0344                 return;
0345         } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
0346             if (!(sl->mode & SL_MODE_CSLIP)) {
0347                 /* turn on header compression */
0348                 sl->mode |= SL_MODE_CSLIP;
0349                 sl->mode &= ~SL_MODE_ADAPTIVE;
0350                 printk(KERN_INFO "%s: header compression turned on\n", dev->name);
0351             }
0352             sl->rbuff[0] &= 0x4f;
0353             if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0)
0354                 return;
0355         }
0356     }
0357 #endif  /* SL_INCLUDE_CSLIP */
0358 
0359     dev->stats.rx_bytes += count;
0360 
0361     skb = dev_alloc_skb(count);
0362     if (skb == NULL) {
0363         printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n", dev->name);
0364         dev->stats.rx_dropped++;
0365         return;
0366     }
0367     skb->dev = dev;
0368     skb_put_data(skb, sl->rbuff, count);
0369     skb_reset_mac_header(skb);
0370     skb->protocol = htons(ETH_P_IP);
0371     netif_rx(skb);
0372     dev->stats.rx_packets++;
0373 }
0374 
0375 /* Encapsulate one IP datagram and stuff into a TTY queue. */
0376 static void sl_encaps(struct slip *sl, unsigned char *icp, int len)
0377 {
0378     unsigned char *p;
0379     int actual, count;
0380 
0381     if (len > sl->mtu) {        /* Sigh, shouldn't occur BUT ... */
0382         printk(KERN_WARNING "%s: truncating oversized transmit packet!\n", sl->dev->name);
0383         sl->dev->stats.tx_dropped++;
0384         sl_unlock(sl);
0385         return;
0386     }
0387 
0388     p = icp;
0389 #ifdef SL_INCLUDE_CSLIP
0390     if (sl->mode & SL_MODE_CSLIP)
0391         len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
0392 #endif
0393 #ifdef CONFIG_SLIP_MODE_SLIP6
0394     if (sl->mode & SL_MODE_SLIP6)
0395         count = slip_esc6(p, sl->xbuff, len);
0396     else
0397 #endif
0398         count = slip_esc(p, sl->xbuff, len);
0399 
0400     /* Order of next two lines is *very* important.
0401      * When we are sending a little amount of data,
0402      * the transfer may be completed inside the ops->write()
0403      * routine, because it's running with interrupts enabled.
0404      * In this case we *never* got WRITE_WAKEUP event,
0405      * if we did not request it before write operation.
0406      *       14 Oct 1994  Dmitry Gorodchanin.
0407      */
0408     set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
0409     actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
0410 #ifdef SL_CHECK_TRANSMIT
0411     netif_trans_update(sl->dev);
0412 #endif
0413     sl->xleft = count - actual;
0414     sl->xhead = sl->xbuff + actual;
0415 #ifdef CONFIG_SLIP_SMART
0416     /* VSV */
0417     clear_bit(SLF_OUTWAIT, &sl->flags); /* reset outfill flag */
0418 #endif
0419 }
0420 
0421 /* Write out any remaining transmit buffer. Scheduled when tty is writable */
0422 static void slip_transmit(struct work_struct *work)
0423 {
0424     struct slip *sl = container_of(work, struct slip, tx_work);
0425     int actual;
0426 
0427     spin_lock_bh(&sl->lock);
0428     /* First make sure we're connected. */
0429     if (!sl->tty || sl->magic != SLIP_MAGIC || !netif_running(sl->dev)) {
0430         spin_unlock_bh(&sl->lock);
0431         return;
0432     }
0433 
0434     if (sl->xleft <= 0)  {
0435         /* Now serial buffer is almost free & we can start
0436          * transmission of another packet */
0437         sl->dev->stats.tx_packets++;
0438         clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
0439         spin_unlock_bh(&sl->lock);
0440         sl_unlock(sl);
0441         return;
0442     }
0443 
0444     actual = sl->tty->ops->write(sl->tty, sl->xhead, sl->xleft);
0445     sl->xleft -= actual;
0446     sl->xhead += actual;
0447     spin_unlock_bh(&sl->lock);
0448 }
0449 
0450 /*
0451  * Called by the driver when there's room for more data.
0452  * Schedule the transmit.
0453  */
0454 static void slip_write_wakeup(struct tty_struct *tty)
0455 {
0456     struct slip *sl;
0457 
0458     rcu_read_lock();
0459     sl = rcu_dereference(tty->disc_data);
0460     if (sl)
0461         schedule_work(&sl->tx_work);
0462     rcu_read_unlock();
0463 }
0464 
0465 static void sl_tx_timeout(struct net_device *dev, unsigned int txqueue)
0466 {
0467     struct slip *sl = netdev_priv(dev);
0468 
0469     spin_lock(&sl->lock);
0470 
0471     if (netif_queue_stopped(dev)) {
0472         if (!netif_running(dev) || !sl->tty)
0473             goto out;
0474 
0475         /* May be we must check transmitter timeout here ?
0476          *      14 Oct 1994 Dmitry Gorodchanin.
0477          */
0478 #ifdef SL_CHECK_TRANSMIT
0479         if (time_before(jiffies, dev_trans_start(dev) + 20 * HZ))  {
0480             /* 20 sec timeout not reached */
0481             goto out;
0482         }
0483         printk(KERN_WARNING "%s: transmit timed out, %s?\n",
0484             dev->name,
0485             (tty_chars_in_buffer(sl->tty) || sl->xleft) ?
0486                 "bad line quality" : "driver error");
0487         sl->xleft = 0;
0488         clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
0489         sl_unlock(sl);
0490 #endif
0491     }
0492 out:
0493     spin_unlock(&sl->lock);
0494 }
0495 
0496 
0497 /* Encapsulate an IP datagram and kick it into a TTY queue. */
0498 static netdev_tx_t
0499 sl_xmit(struct sk_buff *skb, struct net_device *dev)
0500 {
0501     struct slip *sl = netdev_priv(dev);
0502 
0503     spin_lock(&sl->lock);
0504     if (!netif_running(dev)) {
0505         spin_unlock(&sl->lock);
0506         printk(KERN_WARNING "%s: xmit call when iface is down\n", dev->name);
0507         dev_kfree_skb(skb);
0508         return NETDEV_TX_OK;
0509     }
0510     if (sl->tty == NULL) {
0511         spin_unlock(&sl->lock);
0512         dev_kfree_skb(skb);
0513         return NETDEV_TX_OK;
0514     }
0515 
0516     sl_lock(sl);
0517     dev->stats.tx_bytes += skb->len;
0518     sl_encaps(sl, skb->data, skb->len);
0519     spin_unlock(&sl->lock);
0520 
0521     dev_kfree_skb(skb);
0522     return NETDEV_TX_OK;
0523 }
0524 
0525 
0526 /******************************************
0527  *   Routines looking at netdevice side.
0528  ******************************************/
0529 
0530 /* Netdevice UP -> DOWN routine */
0531 
0532 static int
0533 sl_close(struct net_device *dev)
0534 {
0535     struct slip *sl = netdev_priv(dev);
0536 
0537     spin_lock_bh(&sl->lock);
0538     if (sl->tty)
0539         /* TTY discipline is running. */
0540         clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
0541     netif_stop_queue(dev);
0542     sl->rcount   = 0;
0543     sl->xleft    = 0;
0544     spin_unlock_bh(&sl->lock);
0545 
0546     return 0;
0547 }
0548 
0549 /* Netdevice DOWN -> UP routine */
0550 
0551 static int sl_open(struct net_device *dev)
0552 {
0553     struct slip *sl = netdev_priv(dev);
0554 
0555     if (sl->tty == NULL)
0556         return -ENODEV;
0557 
0558     sl->flags &= (1 << SLF_INUSE);
0559     netif_start_queue(dev);
0560     return 0;
0561 }
0562 
0563 /* Netdevice change MTU request */
0564 
0565 static int sl_change_mtu(struct net_device *dev, int new_mtu)
0566 {
0567     struct slip *sl = netdev_priv(dev);
0568 
0569     return sl_realloc_bufs(sl, new_mtu);
0570 }
0571 
0572 /* Netdevice get statistics request */
0573 
0574 static void
0575 sl_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
0576 {
0577     struct net_device_stats *devstats = &dev->stats;
0578 #ifdef SL_INCLUDE_CSLIP
0579     struct slip *sl = netdev_priv(dev);
0580     struct slcompress *comp = sl->slcomp;
0581 #endif
0582     stats->rx_packets     = devstats->rx_packets;
0583     stats->tx_packets     = devstats->tx_packets;
0584     stats->rx_bytes       = devstats->rx_bytes;
0585     stats->tx_bytes       = devstats->tx_bytes;
0586     stats->rx_dropped     = devstats->rx_dropped;
0587     stats->tx_dropped     = devstats->tx_dropped;
0588     stats->tx_errors      = devstats->tx_errors;
0589     stats->rx_errors      = devstats->rx_errors;
0590     stats->rx_over_errors = devstats->rx_over_errors;
0591 
0592 #ifdef SL_INCLUDE_CSLIP
0593     if (comp) {
0594         /* Generic compressed statistics */
0595         stats->rx_compressed   = comp->sls_i_compressed;
0596         stats->tx_compressed   = comp->sls_o_compressed;
0597 
0598         /* Are we really still needs this? */
0599         stats->rx_fifo_errors += comp->sls_i_compressed;
0600         stats->rx_dropped     += comp->sls_i_tossed;
0601         stats->tx_fifo_errors += comp->sls_o_compressed;
0602         stats->collisions     += comp->sls_o_misses;
0603     }
0604 #endif
0605 }
0606 
0607 /* Netdevice register callback */
0608 
0609 static int sl_init(struct net_device *dev)
0610 {
0611     struct slip *sl = netdev_priv(dev);
0612 
0613     /*
0614      *  Finish setting up the DEVICE info.
0615      */
0616 
0617     dev->mtu        = sl->mtu;
0618     dev->type       = ARPHRD_SLIP + sl->mode;
0619 #ifdef SL_CHECK_TRANSMIT
0620     dev->watchdog_timeo = 20*HZ;
0621 #endif
0622     return 0;
0623 }
0624 
0625 
0626 static void sl_uninit(struct net_device *dev)
0627 {
0628     struct slip *sl = netdev_priv(dev);
0629 
0630     sl_free_bufs(sl);
0631 }
0632 
0633 /* Hook the destructor so we can free slip devices at the right point in time */
0634 static void sl_free_netdev(struct net_device *dev)
0635 {
0636     int i = dev->base_addr;
0637 
0638     slip_devs[i] = NULL;
0639 }
0640 
0641 static const struct net_device_ops sl_netdev_ops = {
0642     .ndo_init       = sl_init,
0643     .ndo_uninit     = sl_uninit,
0644     .ndo_open       = sl_open,
0645     .ndo_stop       = sl_close,
0646     .ndo_start_xmit     = sl_xmit,
0647     .ndo_get_stats64        = sl_get_stats64,
0648     .ndo_change_mtu     = sl_change_mtu,
0649     .ndo_tx_timeout     = sl_tx_timeout,
0650 #ifdef CONFIG_SLIP_SMART
0651     .ndo_siocdevprivate = sl_siocdevprivate,
0652 #endif
0653 };
0654 
0655 
0656 static void sl_setup(struct net_device *dev)
0657 {
0658     dev->netdev_ops     = &sl_netdev_ops;
0659     dev->needs_free_netdev  = true;
0660     dev->priv_destructor    = sl_free_netdev;
0661 
0662     dev->hard_header_len    = 0;
0663     dev->addr_len       = 0;
0664     dev->tx_queue_len   = 10;
0665 
0666     /* MTU range: 68 - 65534 */
0667     dev->min_mtu = 68;
0668     dev->max_mtu = 65534;
0669 
0670     /* New-style flags. */
0671     dev->flags      = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
0672 }
0673 
0674 /******************************************
0675   Routines looking at TTY side.
0676  ******************************************/
0677 
0678 
0679 /*
0680  * Handle the 'receiver data ready' interrupt.
0681  * This function is called by the 'tty_io' module in the kernel when
0682  * a block of SLIP data has been received, which can now be decapsulated
0683  * and sent on to some IP layer for further processing. This will not
0684  * be re-entered while running but other ldisc functions may be called
0685  * in parallel
0686  */
0687 
0688 static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
0689         const char *fp, int count)
0690 {
0691     struct slip *sl = tty->disc_data;
0692 
0693     if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
0694         return;
0695 
0696     /* Read the characters out of the buffer */
0697     while (count--) {
0698         if (fp && *fp++) {
0699             if (!test_and_set_bit(SLF_ERROR, &sl->flags))
0700                 sl->dev->stats.rx_errors++;
0701             cp++;
0702             continue;
0703         }
0704 #ifdef CONFIG_SLIP_MODE_SLIP6
0705         if (sl->mode & SL_MODE_SLIP6)
0706             slip_unesc6(sl, *cp++);
0707         else
0708 #endif
0709             slip_unesc(sl, *cp++);
0710     }
0711 }
0712 
0713 /************************************
0714  *  slip_open helper routines.
0715  ************************************/
0716 
0717 /* Collect hanged up channels */
0718 static void sl_sync(void)
0719 {
0720     int i;
0721     struct net_device *dev;
0722     struct slip   *sl;
0723 
0724     for (i = 0; i < slip_maxdev; i++) {
0725         dev = slip_devs[i];
0726         if (dev == NULL)
0727             break;
0728 
0729         sl = netdev_priv(dev);
0730         if (sl->tty || sl->leased)
0731             continue;
0732         if (dev->flags & IFF_UP)
0733             dev_close(dev);
0734     }
0735 }
0736 
0737 
0738 /* Find a free SLIP channel, and link in this `tty' line. */
0739 static struct slip *sl_alloc(void)
0740 {
0741     int i;
0742     char name[IFNAMSIZ];
0743     struct net_device *dev = NULL;
0744     struct slip       *sl;
0745 
0746     for (i = 0; i < slip_maxdev; i++) {
0747         dev = slip_devs[i];
0748         if (dev == NULL)
0749             break;
0750     }
0751     /* Sorry, too many, all slots in use */
0752     if (i >= slip_maxdev)
0753         return NULL;
0754 
0755     sprintf(name, "sl%d", i);
0756     dev = alloc_netdev(sizeof(*sl), name, NET_NAME_UNKNOWN, sl_setup);
0757     if (!dev)
0758         return NULL;
0759 
0760     dev->base_addr  = i;
0761     sl = netdev_priv(dev);
0762 
0763     /* Initialize channel control data */
0764     sl->magic       = SLIP_MAGIC;
0765     sl->dev         = dev;
0766     spin_lock_init(&sl->lock);
0767     INIT_WORK(&sl->tx_work, slip_transmit);
0768     sl->mode        = SL_MODE_DEFAULT;
0769 #ifdef CONFIG_SLIP_SMART
0770     /* initialize timer_list struct */
0771     timer_setup(&sl->keepalive_timer, sl_keepalive, 0);
0772     timer_setup(&sl->outfill_timer, sl_outfill, 0);
0773 #endif
0774     slip_devs[i] = dev;
0775     return sl;
0776 }
0777 
0778 /*
0779  * Open the high-level part of the SLIP channel.
0780  * This function is called by the TTY module when the
0781  * SLIP line discipline is called for.  Because we are
0782  * sure the tty line exists, we only have to link it to
0783  * a free SLIP channel...
0784  *
0785  * Called in process context serialized from other ldisc calls.
0786  */
0787 
0788 static int slip_open(struct tty_struct *tty)
0789 {
0790     struct slip *sl;
0791     int err;
0792 
0793     if (!capable(CAP_NET_ADMIN))
0794         return -EPERM;
0795 
0796     if (tty->ops->write == NULL)
0797         return -EOPNOTSUPP;
0798 
0799     /* RTnetlink lock is misused here to serialize concurrent
0800        opens of slip channels. There are better ways, but it is
0801        the simplest one.
0802      */
0803     rtnl_lock();
0804 
0805     /* Collect hanged up channels. */
0806     sl_sync();
0807 
0808     sl = tty->disc_data;
0809 
0810     err = -EEXIST;
0811     /* First make sure we're not already connected. */
0812     if (sl && sl->magic == SLIP_MAGIC)
0813         goto err_exit;
0814 
0815     /* OK.  Find a free SLIP channel to use. */
0816     err = -ENFILE;
0817     sl = sl_alloc();
0818     if (sl == NULL)
0819         goto err_exit;
0820 
0821     sl->tty = tty;
0822     tty->disc_data = sl;
0823     sl->pid = current->pid;
0824 
0825     if (!test_bit(SLF_INUSE, &sl->flags)) {
0826         /* Perform the low-level SLIP initialization. */
0827         err = sl_alloc_bufs(sl, SL_MTU);
0828         if (err)
0829             goto err_free_chan;
0830 
0831         set_bit(SLF_INUSE, &sl->flags);
0832 
0833         err = register_netdevice(sl->dev);
0834         if (err)
0835             goto err_free_bufs;
0836     }
0837 
0838 #ifdef CONFIG_SLIP_SMART
0839     if (sl->keepalive) {
0840         sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
0841         add_timer(&sl->keepalive_timer);
0842     }
0843     if (sl->outfill) {
0844         sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
0845         add_timer(&sl->outfill_timer);
0846     }
0847 #endif
0848 
0849     /* Done.  We have linked the TTY line to a channel. */
0850     rtnl_unlock();
0851     tty->receive_room = 65536;  /* We don't flow control */
0852 
0853     /* TTY layer expects 0 on success */
0854     return 0;
0855 
0856 err_free_bufs:
0857     sl_free_bufs(sl);
0858 
0859 err_free_chan:
0860     sl->tty = NULL;
0861     tty->disc_data = NULL;
0862     clear_bit(SLF_INUSE, &sl->flags);
0863     sl_free_netdev(sl->dev);
0864     /* do not call free_netdev before rtnl_unlock */
0865     rtnl_unlock();
0866     free_netdev(sl->dev);
0867     return err;
0868 
0869 err_exit:
0870     rtnl_unlock();
0871 
0872     /* Count references from TTY module */
0873     return err;
0874 }
0875 
0876 /*
0877  * Close down a SLIP channel.
0878  * This means flushing out any pending queues, and then returning. This
0879  * call is serialized against other ldisc functions.
0880  *
0881  * We also use this method fo a hangup event
0882  */
0883 
0884 static void slip_close(struct tty_struct *tty)
0885 {
0886     struct slip *sl = tty->disc_data;
0887 
0888     /* First make sure we're connected. */
0889     if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
0890         return;
0891 
0892     spin_lock_bh(&sl->lock);
0893     rcu_assign_pointer(tty->disc_data, NULL);
0894     sl->tty = NULL;
0895     spin_unlock_bh(&sl->lock);
0896 
0897     synchronize_rcu();
0898     flush_work(&sl->tx_work);
0899 
0900     /* VSV = very important to remove timers */
0901 #ifdef CONFIG_SLIP_SMART
0902     del_timer_sync(&sl->keepalive_timer);
0903     del_timer_sync(&sl->outfill_timer);
0904 #endif
0905     /* Flush network side */
0906     unregister_netdev(sl->dev);
0907     /* This will complete via sl_free_netdev */
0908 }
0909 
0910 static void slip_hangup(struct tty_struct *tty)
0911 {
0912     slip_close(tty);
0913 }
0914  /************************************************************************
0915   *         STANDARD SLIP ENCAPSULATION          *
0916   ************************************************************************/
0917 
0918 static int slip_esc(unsigned char *s, unsigned char *d, int len)
0919 {
0920     unsigned char *ptr = d;
0921     unsigned char c;
0922 
0923     /*
0924      * Send an initial END character to flush out any
0925      * data that may have accumulated in the receiver
0926      * due to line noise.
0927      */
0928 
0929     *ptr++ = END;
0930 
0931     /*
0932      * For each byte in the packet, send the appropriate
0933      * character sequence, according to the SLIP protocol.
0934      */
0935 
0936     while (len-- > 0) {
0937         switch (c = *s++) {
0938         case END:
0939             *ptr++ = ESC;
0940             *ptr++ = ESC_END;
0941             break;
0942         case ESC:
0943             *ptr++ = ESC;
0944             *ptr++ = ESC_ESC;
0945             break;
0946         default:
0947             *ptr++ = c;
0948             break;
0949         }
0950     }
0951     *ptr++ = END;
0952     return ptr - d;
0953 }
0954 
0955 static void slip_unesc(struct slip *sl, unsigned char s)
0956 {
0957 
0958     switch (s) {
0959     case END:
0960 #ifdef CONFIG_SLIP_SMART
0961         /* drop keeptest bit = VSV */
0962         if (test_bit(SLF_KEEPTEST, &sl->flags))
0963             clear_bit(SLF_KEEPTEST, &sl->flags);
0964 #endif
0965 
0966         if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
0967             (sl->rcount > 2))
0968             sl_bump(sl);
0969         clear_bit(SLF_ESCAPE, &sl->flags);
0970         sl->rcount = 0;
0971         return;
0972 
0973     case ESC:
0974         set_bit(SLF_ESCAPE, &sl->flags);
0975         return;
0976     case ESC_ESC:
0977         if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
0978             s = ESC;
0979         break;
0980     case ESC_END:
0981         if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
0982             s = END;
0983         break;
0984     }
0985     if (!test_bit(SLF_ERROR, &sl->flags))  {
0986         if (sl->rcount < sl->buffsize)  {
0987             sl->rbuff[sl->rcount++] = s;
0988             return;
0989         }
0990         sl->dev->stats.rx_over_errors++;
0991         set_bit(SLF_ERROR, &sl->flags);
0992     }
0993 }
0994 
0995 
0996 #ifdef CONFIG_SLIP_MODE_SLIP6
0997 /************************************************************************
0998  *           6 BIT SLIP ENCAPSULATION           *
0999  ************************************************************************/
1000 
1001 static int slip_esc6(unsigned char *s, unsigned char *d, int len)
1002 {
1003     unsigned char *ptr = d;
1004     unsigned char c;
1005     int i;
1006     unsigned short v = 0;
1007     short bits = 0;
1008 
1009     /*
1010      * Send an initial END character to flush out any
1011      * data that may have accumulated in the receiver
1012      * due to line noise.
1013      */
1014 
1015     *ptr++ = 0x70;
1016 
1017     /*
1018      * Encode the packet into printable ascii characters
1019      */
1020 
1021     for (i = 0; i < len; ++i) {
1022         v = (v << 8) | s[i];
1023         bits += 8;
1024         while (bits >= 6) {
1025             bits -= 6;
1026             c = 0x30 + ((v >> bits) & 0x3F);
1027             *ptr++ = c;
1028         }
1029     }
1030     if (bits) {
1031         c = 0x30 + ((v << (6 - bits)) & 0x3F);
1032         *ptr++ = c;
1033     }
1034     *ptr++ = 0x70;
1035     return ptr - d;
1036 }
1037 
1038 static void slip_unesc6(struct slip *sl, unsigned char s)
1039 {
1040     unsigned char c;
1041 
1042     if (s == 0x70) {
1043 #ifdef CONFIG_SLIP_SMART
1044         /* drop keeptest bit = VSV */
1045         if (test_bit(SLF_KEEPTEST, &sl->flags))
1046             clear_bit(SLF_KEEPTEST, &sl->flags);
1047 #endif
1048 
1049         if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
1050             (sl->rcount > 2))
1051             sl_bump(sl);
1052         sl->rcount = 0;
1053         sl->xbits = 0;
1054         sl->xdata = 0;
1055     } else if (s >= 0x30 && s < 0x70) {
1056         sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1057         sl->xbits += 6;
1058         if (sl->xbits >= 8) {
1059             sl->xbits -= 8;
1060             c = (unsigned char)(sl->xdata >> sl->xbits);
1061             if (!test_bit(SLF_ERROR, &sl->flags))  {
1062                 if (sl->rcount < sl->buffsize)  {
1063                     sl->rbuff[sl->rcount++] = c;
1064                     return;
1065                 }
1066                 sl->dev->stats.rx_over_errors++;
1067                 set_bit(SLF_ERROR, &sl->flags);
1068             }
1069         }
1070     }
1071 }
1072 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1073 
1074 /* Perform I/O control on an active SLIP channel. */
1075 static int slip_ioctl(struct tty_struct *tty, unsigned int cmd,
1076         unsigned long arg)
1077 {
1078     struct slip *sl = tty->disc_data;
1079     unsigned int tmp;
1080     int __user *p = (int __user *)arg;
1081 
1082     /* First make sure we're connected. */
1083     if (!sl || sl->magic != SLIP_MAGIC)
1084         return -EINVAL;
1085 
1086     switch (cmd) {
1087     case SIOCGIFNAME:
1088         tmp = strlen(sl->dev->name) + 1;
1089         if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1090             return -EFAULT;
1091         return 0;
1092 
1093     case SIOCGIFENCAP:
1094         if (put_user(sl->mode, p))
1095             return -EFAULT;
1096         return 0;
1097 
1098     case SIOCSIFENCAP:
1099         if (get_user(tmp, p))
1100             return -EFAULT;
1101 #ifndef SL_INCLUDE_CSLIP
1102         if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
1103             return -EINVAL;
1104 #else
1105         if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1106             (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
1107             /* return -EINVAL; */
1108             tmp &= ~SL_MODE_ADAPTIVE;
1109 #endif
1110 #ifndef CONFIG_SLIP_MODE_SLIP6
1111         if (tmp & SL_MODE_SLIP6)
1112             return -EINVAL;
1113 #endif
1114         sl->mode = tmp;
1115         sl->dev->type = ARPHRD_SLIP + sl->mode;
1116         return 0;
1117 
1118     case SIOCSIFHWADDR:
1119         return -EINVAL;
1120 
1121 #ifdef CONFIG_SLIP_SMART
1122     /* VSV changes start here */
1123     case SIOCSKEEPALIVE:
1124         if (get_user(tmp, p))
1125             return -EFAULT;
1126         if (tmp > 255) /* max for unchar */
1127             return -EINVAL;
1128 
1129         spin_lock_bh(&sl->lock);
1130         if (!sl->tty) {
1131             spin_unlock_bh(&sl->lock);
1132             return -ENODEV;
1133         }
1134         sl->keepalive = (u8)tmp;
1135         if (sl->keepalive != 0) {
1136             mod_timer(&sl->keepalive_timer,
1137                     jiffies + sl->keepalive * HZ);
1138             set_bit(SLF_KEEPTEST, &sl->flags);
1139         } else
1140             del_timer(&sl->keepalive_timer);
1141         spin_unlock_bh(&sl->lock);
1142         return 0;
1143 
1144     case SIOCGKEEPALIVE:
1145         if (put_user(sl->keepalive, p))
1146             return -EFAULT;
1147         return 0;
1148 
1149     case SIOCSOUTFILL:
1150         if (get_user(tmp, p))
1151             return -EFAULT;
1152         if (tmp > 255) /* max for unchar */
1153             return -EINVAL;
1154         spin_lock_bh(&sl->lock);
1155         if (!sl->tty) {
1156             spin_unlock_bh(&sl->lock);
1157             return -ENODEV;
1158         }
1159         sl->outfill = (u8)tmp;
1160         if (sl->outfill != 0) {
1161             mod_timer(&sl->outfill_timer,
1162                         jiffies + sl->outfill * HZ);
1163             set_bit(SLF_OUTWAIT, &sl->flags);
1164         } else
1165             del_timer(&sl->outfill_timer);
1166         spin_unlock_bh(&sl->lock);
1167         return 0;
1168 
1169     case SIOCGOUTFILL:
1170         if (put_user(sl->outfill, p))
1171             return -EFAULT;
1172         return 0;
1173     /* VSV changes end */
1174 #endif
1175     default:
1176         return tty_mode_ioctl(tty, cmd, arg);
1177     }
1178 }
1179 
1180 /* VSV changes start here */
1181 #ifdef CONFIG_SLIP_SMART
1182 /* function sl_siocdevprivate called from net/core/dev.c
1183    to allow get/set outfill/keepalive parameter
1184    by ifconfig                                 */
1185 
1186 static int sl_siocdevprivate(struct net_device *dev, struct ifreq *rq,
1187                  void __user *data, int cmd)
1188 {
1189     struct slip *sl = netdev_priv(dev);
1190     unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1191 
1192     if (sl == NULL)     /* Allocation failed ?? */
1193         return -ENODEV;
1194 
1195     if (in_compat_syscall())
1196         return -EOPNOTSUPP;
1197 
1198     spin_lock_bh(&sl->lock);
1199 
1200     if (!sl->tty) {
1201         spin_unlock_bh(&sl->lock);
1202         return -ENODEV;
1203     }
1204 
1205     switch (cmd) {
1206     case SIOCSKEEPALIVE:
1207         /* max for unchar */
1208         if ((unsigned)*p > 255) {
1209             spin_unlock_bh(&sl->lock);
1210             return -EINVAL;
1211         }
1212         sl->keepalive = (u8)*p;
1213         if (sl->keepalive != 0) {
1214             sl->keepalive_timer.expires =
1215                         jiffies + sl->keepalive * HZ;
1216             mod_timer(&sl->keepalive_timer,
1217                         jiffies + sl->keepalive * HZ);
1218             set_bit(SLF_KEEPTEST, &sl->flags);
1219         } else
1220             del_timer(&sl->keepalive_timer);
1221         break;
1222 
1223     case SIOCGKEEPALIVE:
1224         *p = sl->keepalive;
1225         break;
1226 
1227     case SIOCSOUTFILL:
1228         if ((unsigned)*p > 255) { /* max for unchar */
1229             spin_unlock_bh(&sl->lock);
1230             return -EINVAL;
1231         }
1232         sl->outfill = (u8)*p;
1233         if (sl->outfill != 0) {
1234             mod_timer(&sl->outfill_timer,
1235                         jiffies + sl->outfill * HZ);
1236             set_bit(SLF_OUTWAIT, &sl->flags);
1237         } else
1238             del_timer(&sl->outfill_timer);
1239         break;
1240 
1241     case SIOCGOUTFILL:
1242         *p = sl->outfill;
1243         break;
1244 
1245     case SIOCSLEASE:
1246         /* Resolve race condition, when ioctl'ing hanged up
1247            and opened by another process device.
1248          */
1249         if (sl->tty != current->signal->tty &&
1250                         sl->pid != current->pid) {
1251             spin_unlock_bh(&sl->lock);
1252             return -EPERM;
1253         }
1254         sl->leased = 0;
1255         if (*p)
1256             sl->leased = 1;
1257         break;
1258 
1259     case SIOCGLEASE:
1260         *p = sl->leased;
1261     }
1262     spin_unlock_bh(&sl->lock);
1263     return 0;
1264 }
1265 #endif
1266 /* VSV changes end */
1267 
1268 static struct tty_ldisc_ops sl_ldisc = {
1269     .owner      = THIS_MODULE,
1270     .num        = N_SLIP,
1271     .name       = "slip",
1272     .open       = slip_open,
1273     .close      = slip_close,
1274     .hangup     = slip_hangup,
1275     .ioctl      = slip_ioctl,
1276     .receive_buf    = slip_receive_buf,
1277     .write_wakeup   = slip_write_wakeup,
1278 };
1279 
1280 static int __init slip_init(void)
1281 {
1282     int status;
1283 
1284     if (slip_maxdev < 4)
1285         slip_maxdev = 4; /* Sanity */
1286 
1287     printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1288 #ifdef CONFIG_SLIP_MODE_SLIP6
1289            " (6 bit encapsulation enabled)"
1290 #endif
1291            ".\n",
1292            SLIP_VERSION, slip_maxdev);
1293 #if defined(SL_INCLUDE_CSLIP)
1294     printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1295 #endif
1296 #ifdef CONFIG_SLIP_SMART
1297     printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1298 #endif
1299 
1300     slip_devs = kcalloc(slip_maxdev, sizeof(struct net_device *),
1301                                 GFP_KERNEL);
1302     if (!slip_devs)
1303         return -ENOMEM;
1304 
1305     /* Fill in our line protocol discipline, and register it */
1306     status = tty_register_ldisc(&sl_ldisc);
1307     if (status != 0) {
1308         printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1309         kfree(slip_devs);
1310     }
1311     return status;
1312 }
1313 
1314 static void __exit slip_exit(void)
1315 {
1316     int i;
1317     struct net_device *dev;
1318     struct slip *sl;
1319     unsigned long timeout = jiffies + HZ;
1320     int busy = 0;
1321 
1322     if (slip_devs == NULL)
1323         return;
1324 
1325     /* First of all: check for active disciplines and hangup them.
1326      */
1327     do {
1328         if (busy)
1329             msleep_interruptible(100);
1330 
1331         busy = 0;
1332         for (i = 0; i < slip_maxdev; i++) {
1333             dev = slip_devs[i];
1334             if (!dev)
1335                 continue;
1336             sl = netdev_priv(dev);
1337             spin_lock_bh(&sl->lock);
1338             if (sl->tty) {
1339                 busy++;
1340                 tty_hangup(sl->tty);
1341             }
1342             spin_unlock_bh(&sl->lock);
1343         }
1344     } while (busy && time_before(jiffies, timeout));
1345 
1346     /* FIXME: hangup is async so we should wait when doing this second
1347        phase */
1348 
1349     for (i = 0; i < slip_maxdev; i++) {
1350         dev = slip_devs[i];
1351         if (!dev)
1352             continue;
1353         slip_devs[i] = NULL;
1354 
1355         sl = netdev_priv(dev);
1356         if (sl->tty) {
1357             printk(KERN_ERR "%s: tty discipline still running\n",
1358                    dev->name);
1359         }
1360 
1361         unregister_netdev(dev);
1362     }
1363 
1364     kfree(slip_devs);
1365     slip_devs = NULL;
1366 
1367     tty_unregister_ldisc(&sl_ldisc);
1368 }
1369 
1370 module_init(slip_init);
1371 module_exit(slip_exit);
1372 
1373 #ifdef CONFIG_SLIP_SMART
1374 /*
1375  * This is start of the code for multislip style line checking
1376  * added by Stanislav Voronyi. All changes before marked VSV
1377  */
1378 
1379 static void sl_outfill(struct timer_list *t)
1380 {
1381     struct slip *sl = from_timer(sl, t, outfill_timer);
1382 
1383     spin_lock(&sl->lock);
1384 
1385     if (sl->tty == NULL)
1386         goto out;
1387 
1388     if (sl->outfill) {
1389         if (test_bit(SLF_OUTWAIT, &sl->flags)) {
1390             /* no packets were transmitted, do outfill */
1391 #ifdef CONFIG_SLIP_MODE_SLIP6
1392             unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1393 #else
1394             unsigned char s = END;
1395 #endif
1396             /* put END into tty queue. Is it right ??? */
1397             if (!netif_queue_stopped(sl->dev)) {
1398                 /* if device busy no outfill */
1399                 sl->tty->ops->write(sl->tty, &s, 1);
1400             }
1401         } else
1402             set_bit(SLF_OUTWAIT, &sl->flags);
1403 
1404         mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1405     }
1406 out:
1407     spin_unlock(&sl->lock);
1408 }
1409 
1410 static void sl_keepalive(struct timer_list *t)
1411 {
1412     struct slip *sl = from_timer(sl, t, keepalive_timer);
1413 
1414     spin_lock(&sl->lock);
1415 
1416     if (sl->tty == NULL)
1417         goto out;
1418 
1419     if (sl->keepalive) {
1420         if (test_bit(SLF_KEEPTEST, &sl->flags)) {
1421             /* keepalive still high :(, we must hangup */
1422             if (sl->outfill)
1423                 /* outfill timer must be deleted too */
1424                 (void)del_timer(&sl->outfill_timer);
1425             printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1426             /* this must hangup tty & close slip */
1427             tty_hangup(sl->tty);
1428             /* I think we need not something else */
1429             goto out;
1430         } else
1431             set_bit(SLF_KEEPTEST, &sl->flags);
1432 
1433         mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1434     }
1435 out:
1436     spin_unlock(&sl->lock);
1437 }
1438 
1439 #endif
1440 MODULE_LICENSE("GPL");
1441 MODULE_ALIAS_LDISC(N_SLIP);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!