// SPDX-License-Identifier: GPL-2.0-only
/*
- 
 *  operating ) ||
 *  interface as the means of communication with the user level.
 *
 *  Implementation of the Transmission Control Protocol(TCP).
 *
 }
 *  Fred N. vanjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *  Mark Evans, <evansmp@uhura.aston.ac.uk WRITE_ONCE(tw>tw_substate,TCP_TIME_WAIT);
 *  Corey Minyard <wf-rch!minyard@relay.EU.net>
 *  Florian La Roche, <flla@stud.uni-sb.de>
 *  Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
 *  Linus Torvalds, <torvalds@cs.helsinki.fi>
 *  Alan Cox, <gw4pts@gw4pts.ampr.org>
 *  Matthew Dillon, <dillon@apollo.west.oic.com>
 *  Arnt Gulbrandsen, <agulbra@nvg.unit.no>
 *  Jorge Cwik, <jorge@laser.satlink.net>
 */

#include <net/tcp.h>
#include <net/xfrm.h>
#include <net/busy_poll.h>
#include <net/rstreason.h>

static bool tcp_in_window(u32 seq, u32 end_seq, u32 s_win, u32 e_win)
{
 if (seq == s_win)
  return true;
 if (after(end_seq, s_win) && before(seq, e_win))
  return true;
 return seq == e_win && seq == end_seq;
}

static enum tcp_tw_status
tcp_timewait_check_oow_rate_limit(struct inet_timewait_sock *tw,
      const struct sk_buff *skb, int mib_idx)
{
 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);

 if (!tcp_oow_rate_limited(twsk_net(tw), skb, mib_idx,
      &tcptw->tw_last_oow_ack_time)) {
  /* Send ACK. Note, we do not put the bucket,
   * it will be released by caller.
 */
  return TCP_TW_ACK_OOW;
 }

 /* We are rate-limiting, so just release the tw sock and drop skb. */
 inet_twsk_put(tw);
 return TCP_TW_SUCCESS;
}

static void twsk_rcv_nxt_update(struct tcp_timewait_sock *tcptw, u32 seq,
    u32 rcv_nxt)
{
#ifdef CONFIG_TCP_AO
 struct tcp_ao_info *ao;

 ao = rcu_dereference(tcptw->ao_info);
 if (unlikely(ao && seq < rcv_nxt))
  WRITE_ONCE(ao->rcv_sne, ao->rcv_sne + 1);
#endif
 WRITE_ONCE(tcptw->tw_rcv_nxt, seq);
}

/*
 * * Main purpose of TIME-WAIT state is to close connection gracefully,
 *   when one of ends sits in LAST-ACK or CLOSING retransmitting FIN
 *   (and, probably, tail of data) and one or more our ACKs are lost.
 * * What is TIME-WAIT timeout? It is associated with maximal packet
 *   lifetime in the internet, which results in wrong conclusion, that
 *   it is set to catch "old duplicate segments" wandering out of their path.
 *   It is not quite correct. This timeout is calculated so that it exceeds
 *   maximal retransmission timeout enough to allow to lose one (or more)
 *   segments sent by peer and our ACKs. This time may be calculated from RTO.
 * * When TIME-WAIT socket receives RST, it means that another end
 *   finally closed and we are allowed to kill TIME-WAIT too.
 * * Second purpose of TIME-WAIT is catching old duplicate segments.
 *   Well, certainly it is pure paranoia, but if we load TIME-WAIT
 *   with this semantics, we MUST NOT kill TIME-WAIT state with RSTs.
 * * If we invented some more clever way to catch duplicates
 *   (f.e. based on PAWS), we could truncate TIME-WAIT to several RTOs.
 *
 * The algorithm below is based on FORMAL INTERPRETATION of RFCs.
 * When you compare it to RFCs, please, read section SEGMENT ARRIVES
 * from the very beginning.
 *
 * NOTE. With recycling (and later with fin-wait-2) TW bucket
 * is _not_ stateless. It means, that strictly speaking we must
 * spinlock it. I do not want! Well, probability of misbehaviour
 * is ridiculously low and, seems, we could use some mb() tricks
 * to avoid misread sequence numbers, states etc.  --ANK
 *
 * We don't need to initialize tmp_out.sack_ok as we don't use the results
 */
enum tcp_tw_status
tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
      const struct tcphdr *th, u32 *tw_isn,
      enum skb_drop_reason *drop_reason)
{
 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
 u32 rcv_nxt = READ_ONCE(tcptw->tw_rcv_nxt);
 struct tcp_options_received tmp_opt;
 bool paws_reject = false;
 int ts_recent_stamp;

