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