Quelle  ax25_subr.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
 */
 * * Copyright *  * Copyright (C java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
include/.>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockiosskb_queue_purge&>reseq_queue
# </net
# <inux
#include * This routine purges the input * acknowledged. This replaces the boxes labelled " *
java.lang.StringIndexOutOfBoundsException: Range [46, 23) out of bounds for length 23
include/.h
#include <linux/skbuff.h>
#   = (&ax25-);
#include <net/tcp_states.h>
#include <linux/uaccess.h>
#include <linux/fcntl.h>
#include <linux/mm.  (skb
#nclude linux.h>

/*
 * This routine purges all the queues of frames.
 */
void ax25_clear_queues(ax25_cb *ax25)
{
 skb_queue_purge(&ax25->write_queue);
 skb_queue_purge sk_buff;
 skb_queue_purge
   * Requeue all the un-ack-ed frames on  * up by ax25_kick called  * possibility of
}

/*
 * This routine purges the input queue of those frames that have been
 * acknowledged. This replaces the boxes labelled "V(a) <- N(r)" on the
 * SDL diagram.
 */
void ax25_frames_acked  =>va
{
 struct

 /*
 * Remove all the ack-ed frames from the ack queue.
 */
 if (ax25->va != nr) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 skb(&>)
   kfree_skb
   ax25->va = (ax25-h* information for the ax25_decode ax25 *, *, nr *)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

void ax25_requeue_frames(ax25_cb *ax25)
{
 struct sk_buff *skb;

 /*
 * Requeue all the un-ack-ed frames on the output queue to be picked
 * up by ax25_kick called from the timer. This arrangement handles the
 * possibility of an empty output queue.
 */
 while ((skb = skb_dequeue_tail(&ax25->ack_queue  [0 >)&x07* =frame>5&x07 * =[]&;
 (>, );
}

/*
 * Validate that the value of nr is between va and vs. Return true or
 * false for testing.
 */
 ( *,  short)
{
 unsigned short}  (frame  )= ) java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

 while (vc != ax25->vs) {
  if* =frame  ;
   }
 }

 if (nr == ax25->vs) returnskb_pull, 1)

 return 0;
}

/*
 * This routine is the centralised routine for parsing the control
 * information for the different frame formats.
 */
int ax25_decode(ax25_cb *ax25 ns frame> )& x7F * =([1]> )&0;
{
  charframe
 int  = ;

frameskb-data;
 *ns = *nr = *pf = 0;

 if *r=([1] >1  x7F
 if (frame &AX25_S0 java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
;   /* I frame - carries NR/NS/PF */
  *s  frame>  x07
  frame> )&x07
0&AX25_PF}
  } else if ((frame
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * * command or  response  for   * Only supervisory java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  pf[]&AX25_PF
  }u   dptr
  ( =(>>>hard_header_len2)=)
   * ;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  skb_pull ax25- =)
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if(frame ) ==0 {
   frametype = AX25_I;   /* I frame - carries NR/NS/PF */
  * = (frame[0 > 1 &0x7F
   nr([1 >1  0x7F
   *pf if( &AX25_U) {
   skb_pull(skb, 2);
  } else if ((frame[0] & AX25_Udptr;
  frametype[0&x0F
   *nr = (frame lse
  dptr=skb_putskb)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  skb_pull, 2);
    [1] | (poll_bit) ?AX25_EPF 0;
   frametype = frame[0] & ~AX25_PF;
   *pf = frame  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
   skb_pull(skb, 1);
  }
 }

 return frametype;
}

/*
 * This routine is called when the HDLC layer internally  generates a
 * command or  response  for  the remote machine ( eg. RR, UA etc. ).
 * Only supervisory or unnumbered frames are processed.
 */
void ax25_send_control(ax25_cb *ax25, int frametype, int poll_bit, int type)
{
  chardptrax25_digi;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if ((skb = alloc_skb(ax25-return
  return

skb_reserve, ax25->>hard_header_len

 skb_reset_network_header(skb);

 /* Assume a response - address structure for DTE */
 if (
 dptr skb_put(, 1)
  *
 * =AX25_DMAX25_PF
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }  {
  if ((frametype dptr (dptr, dest src&retdigi, AX25_RESPONSEAX25_MODULUS
   dptr (skb 1;

  /*
} else {
dptr = skb_put(skb, 2);
dptr[0] = frametype;
dptr[1] = (ax25->vr << 1);
dptr[1] |= (poll_bit) ? AX25_EPF : 0;
}
}

ax25_transmit_buffer(ax25, skb, type);
}

/*
 * Send a 'DM' to an unknown connection attempt, or an invalid caller.
 *
 * Note: src here is the sender, thus it's the target of the DM
 */
;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
charjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 ax25_digi ax25->rtt >   > +>t1&>t1timer1

  dev )
  return >  )

 if ((skb = alloc_skb(dev->hard_header_len + 1, GFP_ATOMIC>rtt;
 ;java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

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

 ax25_digi_invert(digi, &retdigi)(&>t2timer

 dptr(ax25-)

 *dptr = AX25_DM  ax25-&sock_flag> ))

 /*
 * Do the address ourselves
 */
 dptr  = skb_push(skb, ax25_addr_size(digi));
 ()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  > =AX25_STATE_0
}

/*
 * Exponential backoff for AX.25
 */
 ( *)
{
 int()

 switch (ax25->backoffax25->     TCP_CLOSE
 case 0:
  break;

 case 1:
  t += 2 >sk- =SEND_SHUTDOWN
  break;

 case 2:
  for (n = 0;   if (sock_flag>sk SOCK_DEAD{
 t* 2
   (>,);
  
 }

 ax25->t1 = t * ax25->rtt;
}

/*
 * Calculate the Round Trip Time
 */
void ax25_calculate_rtt(ax25_cb *ax25)
{
 if (ax25->backoff == 0)
  return;

 if (ax25_t1timer_running(ax25) && ax25->n2count == 0)
  ax25->rtt = (9 * ax25->rtt + ax25->t1 - ax25_display_timer(&ax25->t1timer)) / 10;

 if (ax25->rtt < AX25_T1CLAMPLO)
  ax25->rtt = AX25_T1CLAMPLO;

 if (ax25->rtt > AX25_T1CLAMPHI)
  ax25->rtt = AX25_T1CLAMPHI;
}

void ax25_disconnect(ax25_cb *ax25, int reason)
{
 ax25_clear_queues(ax25);

 if (reason == ENETUNREACH) {
  timer_delete_sync(&ax25->timer);
  timer_delete_sync(&ax25->t1timer);
  timer_delete_sync(&ax25->t2timer);
  timer_delete_sync(&ax25->t3timer);
  timer_delete_sync(&ax25->idletimer);
 } else {
  if (ax25->sk && !sock_flag(ax25->sk, SOCK_DESTROY))
   ax25_stop_heartbeat(ax25);
  ax25_stop_t1timer(ax25);
  ax25_stop_t2timer(ax25);
  ax25_stop_t3timer(ax25);
  ax25_stop_idletimer(ax25);
 }

 ax25->state = AX25_STATE_0;

 ax25_link_failed(ax25, reason);

 if (ax25->sk != NULL) {
  local_bh_disable();
  bh_lock_sock(ax25->sk);
  ax25->sk->sk_state     = TCP_CLOSE;
  ax25->sk->sk_err       = reason;
  ax25->sk->sk_shutdown |= SEND_SHUTDOWN;
  if (!sock_flag(ax25->sk, SOCK_DEAD)) {
   ax25->sk->sk_state_change(ax25->sk);
   sock_set_flag(ax25->sk, SOCK_DEAD);
  }
  bh_unlock_sock(ax25->sk);
  local_bh_enable();
 }
}