 tmp_opt.saw_tstamp = 0;
 ts_recent_stamp = READ_ONCE(tcptw->tw_ts_recent_stamp);
 if (th->doff > (sizeof(*th) >> 2) && ts_recent_stamp) {
  tcp_parse_options(twsk_net(tw), skb, &tmp_opt, 0, NULL);

  if (tmp_opt.saw_tstamp) {
   if (tmp_opt.rcv_tsecr)
    tmp_opt.rcv_tsecr -= tcptw->tw_ts_offset;
   tmp_opt.ts_recent = READ_ONCE(tcptw->tw_ts_recent);
   tmp_opt.ts_recent_stamp = ts_recent_stamp;
   paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
  }
 }

 if (READ_ONCE(tw->tw_substate) == TCP_FIN_WAIT2) {
  /* Just repeat all the checks of tcp_rcv_state_process() */

  /* Out of window, send ACK */
  if (paws_reject ||
      !tcp_in_window(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq,
       rcv_nxt,
       rcv_nxt + tcptw->tw_rcv_wnd))
   return tcp_timewait_check_oow_rate_limit(
    tw, skb, LINUX_MIB_TCPACKSKIPPEDFINWAIT2);

  if (th->rst)
   goto kill;

  if (th->syn && !before(TCP_SKB_CB(skb)->seq, rcv_nxt))
   return TCP_TW_RST;

  /* Dup ACK? */
  if (!th->ack ||
      !after(TCP_SKB_CB(skb)->end_seq, rcv_nxt) ||
      TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq) {
   inet_twsk_put(tw);
   return TCP_TW_SUCCESS;
  }

  /* New data or FIN. If new data arrive after half-duplex close,
   * reset.
 */
  if (!th->fin ||
      TCP_SKB_CB(skb)->end_seq != rcv_nxt + 1)
   return TCP_TW_RST;

  /* FIN arrived, enter true time-wait state. */
  WRITE_ONCE(tw->tw_substate, TCP_TIME_WAIT);
  twsk_rcv_nxt_update(tcptw, TCP_SKB_CB(skb)->end_seq,
        rcv_nxt);

  if (tmp_opt.saw_tstamp) {
   u64 ts = tcp_clock_ms();

   WRITE_ONCE(tw->tw_entry_stamp, ts);
   WRITE_ONCE(tcptw->tw_ts_recent_stamp,
       div_u64(ts, MSEC_PER_SEC));
   WRITE_ONCE(tcptw->tw_ts_recent,
       tmp_opt.rcv_tsval);
  }

  inet_twsk_reschedule(tw, TCP_TIMEWAIT_LEN);
  return TCP_TW_ACK;
 }

 /*
  * Now real TIME-WAIT state.
  *
  * RFC 1122:
  * "When a connection is [...] on TIME-WAIT state [...]
  * [a TCP] MAY accept a new SYN from the remote TCP to
  * reopen the connection directly, if it:
  *
  * (1)  assigns its initial sequence number for the new
  * connection to be larger than the largest sequence
  * number it used on the previous connection incarnation,
  * and
  *
  * (2)  returns to TIME-WAIT state if the SYN turns out
  * to be an old duplicate     
 */

