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 0;
 488         }
 489         if (sl->tty == NULL) {
 490                 spin_unlock(&sl->lock);
 491                 dev_kfree_skb(skb);
 492                 return 0;
 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 0;
 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->tx_timeout         = sl_tx_timeout;
 607         dev->watchdog_timeo     = 20*HZ;
 608 #endif
 609         return 0;
 610 }
 611
 612
 613 static void sl_uninit(struct net_device *dev)
 614 {
 615         struct slip *sl = netdev_priv(dev);
 616
 617         sl_free_bufs(sl);
 618 }
 619
 620 static void sl_setup(struct net_device *dev)
 621 {
 622         dev->init               = sl_init;
 623         dev->uninit             = sl_uninit;
 624         dev->open               = sl_open;
 625         dev->destructor         = free_netdev;
 626         dev->stop               = sl_close;
 627         dev->get_stats          = sl_get_stats;
 628         dev->change_mtu         = sl_change_mtu;
 629         dev->hard_start_xmit    = sl_xmit;
 630 #ifdef CONFIG_SLIP_SMART
 631         dev->do_ioctl           = sl_ioctl;
 632 #endif
 633         dev->hard_header_len    = 0;
 634         dev->addr_len           = 0;
 635         dev->tx_queue_len       = 10;
 636
 637         /* New-style flags. */
 638         dev->flags              = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
 639 }
 640
 641 /******************************************
 642   Routines looking at TTY side.
 643  ******************************************/
 644
 645
 646 /*
 647  * Handle the 'receiver data ready' interrupt.
 648  * This function is called by the 'tty_io' module in the kernel when
 649  * a block of SLIP data has been received, which can now be decapsulated
 650  * and sent on to some IP layer for further processing. This will not
 651  * be re-entered while running but other ldisc functions may be called
 652  * in parallel
 653  */
 654
 655 static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 656                                                         char *fp, int count)
 657 {
 658         struct slip *sl = tty->disc_data;
 659
 660         if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
 661                 return;
 662
 663         /* Read the characters out of the buffer */
 664         while (count--) {
 665                 if (fp && *fp++) {
 666                         if (!test_and_set_bit(SLF_ERROR, &sl->flags))
 667                                 sl->rx_errors++;
 668                         cp++;
 669                         continue;
 670                 }
 671 #ifdef CONFIG_SLIP_MODE_SLIP6
 672                 if (sl->mode & SL_MODE_SLIP6)
 673                         slip_unesc6(sl, *cp++);
 674                 else
 675 #endif
 676                         slip_unesc(sl, *cp++);
 677         }
 678 }
 679
 680 /************************************
 681  *  slip_open helper routines.
 682  ************************************/
 683
 684 /* Collect hanged up channels */
 685 static void sl_sync(void)
 686 {
 687         int i;
 688         struct net_device *dev;
 689         struct slip       *sl;
 690
 691         for (i = 0; i < slip_maxdev; i++) {
 692                 dev = slip_devs[i];
 693                 if (dev == NULL)
 694                         break;
 695
 696                 sl = netdev_priv(dev);
 697                 if (sl->tty || sl->leased)
 698                         continue;
 699                 if (dev->flags & IFF_UP)
 700                         dev_close(dev);
 701         }
 702 }
 703
 704
 705 /* Find a free SLIP channel, and link in this `tty' line. */
 706 static struct slip *sl_alloc(dev_t line)
 707 {
 708         int i;
 709         int sel = -1;
 710         int score = -1;
 711         struct net_device *dev = NULL;
 712         struct slip       *sl;
 713
 714         if (slip_devs == NULL)
 715                 return NULL;    /* Master array missing ! */
 716
 717         for (i = 0; i < slip_maxdev; i++) {
 718                 dev = slip_devs[i];
 719                 if (dev == NULL)
 720                         break;
 721
 722                 sl = netdev_priv(dev);
 723                 if (sl->leased) {
 724                         if (sl->line != line)
 725                                 continue;
 726                         if (sl->tty)
 727                                 return NULL;
 728
 729                         /* Clear ESCAPE & ERROR flags */
 730                         sl->flags &= (1 << SLF_INUSE);
 731                         return sl;
 732                 }
 733
 734                 if (sl->tty)
 735                         continue;
 736
 737                 if (current->pid == sl->pid) {
 738                         if (sl->line == line && score < 3) {
 739                                 sel = i;
 740                                 score = 3;
 741                                 continue;
 742                         }
 743                         if (score < 2) {
 744                                 sel = i;
 745                                 score = 2;
 746                         }
 747                         continue;
 748                 }
 749                 if (sl->line == line && score < 1) {
 750                         sel = i;
 751                         score = 1;
 752                         continue;
 753                 }
 754                 if (score < 0) {
 755                         sel = i;
 756                         score = 0;
 757                 }
 758         }
 759
 760         if (sel >= 0) {
 761                 i = sel;
 762                 dev = slip_devs[i];
 763                 if (score > 1) {
 764                         sl = netdev_priv(dev);
 765                         sl->flags &= (1 << SLF_INUSE);
 766                         return sl;
 767                 }
 768         }
 769
 770         /* Sorry, too many, all slots in use */
 771         if (i >= slip_maxdev)
 772                 return NULL;
 773
 774         if (dev) {
 775                 sl = netdev_priv(dev);
 776                 if (test_bit(SLF_INUSE, &sl->flags)) {
 777                         unregister_netdevice(dev);
 778                         dev = NULL;
 779                         slip_devs[i] = NULL;
 780                 }
 781         }
 782
 783         if (!dev) {
 784                 char name[IFNAMSIZ];
 785                 sprintf(name, "sl%d", i);
 786
 787                 dev = alloc_netdev(sizeof(*sl), name, sl_setup);
 788                 if (!dev)
 789                         return NULL;
 790                 dev->base_addr  = i;
 791         }
 792
 793         sl = netdev_priv(dev);
 794
 795         /* Initialize channel control data */
 796         sl->magic       = SLIP_MAGIC;
 797         sl->dev         = dev;
 798         spin_lock_init(&sl->lock);
 799         sl->mode        = SL_MODE_DEFAULT;
 800 #ifdef CONFIG_SLIP_SMART
 801         /* initialize timer_list struct */
 802         init_timer(&sl->keepalive_timer);
 803         sl->keepalive_timer.data = (unsigned long)sl;
 804         sl->keepalive_timer.function = sl_keepalive;
 805         init_timer(&sl->outfill_timer);
 806         sl->outfill_timer.data = (unsigned long)sl;
 807         sl->outfill_timer.function = sl_outfill;
 808 #endif
 809         slip_devs[i] = dev;
 810         return sl;
 811 }
 812
 813 /*
 814  * Open the high-level part of the SLIP channel.
 815  * This function is called by the TTY module when the
 816  * SLIP line discipline is called for.  Because we are
 817  * sure the tty line exists, we only have to link it to
 818  * a free SLIP channel...
 819  *
 820  * Called in process context serialized from other ldisc calls.
 821  */
 822
 823 static int slip_open(struct tty_struct *tty)
 824 {
 825         struct slip *sl;
 826         int err;
 827
 828         if (!capable(CAP_NET_ADMIN))
 829                 return -EPERM;
 830
 831         if (tty->ops->write == NULL)
 832                 return -EOPNOTSUPP;
 833
 834         /* RTnetlink lock is misused here to serialize concurrent
 835            opens of slip channels. There are better ways, but it is
 836            the simplest one.
 837          */
 838         rtnl_lock();
 839
 840         /* Collect hanged up channels. */
 841         sl_sync();
 842
 843         sl = tty->disc_data;
 844
 845         err = -EEXIST;
 846         /* First make sure we're not already connected. */
 847         if (sl && sl->magic == SLIP_MAGIC)
 848                 goto err_exit;
 849
 850         /* OK.  Find a free SLIP channel to use. */
 851         err = -ENFILE;
 852         sl = sl_alloc(tty_devnum(tty));
 853         if (sl == NULL)
 854                 goto err_exit;
 855
 856         sl->tty = tty;
 857         tty->disc_data = sl;
 858         sl->line = tty_devnum(tty);
 859         sl->pid = current->pid;
 860
 861         if (!test_bit(SLF_INUSE, &sl->flags)) {
 862                 /* Perform the low-level SLIP initialization. */
 863                 err = sl_alloc_bufs(sl, SL_MTU);
 864                 if (err)
 865                         goto err_free_chan;
 866
 867                 set_bit(SLF_INUSE, &sl->flags);
 868
 869                 err = register_netdevice(sl->dev);
 870                 if (err)
 871                         goto err_free_bufs;
 872         }
 873
 874 #ifdef CONFIG_SLIP_SMART
 875         if (sl->keepalive) {
 876                 sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
 877                 add_timer(&sl->keepalive_timer);
 878         }
 879         if (sl->outfill) {
 880                 sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
 881                 add_timer(&sl->outfill_timer);
 882         }
 883 #endif
 884
 885         /* Done.  We have linked the TTY line to a channel. */
 886         rtnl_unlock();
 887         tty->receive_room = 65536;      /* We don't flow control */
 888         return sl->dev->base_addr;
 889
 890 err_free_bufs:
 891         sl_free_bufs(sl);
 892
 893 err_free_chan:
 894         sl->tty = NULL;
 895         tty->disc_data = NULL;
 896         clear_bit(SLF_INUSE, &sl->flags);
 897
 898 err_exit:
 899         rtnl_unlock();
 900
 901         /* Count references from TTY module */
 902         return err;
 903 }
 904
 905 /*
 906
 907   FIXME: 1,2 are fixed 3 was never true anyway.
 908
 909    Let me to blame a bit.
 910    1. TTY module calls this funstion on soft interrupt.
 911    2. TTY module calls this function WITH MASKED INTERRUPTS!
 912    3. TTY module does not notify us about line discipline
 913       shutdown,
 914
 915    Seems, now it is clean. The solution is to consider netdevice and
 916    line discipline sides as two independent threads.
 917
 918    By-product (not desired): sl? does not feel hangups and remains open.
 919    It is supposed, that user level program (dip, diald, slattach...)
 920    will catch SIGHUP and make the rest of work.
 921
 922    I see no way to make more with current tty code. --ANK
 923  */
 924
 925 /*
 926  * Close down a SLIP channel.
 927  * This means flushing out any pending queues, and then returning. This
 928  * call is serialized against other ldisc functions.
 929  */
 930 static void slip_close(struct tty_struct *tty)
 931 {
 932         struct slip *sl = tty->disc_data;
 933
 934         /* First make sure we're connected. */
 935         if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
 936                 return;
 937
 938         tty->disc_data = NULL;
 939         sl->tty = NULL;
 940         if (!sl->leased)
 941                 sl->line = 0;
 942
 943         /* VSV = very important to remove timers */
 944 #ifdef CONFIG_SLIP_SMART
 945         del_timer_sync(&sl->keepalive_timer);
 946         del_timer_sync(&sl->outfill_timer);
 947 #endif
 948
 949         /* Count references from TTY module */
 950 }
 951
 952  /************************************************************************
 953   *                     STANDARD SLIP ENCAPSULATION                      *
 954   ************************************************************************/
 955
 956 static int slip_esc(unsigned char *s, unsigned char *d, int len)
 957 {
 958         unsigned char *ptr = d;
 959         unsigned char c;
 960
 961         /*
 962          * Send an initial END character to flush out any
 963          * data that may have accumulated in the receiver
 964          * due to line noise.
 965          */
 966
 967         *ptr++ = END;
 968
 969         /*
 970          * For each byte in the packet, send the appropriate
 971          * character sequence, according to the SLIP protocol.
 972          */
 973
 974         while (len-- > 0) {
 975                 switch (c = *s++) {
 976                 case END:
 977                         *ptr++ = ESC;
 978                         *ptr++ = ESC_END;
 979                         break;
 980                 case ESC:
 981                         *ptr++ = ESC;
 982                         *ptr++ = ESC_ESC;
 983                         break;
 984                 default:
 985                         *ptr++ = c;
 986                         break;
 987                 }
 988         }
 989         *ptr++ = END;
 990         return (ptr - d);
 991 }
 992
 993 static void slip_unesc(struct slip *sl, unsigned char s)
 994 {
 995
 996         switch (s) {
 997         case END:
 998 #ifdef CONFIG_SLIP_SMART
 999                 /* drop keeptest bit = VSV */
1000                 if (test_bit(SLF_KEEPTEST, &sl->flags))
1001                         clear_bit(SLF_KEEPTEST, &sl->flags);
1002 #endif
1003
1004                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1005                                                         && (sl->rcount > 2))
1006                         sl_bump(sl);
1007                 clear_bit(SLF_ESCAPE, &sl->flags);
1008                 sl->rcount = 0;
1009                 return;
1010
1011         case ESC:
1012                 set_bit(SLF_ESCAPE, &sl->flags);
1013                 return;
1014         case ESC_ESC:
1015                 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
1016                         s = ESC;
1017                 break;
1018         case ESC_END:
1019                 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
1020                         s = END;
1021                 break;
1022         }
1023         if (!test_bit(SLF_ERROR, &sl->flags))  {
1024                 if (sl->rcount < sl->buffsize)  {
1025                         sl->rbuff[sl->rcount++] = s;
1026                         return;
1027                 }
1028                 sl->rx_over_errors++;
1029                 set_bit(SLF_ERROR, &sl->flags);
1030         }
1031 }
1032
1033
1034 #ifdef CONFIG_SLIP_MODE_SLIP6
1035 /************************************************************************
1036  *                       6 BIT SLIP ENCAPSULATION                       *
1037  ************************************************************************/
1038
1039 static int slip_esc6(unsigned char *s, unsigned char *d, int len)
1040 {
1041         unsigned char *ptr = d;
1042         unsigned char c;
1043         int i;
1044         unsigned short v = 0;
1045         short bits = 0;
1046
1047         /*
1048          * Send an initial END character to flush out any
1049          * data that may have accumulated in the receiver
1050          * due to line noise.
1051          */
1052
1053         *ptr++ = 0x70;
1054
1055         /*
1056          * Encode the packet into printable ascii characters
1057          */
1058
1059         for (i = 0; i < len; ++i) {
1060                 v = (v << 8) | s[i];
1061                 bits += 8;
1062                 while (bits >= 6) {
1063                         bits -= 6;
1064                         c = 0x30 + ((v >> bits) & 0x3F);
1065                         *ptr++ = c;
1066                 }
1067         }
1068         if (bits) {
1069                 c = 0x30 + ((v << (6 - bits)) & 0x3F);
1070                 *ptr++ = c;
1071         }
1072         *ptr++ = 0x70;
1073         return ptr - d;
1074 }
1075
1076 static void slip_unesc6(struct slip *sl, unsigned char s)
1077 {
1078         unsigned char c;
1079
1080         if (s == 0x70) {
1081 #ifdef CONFIG_SLIP_SMART
1082                 /* drop keeptest bit = VSV */
1083                 if (test_bit(SLF_KEEPTEST, &sl->flags))
1084                         clear_bit(SLF_KEEPTEST, &sl->flags);
1085 #endif
1086
1087                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1088                                                         && (sl->rcount > 2))
1089                         sl_bump(sl);
1090                 sl->rcount = 0;
1091                 sl->xbits = 0;
1092                 sl->xdata = 0;
1093         } else if (s >= 0x30 && s < 0x70) {
1094                 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1095                 sl->xbits += 6;
1096                 if (sl->xbits >= 8) {
1097                         sl->xbits -= 8;
1098                         c = (unsigned char)(sl->xdata >> sl->xbits);
1099                         if (!test_bit(SLF_ERROR, &sl->flags))  {
1100                                 if (sl->rcount < sl->buffsize)  {
1101                                         sl->rbuff[sl->rcount++] = c;
1102                                         return;
1103                                 }
1104                                 sl->rx_over_errors++;
1105                                 set_bit(SLF_ERROR, &sl->flags);
1106                         }
1107                 }
1108         }
1109 }
1110 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1111
1112 /* Perform I/O control on an active SLIP channel. */
1113 static int slip_ioctl(struct tty_struct *tty, struct file *file,
1114                                         unsigned int cmd, unsigned long arg)
1115 {
1116         struct slip *sl = tty->disc_data;
1117         unsigned int tmp;
1118         int __user *p = (int __user *)arg;
1119
1120         /* First make sure we're connected. */
1121         if (!sl || sl->magic != SLIP_MAGIC)
1122                 return -EINVAL;
1123
1124         switch (cmd) {
1125         case SIOCGIFNAME:
1126                 tmp = strlen(sl->dev->name) + 1;
1127                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1128                         return -EFAULT;
1129                 return 0;
1130
1131         case SIOCGIFENCAP:
1132                 if (put_user(sl->mode, p))
1133                         return -EFAULT;
1134                 return 0;
1135
1136         case SIOCSIFENCAP:
1137                 if (get_user(tmp, p))
1138                         return -EFAULT;
1139 #ifndef SL_INCLUDE_CSLIP
1140                 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
1141                         return -EINVAL;
1142 #else
1143                 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1144                     (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
1145                         /* return -EINVAL; */
1146                         tmp &= ~SL_MODE_ADAPTIVE;
1147 #endif
1148 #ifndef CONFIG_SLIP_MODE_SLIP6
1149                 if (tmp & SL_MODE_SLIP6)
1150                         return -EINVAL;
1151 #endif
1152                 sl->mode = tmp;
1153                 sl->dev->type = ARPHRD_SLIP + sl->mode;
1154                 return 0;
1155
1156         case SIOCSIFHWADDR:
1157                 return -EINVAL;
1158
1159 #ifdef CONFIG_SLIP_SMART
1160         /* VSV changes start here */
1161         case SIOCSKEEPALIVE:
1162                 if (get_user(tmp, p))
1163                         return -EFAULT;
1164                 if (tmp > 255) /* max for unchar */
1165                         return -EINVAL;
1166
1167                 spin_lock_bh(&sl->lock);
1168                 if (!sl->tty) {
1169                         spin_unlock_bh(&sl->lock);
1170                         return -ENODEV;
1171                 }
1172                 sl->keepalive = (u8)tmp;
1173                 if (sl->keepalive != 0) {
1174                         mod_timer(&sl->keepalive_timer,
1175                                         jiffies + sl->keepalive * HZ);
1176                         set_bit(SLF_KEEPTEST, &sl->flags);
1177                 } else
1178                         del_timer(&sl->keepalive_timer);
1179                 spin_unlock_bh(&sl->lock);
1180                 return 0;
1181
1182         case SIOCGKEEPALIVE:
1183                 if (put_user(sl->keepalive, p))
1184                         return -EFAULT;
1185                 return 0;
1186
1187         case SIOCSOUTFILL:
1188                 if (get_user(tmp, p))
1189                         return -EFAULT;
1190                 if (tmp > 255) /* max for unchar */
1191                         return -EINVAL;
1192                 spin_lock_bh(&sl->lock);
1193                 if (!sl->tty) {
1194                         spin_unlock_bh(&sl->lock);
1195                         return -ENODEV;
1196                 }
1197                 sl->outfill = (u8)tmp;
1198                 if (sl->outfill != 0) {
1199                         mod_timer(&sl->outfill_timer,
1200                                                 jiffies + sl->outfill * HZ);
1201                         set_bit(SLF_OUTWAIT, &sl->flags);
1202                 } else
1203                         del_timer(&sl->outfill_timer);
1204                 spin_unlock_bh(&sl->lock);
1205                 return 0;
1206
1207         case SIOCGOUTFILL:
1208                 if (put_user(sl->outfill, p))
1209                         return -EFAULT;
1210                 return 0;
1211         /* VSV changes end */
1212 #endif
1213         default:
1214                 return tty_mode_ioctl(tty, file, cmd, arg);
1215         }
1216 }
1217
1218 /* VSV changes start here */
1219 #ifdef CONFIG_SLIP_SMART
1220 /* function do_ioctl called from net/core/dev.c
1221    to allow get/set outfill/keepalive parameter
1222    by ifconfig                                 */
1223
1224 static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1225 {
1226         struct slip *sl = netdev_priv(dev);
1227         unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1228
1229         if (sl == NULL)         /* Allocation failed ?? */
1230                 return -ENODEV;
1231
1232         spin_lock_bh(&sl->lock);
1233
1234         if (!sl->tty) {
1235                 spin_unlock_bh(&sl->lock);
1236                 return -ENODEV;
1237         }
1238
1239         switch (cmd) {
1240         case SIOCSKEEPALIVE:
1241                 /* max for unchar */
1242                 if ((unsigned)*p > 255) {
1243                         spin_unlock_bh(&sl->lock);
1244                         return -EINVAL;
1245                 }
1246                 sl->keepalive = (u8)*p;
1247                 if (sl->keepalive != 0) {
1248                         sl->keepalive_timer.expires =
1249                                                 jiffies + sl->keepalive * HZ;
1250                         mod_timer(&sl->keepalive_timer,
1251                                                 jiffies + sl->keepalive * HZ);
1252                         set_bit(SLF_KEEPTEST, &sl->flags);
1253                 } else
1254                         del_timer(&sl->keepalive_timer);
1255                 break;
1256
1257         case SIOCGKEEPALIVE:
1258                 *p = sl->keepalive;
1259                 break;
1260
1261         case SIOCSOUTFILL:
1262                 if ((unsigned)*p > 255) { /* max for unchar */
1263                         spin_unlock_bh(&sl->lock);
1264                         return -EINVAL;
1265                 }
1266                 sl->outfill = (u8)*p;
1267                 if (sl->outfill != 0) {
1268                         mod_timer(&sl->outfill_timer,
1269                                                 jiffies + sl->outfill * HZ);
1270                         set_bit(SLF_OUTWAIT, &sl->flags);
1271                 } else
1272                         del_timer(&sl->outfill_timer);
1273                 break;
1274
1275         case SIOCGOUTFILL:
1276                 *p = sl->outfill;
1277                 break;
1278
1279         case SIOCSLEASE:
1280                 /* Resolve race condition, when ioctl'ing hanged up
1281                    and opened by another process device.
1282                  */
1283                 if (sl->tty != current->signal->tty &&
1284                                                 sl->pid != current->pid) {
1285                         spin_unlock_bh(&sl->lock);
1286                         return -EPERM;
1287                 }
1288                 sl->leased = 0;
1289                 if (*p)
1290                         sl->leased = 1;
1291                 break;
1292
1293         case SIOCGLEASE:
1294                 *p = sl->leased;
1295         };
1296         spin_unlock_bh(&sl->lock);
1297         return 0;
1298 }
1299 #endif
1300 /* VSV changes end */
1301
1302 static struct tty_ldisc_ops sl_ldisc = {
1303         .owner          = THIS_MODULE,
1304         .magic          = TTY_LDISC_MAGIC,
1305         .name           = "slip",
1306         .open           = slip_open,
1307         .close          = slip_close,
1308         .ioctl          = slip_ioctl,
1309         .receive_buf    = slip_receive_buf,
1310         .write_wakeup   = slip_write_wakeup,
1311 };
1312
1313 static int __init slip_init(void)
1314 {
1315         int status;
1316
1317         if (slip_maxdev < 4)
1318                 slip_maxdev = 4; /* Sanity */
1319
1320         printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1321 #ifdef CONFIG_SLIP_MODE_SLIP6
1322                " (6 bit encapsulation enabled)"
1323 #endif
1324                ".\n",
1325                SLIP_VERSION, slip_maxdev);
1326 #if defined(SL_INCLUDE_CSLIP)
1327         printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1328 #endif
1329 #ifdef CONFIG_SLIP_SMART
1330         printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1331 #endif
1332
1333         slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
1334                                                                 GFP_KERNEL);
1335         if (!slip_devs) {
1336                 printk(KERN_ERR "SLIP: Can't allocate slip devices array.\n");
1337                 return -ENOMEM;
1338         }
1339
1340         /* Fill in our line protocol discipline, and register it */
1341         status = tty_register_ldisc(N_SLIP, &sl_ldisc);
1342         if (status != 0) {
1343                 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1344                 kfree(slip_devs);
1345         }
1346         return status;
1347 }
1348
1349 static void __exit slip_exit(void)
1350 {
1351         int i;
1352         struct net_device *dev;
1353         struct slip *sl;
1354         unsigned long timeout = jiffies + HZ;
1355         int busy = 0;
1356
1357         if (slip_devs == NULL)
1358                 return;
1359
1360         /* First of all: check for active disciplines and hangup them.
1361          */
1362         do {
1363                 if (busy)
1364                         msleep_interruptible(100);
1365
1366                 busy = 0;
1367                 for (i = 0; i < slip_maxdev; i++) {
1368                         dev = slip_devs[i];
1369                         if (!dev)
1370                                 continue;
1371                         sl = netdev_priv(dev);
1372                         spin_lock_bh(&sl->lock);
1373                         if (sl->tty) {
1374                                 busy++;
1375                                 tty_hangup(sl->tty);
1376                         }
1377                         spin_unlock_bh(&sl->lock);
1378                 }
1379         } while (busy && time_before(jiffies, timeout));
1380
1381
1382         for (i = 0; i < slip_maxdev; i++) {
1383                 dev = slip_devs[i];
1384                 if (!dev)
1385                         continue;
1386                 slip_devs[i] = NULL;
1387
1388                 sl = netdev_priv(dev);
1389                 if (sl->tty) {
1390                         printk(KERN_ERR "%s: tty discipline still running\n",
1391                                dev->name);
1392                         /* Intentionally leak the control block. */
1393                         dev->destructor = NULL;
1394                 }
1395
1396                 unregister_netdev(dev);
1397         }
1398
1399         kfree(slip_devs);
1400         slip_devs = NULL;
1401
1402         i = tty_unregister_ldisc(N_SLIP);
1403         if (i != 0)
1404                 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
1405 }
1406
1407 module_init(slip_init);
1408 module_exit(slip_exit);
1409
1410 #ifdef CONFIG_SLIP_SMART
1411 /*
1412  * This is start of the code for multislip style line checking
1413  * added by Stanislav Voronyi. All changes before marked VSV
1414  */
1415
1416 static void sl_outfill(unsigned long sls)
1417 {
1418         struct slip *sl = (struct slip *)sls;
1419
1420         spin_lock(&sl->lock);
1421
1422         if (sl->tty == NULL)
1423                 goto out;
1424
1425         if (sl->outfill) {
1426                 if (test_bit(SLF_OUTWAIT, &sl->flags)) {
1427                         /* no packets were transmitted, do outfill */
1428 #ifdef CONFIG_SLIP_MODE_SLIP6
1429                         unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1430 #else
1431                         unsigned char s = END;
1432 #endif
1433                         /* put END into tty queue. Is it right ??? */
1434                         if (!netif_queue_stopped(sl->dev)) {
1435                                 /* if device busy no outfill */
1436                                 sl->tty->ops->write(sl->tty, &s, 1);
1437                         }
1438                 } else
1439                         set_bit(SLF_OUTWAIT, &sl->flags);
1440
1441                 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1442         }
1443 out:
1444         spin_unlock(&sl->lock);
1445 }
1446
1447 static void sl_keepalive(unsigned long sls)
1448 {
1449         struct slip *sl = (struct slip *)sls;
1450
1451         spin_lock(&sl->lock);
1452
1453         if (sl->tty == NULL)
1454                 goto out;
1455
1456         if (sl->keepalive) {
1457                 if (test_bit(SLF_KEEPTEST, &sl->flags)) {
1458                         /* keepalive still high :(, we must hangup */
1459                         if (sl->outfill)
1460                                 /* outfill timer must be deleted too */
1461                                 (void)del_timer(&sl->outfill_timer);
1462                         printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1463                         /* this must hangup tty & close slip */
1464                         tty_hangup(sl->tty);
1465                         /* I think we need not something else */
1466                         goto out;
1467                 } else
1468                         set_bit(SLF_KEEPTEST, &sl->flags);
1469
1470                 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1471         }
1472 out:
1473         spin_unlock(&sl->lock);
1474 }
1475
1476 #endif
1477 MODULE_LICENSE("GPL");
1478 MODULE_ALIAS_LDISC(N_SLIP);