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