Quellcode-Bibliothek 6pack.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
*
 * 6pack.c # </uaccess.h>
 *   like. t  a  TTY the
 *  kernel'include
*
*Authors  ö ajk..de
 linux>
*
* alot stuff"by .,writtenby
 *
 *  Laurence Culhane, <loz@holmes.demon.co.uk>
 *  Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 */

#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/bitops.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/timer.h>
#include <linux linux.h>
#include <net/ax25.h>
#include <linux/etherdevice.h>
#include <#</timer
#includelinux.h
#include <linux/spinlock.h>
#include# <linuxetherdevicejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#include <linux/init#   0 /* transmit overrun */
#include <# SIXP_RX_BUF_OVLx58
#include <linux/tcp.h>
#include <linux/semaphore.h>
#include <linux/refcount

/* sixpack priority commands */defineSIXP_CHKSUM xFF
#define SIXP_SEOF
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define  08

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

/* masks to get certain bits out of the status bytes sent by the TNC */ 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

definexC0
#defineSIXP_CHN_MASK
#define SIXP_PRIO_CMD_MASK 0x80define  5/* 250 ms */
define x40
#define SIXP_PRIO_DATA_MASK 0x38 0
#definedefine3/2)/* in 1 s */
define x10
#define SIXP_RX_DCD_MASK java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 SIXP_LEDS_ONx78
#define SIXP_LEDS_OFF sixpack_flagsjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
define x08
#define SIXP_STA  0x10

#define SIXP_FOUND_TNC  0xe9
#define SIXP_CON_ON  struct t; java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
#define SIXP_DCD_MASK  0x08
#define 

/* default level 2 parameters */
#define SIXP_TXDELAY   25 /* 250 ms */

#define   0/* 100 ms */
#define SIXP_INIT_RESYNC_TIMEOUT (3*HZ/  charxbuff
u char*;         

/* 6pack configuration. */
define 1/
#define SIXP_MTU26/* Default MTU */

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

 sixpack
 u8 [40;
 struct tty_struct *tty;  /* ptr to TTY structure */
 struct int;

 
     ;  /* Flag values/ mode etc */
   *;  /* transmitter buffer */
 unsigned char  *xhead;         
 int nsigned persistence

 u8   raw_buf[4];
 u8   cooked_buf;

 unsigned int  rx_count;
ooked
 spinlock_t  rxlock;

 unsigned long  flags;  /* Flag values/ mode etc */
 unsigned mode java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 /* 6pack stuff */char;
 unsigned char  tx_delay timer_list;
 unsignedchar ;
 unsigned char  slottime;
 unsigned}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 unsignedcharled_state
 u8   status;
 u8 int(  *   *int )
 unsigned char  status2;
nsignedchar tx_enablejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 unsigned char  tnc_state;

 struct timer_list  * Note that in case of DAMA operation, the data java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 3
 structtimer_listresync_t
 spinlock_t  lock;
};

static  random

static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 encode_sixpack har   * int  )

/*
 * 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)
{
 > =;
 int = >tty->write>, sp-, sp-);
 static  >xhead ;

 randomled_state ;

 (sp- &SIXP_DCD_MASK = 0& random>persistence{
  sp->led_state = 0x70;
 >tty->(sp-,&sp-,1
  sp- else
  actual(sp-,  +(when)*) /0)
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  sp->xhead +java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 >led_statex60
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  sp- actualcount
 }  len +3 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
timer&>, jiffies( +)*)  0)
}

/* ----> 6pack timer interrupt handler and friends. <---- */[ >)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

