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 the ops->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->ops->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->ops->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                         (tty_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         if (tty->ops->write == NULL)
 834                 return -EOPNOTSUPP;
 835
 836         /* RTnetlink lock is misused here to serialize concurrent
 837            opens of slip channels. There are better ways, but it is
 838            the simplest one.
 839          */
 840         rtnl_lock();
 841
 842         /* Collect hanged up channels. */
 843         sl_sync();
 844
 845         sl = tty->disc_data;
 846
 847         err = -EEXIST;
 848         /* First make sure we're not already connected. */
 849         if (sl && sl->magic == SLIP_MAGIC)
 850                 goto err_exit;
 851
 852         /* OK.  Find a free SLIP channel to use. */
 853         err = -ENFILE;
 854         sl = sl_alloc(tty_devnum(tty));
 855         if (sl == NULL)
 856                 goto err_exit;
 857
 858         sl->tty = tty;
 859         tty->disc_data = sl;
 860         sl->line = tty_devnum(tty);
 861         sl->pid = current->pid;
 862
 863         if (!test_bit(SLF_INUSE, &sl->flags)) {
 864                 /* Perform the low-level SLIP initialization. */
 865                 err = sl_alloc_bufs(sl, SL_MTU);
 866                 if (err)
 867                         goto err_free_chan;
 868
 869                 set_bit(SLF_INUSE, &sl->flags);
 870
 871                 err = register_netdevice(sl->dev);
 872                 if (err)
 873                         goto err_free_bufs;
 874         }
 875
 876 #ifdef CONFIG_SLIP_SMART
 877         if (sl->keepalive) {
 878                 sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
 879                 add_timer(&sl->keepalive_timer);
 880         }
 881         if (sl->outfill) {
 882                 sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
 883                 add_timer(&sl->outfill_timer);
 884         }
 885 #endif
 886
 887         /* Done.  We have linked the TTY line to a channel. */
 888         rtnl_unlock();
 889         tty->receive_room = 65536;      /* We don't flow control */
 890         return sl->dev->base_addr;
 891
 892 err_free_bufs:
 893         sl_free_bufs(sl);
 894
 895 err_free_chan:
 896         sl->tty = NULL;
 897         tty->disc_data = NULL;
 898         clear_bit(SLF_INUSE, &sl->flags);
 899
 900 err_exit:
 901         rtnl_unlock();
 902
 903         /* Count references from TTY module */
 904         return err;
 905 }
 906
 907 /*
 908
 909   FIXME: 1,2 are fixed 3 was never true anyway.
 910
 911    Let me to blame a bit.
 912    1. TTY module calls this funstion on soft interrupt.
 913    2. TTY module calls this function WITH MASKED INTERRUPTS!
 914    3. TTY module does not notify us about line discipline
 915       shutdown,
 916
 917    Seems, now it is clean. The solution is to consider netdevice and
 918    line discipline sides as two independent threads.
 919
 920    By-product (not desired): sl? does not feel hangups and remains open.
 921    It is supposed, that user level program (dip, diald, slattach...)
 922    will catch SIGHUP and make the rest of work.
 923
 924    I see no way to make more with current tty code. --ANK
 925  */
 926
 927 /*
 928  * Close down a SLIP channel.
 929  * This means flushing out any pending queues, and then returning. This
 930  * call is serialized against other ldisc functions.
 931  */
 932 static void slip_close(struct tty_struct *tty)
 933 {
 934         struct slip *sl = 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 slip_esc(unsigned char *s, unsigned char *d, int len)
 959 {
 960         unsigned char *ptr = d;
 961         unsigned char c;
 962
 963         /*
 964          * Send an initial END character to flush out any
 965          * data that may have accumulated in the receiver
 966          * due to line noise.
 967          */
 968
 969         *ptr++ = END;
 970
 971         /*
 972          * For each byte in the packet, send the appropriate
 973          * character sequence, according to the SLIP protocol.
 974          */
 975
 976         while (len-- > 0) {
 977                 switch (c = *s++) {
 978                 case END:
 979                         *ptr++ = ESC;
 980                         *ptr++ = ESC_END;
 981                         break;
 982                 case ESC:
 983                         *ptr++ = ESC;
 984                         *ptr++ = ESC_ESC;
 985                         break;
 986                 default:
 987                         *ptr++ = c;
 988                         break;
 989                 }
 990         }
 991         *ptr++ = END;
 992         return (ptr - d);
 993 }
 994
 995 static void slip_unesc(struct slip *sl, unsigned char s)
 996 {
 997
 998         switch (s) {
 999         case END:
1000 #ifdef CONFIG_SLIP_SMART
1001                 /* drop keeptest bit = VSV */
1002                 if (test_bit(SLF_KEEPTEST, &sl->flags))
1003                         clear_bit(SLF_KEEPTEST, &sl->flags);
1004 #endif
1005
1006                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1007                                                         && (sl->rcount > 2))
1008                         sl_bump(sl);
1009                 clear_bit(SLF_ESCAPE, &sl->flags);
1010                 sl->rcount = 0;
1011                 return;
1012
1013         case ESC:
1014                 set_bit(SLF_ESCAPE, &sl->flags);
1015                 return;
1016         case ESC_ESC:
1017                 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
1018                         s = ESC;
1019                 break;
1020         case ESC_END:
1021                 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
1022                         s = END;
1023                 break;
1024         }
1025         if (!test_bit(SLF_ERROR, &sl->flags))  {
1026                 if (sl->rcount < sl->buffsize)  {
1027                         sl->rbuff[sl->rcount++] = s;
1028                         return;
1029                 }
1030                 sl->rx_over_errors++;
1031                 set_bit(SLF_ERROR, &sl->flags);
1032         }
1033 }
1034
1035
1036 #ifdef CONFIG_SLIP_MODE_SLIP6
1037 /************************************************************************
1038  *                       6 BIT SLIP ENCAPSULATION                       *
1039  ************************************************************************/
1040
1041 static int slip_esc6(unsigned char *s, unsigned char *d, int len)
1042 {
1043         unsigned char *ptr = d;
1044         unsigned char c;
1045         int i;
1046         unsigned short v = 0;
1047         short bits = 0;
1048
1049         /*
1050          * Send an initial END character to flush out any
1051          * data that may have accumulated in the receiver
1052          * due to line noise.
1053          */
1054
1055         *ptr++ = 0x70;
1056
1057         /*
1058          * Encode the packet into printable ascii characters
1059          */
1060
1061         for (i = 0; i < len; ++i) {
1062                 v = (v << 8) | s[i];
1063                 bits += 8;
1064                 while (bits >= 6) {
1065                         bits -= 6;
1066                         c = 0x30 + ((v >> bits) & 0x3F);
1067                         *ptr++ = c;
1068                 }
1069         }
1070         if (bits) {
1071                 c = 0x30 + ((v << (6 - bits)) & 0x3F);
1072                 *ptr++ = c;
1073         }
1074         *ptr++ = 0x70;
1075         return ptr - d;
1076 }
1077
1078 static void slip_unesc6(struct slip *sl, unsigned char s)
1079 {
1080         unsigned char c;
1081
1082         if (s == 0x70) {
1083 #ifdef CONFIG_SLIP_SMART
1084                 /* drop keeptest bit = VSV */
1085                 if (test_bit(SLF_KEEPTEST, &sl->flags))
1086                         clear_bit(SLF_KEEPTEST, &sl->flags);
1087 #endif
1088
1089                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1090                                                         && (sl->rcount > 2))
1091                         sl_bump(sl);
1092                 sl->rcount = 0;
1093                 sl->xbits = 0;
1094                 sl->xdata = 0;
1095         } else if (s >= 0x30 && s < 0x70) {
1096                 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1097                 sl->xbits += 6;
1098                 if (sl->xbits >= 8) {
1099                         sl->xbits -= 8;
1100                         c = (unsigned char)(sl->xdata >> sl->xbits);
1101                         if (!test_bit(SLF_ERROR, &sl->flags))  {
1102                                 if (sl->rcount < sl->buffsize)  {
1103                                         sl->rbuff[sl->rcount++] = c;
1104                                         return;
1105                                 }
1106                                 sl->rx_over_errors++;
1107                                 set_bit(SLF_ERROR, &sl->flags);
1108                         }
1109                 }
1110         }
1111 }
1112 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1113
1114 /* Perform I/O control on an active SLIP channel. */
1115 static int slip_ioctl(struct tty_struct *tty, struct file *file,
1116                                         unsigned int cmd, unsigned long arg)
1117 {
1118         struct slip *sl = tty->disc_data;
1119         unsigned int tmp;
1120         int __user *p = (int __user *)arg;
1121
1122         /* First make sure we're connected. */
1123         if (!sl || sl->magic != SLIP_MAGIC)
1124                 return -EINVAL;
1125
1126         switch (cmd) {
1127         case SIOCGIFNAME:
1128                 tmp = strlen(sl->dev->name) + 1;
1129                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1130                         return -EFAULT;
1131                 return 0;
1132
1133         case SIOCGIFENCAP:
1134                 if (put_user(sl->mode, p))
1135                         return -EFAULT;
1136                 return 0;
1137
1138         case SIOCSIFENCAP:
1139                 if (get_user(tmp, p))
1140                         return -EFAULT;
1141 #ifndef SL_INCLUDE_CSLIP
1142                 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
1143                         return -EINVAL;
1144 #else
1145                 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1146                     (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
1147                         /* return -EINVAL; */
1148                         tmp &= ~SL_MODE_ADAPTIVE;
1149 #endif
1150 #ifndef CONFIG_SLIP_MODE_SLIP6
1151                 if (tmp & SL_MODE_SLIP6)
1152                         return -EINVAL;
1153 #endif
1154                 sl->mode = tmp;
1155                 sl->dev->type = ARPHRD_SLIP + sl->mode;
1156                 return 0;
1157
1158         case SIOCSIFHWADDR:
1159                 return -EINVAL;
1160
1161 #ifdef CONFIG_SLIP_SMART
1162         /* VSV changes start here */
1163         case SIOCSKEEPALIVE:
1164                 if (get_user(tmp, p))
1165                         return -EFAULT;
1166                 if (tmp > 255) /* max for unchar */
1167                         return -EINVAL;
1168
1169                 spin_lock_bh(&sl->lock);
1170                 if (!sl->tty) {
1171                         spin_unlock_bh(&sl->lock);
1172                         return -ENODEV;
1173                 }
1174                 sl->keepalive = (u8)tmp;
1175                 if (sl->keepalive != 0) {
1176                         mod_timer(&sl->keepalive_timer,
1177                                         jiffies + sl->keepalive * HZ);
1178                         set_bit(SLF_KEEPTEST, &sl->flags);
1179                 } else
1180                         del_timer(&sl->keepalive_timer);
1181                 spin_unlock_bh(&sl->lock);
1182                 return 0;
1183
1184         case SIOCGKEEPALIVE:
1185                 if (put_user(sl->keepalive, p))
1186                         return -EFAULT;
1187                 return 0;
1188
1189         case SIOCSOUTFILL:
1190                 if (get_user(tmp, p))
1191                         return -EFAULT;
1192                 if (tmp > 255) /* max for unchar */
1193                         return -EINVAL;
1194                 spin_lock_bh(&sl->lock);
1195                 if (!sl->tty) {
1196                         spin_unlock_bh(&sl->lock);
1197                         return -ENODEV;
1198                 }
1199                 sl->outfill = (u8)tmp;
1200                 if (sl->outfill != 0) {
1201                         mod_timer(&sl->outfill_timer,
1202                                                 jiffies + sl->outfill * HZ);
1203                         set_bit(SLF_OUTWAIT, &sl->flags);
1204                 } else
1205                         del_timer(&sl->outfill_timer);
1206                 spin_unlock_bh(&sl->lock);
1207                 return 0;
1208
1209         case SIOCGOUTFILL:
1210                 if (put_user(sl->outfill, p))
1211                         return -EFAULT;
1212                 return 0;
1213         /* VSV changes end */
1214 #endif
1215         default:
1216                 return tty_mode_ioctl(tty, file, cmd, arg);
1217         }
1218 }
1219
1220 /* VSV changes start here */
1221 #ifdef CONFIG_SLIP_SMART
1222 /* function do_ioctl called from net/core/dev.c
1223    to allow get/set outfill/keepalive parameter
1224    by ifconfig                                 */
1225
1226 static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1227 {
1228         struct slip *sl = netdev_priv(dev);
1229         unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1230
1231         if (sl == NULL)         /* Allocation failed ?? */
1232                 return -ENODEV;
1233
1234         spin_lock_bh(&sl->lock);
1235
1236         if (!sl->tty) {
1237                 spin_unlock_bh(&sl->lock);
1238                 return -ENODEV;
1239         }
1240
1241         switch (cmd) {
1242         case SIOCSKEEPALIVE:
1243                 /* max for unchar */
1244                 if ((unsigned)*p > 255) {
1245                         spin_unlock_bh(&sl->lock);
1246                         return -EINVAL;
1247                 }
1248                 sl->keepalive = (u8)*p;
1249                 if (sl->keepalive != 0) {
1250                         sl->keepalive_timer.expires =
1251                                                 jiffies + sl->keepalive * HZ;
1252                         mod_timer(&sl->keepalive_timer,
1253                                                 jiffies + sl->keepalive * HZ);
1254                         set_bit(SLF_KEEPTEST, &sl->flags);
1255                 } else
1256                         del_timer(&sl->keepalive_timer);
1257                 break;
1258
1259         case SIOCGKEEPALIVE:
1260                 *p = sl->keepalive;
1261                 break;
1262
1263         case SIOCSOUTFILL:
1264                 if ((unsigned)*p > 255) { /* max for unchar */
1265                         spin_unlock_bh(&sl->lock);
1266                         return -EINVAL;
1267                 }
1268                 sl->outfill = (u8)*p;
1269                 if (sl->outfill != 0) {
1270                         mod_timer(&sl->outfill_timer,
1271                                                 jiffies + sl->outfill * HZ);
1272                         set_bit(SLF_OUTWAIT, &sl->flags);
1273                 } else
1274                         del_timer(&sl->outfill_timer);
1275                 break;
1276
1277         case SIOCGOUTFILL:
1278                 *p = sl->outfill;
1279                 break;
1280
1281         case SIOCSLEASE:
1282                 /* Resolve race condition, when ioctl'ing hanged up
1283                    and opened by another process device.
1284                  */
1285                 if (sl->tty != current->signal->tty &&
1286                                                 sl->pid != current->pid) {
1287                         spin_unlock_bh(&sl->lock);
1288                         return -EPERM;
1289                 }
1290                 sl->leased = 0;
1291                 if (*p)
1292                         sl->leased = 1;
1293                 break;
1294
1295         case SIOCGLEASE:
1296                 *p = sl->leased;
1297         };
1298         spin_unlock_bh(&sl->lock);
1299         return 0;
1300 }
1301 #endif
1302 /* VSV changes end */
1303
1304 static struct tty_ldisc_ops sl_ldisc = {
1305         .owner          = THIS_MODULE,
1306         .magic          = TTY_LDISC_MAGIC,
1307         .name           = "slip",
1308         .open           = slip_open,
1309         .close          = slip_close,
1310         .ioctl          = slip_ioctl,
1311         .receive_buf    = slip_receive_buf,
1312         .write_wakeup   = slip_write_wakeup,
1313 };
1314
1315 static int __init slip_init(void)
1316 {
1317         int status;
1318
1319         if (slip_maxdev < 4)
1320                 slip_maxdev = 4; /* Sanity */
1321
1322         printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1323 #ifdef CONFIG_SLIP_MODE_SLIP6
1324                " (6 bit encapsulation enabled)"
1325 #endif
1326                ".\n",
1327                SLIP_VERSION, slip_maxdev);
1328 #if defined(SL_INCLUDE_CSLIP)
1329         printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1330 #endif
1331 #ifdef CONFIG_SLIP_SMART
1332         printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1333 #endif
1334
1335         slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
1336                                                                 GFP_KERNEL);
1337         if (!slip_devs) {
1338                 printk(KERN_ERR "SLIP: Can't allocate slip devices array.\n");
1339                 return -ENOMEM;
1340         }
1341
1342         /* Fill in our line protocol discipline, and register it */
1343         status = tty_register_ldisc(N_SLIP, &sl_ldisc);
1344         if (status != 0) {
1345                 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1346                 kfree(slip_devs);
1347         }
1348         return status;
1349 }
1350
1351 static void __exit slip_exit(void)
1352 {
1353         int i;
1354         struct net_device *dev;
1355         struct slip *sl;
1356         unsigned long timeout = jiffies + HZ;
1357         int busy = 0;
1358
1359         if (slip_devs == NULL)
1360                 return;
1361
1362         /* First of all: check for active disciplines and hangup them.
1363          */
1364         do {
1365                 if (busy)
1366                         msleep_interruptible(100);
1367
1368                 busy = 0;
1369                 for (i = 0; i < slip_maxdev; i++) {
1370                         dev = slip_devs[i];
1371                         if (!dev)
1372                                 continue;
1373                         sl = netdev_priv(dev);
1374                         spin_lock_bh(&sl->lock);
1375                         if (sl->tty) {
1376                                 busy++;
1377                                 tty_hangup(sl->tty);
1378                         }
1379                         spin_unlock_bh(&sl->lock);
1380                 }
1381         } while (busy && time_before(jiffies, timeout));
1382
1383
1384         for (i = 0; i < slip_maxdev; i++) {
1385                 dev = slip_devs[i];
1386                 if (!dev)
1387                         continue;
1388                 slip_devs[i] = NULL;
1389
1390                 sl = netdev_priv(dev);
1391                 if (sl->tty) {
1392                         printk(KERN_ERR "%s: tty discipline still running\n",
1393                                dev->name);
1394                         /* Intentionally leak the control block. */
1395                         dev->destructor = NULL;
1396                 }
1397
1398                 unregister_netdev(dev);
1399         }
1400
1401         kfree(slip_devs);
1402         slip_devs = NULL;
1403
1404         i = tty_unregister_ldisc(N_SLIP);
1405         if (i != 0)
1406                 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
1407 }
1408
1409 module_init(slip_init);
1410 module_exit(slip_exit);
1411
1412 #ifdef CONFIG_SLIP_SMART
1413 /*
1414  * This is start of the code for multislip style line checking
1415  * added by Stanislav Voronyi. All changes before marked VSV
1416  */
1417
1418 static void sl_outfill(unsigned long sls)
1419 {
1420         struct slip *sl = (struct slip *)sls;
1421
1422         spin_lock(&sl->lock);
1423
1424         if (sl->tty == NULL)
1425                 goto out;
1426
1427         if (sl->outfill) {
1428                 if (test_bit(SLF_OUTWAIT, &sl->flags)) {
1429                         /* no packets were transmitted, do outfill */
1430 #ifdef CONFIG_SLIP_MODE_SLIP6
1431                         unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1432 #else
1433                         unsigned char s = END;
1434 #endif
1435                         /* put END into tty queue. Is it right ??? */
1436                         if (!netif_queue_stopped(sl->dev)) {
1437                                 /* if device busy no outfill */
1438                                 sl->tty->ops->write(sl->tty, &s, 1);
1439                         }
1440                 } else
1441                         set_bit(SLF_OUTWAIT, &sl->flags);
1442
1443                 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1444         }
1445 out:
1446         spin_unlock(&sl->lock);
1447 }
1448
1449 static void sl_keepalive(unsigned long sls)
1450 {
1451         struct slip *sl = (struct slip *)sls;
1452
1453         spin_lock(&sl->lock);
1454
1455         if (sl->tty == NULL)
1456                 goto out;
1457
1458         if (sl->keepalive) {
1459                 if (test_bit(SLF_KEEPTEST, &sl->flags)) {
1460                         /* keepalive still high :(, we must hangup */
1461                         if (sl->outfill)
1462                                 /* outfill timer must be deleted too */
1463                                 (void)del_timer(&sl->outfill_timer);
1464                         printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1465                         /* this must hangup tty & close slip */
1466                         tty_hangup(sl->tty);
1467                         /* I think we need not something else */
1468                         goto out;
1469                 } else
1470                         set_bit(SLF_KEEPTEST, &sl->flags);
1471
1472                 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1473         }
1474 out:
1475         spin_unlock(&sl->lock);
1476 }
1477
1478 #endif
1479 MODULE_LICENSE("GPL");
1480 MODULE_ALIAS_LDISC(N_SLIP);