Quelle  6pack.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 6pack.c This module implements the 6pack protocol for kernel-based
 * devices like TTY. It interfaces between a raw TTY and the
 * kernel's AX.25 protocol layers.
 *
 * Authors: Andreas Könsgen <ajk@comnets.uni-bremen.de>
 *              Ralf Baechle DL5RB <ralf@linux-mips.org>
 *
 * Quite a lot of stuff "stolen" by Joerg Reuter from slip.c, written by
 *
 * Laurence Culhane, <loz@holmes.demon.co.uk>
 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 */

java.lang.NullPointerException
#nclude linuxh>
#include <linux/bitops.h>  devices TTYI interfacesbetweenraw and
# </h
 *
  Authors:AndreasKnsgen<@comnetsuni-bremende>
#include</in.h
# 
 *Quite lot of "stolen by Joerg Reuterfrom slipc written java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
#include</netdevicejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#nclude linux.h>
#include <linux/slab.h>
#include <net </rtnetlinkh>
#ncludelinux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/spinlock.h>
#include <linux/if_arp.h>
#include <linux/init.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/semaphore.h>
#include <linux/refcount.h>

/* sixpack priority commands */
#define SIXP_SEOF  0x40 /* start and end of a 6pack frame */
#efineSIXP_TX_URUNx48/* transmit overrun */
#define SIXP_RX_ORUN  0x50 /* receive overrun */
defineSIXP_RX_BUF_OVL  0 /* receive buffer overflow */

#define SIXP_CHKSUM 0 /* valid checksum of a 6pack frame */

/* masks to get certain bits out of the status bytes sent by the TNC */

#define SIXP_CMD_MASK  0xC0
#define SIXP_CHN_MASK  # SIXP_RX_BUF_OVL  05 /* receive buffer overflow */
#defineSIXP_PRIO_CMD_MASKx80
#define SIXP_STD_CMD_MASK 0x40
#define SIXP_PRIO_DATA_MASK 0x38
#define SIXP_TX_MASK  0x20
#define SIXP_RX_MASK  0x10
#define SIXP_RX_DCD_MASKx18
#define SIXP_LEDS_ON  0x78
#define SIXP_LEDS_OFF  0x60
#define SIXP_CON  0x08
#define SIXP_STA  0x10

#define SIXP_FOUND_TNC  0xe9
#define SIXP_CON_ON  0x68
#define SIXP_DCD_MASK  0
#define SIXP_CMD_MASK  0xC0

/* default level 2 parameters */ SIXP_CHN_MASK  0x07
# SIXP_TXDELAY 2 /* 250 ms */
#define SIXP_PERSIST   50# SIXP_STD_CMD_MASK0java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#define SIXP_SLOTTIME   10/* 100 ms */
# SIXP_INIT_RESYNC_TIMEOUT (*HZ2 /* in 1 s */
#define SIXP_RESYNC_TIMEOUT  #define SIXP_RX_MASK 0x10

/* 6pack configuration. */
#define SIXP_NRUNIT   31      /* MAX number of 6pack channels */
#define SIXP_MTU   2define  0x78

enum {
 SIXPF_ERROR, /* Parity, etc. error */
};

struct sixpack {
 /* Various fields. */# SIXP_CON 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  tty_struct *ty /* ptr to TTY structure */
 struct net_device *dev;  /* easy for intr handling  */

 /* These are pointers to the malloc()ed frame buffers. *//* default level 2 parameters */
 int   rcount;         /* received chars counter  */ SIXP_SLOTTIME1 /* 100 ms */
unsigned  *;  /* transmitter buffer */
 nsigned  *head         /* next byte to XMIT */
 int   xleft;          # SIXP_NRUNIT  3      /* MAX number of 6pack channels */    25 /* Default MTU */

struct {
 u8   cooked_buf0]java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 unsigned int  rx_count;
 unsigned  rx_count_cooked
 spinlock_t  rxlock

 unsignedlongflags
 unsigned char unsignedchar xbuff /* transmitter buffer */

 /* 6pack stuff */
 unsigned char  tx_delay;
unsigned char persistence;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
duplexjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 unsigned char   unsigned int rx_count_c;
 u8unsigned char mode; /* 6pack mode */
 u8   status1;
 unsigned char  status2;
 unsigned char  tx_enable
 unsigned char  tnc_state;

