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