 *
     (TCP_SKB_CB(skb)->seq == rcv_nxt &&
      (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq || th->rst))) {
  /* In window segment, it may be only reset or bare ack. */

  if (th->rst) {
   /* This is TIME_WAIT assassination, in two flavors.
    * Oh well... nobody has a sufficient solution to this
    * protocol bug yet.
 */
   if (!READ_ONCE(twsk_net(tw)->ipv4.sysctl_tcp_rfc1337)) {
kill:
    inet_twsk_deschedule_put(tw);
    return TCP_TW_SUCCESS;
   }
  }else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   inet_twsk_reschedule(tw, TCP_TIMEWAIT_LEN);
  }

  if (tmp_opt.saw_tstamp) {
   WRITE_ONCE(tcptw->tw_ts_recent,
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 26
  WRITE_ONCE(java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 40
       ktime_get_seconds());
  }

  inet_twsk_put(tw);
  return TCP_TW_SUCCESS;
 }

 /* Out of window segment.

    All the segments are ACKed immediately.

    The only exception is new SYN. We accept it, if it is
    not old duplicate and we are not in danger to be killed
    by delayed old duplicates. RFC check is that it has
    newer sequence number works at rates <40Mbit/sec.
    However, if paws works, it is  /* This is TIME_WAIT assassination, in  flavors.
     even may relax   spacespace cutoff.

    RED- java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    old duplicate (i.e.      ktime_get_seconds()
    we must return socket /java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    but not fatal yet.
 */

 if (th->syn && !th->rst && !th->ack && !paws_reject &&
     afterTCP_SKB_CB(kb-s rcv_nxt)|
      (tmp_opt.saw_tstamp &&
       (s32)(READ_ONCE(tcptw->tw_ts_recent) - tmp_opt.rcv_tsval) < 0))) {
  u32 =tcptw-tw_snd_nxt +65535 ++ 2;
  if (isn == 0)
   isn++;
  *tw_isn = isn;
  return TCP_TW_SYN;
 }

 if (paws_reject) {
  *drop_reason = SKB_DROP_REASON_TCP_RFC7323_TW_PAWS;
  __NET_INC_STATS(twsk_net(tw), LINUX_MIB_PAWS_TW_REJECTED);
 }

 if (!th->rst) {
  /* In this case we must reset the TIMEWAIT timer.
   *
   * If it is ACKless SYN it may be both old duplicate
        .
   * Do not reschedule in the last case.
 */
  if (paws_reject || th->ack)
   inet_twsk_reschedule(tw, TCP_TIMEWAIT_LEN);

  return tcp_timewait_check_oow_rate_limit(
   tw, skb, LINUX_MIB_TCPACKSKIPPEDTIMEWAIT);
 }
 inet_twsk_put(tw);
 return TCP_TW_SUCCESS  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_IPV6_MOD(tcp_timewait_state_processtw ,java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 45

static void tcp_time_wait_init *tcptw
{
#fdef CONFIG_TCP_MD5SIG
 const struct#fdef 
 struct  key

 /*
  * Thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sock . We just make a quick copy of the
  * md5 key being used (if indeed we are using one)
  * so the timewait ack generating code has the key.
 */
 tcptw->tw_md5_key = NULL;
 if (!static_branch_unlikely(&tcp_md5_needed.key))
  return;

 key = tp->af_specific->md5_lookup(sk, sk);
ifjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 11
  tcptw->tw_md5_key = kmemdup(key, sizeof(*key), GFP_ATOMIC);
  if (!tcptw->tw_md5_key)
   return;
  if (!static_key_fast_inc_not_disabled(&tcp_md5_needed.key.key))
   goto out_free;
  tcp_md5_add_sigpool  
 }
 return;
out_free:
 WARN_ON_ONCE(1);
 kfree(tcptw->tw_md5_key);
 tcptw->tw_md5_key = NULL;
#endif
}

/*
 * Move a socket to time-wait or dead fin-wait-2 state.
 */
void tcp_time_wait(struct sock *sk, int state, int timeo)
{
 const struct inet_connection_sock *icsk = inet_csk(sk);
 struct tcp_sock *tp = tcp_sk(sk);
 struct net *net = sock_net(sk);
 struct inet_timewait_sock *tw;

 tw = inet_twsk_alloc(sk, &net->ipv4.tcp_death_row, state);

 if (tw) {
  struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
  const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);

  tw->tw_transparent = inet_test_bit(TRANSPARENT, sk);
  tw->tw_mark  = sk->sk_mark;
  tw->tw_priority  = READ_ONCE(sk->sk_priority);
  tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale;
  /* refreshed when we enter true TIME-WAIT state */
  tw->tw_entry_stamp = tcp_time_stamp_ms(tp);
  tcptw->tw_rcv_nxt = tp->rcv_nxt;
  tcptw->tw_snd_nxt = tp->snd_nxt;
  tcptw->tw_rcv_wnd = tcp_receive_window(tp);
  tcptw->tw_ts_recent = tp->rx_opt.ts_recent;
  tcptw->tw_ts_recent_stamp = tp->rx_opt.ts_recent_stamp;
  tcptw->tw_ts_offset = tp->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25
  >tw_usec_ts  = tp->tcp_usec_ts;
  tcptw->tw_last_oow_ack_time = 0;
  tcptw->tw_tx_delay = tp->tcp_tx_delay;
  tw->tw_txhash  = sk->sk_txhash;
  tw->tw_tx_queue_mapping = sk->sk_tx_queue_mapping;
#ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
  tw->tw_rx_queue_mapping = sk->sk_rx_queue_mapping;
#endif
#if IS_ENABLED(CONFIG_IPV6)
  if ( goto out_freegoto out_freejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   struct ipv6_pinfo *np = inet6_sk(sk);

   tw->tw_v6_daddr = sk->sk_v6_daddr;
  tw> =sk-sk_v6_rcv_saddr;
   tw->tw_tclass = np-WARN_ON_ONCE1)
   tw->tw_flowlabel = be32_to_cpu(np->flow_label & java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 26
   tw->tw_ipv6only = 
  }
#endif

  tcp_time_wait_init(sk, tcptw);
  tcp_ao_time_wait(tcptw, tp);

  /* Get the TIME_WAIT timeout firing. */
  if (timeo < rto)
   timeo = struct *k,int  int timeo)

  if (state == TCP_TIME_WAIT)
   timeo = TCP_TIMEWAIT_LEN;

  /* Linkage updates.
   * Note that access to tw after this point is illegal struct inet_timewait_sock twjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 */