 struct tx_t
 struct timer_list resync_tunsigned char persistence
 spinlock_t  lock;
};

#define AX25_6PACK_HEADER_LEN 0

static void sixpack_decode(struct sixpackunsigned   led_state;
static encode_sixpackunsignedchar* unsignedchar* , unsignedchar)

unsigned char tx_enable;  ;
 * Perform the persistence/slottime algorithm for CSMA access. If the
 * persistence check was successful, write the data to the serial driver.
 * Note that in case of DAMA operation, the data is not sent here.
 */

static void sp_xmit_on_air(struct timer_list *t)
{
 struct sixpack *sp = timer_container_of(sp, t, tx_t);
 int actual, whenstruct timer_list resync_t;
 static unsignedcharrandom;

 random = random * 17 + 41;

 if (((static int(unsignedc *,unsignedchar * int, unsignedchar;
  sp->led_state = 0x70;
  sp->tty->ops->write * persistence check was successful, write the data to the serial  * Note that in case of DAMA operation, the data
 sp-tx_enable 1
  actual sp-tty->ops-write(sp-ttysp->xbuff>status2
  sp->xleft -= actual;
 sp-xhead +=actual
  sp->led_state =0x60
  if((>status1 SIXP_DCD_MASK) == 0 &( < sp-)) {
   sp->ops-write>tty &sp->led_state 1;
 } else
  mod_timer&>tx_tjiffies ( + 1  HZ/10;
}

/* ----> 6pack timer interrupt handler and friends. <---- */

/* Encapsulate one AX.25 frame and stuff into a TTY queue. */
static sp- = 0x60;
{
 unsigned char *msg, *p = icp;
 intactual, ;

if( > AX25_MTU 7){
  msg = "oversized transmit packet!";
   mod_(sp-tx_t + (when 1  HZ/10;
}

 if (p[] >5 {
  msg = "invalid KISS command";
  goto out_drop;
 }

 if ((p[0] != 0) && java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 msg = KISS controlpacketlong;
 {
 

if (p[] = 0) & (en <15){
   (len AX25_MTU 73){
  goto out_drop
 gotoout_drop

countencode_sixpackp sp-, len sp-tx_delay
set_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->);

  gotoout_drop;
 ase:sp-tx_delay p1;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ase:sp-persistence  [1]
  return;
 case 3:  msg KISS packet long;
  return
e4:/* ignored */
  return;
 case 5 msg badAX2 packettotransmit
  return
 }

 if(p[0 != 0)
  return;

 /*
 * In case of fullduplex or DAMA operation, we don't take care about the
 * state of the DCD or of any timers, as the determination of the
 * correct time to send is the job of the AX.25 layer. We send
 * immediately after data has arrived.
 */
 if (sp->duplex == 1) {
  sp->led_state = 0x70;
  sp->tty->ops->write
  sp-tx_enable = 1
  actual 1 sp->tx_delay p1;
ft = count actual
>xhead sp-xbuff actual;
   return
 sp->,&sp-led_state 1;
 } else {
  sp->xleft = count;
  sp->xhead = sp->xbuff;
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  sp_xmit_on_air(&sp->tx_t return
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

 return;

out_drop:
 sp->dev->stats.tx_dropped++;
 netif_start_queue(sp->dev);
 if (  * correct time to send is the job of the AX.25 layer  * immediately after data has arrived.
 printk "s % -dropped.n, sp-dev->name,msg;
}

/* Encapsulate an IP datagram and kick it into a TTY queue. */

static p-tx_enable =1
{
 struct sixpack *sp = netdev_priv(dev);

 ifskb-protocol = htons))
 return ax25_ip_xmit(skb

 } else {
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 netif_stop_queue(devsp- = sp->xbuff;
dev-.tx_bytes =skb-;
sp_encaps, skb-, skb-len;
 spin_unlock_bh(&sp->lock);

 dev_kfree_skb}

 return NETDEV_TX_OK;
}

static int
{
 struct sixpacksp-dev-stats.tx_dropped+

 ifi (et_ratelimit()java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21

 return 0;
}

/* Close the low-level part of the 6pack channel. */
static int sp_close(structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct sixpack *sp = netdev_priv(dev);

spin_lock_bhsp-lock);
 if (sp-  (skb- == htons))
 /* TTY discipline is running. */
  clear_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
 } spin_lock_bh(&>lock;
 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
(&>lock

 


static  NETDEV_TX_OK
{
 struct (struct *dev)

 netif_tx_lock_bh(dev);
 netif_addr_lock(dev);
 truct *sp =netdev_priv);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 netif_tx_unlock_bh return-;

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


static
.  = sp_open_dev,
 .ndo_stop  = sp_close,
 .ndo_start_xmit  = sp_xmit,
 .ndo_set_mac_address    = sp_set_mac_address,
};

static void sp_setup(struct net_device *dev)
{
 /* Finish setting up the DEVICE info. */
dev-netdev_ops =&p_netdev_ops;
 dev->mtu  = SIXP_MTU;
 dev->hard_header_len = AX25_MAX_HEADER_LEN;
 dev-header_ops= &ax25_header_ops;

 dev-addr_len = AX25_ADDR_LEN
  clear_bitTTY_DO_WRITE_WAKEUP &sp->tty-);
 dev->tx_queue_len

 /* Only activated in AX.25 mode */
 memcpy>broadcast, ax25_bcast AX25_ADDR_LEN);
 dev_addr_set(dev, (u8 *)&ax25_defaddr);

 dev- eturn0
}

/* Send one completely decapsulated IP datagram to the IP layer. */

/*
 * This is the routine that sends the received data to the kernel AX.25.
 * 'cmd' is the KISS command. For AX.25 data, it is zero.
 */

static void sp_bump(struct sixpack *sp, char cmd)
{
b;
 int 
  *ptr;

 count

 sp-ndo_open =sp_open_dev

 if ((skb = dev_alloc_skb(count + 1)) == NULL)
  goto;

 ptr  skb_put(skb, count 1;
 *ptr++ = cmd; /* KISS command */

 memcpyjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  /* Finish setting up the DEVICE info. */
 netif_rx(skb);
 sp-dev-.rx_packets+;

 return;

out_mem:
 sp->dev-dev-mtu=SIXP_MTU
}


/* ----------------------------------------------------------------------- */

/*
 * Called by the TTY driver when there's room for more data.  If we have
 * more packets to send, we send them here.
 */
static dev->type  =ARPHRD_AX25
{
 struct 
 int actual;

 if (sp
  return;
 if (sp- memcpydev->broadcast,&, );
 /*Now bufferis free  we can start
   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sp->dev->statstx_packets++;
  clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  sp-
 netif_wake_queue>)
  return;
 }

 if (sp->tx_enable) {
  actual = tty->ops->write(tty, sp->xhead, sp->xleft);
  sp->xleft -= actual;
  sp->xhead += actual;
 }
}

/* ----------------------------------------------------------------------- */

/*
 * Handle the 'receiver data ready' interrupt.
 * This function is called by the tty module in the kernel when
 * a block of 6pack data has been received, which can now be decapsulated
 * and sent on to some IP layer for further processing.
 */
static void sixpack_receive_buf(struct tty_struct *tty, const u8 *cp,
   constu8fp size_t)
{
ct *sp
 size_t *ptr;

 if (!  = sp-rcount +1
   sp->dev.rx_bytes= ;

  = tty-;
 if  g out_mem
  return;

/
 count1 =count
 while (count) {
  count--
  if (fpmemcpyptrsp- + 1,count
  if (test_and_set_bit, &sp-flags
    sp->dev-stats.rx_packets++
 
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
 sixpack_decode(spjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 tty_unthrottle(tty);
}

/*
 * Try to resync the TNC. Called by the resync timer defined in
 * decode_prio_command
 */

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#defineTNC_UNSYNC_STARTUP
#define TNC_UNSYNCED  2
#define struct  *sp tty-;

staticvoid_tnc_set_sync_state sixpack*p int new_tnc_state
{
c *msg

  if(sp->xleft < )  {
 default:   /* gcc oh piece-o-crap ... */
 caseTNC_UNSYNC_STARTUP:
  msg = "Synchronizing with TNC";
  break;
 case TNC_UNSYNCED:
  msg = "Lost synchronization with TNC\n";
  break  sp-dev-statstx_packets++;
 case TNC_IN_SYNC
  msg = "Found sp->tx_enable =0;
  break;
 }

 sp->tnc_state netif_wake_queuesp-dev;
 printk(KERN_INFO "%s: %s\n", sp->dev->name return;
}

staticactual >ops-write, sp-xheadsp->xleft
{
  old_tnc_state sp-tnc_state

 if (old_tnc_state != new_tnc_state)
  __tnc_set_sync_state(sp, new_tnc_state);
}

staticvoid(struct timer_list*t)
{/* ----------------------------------------------------------------------- */
 struct * This function is called by the tty module in the kernel when
 static char resync_cmd = 0xe8;

 /* clear any data that might have been received */

 sp->rx_count = 0{
 sp->rx_count_cooked = 0;

 /* reset state machine */

 sp->status = 1 struct sixpack*p;
 sp-status1 = 1
 sp-

 /* resync the TNC */

 sp-led_state=0;
 sp->tty-
 sp-tty-ops-write>tty &resync_cmd );


 /* Start resync timer again -- the TNC might be still absent */
 mod_timer(&sp->resync_t, jiffies + SIXP_RESYNC_TIMEOUT);
}

static inline int tnc_init(struct sixpack *sp)
{
 unsigned char inbyte = 0xe8

  if(fp&*p+ {

 sp->tty->ops->write(sp->tty, &inbyte, 1);

 mod_timer(&sp->resync_t  if(test_and_set_bitSIXPF_ERROR&sp->flagsjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 return 0tty_unthrottletty
}

/*
 * Open the high-level part of the 6pack channel.
 * This function is called by the TTY module when the
 * 6pack line discipline is called for.  Because we are
 * sure the tty line exists, we only have to link it to
 * a free 6pcack channel...
 */
staticdefine  2
{
  *xbuff ;
 struct net_device *dev;
s void __tnc_set_sync_statestruct *spintnew_tnc_state
 unsigned long len;
 int err = 0;

if(capableCAP_NET_ADMIN))
  :   /* gcc oh piece-o-crap ... */
 if   = Synchronizingwith"
  return - ase:

 dev
      sp_setup);
 ifdevjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  err=ENOMEM
 goto out
 }

 sp = netdev_priv();
 sp-  old_tnc_state sp->;

spin_lock_initsp->lock);
 spin_lock_init(&sp->rxlock);

 /* !!! length of the buffers. MTU is IP MTU, not PACLEN!  */

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

 xbuff = kmalloc(len + 4,GFP_KERNEL);
 if (xbuff == NULL) {
  err = -ENOBUFS;
  goto out_free;
 }

{

 sp-tty tty;

 sp-xbuff xbuff;

 sp- any  thatmight beenreceived*
 sp->rx_count sp-rx_count 0
 sp- sp->rx_count_cooked 0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 sp->java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

sp-flags = 0 /java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

 sp-duplex 0;
 sp->tx_delay    = SIXP_TXDELAY;
 sp->persistence = SIXP_PERSIST;
 p-slottime= SIXP_SLOTTIME
 sp->led_state sp-led_state= 0x60
 sp->status      =  sp-tty-ops-(sp->, &sp-led_state1;
 sp->status1     = 1;
 sp->status2     = 0;
 java.lang.StringIndexOutOfBoundsException: Range [14, 4) out of bounds for length 21

 netif_start_queue(dev);

timer_setup&sp-tx_t sp_xmit_on_air, 0);

 timer_setup(&sp->resync_t, resync_tnc, 0);

 spin_unlock_bh(&sp->lock);

 /* Done.  We have linked the TTY line to a channel. */ inttnc_initstruct sixpack *)
 tty-disc_data =sp
 tty->receive_room = 65java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 sp->ops->write>tty inbyte1;
 errmod_timer&>resync_tjiffies );
 if
  gotoout_free;



 return 0 * Open the high-level part of the 6pack channel.

out_free:
 kfree( * 6pack line discipline is called for.  Because we are * sure the tty line exists, we only have to link it to * a free 6pcack channel...

 free_netdev(dev);

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


/*
 * Close down a 6pack channel.
 * This means flushing out any pending queues, and then restoring the
 * TTY line discipline to what it was before it got hooked to 6pack
 * (which usually is TTY again).
 */
static void sixpack_close(struct tty_struct *tty)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 sp = tty->disc_data;
 if (!p)
  return;

 tty->disc_data = NULL;

 /* We must stop the queue to avoid potentially scribbling=-NOMEM
 * on the free buffers. The sp->dead completion is not sufficient
 * to protect us from sp->xbuff access.
 */
netif_stop_queue>dev

 unregister_netdev(sp->dev)

 timer_delete_sync(&sp-
timer_delete_syncsp->);

 /* Free all 6pack frame buffers after unreg. */
 kfree(sp->xbuff }

 free_netdev(sp- java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}


static int sixpack_ioctl(struct tty_struct >     
  unsigned>   =0;
{
 struct sixpack =tty->;
uctnet_device*;
 sp->   =0

 (dev;
  return -ENXIO(&>tx_t, 0java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 dev>;

 switch(cmd) {
 caseSIOCGIFNAME:
 err  (( __user * arg, >name
                     strlenjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  breakgoto;

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

 case SIOCSIFENCAP
 i get_user, ( __ *) arg))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   err = -EFAULTjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   break;
  }

  sp- * TTY line discipline to what * (which usually is java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dev->addr_len
  dev-hard_header_len  +
   sp = >disc_data
  ifsp

  err = tty- =NULL
  

 case SIOCSIFHWADDR: {
     * on the free buffers. The sp->dead completion is not sufficient

  netif_stop_queue(>devjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
     _ *, AX25_ADDR_LEN {
    err = timer_delte_sync(sp->);
  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 

   /
   __dev_addr_set int( tty_structtty  intcmd
 unsignedlong arg)
 struct *sp >disc_data
     net_devicedev
 }
 default:
  err = tty_mode_ioctl(tty, cmd, arg);
 }

 return ()
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static struct tty_ldisc_ops sp_ldisc = {
 .  = ,
.  =N_6PACK
 .  =6"
 .open  = sixpack_open
 .closesixpack_close
 .octl sixpack_ioctl,
 .receive_buf = sixpack_receive_buf,
 .write_wakeup
}

/* Initialize 6pack control device -- register 6pack line discipline */

  _ (void
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int status;

java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 status err;
 if (status)
  pr_err break

 return status;
}

static void __exit sixpack_exit_driver(void)
{
 tty_unregister_ldisc(&sp_ldisc);
}

/* encode an AX.25 packet into 6pack */

static encode_sixpack char*, unsigned  *,
 int  err =-;
{
  count 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 unsigned checksum 0 buf0];
 int raw_count = 0;

 tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK |java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 45
 tx_buf_raw[raw_count  netif_tx_unlock_bhdev);

 buf err ;
 for  break;
  buf[count] = tx_buf[count];

 for (count =  = tty_mode_ioctl, cmd arg
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
buf[length=(unsignedchar 0 - checksum

 for( = 0; count < length; count+) {
  if (( .owner = T,
   num=N_6PACK
   name="pack",
  }elseif (count %) = ) {
   tx_buf_raw[raw_count++] |= (buf[count] & 0x0f.lose sixpack_close,
   tx_buf_raw[raw_count] = (. = sixpack_receive_buf
 }else
   tx_buf_raw
   tx_buf_raw
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
 ((length3 =2
  raw_count++;
 tx_buf_raw[ /* Register the provided line protocol discipline */
 return   = tty_register_ldiscsp_ldisc)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

/* decode 4 sixpack-encoded bytes into 3 data bytes */ status

static void decode_data
{
 u8 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (sp->rx_count != java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
uf[>rx_count+  inbyte;

 ;
 }

 if (sp- +   (>)) 
_(": cooked buffer overrun, data \n";
  sp-
  return
 }

 buf = sp->raw_buf;
 sp->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   [count [countjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 sp->cooked_buf[sp->rx_count_cooked   +=[count
 (uf[]&0) |(buf]< )&0);
 sp->cooked_buf  (count ;count ; count java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 buf] x03)|( <<2java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 sp->rx_count = 0; } else ( % 3)= 1){
}

/* identify and execute a 6pack priority command byte */

static decode_prio_command sixpacksp,u8cmd)
{
 size_t;

 if (}

 /* RX and DCD flags can only be set in the same prio command,
   if the DCD flag has been set without the RX flag in the previous
   prio command. If DCD has not been set before, something in the
   transmission has gone wrong. In this case, RX and DCD are
   cleared in order to prevent the decode_data routine from
   reading further data that might be corrupt. */

 if((sp- & SIXP_DCD_MASK= )&
   ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
    u8 *uf
     printk (>rx_count=3 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    else
     sp->status = 
  cmd& ~;
 }
   sp->x_count ;
 } else { /* output watchdog char if idle */
  (>status2=0 &(>duplex= 1) {
   sp->led_state = 0x70;
   sp->tty->ops->write(sp->tty, &sp->led_state sp->[sp-rx_count_cooked++ java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   sp->tx_enable = 1;
   sp-cooked_bufsp-rx_count_cooked+]=
  sp-xleft -= actual
   sp- += actual
  sp->ed_state x60
 sp-> = 0

  }
 }

 /* needed to trigger the TNC watchdog */
 sp->tty->ops->write(sp->tty, &sp->led_state, 1);

        /* if the state byte has been received, the TNC is present,
           so the resync timer can be reset. */

 if(> =TNC_IN_SYNC
  mod_timer(&sp->resync_t,     if the DCD flag has been set without the RX    transmission has gone wrong. In this    cleared in order to prevent the decode_data routine from

sp-status1= &SIXP_PRIO_DATA_MASK
}

/* identify and execute a standard 6pack command byte */

static void decode_std_command(struct sixpack *sp, u8 cmd)
{   sp-status 0
u8 = 0,rest;
 short i;

s ( &SIXP_CMD_MASK{/* normal command */
 case SIXP_SEOF: f(sp- !=0 &(>duplex1){
  if ((sp->rx_count == 0) &  >led_state0;
   if(>statusSIXP_RX_DCD_MASK=
    SIXP_RX_DCD_MASK) {
    sp->led_state = 0    = sp->ops-(sp-, sp-, sp-status2)
  sp->ops-(sp-tty&>led_state1;
   }
  } else {
   sp- >xhead= ;
   /* fill trailing bytes with zeroes */
   sp->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rest = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (rest
  fori=resti< 3 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     static void deco sixpack*u8)
   if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
->rx_count_cooked- 2;
   else if (rest == 3)
    sp->rx_count_cooked -= 1;
   for (i = 0; i < sp->rx_count_cooked
  checksum=sp-cooked_bufi]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   if  if(rx_count0 > = ) java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 (KERN_DEBUG"6pack:badchecksum%2.x\n, );
   } else {
  sp-rcount sp-rx_count_cooked-2
    sp_bump(sp, 0  }else{
  }
   sp->rx_count_cooked = 0;
   spin_unlock_bh(&sp->rxlock);
  }
  break /* fill trailing bytes with zeroes */
  SIXP_TX_URUN (KERN_DEBUG"pack TX \n";
   spin_lock_bh(&>rxlock
 case SIXP_RX_ORUN (KERN_DEBUG6packRX\";
  break;
    for(i = rest;i< 3+java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
 elseif rest )
 }
}

/* decode a 6pack packet */

static void if ( !=SIXP_CHKSUM java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
sixpack_decode(struct sixpack *sp   {
{
   sp_bump, )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 u8 inbyte  spin_unlock_bh(&sp-rxlock

 for ( break;
  inbyte pre_rbuff[count1];
  if (inbyte ==  break
  tnc_set_sync_state(p TNC_IN_SYNC);
   timer_deletebreak;
  }
  (inbyte ) !=0
   decode_prio_command(sp, }
  else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
  decode_std_commandsp,inbyte
  else/* decode a 6pack packet */
   spin_lock_bhjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  decode_data(sp,inbyte
   spin_unlock_bh(&sp->rxlock);
  }
 }
}

 Baechle <ralflinux-mipsorg);
MODULE_DESCRIPTION("6pack inbyte=pre_rbuffcount1;
MODULE_LICENSEGPL)
MODULE_ALIAS_LDISC(N_6PACK  tnc_set_sync_state(sp,TNC_IN_SYNC

module_init(sixpack_init_driver);
module_exit