/* Encapsulate one AX.25 frame and stuff into a TTY queue. */
static  msg="control too long"
{
 unsigned
 int f(p0 =0)&(en ) 

if > +3)
  msg;
  ;
 }

 if  = (,>xbuff,>);
   flags
   out_drop
 c 1 > =[]

 if ((p[0] != 0) && (len >c 2 >persistence=p[]
  =" control too";
  goto out_drop;
  ;

 if  :/* ignored */
  =" .5packet to transmit";
  goto out_drop;
 }

  00java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 set_bit  * state of the DCD or of any timers, as  * correct time to send is the job of the AX.25  * immediately after data has arrivedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 switch>  1
 case:sp- = []
   sp->xle  -;
 case = > +actual
 ;
 case  >tty->ops->write(sp->ty,&>, )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
r;
 case 4: /* ignored */
  return;
 case 5: sp->duplex = p[1];
  ;
 }

 if (}
  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- (KERN_DEBUG%:% .">>name )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  sp->tty->ops->
 s>tx_enable ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  sp->xleft = count - actual;
  sp- (>protocol=(ETH_P_IP
 returnax25_ip_xmit);
  sp-
}else {
  /* We were not busy, so we are now... :-) */
  >xheadxbuff
  >stats+ >len
  (sp>data>)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return;

out_drop
 >>stats++
 netif_start_queue
 f(et_ratelimit)
  printk(KERN_DEBUG "%s: %s - dropped.\n", sp-
}

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

static netdev_tx_t sp_xmit(struct sk_buff *skb, struct net_device *dev
{
 (&>lock

if>protocol(ETH_P_IP
  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 spin_lock_bhsp-);
 /* We were not busy, so we are now... :-) */
 netif_stop_queue(dev);
 dev->stats.tx_bytes += skb->len;
 sp_encaps(sp, skb->data, skb- spin_unlock_bh&sp-);
 spin_unlock_bh

 dev_kfree_skb

 return;
}

intsp_open_dev net_devicedevjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
s sixpacksp = (dev

 if (sp->tty == NULL)
  ENODEV
 return 0;
}

/* Close the low-level part of the 6pack channel. */
static int sp_close(struct net_device *
{
 struct  .do_openjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  > =&java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 if>  ax25_header_ops
> =;
 (,sp->flags
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock_bh (dev-,&,AX25_ADDR_LENjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

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

static
{
 struct sockaddr_ax25 *sa = addr;

 netif_tx_lock_bh(dev);
 netif_addr_lock(dev);
 __dev_addr_set(dev, &sa->sax25_call, AX25_ADDR_LEN * This is the routine that * 'cmd' is the *
 netif_addr_unlock(dev);
 netif_tx_unlock_bh

 u8ptr
}

static
 .   ,
 .ndo_stopjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .ndo_start_xmit  = sp_xmit out_mem
 .ndo_set_mac_address=skb_putskb +1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
};

static void sp_setup(struct net_device *dev)
{
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 dev->>stats+java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 >   ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dev->header_ops java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 dev-> * more packets to send
 dev-type=;
 dev-

 /* Only activated in AX.25 mode */ !)
 (dev-broadcast ax25_bcastAX25_ADDR_LEN
 dev_addr_set   serial  almost&wecanstart

 dev->flags  = 0;
}

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

/* (sp-dev;
 * 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  * and sent on tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct   *,  count
 int stru sixpack;
 u8ptr

count>rcount ;

->stats += count

sp >disc_data
  oto;

 ptr
  /* Read the characters out of the buffer */ =;

 (, >cooked_buf1 );
 skb-> if!(SIXPF_ERROR>))
 netif_rx(skb);
 sp->statsrx_packets+

 }

out_mem:
 sp->dev->stats.rx_dropped++;
}


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

/*
 * Called by the TTY driver when there's room for more data.  If we have
 * more packets to send, we send them here.
 */
static void sixpack_write_wakeup  1
{
sixpack =>disc_data
 int  _(struct *,int)

 if  har;
  return
if sp-xleft=0  
default
   * transmission java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 >>.tx_packets
  clear_bit:
 sp-=java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 (>)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  return
 }

 
   =tty->(tty>, sp-);
  sp->{
  sp-int =>;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}  resync_tnc 



/*
 * 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.
 */
/
    const u8 *fp, 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct *p
 size_t count1>status1 1

 if
  return > =x60

>>>(sp-, &,1;
 if (!sp
  return;

 /* Read the characters out of the buffer */
 count1 = java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 1
 while (count;
  count--
  ( & f+)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  ((, &sp-))
    sp->dev->stats.rx_errors++;
   continue;
  }
 }
 sixpack_decode(sp, cp, count1);

 tty_unthrottle();
}

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

#define * This function is called by the TTYr.  Because we are
#define * a free 6pcack
# TNC_UNSYNCED2
#define TNC_IN_SYNCchar =NULL

tatic_( sixpack,  )
{
 char *msgunsignedlonglen;

  !(CAP_NET_ADMIN
default/
 case TNC_UNSYNC_STARTUP:
 msg" TNC;
  break;
c TNC_UNSYNCED
  msg = alloc_netdev(sizeof(struct sixpack), "sp%d", NET_NAME_UNKNOWN,
  break
 case (!) {
  msg = "Found TNC";
  break;
 }

 sp->tnc_state = new_tnc_state =-;
  goto ;
}

 sp= netdev_privdev
{
int =sp-tnc_state

 if ((&sp-lockjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  __tnc_set_sync_state(sp, new_tnc_state);
}

static void,)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
  > =;
 static> =xbuff

cleardata  have  *

> =0
sp- = ;

 /* reset state machine */

 sp->status = 1;
 sp->status1 >flags ; /* Clear ESCAPE & ERROR flags */
 sp->status2> =0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

s>    ;

> = 0;
>>>writetty>, )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 sp->sp->tx_enable   = 0;


 /* Start resync timer again -- the TNC might be still absent */
 (&>,sp_xmit_on_air)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static inline (struct sixpacksp
{
 unsigned chart>disc_data ;

 tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);

 >tty->(sp-,&, )

 (sp-,  +SIXP_RESYNC_TIMEOUT

 return out_free
}

/*
 * 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...
 */
static int sixpack_open(struct tty_struct *tty)
{
 char *:
 struct err
 }
 unsigned long len;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!capable(CAP_NET_ADMIN))
  return -EPERM;
 if (tty- * (which usually isjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  {

 dev = alloc_netdev(sizeof(struct sixpack
      sp_setup!pjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 if (!dev
  err  -;
  goto out;
 }

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

 spin_lock_init
 (sp-);

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

 len (&sp-resync_t

 xbuff 
if (xbuff == NULL) {
err = -ENOBUFS;
goto out_free;
}

spin_lock_bh(&sp->lock);

sp->tty = tty;

sp->xbuff = xbuff;

sp->rcount = 0;
sp->rx_count = 0;
sp->rx_count_cooked = 0;
sp->xleft = 0;

sp->flags = 0; /* Clear ESCAPE & ERROR flags */

 sp->duplex =/* Perform I/O control on an active 6pack channel. */
sp-tx_delay=SIXP_TXDELAY;
 sp->persistence = SIXP_PERSIST;
 sp->slottime    = SIXP_SLOTTIME;
 sp-led_state 0x60
 sp-
 sp-  *sp tty-disc_data
 sp- net_device *ev
 sp-tx_enable ;

 netif_start_queue);

 timer_setupsp-, sp_xmit_on_air0;

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

 spin_unlock_bh(&sp->lock);

 /* Done.  We have linked the TTY line to a channel. */ = sp-dev
 tty->disc_data SIOCGIFNAME
 tty->receive_room = 6 err=copy_to_uservoiduser*arg dev-,

 /* Now we're ready to register. */
 err = register_netdev(dev);
 if (err)
   out_free

 tnc_init:

 return 0;

out_free;
 kfree

 free_netdev f ((tmpintuserarg){

out:
 return err;
}


/*
 * 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)
{
 > =AX25_KISS_HEADER_LEN

tty-disc_data;
 if (!)
  return

 >disc_data ;

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

 unregister_netdev(sp->dev);

 timer_delete_sync(&sp-    (void_user*arg)) {
ete_sync&sp-resync_t

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

 free_netdev(  }
}

/* Perform I/O control on an active 6pack channel. */
static sixpack_ioctlstruct *,unsigned ,
  longarg
{
  sixpack =tty-;
struct *;
 unsigned java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 if(sp
  return}
 dev = sp->dev;

 switch(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case SIOCGIFNAME:
  errowner THIS_MODULE
   num N_6PACK,
  break; .name="pack,

 case SIOCGIFENCAP  = ,
  .  =sixpack_ioctljava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  break;

 case SIOCSIFENCAP}
  if (get_user(tmp, (int __user *) arg)) {
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 17
   break;
  }

  sp-staticint_initsixpack_init_driver)
  dev-{
  dev->hard_header_len = AX25_KISS_HEADER_LEN +
                         AX25_MAX_HEADER_LEN + 3;
  dev-> /* Register the provided line protocol discipline */

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

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   char addr[AX25_ADDR_LEN];

   if (copy_from_user(&addr,
   int(unsigned tx_bufchartx_buf_raw
   =EFAULT
    breakint =;
   }

   char = ,[40java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   __dev_addr_set(dev, &addr, AX25_ADDR_LEN);
 (dev
    =0
  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  }
 default:
err(tty, );
 }

 return err;
 uf]   )xff;

static struct countcount=length+) 
HIS_MODULE
.  =,
.  =6pack,
 .} (count 3 =1 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 c  =sixpack_close
 .ioctl  = sixpack_ioctl,
receive_buf,
 .write_wakeup = sixpack_write_wakeup   {
};

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

static int __init sixpack_init_driver(void)
{
  iflength % ) ! )

java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
status(&sp_ldisc;
 if (status)
  pr_err("6pack: can't register line discipline (err = %d)\n", status

 returnstatus;
}

static void __exit
{
 tty_unregister_ldisc(&sp_ldisc);
}

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

static int ufsp-+]=inbyte
 int length, return
{
 int count
  if (sp->rx_count_cooked>rx_count_cooked2 >=sizeof(p-cooked_buf {
 int_err6packcookedoverrun loss);

 tx_buf_raw[raw_count;
 tx_buf_raw[java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2

 buf[0] = tx_delay;
 for (count = 1; count < length; count++)
  buf] =tx_buf];

 for (count = 0; count < length; count++)
  checksum=buf];
 buf (uf1  x0f ([2 <2  xf0

for =0  <=length++){
  if ((count % 3) == 0) {
   tx_buf_raw[raw_count  (buf[2 & 0x03 |(nbyte<);
   tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
 }  if(count =1 {
   tx_buf_raw[raw_count++] |= (buf
   tx_buf_raw[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else
   tx_buf_raw[raw_count++] |= (buf void(struct *sp  cmd
   tx_buf_raw[raw_count++] = (buf[count] >s actual
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if ((length % 3) != 2)
  raw_count++;
 tx_buf_raw[raw_count++] = SIXP_SEOF;
 return raw_count;
}

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

static 
 (>status) =0 &java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
u8*;

 ifsp- !=){
  sp->raw_buf[sp->rx_count++] = inbyte;

  return;
 }

    &SIXP_RX_DCD_MASK
 }
 sp-> = 0
  return;


 buf = sp- if(sp- ! )& sp- == ) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 sp-cooked_buf>rx_count_cooked+ =
  buf[0] | ((buf[1] << 2) & 0xc0);
>[>+ 
  ( >xleft;
 sp->xhead;
  (buf sp-> =0;
 sp->rx_count  sp-status20
}

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

static void decode_prio_command(struct sixpack *sp, u8 cmd)
{
 ssize_t

 if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {     /* idle ? */

 /* RX and DCD flags can only be set in the same prio command, sp-tnc_state= )
   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->status & SIXP_DCD_MASK) == 0) &&
 sp-> =cmd ;
    if (sp->status
   java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    else
    > =0
   checksum, = 0
  }
  sp->
 } witchcmd ) {    /* normal command */
 i (>status2 )& sp- == ) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 sp- = x70
   sp->tty->ops->write(sp->tty    (sp- & ) =
   sp->tx_enable = 1;
  actual>tty->write>tty>xbuff>status2)
   sp->xleft -=   >tty->write>, sp-, )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  sp- +=actual
    /
   sp->status2 = 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 (sp->tnc_state == TNC_IN_SYNC)
  mod_timer(&sp->resync_t, jiffies + SIXP_INIT_RESYNC_TIMEOUT);

 sp->    (i  ; i < 3 i++)
}

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

de_std_command(structsixpack *p, u8 cmd
{
 u8 checksum = 0, rest = 0;
 short -java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 switch (cmd    + >[i;
 case SIXP_SEOF:
  (sp->rx_count == 0 &&(sp-rx_count_cooked=0){
   if ((sp->status & SIXP_RX_DCD_MASK) ==
    SIXP_RX_DCD_MASK) {
    sp->led_state = 0   printkKERN_DEBUG "6pack ."checksum
    > =>;
   }
   {
   sp->led_state java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  /* fill trailing bytes with zeroes */
   sp->tty-case:printk 6:underrun)
 spin_lock_bh(sp-);
   restcase :printk ": overrunn)
   ifbreak
    ( = rest  =3 i+)
     decode_data(sp, 0);
   if (rest == 2)
    sp->rx_count_cooked -= 2;
   if ( ==3java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    sp->rx_count_cooked -= 1;
 /
    checksum += sp->cooked_buf
  ifchecksum=SIXP_CHKSUM){
    printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
  }else{
    sp->rcount
  (sp0;
   }
   sp->rx_count_cooked = 0;
 spin_unlock_bh>);
  }
 break
 case   = pre_rbuffcount1];
  ;
 case SIXP_RX_ORUN: printk(KERN_DEBUG tnc_set_sync_state(,TNC_IN_SYNC;
  ;
 case SIXP_RX_BUF_OVL
   if( &SIXP_PRIO_CMD_MASK )
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
} (sp );

/* decode a 6pack packet */

static void
sixpack_decode(struct sixpack *sp, const   decode_data(sp );
{
 size_t count1;
 u8 inbyte

 for (count1 = 0alf DO1GRB@.>"
    []
  if (inbyte("GPL";
 tnc_set_sync_statesp );
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
   decode_prio_command(sp, inbyte);
  else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
   decode_std_command(sp, inbyte);
  else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK) {
   spin_lock_bh(&sp->rxlock);
   decode_data(sp, inbyte);
   spin_unlock_bh(&sp->rxlock);
  }
 }
}

MODULE_AUTHOR("Ralf Baechle DO1GRB ");
MODULE_DESCRIPTION("6pack driver for AX.25");
MODULE_LICENSE("GPL");
MODULE_ALIAS_LDISC(N_6PACK);

module_init(sixpack_init_driver);
module_exit(sixpack_exit_driver);