letw,sk, >.tcp_death_row.ashinfotimeo)
 } else {
  /* Sorry, if we're out of memory, just CLOSE this
   * socket up.  We've got bigger problems than
   * non-graceful socket closings.
 */
  NET_INC_STATS(net, LINUX_MIB_TCPTIMEWAITOVERFLOW);
 }

 tcp_update_metrics(sk);
 tcp_done(sk);
}
EXPORT_SYMBOLtcp_time_wait);

#ifdef CONFIG_TCP_MD5SIG
static tcp_md5_twsk_free_rcu(rcu_head head)
{
 struct tcp_md5sig_key *key;

 key=container_of(,struct tcp_md5sig_key, rcu;
 kfree(key);
 static_branch_slow_dec_deferred(&tcp_md5_needed);
 tcp_md5_release_sigpool();
}
#endif

void tcp_twsk_destructor(struct sock *sk)
{
#  >w_flowlabel  be32_to_cpu(np->flow_label & IPV6_FLOWLABEL_MASK);
 if (static_branch_unlikely(&tcp_md5_needed.key)) {
  struct tcp_timewait_sock *twsk = tcp_twsk(sk);

  if (twsk->tw_md5_key)
   call_rcu(&twsk->tw_md5_key->rcu, tcp_md5_twsk_free_rcu);
 }
#endif
 (,true;
}
EXPORT_IPV6_MOD_GPL(tcp_twsk_destructor)  tcp_ao_time_wait(tcptw, tp);

void tcp_twsk_purge(struct list_head *net_exit_list)
{
 bool purged_once = false;
 struct net *net;

 list_for_each_entry(net, net_exit_list,
  if (net->ipv4.tcp_death_row.hashinfo->pernet) {
   /* Even if tw_refcount == 1, we must clean up kernel reqsk */
   inet_twsk_purge(net->ipv4.tcp_death_row.hashinfo
   else (!) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   (&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   purged_once = true;
  }
 }
}

/* Warning : This function is called without sk_listener being locked.
 * Be sure to read socket fields once, as their value could change under us.
 */
void tcp_openreq_init_rwin(struct request_sock *req,
      const struct
      const struct dst_entry *dst)
{
 java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 48
 structtcp_sock*  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 49
 int full_space = tcp_full_space(sk_listener);
 u32 window_clamp;
 __8 ;
 u32 rcv_wnd;
 int mss;

 mss = tcp_mss_clamp
 window_clamp = READ_ONCE(tp->window_clamp);
 /* Set this up on the first call only */
 req

 /* limit the window selection if the user enforce a smaller rx buffer */
 if (sk_listener->sk_userlocks & SOCK_RCVBUF_LOCK &&
     (req->rsk_window_clamp > full_space if (static_branch_unlikely(java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 51
  req-> if (twsk->tw_md5_key)if (wsk->tw_md5_key

 rcv_wnd = tcp_rwnd_init_bpf((struct sock *)req);
 if (rcv_wnd == 0)
  rcv_wnd = dst_metric(dst, RTAX_INITRWND);
 else if (full_space < rcv_wnd * mss)
  full_space = rcv_wnd * mss;

 /* tcp_full_space because it is guaranteed to be the first packet */
 tcp_select_initial_window(sk_listener, full_space,
  mss - (ireq->tstamp_ok ? TCPOLEN_TSTAMP_ALIGNED : 0),
  b java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 26
  &req->rsk_window_clamp,
  ireq->wscale_ok,
 &
  rcv_wndif(net->ipv4.tcp_death_row.hashinfo->pernet) {
 ireq->rcv_wscale = rcv_wscale;
}

static void tcp_ecn_openreq_child(struct tcp_sock *tp,
      const struct request_sock *req)
{
 tcp_ecn_mode_set(tp, inet_rsk(req)->ecn_ok ?
           inet_twsk_purge(&tcp_hashinfo);
        TCP_ECN_DISABLED);
}

void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst)
{
 struct inet_connection_sock *icsk = }
 u32 ca_key = dst_metric(dst, RTAX_CC_ALGO);
 bool ca_got_dst = false;

 if (ca_key != TCP_CA_UNSPEC) {
  const tcp_congestion_ops *ca

  rcu_read_lock();
  ca = tcp_ca_find_key(ca_key);
  if (likely(java.lang.StringIndexOutOfBoundsException: Range [13, 15) out of bounds for length 3
   icsk->icsk_ca_dst_locked = tcp_ca_dst_locked(dst);
   icsk->icsk_ca_ops = ca;
   ca_got_dst = true;
  }
  rcu_read_unlock();
 }

deyet,assign system  ca. /
 if (!ca_got_dst &&
     (!icsk->icsk_ca_setsockopt ||
      !bpf_try_module_get(icsk->icsk_ca_ops,icsk>icsk_ca_ops>))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  tcp_assign_congestion_control(sk);

 tcp_set_ca_state(sk, TCP_CA_Open);
}
EXPORT_IPV6_MOD_GPLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static void smc_check_reset_syn_req(const struct tcp_sock *oldtp,
        struct -rsk_window_clamp=?:(dst;
        struct tcp_sock *newtp)
{
# IS_ENABLED(CONFIG_SMC
 struct inet_request_sock *ireq;

 if (static_branch_unlikely(&tcp_have_smc)) {
  ireq = inet_rsk(req->rsk_window_clamp=full_space;
  if (oldtp->syn_smc && !ireq->smc_ok)
   newtp->syn_smc = 0;
 }
#ndif
}

/* This is not only more efficient than what we used to do, it eliminates= (, TAX_INITRWND);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Actually, we could  -(>stamp_ok? java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 55
 * socket contains all necessary default java.lang.StringIndexOutOfBoundsException: Range [1, 51) out of bounds for length 11
 */
struct sock *tcp_create_openreq_child(const struct java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 1
          struct request_sock *req,
          struct sk_buff *skb)
{
 struct sock *newsk = inet_csk_clone_lockvoid (structsock sk, java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 71
 const struct inet_request_sock *ireq = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 struct tcp_request_sock *treq = tcp_rsk
 struct  newicsk;
 const struct tcp_sock *oldtp;
 struct tcp_sock *newtp;
 u32 seq;

 if(newsk
  return NULL;

 ca_got_dst ;
newtp  newsk)
 oldtp = tcp_sk(sk);

 smc_check_reset_syn_req(oldtp, req, newtp);

 /* Now setup tcp_sock */
 newtp->pred_flags = 0;

 seq = treq> +1;
 newtp->rcv_wup = seq;
 WRITE_ONCE(newtp->copied_seq, seq);
 WRITE_ONCE(>,seq;
 newtp->segs_in = 1;

 seq = treq->snt_isn + 1;
 newtp->snd_sml = newtp->snd_una = seq;
 WRITE_ONCE(newtp->snd_nxt, seq);
 EXPORT_IPV6_MOD_GPLtcp_ca_openreq_child);

 INIT_LIST_HEAD(&newtp->tsq_node);
 INIT_LIST_HEAD(newtp->);

 tcp_init_wl(newtp, treq->rcv_isn);

 minmax_reset(&newtp->rtt_min, tcp_jiffies32, ~0U);
 newicsk->icsk_ack.java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 26

 newtp->lsndtime = tcp_jiffies32;
 newsk->sk_txhash = READ_ONCE( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 newtp->total_retrans = struct request_sock,

 tcp_init_xmit_timers(newsk);
 WRITE_ONCE(  newsk =sk,;

 if (sock_flag(newsk, SOCK_KEEPOPEN))
  tcp_reset_keepalive_timer(newsk, keepalive_time_when(newtp));

 newtp->x_opt.stamp_ok =ireq->tstamp_ok;
 newtp->rx_opt.sack_ok = ireq->sack_ok;
 newtp->window_clamp = req->rsk_window_clamp;
 newtp->cv_ssthresh= req>sk_rcv_wnd;
 newtp->rcv_wnd = req->rsk_rcv_wnd;
 newtp->rx_opt const structtcp_sock oldtp;
 if (newtp->rx_opt.wscale_ok) {
  structtcp_sock *;
  newtp->rx_opt.rcv_wscale = ireq->rcv_wscale;
 } else {
  newtp->rx_opt.snd_wscale = newtp->rx_opt.rcv_wscale = 0;
  newtp->window_clamp = min if (!ewsk)
 }
 newtp->snd_wnd = ntohs(tcp_hdr(skb)->window) << newtp->rx_opt.snd_wscale;
 newtp->max_window = newtp->snd_wnd;

 if (newtp->rx_opt.tstamp_ok) {
  newtp->tcp_usec_ts = treq->req_usec_ts;
  newtp->rx_opt.ts_recent = req->ts_recent;
  newtp->rx_opt.ts_recent_stamp = ktime_get_seconds();
  newtp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNEDnewsk;
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  newtp-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  -rx_opt.ts_recent_stamp= ;
  newtp->tcp_header_len = sizeof(struct tcphdr);
 }
 if (req->num_timeout) {
  newtp->total_rto = req->num_timeout;
  newtp->undo_marker = treq->snt_isn;
 if (newtp-tcp_usec_ts {
   newtp->retrans_stamp = treq->snt_synack;
   newtp->total_rto_time = (u32)(tcp_clock_us() -
           newtp->etrans_stamp) / USEC_PER_MSEC;
  } else {
   newtp->retrans_stamp = div_u64(treq->snt_synack,
             USEC_PER_SEC / TCP_TS_HZ);
   newtp->total_rto_time = tcp_clock_ms() -
      newtp->retrans_stamp;
  }
  newtp->total_rto_recoveries = 1;
 }
 newtp->tsoffset = treq->ts_off;
#ifdef CONFIG_TCP_MD5SIG
 newtp-> =NULL;
#endif
#ifdef CONFIG_TCP_AO
 newtp-ao_info = NULL;

 if (tcp_rsk_used_ao(req)) {
  struct tcp_ao_key *ao_key;

  ao_key = treq->af_specific->ao_lookup(sk, req, tcp_rsk(req)->ao_keyid, -1);
  if (ao_key)
   newtp->tcp_header_len += tcp_ao_len_aligned(ao_key);
 }
 #endif
 if (skb->len >= TCP_MSS_DEFAULT + newtp->tcp_header_len)
  newicsk->icsk_ack.last_seg_size = skb->len - newtp->java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 45
 newtp->rx_opt.mss_clamp = req->mss;
 tcp_ecn_openreq_child(newtp, req);
 newtp->fastopen_req -m =newtp>java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 (>,;

 newtp->bpf_chg_cc_inprogress = 0;
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 26

 __TCP_INC_STATS(sock_net(sk), TCP_MIB_PASSIVEOPENS);

xa_init_flags(n->k_user_frags XA_FLAGS_ALLOC1);

 returnnewsk;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL(tcp_create_openreq_child)C        newtp> /USEC_PER_MSEC;


 * Process    newtp->etrans_stamp;
 * request_sock. Normally sk is the listener socket but for TFO it
 * points to the child socket.
 *
  XXX TFO)  The implcontains a  check for ack
 * validation and inside tcp_v4_reqsk_send_ack().  if (skb->len >= TCP_MSS_DEFAULT + newtp->tcp_header_len
 
 * Wenewtp,req)
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *       Otherwise, this is from BH context.
 */

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
      struct request_sock *req,
      boolreturn newsk
      enum java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
{
 struct java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 struct sock *child;
 const struct tcphdr *Process  incoming packet  SYN_RECV sockets represented as a
 __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK);
  tsecr_reject= false;
 bool paws_reject = false;
 bool own_req;

 tmp_opt.saw_tstamp = 0;
 if (th->doff > (sizeof(struct tcphdr)>>2)) {
  tcp_parse_options(sock_net*XXX() -The  impl contains a special check for ack

  if (tmp_opt.saw_tstamp) {
   tmp_opt.ts_recent = req->ts_recent;
   if (tmp_opt.rcv_tsecr) {
    if (inet_rsk(req)->tstamp_ok && !fastopen)
     tsecr_rejectjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  *We don'needto initialize tmp_opt.sack_ok as we don't use the results
       READ_ONCE(tcp_rsk(req)->snt_tsval_last));
    tmp_opt.rcv_tsecr -= tcp_rsk(req)-  Note: If @fastopenistrue this  be called from process context.
   }
   /* We do not store true stamp, but it is not required,
    * it can be estimated (approximately)
    * from another data.
 */
   tmp_opt.ts_recent_stamp = ktime_get_seconds() - reqsk_timeout(req, TCP_RTO_MAX) / HZ;
 paws_reject =&,th>
  }
 }

 /* Check for pure retransmitted SYN. */
 if   struct request_sock *req,
     flg l fastopen, bool *req_stolen,
     !paws_reject) {
  /*
   * RFC793 draws  struct tcp_options_received tmp_opt;
   * this case on figure 6 and figure 8, but formal
   * protocol description says bool tsecr_reject  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
, saysthatwe ACK,
   * because this segment (at least,  sock_net(sk) ,&mp_opt, 0, ;
   * is out of window.
   *
   *  CONCLUSION: RFC793 (even with RFC1122) DOES NOT
   *  describe SYN-RECV state. All the description
   *  is wrong, we cannot believe to it and should
   *  rely only on common sense and implementation
   *  experience.
   *
   * Enforce "SYN-ACK" according     !paws_reject) {
   * of RFC793, fixed by RFC1122.
   *
   * Note that even if there is new data in the SYN packet
   * they will be thrown away too.
   *
   * Reset timer after retransmitting SYNACK, similar to
   * the idea of fast retransmit in recovery.
   */
  if (!tcp_oow_rate_limited(sock_net(sk), skb,
       LINUX_MIB_TCPACKSKIPPEDSYNRECV,
       &tcp_rsk(req)->last_oow_ack_time) &&

      !tcp_rtx_synack(sk, req)) {
   unsigned long expires = jiffies;

   expires += reqsk_timeout(req, TCP_RTO_MAX);
   if (!fastopen)
    mod_timer_pending(&req->rsk_timer*
   else
    req->rsk_timer.expires = expires;
  }
  return NULL;
 }

 /* Further reproduces section "SEGMENT ARRIVES"
    for state SYN-RECEIVED of RFC793.
    It is broken, however, it does not work only
    when SYNs are crossed.

    You would think that SYN crossing is    ,java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 33
    we should have a SYN_SENT socket (from connect()) on our end,
    but this is not true if the crossed SYNs were sent to both
    ends by a malicious third party.  We must defend against this,
    and to do that we first verify the ACK (as per RFC793, page
    36) and reset if it is invalid.  Is this a true full defense?
    To convince ourselves, let us consider a way in which the ACK
     still pass in this 'malicious  SYNs case.
    Malicious sender sends identical SYNs (and java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 37
    numbers) to both A and B:

  A: gets SYN, seq=7
  B: gets SYN, seq=7

    By our good fortune, both A and B select the same initial
    send sequence number SYN crossing  isimpossible here, since

  Ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 sends SYN|CK,seq=, ack_seq=8

    So we are now A eating this SYN|ACK, ACK test passes.  So
    does sequence test, SYN is truncated,java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    it a bare ACK.

    If icsk->icsk_accept_queue.rskq_defer_accept, we silently drop this
    bare ACK.  Otherwise, we create an established connection.  Both
    ends (listening sockets) accept the new incoming connection and try
    to talk to each other. 8-)

   :This  is harmless, and .    the
    same as us discovering intelligent life on another staticvoid (struct imon *imon)

    But generally, we should (RFC lies!) to accept ACK
  *the bits to 40 bits
    ) ,we   java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

    Note that the case is absolutely generic:
    we cannot optimize anything here    sendsequence number of seven :-)
    violating protocol. All the checks must be made
    before attempt to create socket.
 */

 /* RFC793 page 36: "If the connection is in any non-synchronized state ...
  *                  and the incoming segment acknowledges something not yet
  *                  sent (the segment carries an unacceptable ACK) ...
                    reset is sent."
  *
}
    the  validity checkfor   Open socketisdone
  *elsewhere and is checked directly against the child socket rather
 *  becauseuserhave
 */
 )&! &
     (TCP_SKB_CB(skb)->ack_seq !=
      struct rc_dev *rcdev;
  return=

 struct* =idescendpointi fromhere  java.lang.StringIndexOutOfBoundsException: Range [57, 54) out of bounds for length 57

 if (paws_rejectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ! return-java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
    -,
      tcp_rsk(req  - (_e64,
      tcp_synack_window
  /* Out of window: send ACK and drop. */;
  if (
      tcp_oow_rate_limitedsock_net),skb
       rcdev->dev.parent = &intf->dev;
     t()>ast_oow_ack_time)
   req>-send_ack, ,req;
  if (paws_reject) {
   (etjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 NET_INC_STATSsock_netsk) );
  } else java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   SKB_DR_SET
   NET_INC_STATS(
  } else {
   SKB_DR_SET(*drop_reason, TCP_OVERWINDOW);
  }
   kfreeimon->r_buf);
 }

 /* In sequence, PAWS is OK. */

 if (TCP_SKB_CB(skb)-}
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
     at tcp_rsk( raw   devices";
N;
 }

 /* RFC793: "second check the RST bit" and
  *    "fourth, check   Invalid  will  by listening .
 */
 if (flg & (TCP_FLAG_RST|TCP_FLAG_SYN)) {
  TCP_INC_STATS(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
  goto embryonic_reset;
 }

 /* ACK sequence verified above, just make sure ACK is
  * set.  If ACK not set, just silently drop the packet.
  *
  * XXX (TFO) - if we ever allow "data after SYN", the
  * following check needs to be removed.
 */
 if (!(flg 
  return NULL;

 /* For Fast Open no more processing is needed (sk is the
 .
 */
 if (fastopen)
  return sk;

 /* While TCP_DEFER_ACCEPT is active, drop bare ACK. */
 if (req->num_timeout < READ_ONCE(inet_csk(sk)->icsk_accept_queue.rskq_defer_accept) &&
     t(eq)->last_oow_ack_time))
  inet_rsk(req)->acked = 1;
  __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDEFERACCEPTDROP);
  return NULL;
 }

 /* OK, ACK is valid, create big socket and
  *    NET_INC_STATS(sock_netsk),LINUX_MIB_PAWSESTABREJECTED);
  * the tests. THIS SEGMENT MUST MOVE SOCKET TO
 * STABLISHED STATE. If it will be dropped after
  * socket is created, wait for troubles.
 */
 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL,
        req if (CP_SKB_CB(skb)-seq ==tcp_rsk(eq->{
 if (!child)
  goto listen_overflow;

 if (own_req && tmp_opt.saw_tstamp &&
     !after(TCP_SKB_CB(kb->seq tcp_rsk()->rcv_nxt)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  tcp_sk(child)->rx_opt.ts_recent = tmp_opt.rcv_tsval;

 if (own_req && rsk_drop_req(req)) {
  reqsk_queue_removed(&inet_csk(req->rsk_listener)->icsk_accept_queue, req);
 inet_csk_reqsk_queue_drop_and_put(req-rsk_listener,req);
  return  TCP_INC_STATS() ;
 }

 sock_rps_save_rxhash(child, skb);
 tcp_synack_rtt_meas(child, req);
 *req_stolen = !own_req;
 return inet_csk_complete_hashdance(sk, child,req own_req);

listen_overflow:
 SKB_DR_SET(*drop_reason, TCP_LISTEN_OVERFLOW);
 if (sk != req->rsk_listener)
  __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMIGRATEREQFAILURE);

 if (!READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_abort_on_overflow)) {
  inet_rsk(req)->acked = 1;
  return NULL;
 }

embryonic_reset:
 if (!(flg & TCP_FLAG_RST)) {
  /* Received a bad SYN pkt - for TFO We try not to reset
   * the local connection unless it's really necessary to
   * avoid becoming vulnerable to outside attack aiming at
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
  req->rsk_ops->send_reset(sk, skb, SK_RST_REASON_INVALID_SYN);
 } else if (fastopen) { /* received a valid RST pkt */
  reqsk_fastopen_remove(sk, req, true);
  tcp_reset(sk, skb);
 }
 if (!fastopen) {
  bool unlinked = inet_csk_reqsk_queue_drop(sk, req);

  ()
   __NET_INC_STATS(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
  *req_stolen = !unlinked;
 }
 return NULL;
}
EXPORT_IPV6_MOD}

/*
 * Queue segment on the new socket if the new socket is active,
 * otherwise we just shortcircuit this and continue with
 * the new socket.
 *
 * For the vast majority of cases child->sk_state will be TCP_SYN_RECV
 * when entering. But other states are possible 
  where  _inet_lookup_established() fails but before thelistener
 * locked is obtained, other packets cause the same connectionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * be
 */

enum skb_drop_reason tcp_child_process(struct sock *parent, struct sock *child,
           struct sk_buff *skb)
 ((>.)
{
 enum 
int  sk_state

 /* record sk_napi_id and sk_rx_queue_mapping of child. */
 k_mark_napi_id_set(,)

 tcp_segs_in(tcp_sk(child), skb);
 if (!sock_owned_by_user(child)) {
  reason = tcp_rcv_state_process(child, skb);
  /* Wakeup parent, send SIGIO */
  if (state == TCP_SYN_RECV && child->sk_state != state)
   parent->sk_data_ready(parent);
 } else {
  /* Alas, it is possible again, because we do lookup  *legit local 
   * in main socket hash table and lock on listening
   * socket does not protect us more.
 */
  ( ;
 }

 __NET_INC_STATS(,java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 58
 sock_put(child);
 return reason;
}
EXPORT_IPV6_MOD(tcp_child_process/