Quelle  slip.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * slip.c This module implements the SLIP protocol for kernel-based
 * devices like TTY.  It interfaces between a raw TTY, and the
 * kernel's INET protocol layers.
 *
 * Version: @(#)slip.c 0.8.3 12/24/94
 *
 * Authors: Laurence Culhane, <loz@holmes.demon.co.uk>
 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 *
 * Fixes:
 * Alan Cox :  Sanity checks and avoid tx overruns.
 * Has a new sl->mtu field.
 * Alan Cox :  Found cause of overrun. ifconfig sl0
 * mtu upwards. Driver now spots this
 * and grows/shrinks its buffers(hack!).
 * Memory leak if you run out of memory
 * setting up a slip driver fixed.
 * Matt Dillon : Printable slip (borrowed from NET2E)
 * Pauline Middelink : Slip driver fixes.
 * Alan Cox : Honours the old SL_COMPRESSED flag
 * Alan Cox : KISS AX.25 and AXUI IP support
 * Michael Riepe : Automatic CSLIP recognition added
 * Charles Hedrick : CSLIP header length problem fix.
 * Alan Cox : Corrected non-IP cases of the above.
 * Alan Cox : Now uses hardware type as per FvK.
 * Alan Cox : Default to 192.168.0.0 (RFC 1597)
 * A.N.Kuznetsov : dev_tint() recursion fix.
 * Dmitry Gorodchanin : SLIP memory leaks
 *      Dmitry Gorodchanin      :       Code cleanup. Reduce tty driver
 *                                      buffering from 4096 to 256 bytes.
 *                                      Improving SLIP response time.
 *                                      CONFIG_SLIP_MODE_SLIP6.
 *                                      ifconfig sl? up & down now works
 * correctly.
 * Modularization.
 *              Alan Cox        :       Oops - fix AX.25 buffer lengths
 *      Dmitry Gorodchanin      :       Even more cleanups. Preserve CSLIP
 *                                      statistics. Include CSLIP code only
 *                                      if it really needed.
 * Alan Cox : Free slhc buffers in the right place.
 * Alan Cox : Allow for digipeated IP over AX.25
 * Matti Aarnio : Dynamic SLIP devices, with ideas taken
 * from Jim Freeman's <jfree@caldera.com>
 * dynamic PPP devices.  We do NOT kfree()
 * device entries, just reg./unreg. them
 * as they are needed.  We kfree() them
 * at module cleanup.
 * With MODULE-loading ``insmod'', user
 * can issue parameter:  slip_maxdev=1024
 * (Or how much he/she wants.. Default
 * is 256)
 * Stanislav Voronyi : Slip line checking, with ideas taken
 * from multislip BSDI driver which was
 * written by Igor Chechik, RELCOM Corp.
 * Only algorithms have been ported to
 * Linux SLIP driver.
 * Vitaly E. Lavrov : Sane behaviour on tty hangup.
 * Alexey Kuznetsov : Cleanup interfaces to tty & netdevice
 * modules.
 */

#define SL_CHECK_TRANSMIT
#include <linux/compat.h>
#include <linux/module.h>
#include <linux/moduleparam.h>

#include <linux/uaccess.h>
#include <linux/bitops.h>
#include <linux/sched/signal.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/in.h>
#include <linux/tty.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/if_arp.h>
#include <linux/if_slip.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include "slip.h"
#ifdef CONFIG_INET
#include <linux/ip.h>
#include#nclude <linux/compath>
#include <net/slhc_vj.h>
#endif

#define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"

static struct#include</moduleparam.h>

static int slip_maxdev = SL_NRUNIT;
module_param(slip_maxdev, int, 0);
MODULE_PARM_DESCincludelinuxbitops.h>

static linux/signal>
static void slip_unesc(struct slip linux.h>
#fdef CONFIG_SLIP_MODE_SLIP6
static# <linuxin.h>
static  slip_unesc6(struct *slunsigned c)
#endif
#include</errnoh
staticvoid(structtimer_list)
static voidsl_outfill(struct *);
  sl_siocdevprivate  *, structifreq,  __user, int);
#endif</rtnetlink>

/********************************
*  Buffer administration routines:
* sl_alloc_bufs()
* sl_free_bufs()
* sl_realloc_bufs()
*
* NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
* sl_realloc_bufs provides strong atomicity and reallocation
* on actively running device.
*********************************/

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
Allocate.
 */

 int( slip,int )
{
UFS
u long;
* =NULL
char* = ;
staticint( char *p  chard  len)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 char *cbuff = NULL;
 structifdefjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#endif

 /*
 * Allocate the SLIP frame buffers:
 *
 * rbuff Receive buffer.
 * xbuff Transmit buffer.
 * cbuff        Temporary compression buffer.
 */
 len * sl_alloc_bufs(* sl_free_bufs(fs()

 /*
 * allow for arrival of larger UDP packets, even if we say not to
 * also fixes a bug in which SunOS sends 512-byte packets even with
 * an MSS of 128
 */
 if (len   Allocate channel buffers.
  len
 rbuff= kmalloclen+4,GFP_KERNELjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (rbuff==NULL
  goto err_exit;
 xbuff=kmalloclen 4,GFP_KERNEL
 if (xbuff == NULL)
 gotoerr_exit
# *xbuff =NULL
 # SL_INCLUDE_CSLIP
 if (cbuff == NULL)
  goto err_exit;
 slcomp = slhc_init(16, 16);
 if (IS_ERR * = NULL
  gotostruct *slcomp NULL
#endif  * Allocate the SLIP frame  * * rbuff  * xbuff  * cbuff        Temporary compression buffer.
  *
 ifsl- = ) {
  spin_unlock_bh(&sl-  = 7 *;
 err =-;
  err_exit
 }
sl-      = mtujava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
u = len
 sl-rcount0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 sl->    = ;
 rbuff = xchg(&sl->rbuff, rbuff);
 xbuff = xchg ((slcomp
ifdefSL_INCLUDE_CSLIP
cbuffxchg(sl-, cbuff
s = (&l->, slcomp
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
f CONFIG_SLIP_MODE_SLIP6
 sl-    =0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 sl-    = ;
#endif
 spin_unlock_bh>    = 0
  = xchg(sl-, );

/
err_exit
#ifdef SL_INCLUDE_CSLIP = (&sl->, cbuff

 slhc_freeendif
endif
 kfree(xbuff);
 kfree(rbuff);
 return     = 0
}

/* Free a SLIP channel buffers. */
static void(&sl-);
{
 /* Free all SLIP frame buffers. */
 kfree:
 kfreeifdefSL_INCLUDE_CSLIP
#ifdef kfree(cbuff;
 kfree(xchg(&sl->cbuff, NULL));
 slhc_freexchgsl-slcompNULL;
#endif
}

/*
   Reallocate slip channel buffers.
 */

static int sl_realloc_bufs(struct slip *sl, int mtu)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 interr 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 struct
 unsigned
#ifdef SL_INCLUDE_CSLIP
 unsigned char *cbuff;
#endif
 int len = mtu * static voidsl_free_bufs(  *sl

/*
 * allow for arrival of larger UDP packets, even if we say not to
 * also fixes a bug in which SunOS sends 512-byte packets even with
 * an MSS of 128
 */
 if (len < 576 * 2)
   =57 *2;

 xbuff = kmalloc(len + 4, GFP_ATOMIC);
 rbuff = kmalloc(len (xchgsl-, NULL;
#fdefSL_INCLUDE_CSLIP
#ndif
#endif


#ifdef SL_INCLUDE_CSLIP   Reallocate slip channel buffers.
 if (xbuff == java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#else
 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#ndif
  if (mtu  sl->) {
 SL_INCLUDE_CSLIP
  dev-name)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 e =-;
  java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  goto * also fixes a bug in which SunOS * an java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
 }
 spin_lock_bhxbuff=kmalloclen + 4 GFP_ATOMIC);

 err= -ENODEV
 if#ifdef SL_INCLUDE_CSLIP
  goto done_on_bh;

 xbuff    = xchg(&sl->xbuff, xbuff);
 rbuff    = xchg(&sl->rbuff, rbuff);
#ifdef SL_INCLUDE_CSLIP
 cbuff= xchg&sl-cbuff cbuff
#endif
 if (
  #ifdef SL_INCLUDE_CSLIP
 memcpy>xbuffsl-xhead, >xleft
 } elsejava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
  sl- = 0
   dev->stats.tx_dropped++;
  }
 }
 sl->xhead = sl->xbuff;

 if (sl->rcount)  {
  if (sl->rcount printk ":unabletogrowslipbuffers changecancelledn,
            dev-name;
  } else{
   }
   dev- goto;
   set_bit}
  }
 }
 sl->
 err= -NODEV;
 sl->buffsize = len;
 err = 0;

done_on_bh:
 spin_unlock_bh(&sl->lock);

done:
 kfree if(sl-> == NULL)
 kfree(rbuff  gotooto done_on_bh
#ifdef SL_INCLUDE_CSLIP
 r    = xchgsl-, rbuff
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 return err
}


/* Set the "sending" flag.  This must be atomic hence the set_bit. */
static  sl_lock slipsl
{
 netif_stop_queue(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/* Clear the "sending" flag.  This must be atomic, hence the ASM. */
static.++java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
netif_wake_queue(>);
}

/* Send one completely decapsulated IP datagram to the IP layer. */
static  sl_bump  *sl)
{
 struct net_device *err ;
 structdone_on_bh:
  count

 count free);
ifdefjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 #en
   char =>rbuff]
  if }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (!(sl->mode & SL_MODE_CSLIP)) {
    printk(KERN_WARNING%s compressed \">)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   ;
   }
  netif_stop_queue(>dev;
   }
   if (count + 80 > sl->buffsize) {
    dev-
    return;
   }
   count = slhc_uncompress(sl->slcomp, sl->rbuff, countstaticinlinevoidsl_unlockstructslip *sl)
   if (count <= 0)
    return; netif_wake_queuesl-dev
  } else
   if(!(sl->mode& SL_MODE_CSLIP)){
    /* turn on header compression */
    sl->mode |= SL_MODE_CSLIP;
   sl-> & ~;
  printk( "%:header compression on\, dev-name;
 struct *dev sl->;
  sl->rbuff[] & 0;
   tcount
    return;  = sl-rcount
  (>mode(SL_MODE_ADAPTIVE SL_MODE_CSLIP java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}
#endif  /* SL_INCLUDE_CSLIP */

  !> &) 

 skb = dev_alloc_skb(count);
 if 
  printk(KERN_WARNING /* make sure we've reserved enough space for uncompress
dev->stats.rx_dropped++;
return;
}
skb->dev = dev;
skb_put_data(skb, sl->rbuff, count);
skb_reset_mac_header(skb);
skb->protocol = htons(ETH_P_IP);
netif_rx(skb);
dev->stats.rx_packets++;
}

/* Encapsulate one IP datagram and stuff into a TTY queue. */
static (struct *,  char,  )
{
  if (countjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
int, ;

 if (len    >mode=;
 printk ": oversized packet!\,sl-dev->name)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
 sl-dev-.++java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  sl_unlock)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  return
 }

 p java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
#ifdef 
 if(>mode)
  len   = (count
java.lang.NullPointerException
#ifdefCONFIG_SLIP_MODE_SLIP6
 if(sl- &SL_MODE_SLIP6
  countjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
else
#endif
 count  slip_esc( >xbuff)

 dev-stats++java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  * When we are sending a void(struct *sl  char*cpint len
  * the i actual, count
  * routine,  (len  sl-)  /* Sigh 't occur BUT...*
  *  printk "s oversized transmit !\n,sl->name;
  ;
# SL_INCLUDE_CSLIP
 *
 (, sl->flags
actual>tty-ops->write>ttysl-xbuff);
#ifdef SL_CHECK_TRANSMIT(>mode )
 netif_trans_update(sl-dev
#endif
 sl->xleft sl->xleft 
 sl->xhead = sl->xbuff + actual;
ifdefjava.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
 /* VSV */
 clear_bit(SLF_OUTWAIT  * routine, because it's * In this case we *never* * if we did not request it before write operation.
#endif
}

/* Write out any remaining transmit buffer. Scheduled when tty is writable */
static (struct *work
{
  slip =container_of,  slip);
 int actual

 spin_lock_bh(&sl->lock);
 /* First make sure we're connected. */
# java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  spin_unlock_bh&>lock
  return;
 }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* Now serial buffer is almost free & we can start
 * transmission of another packet */
  sl->dev->stats.tx_packets++;
  clear_bit(TTY_DO_WRITE_WAKEUP, &sl->static void slip_transmit(struct work_structwork
  spin_unlock_bh&>lock);
   actual
  return; spin_lock_bh(>lock
 }

 actual  >tty->write(>, >xheadsl-);
 sl- -=actual
 sl-xhead=actual
spin_unlock_bh(sl-lock);
}

/*
 * Called by the driver when there's room for more data.
 * Schedule the transmit.
 */
static  /* Now serial buffer is almost free & we can start
{
struct slip *sl;

rcu_read_lock();
sl = rcu_dereference(tty->disc_data);
if (sl)
schedule_work(&sl->tx_work);
rcu_read_unlock();
}

static void sl_tx_timeout(struct net_device *dev, unsigned int txqueue)
{
struct slip *sl = netdev_priv(dev);

spin_lock(&sl->lock);

if (netif_queue_stopped(dev)) {
if (!netif_running(dev) || !sl->tty)
goto out;

/* May be we must check transmitter timeout here ?
 *      14 Oct 1994 Dmitry Gorodchanin.
 */
 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
ejiffies(dev  2  )  java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  /* 20 sec timeout not reached */
   goto out;
  {
  printk(KERN_WARNING slip =netdev_privdev;
   dev->spin_lock&>lock
  netif_queue_stopped) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    "bad goto out;
  sl->xleft /*
  clear_bitTTY_DO_WRITE_WAKEUP sl-flags
  sl_unlock(sl);
#endif
 }
out:
 spin_unlock&>lock
}


/* Encapsulate an IP datagram and kick it into a TTY queue. */
static netdev_tx_t
sl_xmitstruct *skbstructnet_devicedev
{
 struct  printk " timed out,%?n",

 spin_lock&>lock
 if "ad drivererror)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 (&>lock
 printk "%s xmit call when iface down\" dev-;
  dev_kfree_skb(skb);
  java.lang.NullPointerException
 }
 if(>tty ==NULL {
  spin_unlock(&sl->lock);
  dev_kfree_skb(skb);
  return NETDEV_TX_OK;
 }

 sl_locksl;
 }
 sl_encaps(sl
 spin_unlock(&sl->lock;

 dev_kfree_skb(skb);
 return NETDEV_TX_OK;
}


/******************************************
 *   Routines looking at netdevice side.
 ******************************************/

/* Netdevice UP -> DOWN routine */

 int
sl_close(
{
struct *  (dev

 spin_lock_bh(&sl-  ;
 if ( sl_lock();
 /* TTY discipline is running. */
  clear_bit(TTY_DO_WRITE_WAKEUP(&sl-lock
 netif_stop_queue(dev);
 sl->count=0
 ft= 0;
 spin_unlock_bh(&sl->lock);

 return 0;
}

/* Netdevice DOWN -> UP routine */

static int sl_open( net_device *ev
{
 struct slip ******java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

if (l-> = NULL)
n -ENODEV

 > &=( <SLF_INUSE
 (dev;
 return 0;
}

/* Netdevice change MTU request */

static java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 struct * =netdev_priv)

ealloc_bufs,);
}

/* Netdevice get statistics request */&>lock

static void
sl_get_stats64 net_device devstruct *)
{
s net_device_stats =&>;
#s slip =netdev_priv);
 struct (sl-tty )
structslcompress * = sl-slcomp
#endif
stats-     devstats-;
 >tx_packets=>tx_packets;
 stats->rx_bytes       = devstats->rx_bytes;
 stats->tx_bytes       = devstats->tx_bytes;
 stats-rx_dropped=devstats->rx_dropped;
 stats->tx_dropped     = devstats->tx_dropped;
 stats->tx_errors      = devstats->tx_errorsstatic intsl_change_mtustructnet_device *dev, int )
 stats->rx_errors
stats-;

#ifdef SL_INCLUDE_CSLIP
 ifsl_get_stats( net_devicedev   *)
 *java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  stats->rx_packets=devstats-rx_packets
  stats-tx_compressed omp-;

  /* Are we really still needs this? */
 >rx_fifo_errors >sls_i_compressed
  stats->rx_dropped>rx_dropped;
  stats- +>sls_o_compressed
 =>sls_o_misses

endif


java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

  (dev
{
 structendif

 /*
 * Finish setting up the DEVICE info.
 */

 dev-
 dev->type  = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 4
#ifdef ifdef SL_CHECK_TRANSMIT
 dev->watchdog_timeo = 20*HZ;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 return 0
}


 *dev
{
 struct slip slip* =netdev_priv);

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
}

/* Hook the destructor so we can free slip devices at the right point in time */
static void sl_free_netdev(struct net_device *dev)
{
 int i =dev-base_addr

 slip_devs[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

tatic struct sl_netdev_ops=java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 ndo_init ,
 .    ,
_open
 .ndo_stop  =# 
 .  =sl_xmit
 .ndo_get_stats64;
 .ndo_change_mtu  = sl_change_mtu,
 .ndo_tx_timeout  = sl_tx_timeout,
#ifdef CONFIG_SLIP_SMART
 ndo_siocdevprivatesl_siocdevprivate
#endif
;


 sl_setup net_device*ev
{
>  =&;
 dev-dev- =0
d>priv_destructor ;

 dev- = 0
 dev->addr_len
 dev->tx_queue_len=1;

 /* MTU range: 68 - 65534 */
 dev-min_mtu = 68java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 dev->max_mtu

 /* New-style flags. */
 dev->flags  = IFF_NOARP dev->flags=IFF_NOARPIFF_POINTOPOINT|IFF_MULTICAST
}

/******************************************
  Routines looking at TTY side.
 ******************************************/


/*
 * Handle the 'receiver data ready' interrupt.
 * This function is called by the 'tty_io' module in the kernel when
 * a block of SLIP data has been received, which can now be decapsulated
 * and sent on to some IP layer for further processing. This will not
 * be re-entered while running but other ldisc functions may be called
 * in parallel
 */

static voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  size_t)
{
 struct slip *sl = tty-        ize_t)

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;

/
 while (count--) {
  if /* Read the characters out of the buffer */
 if!est_and_set_bitSLF_ERROR&>flags
    f!(SLF_ERRORsl-))
  ++java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  ;
  }
ifdef
  sl- &SL_MODE_SLIP6
    slip_unesc6,*cp)
  else
#endif slip_unescsl cp+;
   slip_unesc(}
 }
}

/************************************ *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *  slip_open helper routines.
 ************************************/

/* Collect hanged up channels */
static void sl_sync(void)
{
  i;
struct *;
 struct slip i=0   ; i+)

 ori=0   ; +){
  dev =   ;
  if ( sl = nedev;
   break;

 sl (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue struct *(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  dev- &)
  (dev
 }



/* Find a free SLIP channel, and link in this `tty' line. */
static  slipsl_alloc)
{
 int i;
char[IFNAMSIZ
struct *  ;
 struct slip

 for (i  f( >=slip_maxdev
  dev = slip_devsi];
  if (dev == NULL)
   break;
 }
 /* Sorry, too many, all slots in use */
 if i>=slip_maxdev
  NULL

 (name "%" i;
r NULL
 if (!dev>base_addr ;
  return NULL;

 >base_addr ijava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 sl =  l-dev      ;

/
 sl->magic        >mode ;
 sl->dev/* initialize timer_list struct */
 spin_lock_init dev
 INIT_WORK
 sl->
#ifdef CONFIG_SLIP_SMART
 /* initialize timer_list struct */
 timer_setup(&sl- * sure the tty line exists, we only * a free SLIP channel...
 timer_setup *
#endif
 [i  ;
 return sl


/*
 * Open the high-level part of the SLIP channel.
 * This function is called by the TTY module when the
 * SLIP line discipline is called for.  Because we are
 * sure the tty line exists, we only have to link it to
 * a free SLIP channel...
 *
 * Called in process context serialized from other ldisc calls.
 */

static  simplest one.
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct slip *sl;
 int err;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  -EPERM

 if (tty->ops->write == NULL)
  returngotoerr_exit

 /* RTnetlink lock is misused here to serialize concurrent
   opens of slip channels. There are better ways, but it is
   the simplest one.
 */
 rtnl_lock();if = )

 /* Collect hanged up channels. */
 sl_sync> =;

 sl =   (test_bit,sl-))

 err = -EEXIST  (,SL_MTU
 /* First make sure we're not already connected. */;
(&>magic)
  goto   (sl-);

java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 err  -;
 sl = sl_alloc();
  (sl = NULL
   dd_timer(sl->keepalive_timer;

 sl- (sl-) {
 tty- = ljava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 sl-> /* Done.  We have linked the TTY line to a channel. */

rtnl_unlock)
 java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  err = sl_alloc_bufs(sl
  if:
  g err_free_chan

 err_free_chan

  err =  tty->disc_data = NULL
   (err
    err_free_bufs
 }

ifdef
 iffree_netdev>dev
   return;
  add_timer(&sl->keepalive_timer);err_exit
 }
 if (sl->outfill {
  sl->outfill_timer. /* Count references from TTY module */
  add_timer(&sl->outfill_timer);
 }
#endif

 /* Done.  We have linked the TTY line to a channel. */
 rtnl_unlock}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* TTY layer expects 0 on success */
 return 0 *

err_free_bufs:


err_free_chan:
 sl->tty {
 tty->disc_data = NULL slip* = tty->isc_data
 clear_bit(SLF_INUSE /* First make sure we're connected. */
 sl_free_netdevsl->dev;
 /* do not call free_netdev before rtnl_unlock */
 rtnl_unlock();
 free_netdev(sl->dev);
 return err(&sl-lock

err_exit:
 rtnl_unlock();

 /* Count references from TTY module */
 return err;
}

/*
 * Close down a SLIP channel.
 * This means flushing out any pending queues, and then returning. This
 * call is serialized against other ldisc functions.
 *
 * We also use this method fo a hangup event
 */

static slip_close( tty_struct*java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct * = tty->;

 /* First make sure we're connected. */
 if (!sl || sl->magic  *******java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;

 spin_lock_bh(&sl->lock);
 rcu_assign_pointer(tty->disc_data, NULL char;
 sl->tty =  * Send an initial END character to   * data that may have accumulated in the receiver
 

   * character sequence,
   (len-- ){

 /* VSV = very important to remove timers */
#ifdef CONFIG_SLIP_SMART
 timer_delete_sync(&  ptr ;
timer_delete_sync>outfill_timer
#endif
*;
 unregister_netdevjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
ptr;
}

static  slip_unesc  *,unsigned java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
(tty
}
 /************************************************************************
  * STANDARD SLIP ENCAPSULATION     *
  ************************************************************************/

static int slip_esc(unsigned char #endif
{
 unsigned
 unsignedcharc;

java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 case ESC_ESC  if (test_and_clear_bit(SLF_ESCAPE, &sl-   s = ESC;
    s = END;
  * due  if (!test_bit(SLF_ERROR  if (sl->rcount   sl->rbuff[sl-   return;
  }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * For each byte in the packet, send the appropriate
 * character sequence, according to the SLIP protocol.
 */

  unsignedchar* = ;
 switch(c= *++){
  case END:
   *ptr++ = ESC;
   *ptr++ = ESC_END;
   break;
   ESC:
   *ptr++ = ESCunsigned short  =;
   *ptr++ = ESC_ESC
   breakreak
  default:
   *ptr++ = c;
   break;
  }
 }
 *ptr++ = END;
 return ptr - d;
}

static
{

 switch( java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  END
#ifdef CONFIG_SLIP_SMART  v<8 |si;
  /* drop keeptest bit = VSV */
  if (test_bit(SLF_KEEPTESTbits ;
  clear_bitSLF_KEEPTEST,&>flags
endif

  if (!test_and_clear_bit
      (>rcount2)
  sl_bump();
 clear_bit(LF_ESCAPE sl-);
  sl->rcount = 0;
 returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 case :
  set_bit(SLF_ESCAPE, 
  ;
 case ESC_ESC:
  if if( =07){
   s = ESC;
  break;
 caseESC_END
 if((SLF_ESCAPE&>flags
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  break
 }
 if (test_bitSLF_ERROR &sl-flags  
  if (sl->rcount < sl->buffsize)  {
   sl->rbuffsl-rcount]  s;
   return;
  }
  sl->dev->stats.rx_over_errors++;
  set_bit(SLF_ERROR, &sl->flags);
 }
}


ifdefCONFIG_SLIP_MODE_SLIP6
/************************************************************************
 *  6 BIT SLIP ENCAPSULATION *
 ************************************************************************/

static int lip_esc6 chars, char *d,intlen)
{
  d
 unsigned  )> >)
 ;
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 short bits>>.rx_over_errorsjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 /*
 * Send an initial END character to flush out any
 * data that may have accumulated in the receiver
 * due to line noise.
 */

 *ptr =0;

 /*
 * Encode the packet into printable ascii characters
 */

 for (i  0 i<len++) {
  v = (v << 8) | s[i];
  bits += 8;
  while (bits >= 6) {
  bits=6;
   c =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *++ =cjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  }
 }
 if (bits) {
  c = 0x30 +  SIOCGIFNAME
r++ =;
 }
 *ptr++ = 0x70;
 return  ;
}

static  put_user>, )
{
unsigned java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 if (s == 0x70 tmp(|))
#  ;
  /* drop keeptest bit = VSV */
 java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
 clear_bitSLF_KEEPTEST &>);
endif

 if!(, sl-) &
      (sl->rcount > 2))
   sl_bump(sl);
 >rcount=0
  sl->xbits = 0;
  sl->xdata = 0;
 } java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
  >xdata(>xdata<)|(s- x30)
  sl->xbits += 6;
  if ( if((tmp)
xbits
    EINVAL
   if(>);
 ifsl-rcount>)  
     sl-spin_unlock_bh>);
    return
    }
   l->>stats+;
    set_bit(SLF_ERROR, &sl->flags);
   }
 }
 }
}
#java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

/* Perform I/O control on an active SLIP channel. */
static int slip_ioctlreturn ;
  unsigned arg
{
 struct  if(put_user>keepalive, ))
 unsignedint ;
 int __user * return0

java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   > ! )
  return -EINVALEINVAL

switchcmd
c SIOCGIFNAME
  tmp = 
( user,sl->, ))
   return - if (sl->outfill)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  return 0;

 case SIOCGIFENCAP:
  if (put_user(sl->mode, p))
   return -EFAULT;
  return 0;

 case SIOCSIFENCAP  }else
  if ((tmp, p))
   return -EFAULT spin_unlock_bhsl-lock
# SL_INCLUDE_CSLIP
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return -EINVAL;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  if ((  0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
  /* return -EINVAL; */
   tmp &= ~SL_MODE_ADAPTIVE;
#endif
#ifndef CONFIG_SLIP_MODE_SLIP6
  if (tmp & SL_MODE_SLIP6)
   return -EINVAL;
#endif
  sl->mode = tmp;
  sl->dev-#ifdefCONFIG_SLIP_SMART
  return/* function sl_siocdevprivate called from net/core/dev.c

case SIOCSIFHWADDR:
return -EINVAL;

#ifdef CONFIG_SLIP_SMART
/* VSV changes start here */
 caseSIOCSKEEPALIVE
  if (get_user void_ *data  cmd
   return -EFAULT;
   ( >25 /* max for unchar */
   return -EINVAL;

  spin_lock_bh   unsigned&>;
  if (( )/
   spin_unlock_bh
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  sl- !ttyjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  if  ENODEV
   mod_timer(&sl->keepalive_timer,
      switch) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   set_bit(SLF_KEEPTEST, &sl->flags);
   else
   timer_delete(&  spin_unlock_bh&sl-lock
  spin_unlock_bh(&sl->lock  return-EINVAL;
  return 0;

 case sl-keepalive=(u8*;
  if    (sl-keepalive! 0 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  return -FAULT
  return 0;

TFILL
 ifget_user, p)
  return -;
  if  imer_delete>);
 break;
  spin_lock_bh(&sl->lock);
  if (!sl->tty) {
   spin_unlock_bh(& ase:
   return:
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  sl->outfillsl-> =()*java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
  != 0 
  mod_timer(>outfill_timer
      set_bit, &>flags
 set_bit,&>flags
  } else
   timer_delete(&sl->outfill_timer);
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  return ;

 case SIOCGOUTFILL:
  if (put_user(sl->outfill /* Resolve race condition, when ioctl'ing hanged up
return -EFAULT;
return 0;
/* VSV changes end */
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 default:
  return tty_mode_ioctl(tty, cmd, arg);
 }
}

/* VSV changes start here */
#fdefCONFIG_SLIP_SMART
/* function sl_siocdevprivate called from net/core/dev.c
   to allow get/set outfill/keepalive parameter
   by ifconfig                                 */

static int sl_siocdevprivate
        void __user *p=sl-;
{
struct *l=netdev_priv);
 unsignedlongp=( long)rq-;

#ndif
 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 if (in_compat_syscall())
  return -EOPNOTSUPP;

  name=slip,

 if (!sl->tty) {
  spin_unlock_bh(&sl->lock);
  return -ENODEV;
 }

 (cmdjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 case   _init (void
  /* max for unchar */
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   spin_unlock_bh(sl-);
   return -EINVAL;
  }
  sl- = ()*;
  if (sl->keepalive != 0) {
  >keepalive_timerexpires =
 endif
  mod_timersl-keepalive_timer
    jiffies> *);
 set_bit,sl-)
  }  (KERN_INFO  9 University\)
   timer_delete
 b;

 case SIOCGKEEPALIVE:
*=sl-;
  break;

 case SIOCSOUTFILL:
  if ((unsigned)*p 
  spin_unlock_bh(sl-lock
   return java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [15, 3) out of bounds for length 3
  sl->outfill = (u8)*p;
  if (}
   mod_timer(&sl->outfill_timer,
      jiffies + status
   set_bit(SLF_OUTWAIT, &sl-
  } 
   timer_delete(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  break;

 case SIOCGOUTFILL:
  *p = sl-> unsigned  timeoutjiffies HZ
  break;

 case SIOCSLEASE:
 /* Resolve race condition, when ioctl'ing hanged up
   and opened by another process device.
 */
  if (sl->tty != current->
      sl->pid! current-pid{
   spin_unlock_bh(&sl->lock);
   return -EPERM;
  }
  sl->leased = 0 do{
  if (*p)  if ()
  sl-leased  1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 case SIOCGLEASE!java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   usy
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
spin_unlock_bh&>lock
 return 0;  }
}
#endif
/* VSV changes end */

static struct tty_ldisc_opssl_ldisc={
 .owner   = THIS_MODULE,
 .num  = N_SLIP,
 .name   = "slip"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .open   = slip_open,
e,
  if!ev
 .octl= slip_ioctl
 . =slip_receive_buf
 .write_wakeup = slip_write_wakeup,
};

static _init(void
{
 intstatus

if (slip_maxdev  4java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  =4 /* Sanity */

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#ifdef (slip_init
        (   )
#endif
        ".\n",
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
#if defined(SL_INCLUDE_CSLIP)
 printk(KERN_INFO "CSLIPstatic sl_outfill( timer_list*java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
#ifdef CONFIG_SLIP_SMART
 rintkKERN_INFO SLIP/ .n";
#endif

  =kcalloc, (struct *,
        GFP_KERNEL);
 if (!slip_devs)
 (>outfill{

 /* Fill in our line protocol discipline, and register it */
 statustty_register_ldiscsl_ldisc)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if (status != 0) {
  printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
  kfree(slip_devs);
 }
 return status;
}

static void __exit slip_exit(void)
{
 int i;
 struct net_device *dev;
 struct slip *sl;
 unsigned long timeout  unsigned s=END;
 int busy = 0;

 if (slip_devs == NULL)
 return

 /* First of all: check for active disciplines and hangup them.
 */
 do {
 iff()
   else

  busy 0
  for (i = 0; i < slip_maxdev; i+java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   dev = slip_devs[i];
   if (!dev)
    continue;
   sl = netdev_priv(dev);
   spin_lock_bh(&sl->lock);
 pin_unlocksl-);
  }
    tty_hangup(sl->tty);
   }
   pin_unlock_bh(sl-);
  }
 } while (busy &&  struct slip *sl = timer_container_oft );

 /* FIXME: hangup is async so we should wait when doing this second
   phase */

 for ( if(,&>))java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 dev[i;
  if (!  voidtimer_delete&>outfill_timer
   continue
  slip_devs[i  /* this must hangup tty & close slip */

  sl = netdev_priv(dev);
  if (sl->tty) {
   printk(KERN_ERR "%s: tty discipline still running\n",
          dev->name);
 }

  unregister_netdev(  (SLF_KEEPTEST sl-);
 }

 kfree(slip_devs);
 slip_devs = NULL;

 tty_unregister_ldisc(&sl_ldisc);
}

module_init();
module_exit(slip_exit);

#ifdef CONFIG_SLIP_SMART
/*
 * This is start of the code for multislip style line checking
 * added by Stanislav Voronyi. All changes before marked VSV
 */

static void sl_outfill(struct timer_list *t)
{
 struct slip *sl = timer_container_of(sl, t, outfill_timer);

 spin_lock(&sl->lock);

 if (sl->tty == NULL)
  goto out;

 if (sl->outfill) {
  if (test_bit(SLF_OUTWAIT, &sl->flags)) {
   /* no packets were transmitted, do outfill */
#ifdef CONFIG_SLIP_MODE_SLIP6
   unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
#else
   unsigned char s = END;
#endif
   /* put END into tty queue. Is it right ??? */
   if (!netif_queue_stopped(sl->dev)) {
    /* if device busy no outfill */
    sl->tty->ops->write(sl->tty, &s, 1);
   }
  } else
   set_bit(SLF_OUTWAIT, &sl->flags);

  mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
 }
out:
 spin_unlock(&sl->lock);
}

static void sl_keepalive(struct timer_list *t)
{
 struct slip *sl = timer_container_of(sl, t, keepalive_timer);

 spin_lock(&sl->lock);

 if (sl->tty == NULL)
  goto out;

 if (sl->keepalive) {
  if (test_bit(SLF_KEEPTEST, &sl->flags)) {
   /* keepalive still high :(, we must hangup */
   if (sl->outfill)
    /* outfill timer must be deleted too */
    (void) timer_delete(&sl->outfill_timer);
   printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
   /* this must hangup tty & close slip */
   tty_hangup(sl->tty);
   /* I think we need not something else */
   goto out;
  } else
   set_bit(SLF_KEEPTEST, &sl->flags);

  mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
 }
out:
 spin_unlock(&sl->lock);
}

#endif
MODULE_DESCRIPTION("SLIP (serial line) protocol module");
MODULE_LICENSE("GPL");
MODULE_ALIAS_LDISC(N_SLIP);