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