src/vnet/tcp/tcp_input.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vppinfra/sparse_vec.h>
  17 #include <vnet/tcp/tcp_packet.h>
  18 #include <vnet/tcp/tcp.h>
  19 #include <vnet/session/session.h>
  20 #include <math.h>
  21
  22 static char *tcp_error_strings[] = {
  23 #define tcp_error(n,s) s,
  24 #include <vnet/tcp/tcp_error.def>
  25 #undef tcp_error
  26 };
  27
  28 /* All TCP nodes have the same outgoing arcs */
  29 #define foreach_tcp_state_next                  \
  30   _ (DROP4, "ip4-drop")                         \
  31   _ (DROP6, "ip6-drop")                         \
  32   _ (TCP4_OUTPUT, "tcp4-output")                \
  33   _ (TCP6_OUTPUT, "tcp6-output")
  34
  35 typedef enum _tcp_established_next
  36 {
  37 #define _(s,n) TCP_ESTABLISHED_NEXT_##s,
  38   foreach_tcp_state_next
  39 #undef _
  40     TCP_ESTABLISHED_N_NEXT,
  41 } tcp_established_next_t;
  42
  43 typedef enum _tcp_rcv_process_next
  44 {
  45 #define _(s,n) TCP_RCV_PROCESS_NEXT_##s,
  46   foreach_tcp_state_next
  47 #undef _
  48     TCP_RCV_PROCESS_N_NEXT,
  49 } tcp_rcv_process_next_t;
  50
  51 typedef enum _tcp_syn_sent_next
  52 {
  53 #define _(s,n) TCP_SYN_SENT_NEXT_##s,
  54   foreach_tcp_state_next
  55 #undef _
  56     TCP_SYN_SENT_N_NEXT,
  57 } tcp_syn_sent_next_t;
  58
  59 typedef enum _tcp_listen_next
  60 {
  61 #define _(s,n) TCP_LISTEN_NEXT_##s,
  62   foreach_tcp_state_next
  63 #undef _
  64     TCP_LISTEN_N_NEXT,
  65 } tcp_listen_next_t;
  66
  67 /* Generic, state independent indices */
  68 typedef enum _tcp_state_next
  69 {
  70 #define _(s,n) TCP_NEXT_##s,
  71   foreach_tcp_state_next
  72 #undef _
  73     TCP_STATE_N_NEXT,
  74 } tcp_state_next_t;
  75
  76 #define tcp_next_output(is_ip4) (is_ip4 ? TCP_NEXT_TCP4_OUTPUT          \
  77                                         : TCP_NEXT_TCP6_OUTPUT)
  78
  79 #define tcp_next_drop(is_ip4) (is_ip4 ? TCP_NEXT_DROP4                  \
  80                                       : TCP_NEXT_DROP6)
  81
  82 vlib_node_registration_t tcp4_established_node;
  83 vlib_node_registration_t tcp6_established_node;
  84
  85 /**
  86  * Validate segment sequence number. As per RFC793:
  87  *
  88  * Segment Receive Test
  89  *      Length  Window
  90  *      ------- -------  -------------------------------------------
  91  *      0       0       SEG.SEQ = RCV.NXT
  92  *      0       >0      RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
  93  *      >0      0       not acceptable
  94  *      >0      >0      RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
  95  *                      or RCV.NXT =< SEG.SEQ+SEG.LEN-1 < RCV.NXT+RCV.WND
  96  *
  97  * This ultimately consists in checking if segment falls within the window.
  98  * The one important difference compared to RFC793 is that we use rcv_las,
  99  * or the rcv_nxt at last ack sent instead of rcv_nxt since that's the
 100  * peer's reference when computing our receive window.
 101  *
 102  * This:
 103  *  seq_leq (end_seq, tc->rcv_las + tc->rcv_wnd) && seq_geq (seq, tc->rcv_las)
 104  * however, is too strict when we have retransmits. Instead we just check that
 105  * the seq is not beyond the right edge and that the end of the segment is not
 106  * less than the left edge.
 107  *
 108  * N.B. rcv_nxt and rcv_wnd are both updated in this node if acks are sent, so
 109  * use rcv_nxt in the right edge window test instead of rcv_las.
 110  *
 111  */
 112 always_inline u8
 113 tcp_segment_in_rcv_wnd (tcp_connection_t * tc, u32 seq, u32 end_seq)
 114 {
 115   return (seq_geq (end_seq, tc->rcv_las)
 116           && seq_leq (seq, tc->rcv_nxt + tc->rcv_wnd));
 117 }
 118
 119 /**
 120  * Parse TCP header options.
 121  *
 122  * @param th TCP header
 123  * @param to TCP options data structure to be populated
 124  * @param is_syn set if packet is syn
 125  * @return -1 if parsing failed
 126  */
 127 static inline int
 128 tcp_options_parse (tcp_header_t * th, tcp_options_t * to, u8 is_syn)
 129 {
 130   const u8 *data;
 131   u8 opt_len, opts_len, kind;
 132   int j;
 133   sack_block_t b;
 134
 135   opts_len = (tcp_doff (th) << 2) - sizeof (tcp_header_t);
 136   data = (const u8 *) (th + 1);
 137
 138   /* Zero out all flags but those set in SYN */
 139   to->flags &= (TCP_OPTS_FLAG_SACK_PERMITTED | TCP_OPTS_FLAG_WSCALE
 140                 | TCP_OPTS_FLAG_TSTAMP | TCP_OPTION_MSS);
 141
 142   for (; opts_len > 0; opts_len -= opt_len, data += opt_len)
 143     {
 144       kind = data[0];
 145
 146       /* Get options length */
 147       if (kind == TCP_OPTION_EOL)
 148         break;
 149       else if (kind == TCP_OPTION_NOOP)
 150         {
 151           opt_len = 1;
 152           continue;
 153         }
 154       else
 155         {
 156           /* broken options */
 157           if (opts_len < 2)
 158             return -1;
 159           opt_len = data[1];
 160
 161           /* weird option length */
 162           if (opt_len < 2 || opt_len > opts_len)
 163             return -1;
 164         }
 165
 166       /* Parse options */
 167       switch (kind)
 168         {
 169         case TCP_OPTION_MSS:
 170           if (!is_syn)
 171             break;
 172           if ((opt_len == TCP_OPTION_LEN_MSS) && tcp_syn (th))
 173             {
 174               to->flags |= TCP_OPTS_FLAG_MSS;
 175               to->mss = clib_net_to_host_u16 (*(u16 *) (data + 2));
 176             }
 177           break;
 178         case TCP_OPTION_WINDOW_SCALE:
 179           if (!is_syn)
 180             break;
 181           if ((opt_len == TCP_OPTION_LEN_WINDOW_SCALE) && tcp_syn (th))
 182             {
 183               to->flags |= TCP_OPTS_FLAG_WSCALE;
 184               to->wscale = data[2];
 185               if (to->wscale > TCP_MAX_WND_SCALE)
 186                 {
 187                   clib_warning ("Illegal window scaling value: %d",
 188                                 to->wscale);
 189                   to->wscale = TCP_MAX_WND_SCALE;
 190                 }
 191             }
 192           break;
 193         case TCP_OPTION_TIMESTAMP:
 194           if (is_syn)
 195             to->flags |= TCP_OPTS_FLAG_TSTAMP;
 196           if ((to->flags & TCP_OPTS_FLAG_TSTAMP)
 197               && opt_len == TCP_OPTION_LEN_TIMESTAMP)
 198             {
 199               to->tsval = clib_net_to_host_u32 (*(u32 *) (data + 2));
 200               to->tsecr = clib_net_to_host_u32 (*(u32 *) (data + 6));
 201             }
 202           break;
 203         case TCP_OPTION_SACK_PERMITTED:
 204           if (!is_syn)
 205             break;
 206           if (opt_len == TCP_OPTION_LEN_SACK_PERMITTED && tcp_syn (th))
 207             to->flags |= TCP_OPTS_FLAG_SACK_PERMITTED;
 208           break;
 209         case TCP_OPTION_SACK_BLOCK:
 210           /* If SACK permitted was not advertised or a SYN, break */
 211           if ((to->flags & TCP_OPTS_FLAG_SACK_PERMITTED) == 0 || tcp_syn (th))
 212             break;
 213
 214           /* If too short or not correctly formatted, break */
 215           if (opt_len < 10 || ((opt_len - 2) % TCP_OPTION_LEN_SACK_BLOCK))
 216             break;
 217
 218           to->flags |= TCP_OPTS_FLAG_SACK;
 219           to->n_sack_blocks = (opt_len - 2) / TCP_OPTION_LEN_SACK_BLOCK;
 220           vec_reset_length (to->sacks);
 221           for (j = 0; j < to->n_sack_blocks; j++)
 222             {
 223               b.start = clib_net_to_host_u32 (*(u32 *) (data + 2 + 8 * j));
 224               b.end = clib_net_to_host_u32 (*(u32 *) (data + 6 + 8 * j));
 225               vec_add1 (to->sacks, b);
 226             }
 227           break;
 228         default:
 229           /* Nothing to see here */
 230           continue;
 231         }
 232     }
 233   return 0;
 234 }
 235
 236 /**
 237  * RFC1323: Check against wrapped sequence numbers (PAWS). If we have
 238  * timestamp to echo and it's less than tsval_recent, drop segment
 239  * but still send an ACK in order to retain TCP's mechanism for detecting
 240  * and recovering from half-open connections
 241  *
 242  * Or at least that's what the theory says. It seems that this might not work
 243  * very well with packet reordering and fast retransmit. XXX
 244  */
 245 always_inline int
 246 tcp_segment_check_paws (tcp_connection_t * tc)
 247 {
 248   return tcp_opts_tstamp (&tc->rcv_opts)
 249     && timestamp_lt (tc->rcv_opts.tsval, tc->tsval_recent);
 250 }
 251
 252 /**
 253  * Update tsval recent
 254  */
 255 always_inline void
 256 tcp_update_timestamp (tcp_connection_t * tc, u32 seq, u32 seq_end)
 257 {
 258   /*
 259    * RFC1323: If Last.ACK.sent falls within the range of sequence numbers
 260    * of an incoming segment:
 261    *    SEG.SEQ <= Last.ACK.sent < SEG.SEQ + SEG.LEN
 262    * then the TSval from the segment is copied to TS.Recent;
 263    * otherwise, the TSval is ignored.
 264    */
 265   if (tcp_opts_tstamp (&tc->rcv_opts) && seq_leq (seq, tc->rcv_las)
 266       && seq_leq (tc->rcv_las, seq_end))
 267     {
 268       ASSERT (timestamp_leq (tc->tsval_recent, tc->rcv_opts.tsval));
 269       tc->tsval_recent = tc->rcv_opts.tsval;
 270       tc->tsval_recent_age = tcp_time_now_w_thread (tc->c_thread_index);
 271     }
 272 }
 273
 274 /**
 275  * Validate incoming segment as per RFC793 p. 69 and RFC1323 p. 19
 276  *
 277  * It first verifies if segment has a wrapped sequence number (PAWS) and then
 278  * does the processing associated to the first four steps (ignoring security
 279  * and precedence): sequence number, rst bit and syn bit checks.
 280  *
 281  * @return 0 if segments passes validation.
 282  */
 283 static int
 284 tcp_segment_validate (tcp_worker_ctx_t * wrk, tcp_connection_t * tc0,
 285                       vlib_buffer_t * b0, tcp_header_t * th0, u32 * error0)
 286 {
 287   /* We could get a burst of RSTs interleaved with acks */
 288   if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
 289     {
 290       tcp_send_reset (tc0);
 291       *error0 = TCP_ERROR_CONNECTION_CLOSED;
 292       goto error;
 293     }
 294
 295   if (PREDICT_FALSE (!tcp_ack (th0) && !tcp_rst (th0) && !tcp_syn (th0)))
 296     {
 297       *error0 = TCP_ERROR_SEGMENT_INVALID;
 298       goto error;
 299     }
 300
 301   if (PREDICT_FALSE (tcp_options_parse (th0, &tc0->rcv_opts, 0)))
 302     {
 303       *error0 = TCP_ERROR_OPTIONS;
 304       goto error;
 305     }
 306
 307   if (PREDICT_FALSE (tcp_segment_check_paws (tc0)))
 308     {
 309       *error0 = TCP_ERROR_PAWS;
 310       TCP_EVT_DBG (TCP_EVT_PAWS_FAIL, tc0, vnet_buffer (b0)->tcp.seq_number,
 311                    vnet_buffer (b0)->tcp.seq_end);
 312
 313       /* If it just so happens that a segment updates tsval_recent for a
 314        * segment over 24 days old, invalidate tsval_recent. */
 315       if (timestamp_lt (tc0->tsval_recent_age + TCP_PAWS_IDLE,
 316                         tcp_time_now_w_thread (tc0->c_thread_index)))
 317         {
 318           tc0->tsval_recent = tc0->rcv_opts.tsval;
 319           clib_warning ("paws failed - really old segment. REALLY?");
 320         }
 321       else
 322         {
 323           /* Drop after ack if not rst */
 324           if (!tcp_rst (th0))
 325             {
 326               tcp_program_ack (wrk, tc0);
 327               TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc0, vnet_buffer (b0)->tcp);
 328             }
 329         }
 330       goto error;
 331     }
 332
 333   /* 1st: check sequence number */
 334   if (!tcp_segment_in_rcv_wnd (tc0, vnet_buffer (b0)->tcp.seq_number,
 335                                vnet_buffer (b0)->tcp.seq_end))
 336     {
 337       *error0 = TCP_ERROR_RCV_WND;
 338       /* If our window is 0 and the packet is in sequence, let it pass
 339        * through for ack processing. It should be dropped later. */
 340       if (!(tc0->rcv_wnd == 0
 341             && tc0->rcv_nxt == vnet_buffer (b0)->tcp.seq_number))
 342         {
 343           /* If not RST, send dup ack */
 344           if (!tcp_rst (th0))
 345             {
 346               tcp_program_dupack (wrk, tc0);
 347               TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc0, vnet_buffer (b0)->tcp);
 348             }
 349           goto error;
 350         }
 351     }
 352
 353   /* 2nd: check the RST bit */
 354   if (PREDICT_FALSE (tcp_rst (th0)))
 355     {
 356       tcp_connection_reset (tc0);
 357       *error0 = TCP_ERROR_RST_RCVD;
 358       goto error;
 359     }
 360
 361   /* 3rd: check security and precedence (skip) */
 362
 363   /* 4th: check the SYN bit */
 364   if (PREDICT_FALSE (tcp_syn (th0)))
 365     {
 366       /* TODO implement RFC 5961 */
 367       if (tc0->state == TCP_STATE_SYN_RCVD)
 368         {
 369           tcp_options_parse (th0, &tc0->rcv_opts, 1);
 370           tcp_send_synack (tc0);
 371           TCP_EVT_DBG (TCP_EVT_SYN_RCVD, tc0, 0);
 372         }
 373       else
 374         {
 375           tcp_program_ack (wrk, tc0);
 376           TCP_EVT_DBG (TCP_EVT_SYNACK_RCVD, tc0);
 377         }
 378       goto error;
 379     }
 380
 381   /* If segment in window, save timestamp */
 382   tcp_update_timestamp (tc0, vnet_buffer (b0)->tcp.seq_number,
 383                         vnet_buffer (b0)->tcp.seq_end);
 384   return 0;
 385
 386 error:
 387   return -1;
 388 }
 389
 390 always_inline int
 391 tcp_rcv_ack_is_acceptable (tcp_connection_t * tc0, vlib_buffer_t * tb0)
 392 {
 393   /* SND.UNA =< SEG.ACK =< SND.NXT */
 394   return (seq_leq (tc0->snd_una, vnet_buffer (tb0)->tcp.ack_number)
 395           && seq_leq (vnet_buffer (tb0)->tcp.ack_number, tc0->snd_nxt));
 396 }
 397
 398 /**
 399  * Compute smoothed RTT as per VJ's '88 SIGCOMM and RFC6298
 400  *
 401  * Note that although the original article, srtt and rttvar are scaled
 402  * to minimize round-off errors, here we don't. Instead, we rely on
 403  * better precision time measurements.
 404  *
 405  * TODO support us rtt resolution
 406  */
 407 static void
 408 tcp_estimate_rtt (tcp_connection_t * tc, u32 mrtt)
 409 {
 410   int err, diff;
 411
 412   if (tc->srtt != 0)
 413     {
 414       err = mrtt - tc->srtt;
 415
 416       /* XXX Drop in RTT results in RTTVAR increase and bigger RTO.
 417        * The increase should be bound */
 418       tc->srtt = clib_max ((int) tc->srtt + (err >> 3), 1);
 419       diff = (clib_abs (err) - (int) tc->rttvar) >> 2;
 420       tc->rttvar = clib_max ((int) tc->rttvar + diff, 1);
 421     }
 422   else
 423     {
 424       /* First measurement. */
 425       tc->srtt = mrtt;
 426       tc->rttvar = mrtt >> 1;
 427     }
 428 }
 429
 430 void
 431 tcp_update_rto (tcp_connection_t * tc)
 432 {
 433   tc->rto = clib_min (tc->srtt + (tc->rttvar << 2), TCP_RTO_MAX);
 434   tc->rto = clib_max (tc->rto, TCP_RTO_MIN);
 435 }
 436
 437 /**
 438  * Update RTT estimate and RTO timer
 439  *
 440  * Measure RTT: We have two sources of RTT measurements: TSOPT and ACK
 441  * timing. Middle boxes are known to fiddle with TCP options so we
 442  * should give higher priority to ACK timing.
 443  *
 444  * This should be called only if previously sent bytes have been acked.
 445  *
 446  * return 1 if valid rtt 0 otherwise
 447  */
 448 static int
 449 tcp_update_rtt (tcp_connection_t * tc, u32 ack)
 450 {
 451   u32 mrtt = 0;
 452
 453   /* Karn's rule, part 1. Don't use retransmitted segments to estimate
 454    * RTT because they're ambiguous. */
 455   if (tcp_in_cong_recovery (tc) || tc->sack_sb.sacked_bytes)
 456     {
 457       if (tcp_in_recovery (tc))
 458         return 0;
 459       goto done;
 460     }
 461
 462   if (tc->rtt_ts && seq_geq (ack, tc->rtt_seq))
 463     {
 464       f64 sample = tcp_time_now_us (tc->c_thread_index) - tc->rtt_ts;
 465       tc->mrtt_us = tc->mrtt_us + (sample - tc->mrtt_us) * 0.125;
 466       mrtt = clib_max ((u32) (sample * THZ), 1);
 467       /* Allow measuring of a new RTT */
 468       tc->rtt_ts = 0;
 469     }
 470   /* As per RFC7323 TSecr can be used for RTTM only if the segment advances
 471    * snd_una, i.e., the left side of the send window:
 472    * seq_lt (tc->snd_una, ack). This is a condition for calling update_rtt */
 473   else if (tcp_opts_tstamp (&tc->rcv_opts) && tc->rcv_opts.tsecr)
 474     {
 475       u32 now = tcp_time_now_w_thread (tc->c_thread_index);
 476       mrtt = clib_max (now - tc->rcv_opts.tsecr, 1);
 477     }
 478
 479   /* Ignore dubious measurements */
 480   if (mrtt == 0 || mrtt > TCP_RTT_MAX)
 481     goto done;
 482
 483   tcp_estimate_rtt (tc, mrtt);
 484
 485 done:
 486
 487   /* If we got here something must've been ACKed so make sure boff is 0,
 488    * even if mrtt is not valid since we update the rto lower */
 489   tc->rto_boff = 0;
 490   tcp_update_rto (tc);
 491
 492   return 0;
 493 }
 494
 495 static void
 496 tcp_estimate_initial_rtt (tcp_connection_t * tc)
 497 {
 498   u8 thread_index = vlib_num_workers ()? 1 : 0;
 499   int mrtt;
 500
 501   if (tc->rtt_ts)
 502     {
 503       tc->mrtt_us = tcp_time_now_us (thread_index) - tc->rtt_ts;
 504       mrtt = clib_max ((u32) (tc->mrtt_us * THZ), 1);
 505       tc->rtt_ts = 0;
 506     }
 507   else
 508     {
 509       mrtt = tcp_time_now_w_thread (thread_index) - tc->rcv_opts.tsecr;
 510       mrtt = clib_max (mrtt, 1);
 511       tc->mrtt_us = (f64) mrtt *TCP_TICK;
 512     }
 513
 514   if (mrtt > 0 && mrtt < TCP_RTT_MAX)
 515     tcp_estimate_rtt (tc, mrtt);
 516 }
 517
 518 /**
 519  * Dequeue bytes for connections that have received acks in last burst
 520  */
 521 static void
 522 tcp_handle_postponed_dequeues (tcp_worker_ctx_t * wrk)
 523 {
 524   u32 thread_index = wrk->vm->thread_index;
 525   u32 *pending_deq_acked;
 526   tcp_connection_t *tc;
 527   int i;
 528
 529   if (!vec_len (wrk->pending_deq_acked))
 530     return;
 531
 532   pending_deq_acked = wrk->pending_deq_acked;
 533   for (i = 0; i < vec_len (pending_deq_acked); i++)
 534     {
 535       tc = tcp_connection_get (pending_deq_acked[i], thread_index);
 536       tc->flags &= ~TCP_CONN_DEQ_PENDING;
 537
 538       if (PREDICT_FALSE (!tc->burst_acked))
 539         continue;
 540
 541       /* Dequeue the newly ACKed bytes */
 542       stream_session_dequeue_drop (&tc->connection, tc->burst_acked);
 543       tc->burst_acked = 0;
 544       tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
 545
 546       /* If everything has been acked, stop retransmit timer
 547        * otherwise update. */
 548       tcp_retransmit_timer_update (tc);
 549
 550       /* If not congested, update pacer based on our new
 551        * cwnd estimate */
 552       if (!tcp_in_fastrecovery (tc))
 553         tcp_connection_tx_pacer_update (tc);
 554     }
 555   _vec_len (wrk->pending_deq_acked) = 0;
 556 }
 557
 558 static void
 559 tcp_program_dequeue (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
 560 {
 561   if (!(tc->flags & TCP_CONN_DEQ_PENDING))
 562     {
 563       vec_add1 (wrk->pending_deq_acked, tc->c_c_index);
 564       tc->flags |= TCP_CONN_DEQ_PENDING;
 565     }
 566   tc->burst_acked += tc->bytes_acked + tc->sack_sb.snd_una_adv;
 567 }
 568
 569 /**
 570  * Check if duplicate ack as per RFC5681 Sec. 2
 571  */
 572 static u8
 573 tcp_ack_is_dupack (tcp_connection_t * tc, vlib_buffer_t * b, u32 prev_snd_wnd,
 574                    u32 prev_snd_una)
 575 {
 576   return ((vnet_buffer (b)->tcp.ack_number == prev_snd_una)
 577           && seq_gt (tc->snd_una_max, tc->snd_una)
 578           && (vnet_buffer (b)->tcp.seq_end == vnet_buffer (b)->tcp.seq_number)
 579           && (prev_snd_wnd == tc->snd_wnd));
 580 }
 581
 582 /**
 583  * Checks if ack is a congestion control event.
 584  */
 585 static u8
 586 tcp_ack_is_cc_event (tcp_connection_t * tc, vlib_buffer_t * b,
 587                      u32 prev_snd_wnd, u32 prev_snd_una, u8 * is_dack)
 588 {
 589   /* Check if ack is duplicate. Per RFC 6675, ACKs that SACK new data are
 590    * defined to be 'duplicate' */
 591   *is_dack = tc->sack_sb.last_sacked_bytes
 592     || tcp_ack_is_dupack (tc, b, prev_snd_wnd, prev_snd_una);
 593
 594   return ((*is_dack || tcp_in_cong_recovery (tc)) && !tcp_is_lost_fin (tc));
 595 }
 596
 597 static u32
 598 scoreboard_hole_index (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole)
 599 {
 600   ASSERT (!pool_is_free_index (sb->holes, hole - sb->holes));
 601   return hole - sb->holes;
 602 }
 603
 604 static u32
 605 scoreboard_hole_bytes (sack_scoreboard_hole_t * hole)
 606 {
 607   return hole->end - hole->start;
 608 }
 609
 610 sack_scoreboard_hole_t *
 611 scoreboard_get_hole (sack_scoreboard_t * sb, u32 index)
 612 {
 613   if (index != TCP_INVALID_SACK_HOLE_INDEX)
 614     return pool_elt_at_index (sb->holes, index);
 615   return 0;
 616 }
 617
 618 sack_scoreboard_hole_t *
 619 scoreboard_next_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole)
 620 {
 621   if (hole->next != TCP_INVALID_SACK_HOLE_INDEX)
 622     return pool_elt_at_index (sb->holes, hole->next);
 623   return 0;
 624 }
 625
 626 sack_scoreboard_hole_t *
 627 scoreboard_prev_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole)
 628 {
 629   if (hole->prev != TCP_INVALID_SACK_HOLE_INDEX)
 630     return pool_elt_at_index (sb->holes, hole->prev);
 631   return 0;
 632 }
 633
 634 sack_scoreboard_hole_t *
 635 scoreboard_first_hole (sack_scoreboard_t * sb)
 636 {
 637   if (sb->head != TCP_INVALID_SACK_HOLE_INDEX)
 638     return pool_elt_at_index (sb->holes, sb->head);
 639   return 0;
 640 }
 641
 642 sack_scoreboard_hole_t *
 643 scoreboard_last_hole (sack_scoreboard_t * sb)
 644 {
 645   if (sb->tail != TCP_INVALID_SACK_HOLE_INDEX)
 646     return pool_elt_at_index (sb->holes, sb->tail);
 647   return 0;
 648 }
 649
 650 static void
 651 scoreboard_remove_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole)
 652 {
 653   sack_scoreboard_hole_t *next, *prev;
 654
 655   if (hole->next != TCP_INVALID_SACK_HOLE_INDEX)
 656     {
 657       next = pool_elt_at_index (sb->holes, hole->next);
 658       next->prev = hole->prev;
 659     }
 660   else
 661     {
 662       sb->tail = hole->prev;
 663     }
 664
 665   if (hole->prev != TCP_INVALID_SACK_HOLE_INDEX)
 666     {
 667       prev = pool_elt_at_index (sb->holes, hole->prev);
 668       prev->next = hole->next;
 669     }
 670   else
 671     {
 672       sb->head = hole->next;
 673     }
 674
 675   if (scoreboard_hole_index (sb, hole) == sb->cur_rxt_hole)
 676     sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
 677
 678   /* Poison the entry */
 679   if (CLIB_DEBUG > 0)
 680     clib_memset (hole, 0xfe, sizeof (*hole));
 681
 682   pool_put (sb->holes, hole);
 683 }
 684
 685 static sack_scoreboard_hole_t *
 686 scoreboard_insert_hole (sack_scoreboard_t * sb, u32 prev_index,
 687                         u32 start, u32 end)
 688 {
 689   sack_scoreboard_hole_t *hole, *next, *prev;
 690   u32 hole_index;
 691
 692   pool_get (sb->holes, hole);
 693   clib_memset (hole, 0, sizeof (*hole));
 694
 695   hole->start = start;
 696   hole->end = end;
 697   hole_index = scoreboard_hole_index (sb, hole);
 698
 699   prev = scoreboard_get_hole (sb, prev_index);
 700   if (prev)
 701     {
 702       hole->prev = prev_index;
 703       hole->next = prev->next;
 704
 705       if ((next = scoreboard_next_hole (sb, hole)))
 706         next->prev = hole_index;
 707       else
 708         sb->tail = hole_index;
 709
 710       prev->next = hole_index;
 711     }
 712   else
 713     {
 714       sb->head = hole_index;
 715       hole->prev = TCP_INVALID_SACK_HOLE_INDEX;
 716       hole->next = TCP_INVALID_SACK_HOLE_INDEX;
 717     }
 718
 719   return hole;
 720 }
 721
 722 static void
 723 scoreboard_update_bytes (tcp_connection_t * tc, sack_scoreboard_t * sb)
 724 {
 725   sack_scoreboard_hole_t *left, *right;
 726   u32 bytes = 0, blks = 0;
 727
 728   sb->lost_bytes = 0;
 729   sb->sacked_bytes = 0;
 730   left = scoreboard_last_hole (sb);
 731   if (!left)
 732     return;
 733
 734   if (seq_gt (sb->high_sacked, left->end))
 735     {
 736       bytes = sb->high_sacked - left->end;
 737       blks = 1;
 738     }
 739
 740   while ((right = left)
 741          && bytes < (TCP_DUPACK_THRESHOLD - 1) * tc->snd_mss
 742          && blks < TCP_DUPACK_THRESHOLD
 743          /* left not updated if above conditions fail */
 744          && (left = scoreboard_prev_hole (sb, right)))
 745     {
 746       bytes += right->start - left->end;
 747       blks++;
 748     }
 749
 750   /* left is first lost */
 751   if (left)
 752     {
 753       do
 754         {
 755           sb->lost_bytes += scoreboard_hole_bytes (right);
 756           left->is_lost = 1;
 757           left = scoreboard_prev_hole (sb, right);
 758           if (left)
 759             bytes += right->start - left->end;
 760         }
 761       while ((right = left));
 762     }
 763
 764   sb->sacked_bytes = bytes;
 765 }
 766
 767 /**
 768  * Figure out the next hole to retransmit
 769  *
 770  * Follows logic proposed in RFC6675 Sec. 4, NextSeg()
 771  */
 772 sack_scoreboard_hole_t *
 773 scoreboard_next_rxt_hole (sack_scoreboard_t * sb,
 774                           sack_scoreboard_hole_t * start,
 775                           u8 have_unsent, u8 * can_rescue, u8 * snd_limited)
 776 {
 777   sack_scoreboard_hole_t *hole = 0;
 778
 779   hole = start ? start : scoreboard_first_hole (sb);
 780   while (hole && seq_leq (hole->end, sb->high_rxt) && hole->is_lost)
 781     hole = scoreboard_next_hole (sb, hole);
 782
 783   /* Nothing, return */
 784   if (!hole)
 785     {
 786       sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
 787       return 0;
 788     }
 789
 790   /* Rule (1): if higher than rxt, less than high_sacked and lost */
 791   if (hole->is_lost && seq_lt (hole->start, sb->high_sacked))
 792     {
 793       sb->cur_rxt_hole = scoreboard_hole_index (sb, hole);
 794     }
 795   else
 796     {
 797       /* Rule (2): available unsent data */
 798       if (have_unsent)
 799         {
 800           sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
 801           return 0;
 802         }
 803       /* Rule (3): if hole not lost */
 804       else if (seq_lt (hole->start, sb->high_sacked))
 805         {
 806           *snd_limited = 0;
 807           sb->cur_rxt_hole = scoreboard_hole_index (sb, hole);
 808         }
 809       /* Rule (4): if hole beyond high_sacked */
 810       else
 811         {
 812           ASSERT (seq_geq (hole->start, sb->high_sacked));
 813           *snd_limited = 1;
 814           *can_rescue = 1;
 815           /* HighRxt MUST NOT be updated */
 816           return 0;
 817         }
 818     }
 819
 820   if (hole && seq_lt (sb->high_rxt, hole->start))
 821     sb->high_rxt = hole->start;
 822
 823   return hole;
 824 }
 825
 826 static void
 827 scoreboard_init_high_rxt (sack_scoreboard_t * sb, u32 snd_una)
 828 {
 829   sack_scoreboard_hole_t *hole;
 830   hole = scoreboard_first_hole (sb);
 831   if (hole)
 832     {
 833       snd_una = seq_gt (snd_una, hole->start) ? snd_una : hole->start;
 834       sb->cur_rxt_hole = sb->head;
 835     }
 836   sb->high_rxt = snd_una;
 837   sb->rescue_rxt = snd_una - 1;
 838 }
 839
 840 void
 841 scoreboard_init (sack_scoreboard_t * sb)
 842 {
 843   sb->head = TCP_INVALID_SACK_HOLE_INDEX;
 844   sb->tail = TCP_INVALID_SACK_HOLE_INDEX;
 845   sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
 846 }
 847
 848 void
 849 scoreboard_clear (sack_scoreboard_t * sb)
 850 {
 851   sack_scoreboard_hole_t *hole;
 852   while ((hole = scoreboard_first_hole (sb)))
 853     {
 854       scoreboard_remove_hole (sb, hole);
 855     }
 856   ASSERT (sb->head == sb->tail && sb->head == TCP_INVALID_SACK_HOLE_INDEX);
 857   ASSERT (pool_elts (sb->holes) == 0);
 858   sb->sacked_bytes = 0;
 859   sb->last_sacked_bytes = 0;
 860   sb->last_bytes_delivered = 0;
 861   sb->snd_una_adv = 0;
 862   sb->high_sacked = 0;
 863   sb->high_rxt = 0;
 864   sb->lost_bytes = 0;
 865   sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
 866 }
 867
 868 /**
 869  * Test that scoreboard is sane after recovery
 870  *
 871  * Returns 1 if scoreboard is empty or if first hole beyond
 872  * snd_una.
 873  */
 874 static u8
 875 tcp_scoreboard_is_sane_post_recovery (tcp_connection_t * tc)
 876 {
 877   sack_scoreboard_hole_t *hole;
 878   hole = scoreboard_first_hole (&tc->sack_sb);
 879   return (!hole || (seq_geq (hole->start, tc->snd_una)
 880                     && seq_lt (hole->end, tc->snd_una_max)));
 881 }
 882
 883 void
 884 tcp_rcv_sacks (tcp_connection_t * tc, u32 ack)
 885 {
 886   sack_scoreboard_t *sb = &tc->sack_sb;
 887   sack_block_t *blk, tmp;
 888   sack_scoreboard_hole_t *hole, *next_hole, *last_hole;
 889   u32 blk_index = 0, old_sacked_bytes, hole_index;
 890   int i, j;
 891
 892   sb->last_sacked_bytes = 0;
 893   sb->last_bytes_delivered = 0;
 894   sb->snd_una_adv = 0;
 895
 896   if (!tcp_opts_sack (&tc->rcv_opts)
 897       && sb->head == TCP_INVALID_SACK_HOLE_INDEX)
 898     return;
 899
 900   old_sacked_bytes = sb->sacked_bytes;
 901
 902   /* Remove invalid blocks */
 903   blk = tc->rcv_opts.sacks;
 904   while (blk < vec_end (tc->rcv_opts.sacks))
 905     {
 906       if (seq_lt (blk->start, blk->end)
 907           && seq_gt (blk->start, tc->snd_una)
 908           && seq_gt (blk->start, ack)
 909           && seq_lt (blk->start, tc->snd_una_max)
 910           && seq_leq (blk->end, tc->snd_una_max))
 911         {
 912           blk++;
 913           continue;
 914         }
 915       vec_del1 (tc->rcv_opts.sacks, blk - tc->rcv_opts.sacks);
 916     }
 917
 918   /* Add block for cumulative ack */
 919   if (seq_gt (ack, tc->snd_una))
 920     {
 921       tmp.start = tc->snd_una;
 922       tmp.end = ack;
 923       vec_add1 (tc->rcv_opts.sacks, tmp);
 924     }
 925
 926   if (vec_len (tc->rcv_opts.sacks) == 0)
 927     return;
 928
 929   tcp_scoreboard_trace_add (tc, ack);
 930
 931   /* Make sure blocks are ordered */
 932   for (i = 0; i < vec_len (tc->rcv_opts.sacks); i++)
 933     for (j = i + 1; j < vec_len (tc->rcv_opts.sacks); j++)
 934       if (seq_lt (tc->rcv_opts.sacks[j].start, tc->rcv_opts.sacks[i].start))
 935         {
 936           tmp = tc->rcv_opts.sacks[i];
 937           tc->rcv_opts.sacks[i] = tc->rcv_opts.sacks[j];
 938           tc->rcv_opts.sacks[j] = tmp;
 939         }
 940
 941   if (sb->head == TCP_INVALID_SACK_HOLE_INDEX)
 942     {
 943       /* If no holes, insert the first that covers all outstanding bytes */
 944       last_hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX,
 945                                           tc->snd_una, tc->snd_una_max);
 946       sb->tail = scoreboard_hole_index (sb, last_hole);
 947       tmp = tc->rcv_opts.sacks[vec_len (tc->rcv_opts.sacks) - 1];
 948       sb->high_sacked = tmp.end;
 949     }
 950   else
 951     {
 952       /* If we have holes but snd_una_max is beyond the last hole, update
 953        * last hole end */
 954       tmp = tc->rcv_opts.sacks[vec_len (tc->rcv_opts.sacks) - 1];
 955       last_hole = scoreboard_last_hole (sb);
 956       if (seq_gt (tc->snd_una_max, last_hole->end))
 957         {
 958           if (seq_geq (last_hole->start, sb->high_sacked))
 959             {
 960               last_hole->end = tc->snd_una_max;
 961             }
 962           /* New hole after high sacked block */
 963           else if (seq_lt (sb->high_sacked, tc->snd_una_max))
 964             {
 965               scoreboard_insert_hole (sb, sb->tail, sb->high_sacked,
 966                                       tc->snd_una_max);
 967             }
 968         }
 969       /* Keep track of max byte sacked for when the last hole
 970        * is acked */
 971       if (seq_gt (tmp.end, sb->high_sacked))
 972         sb->high_sacked = tmp.end;
 973     }
 974
 975   /* Walk the holes with the SACK blocks */
 976   hole = pool_elt_at_index (sb->holes, sb->head);
 977   while (hole && blk_index < vec_len (tc->rcv_opts.sacks))
 978     {
 979       blk = &tc->rcv_opts.sacks[blk_index];
 980       if (seq_leq (blk->start, hole->start))
 981         {
 982           /* Block covers hole. Remove hole */
 983           if (seq_geq (blk->end, hole->end))
 984             {
 985               next_hole = scoreboard_next_hole (sb, hole);
 986
 987               /* Byte accounting: snd_una needs to be advanced */
 988               if (blk->end == ack)
 989                 {
 990                   if (next_hole)
 991                     {
 992                       if (seq_lt (ack, next_hole->start))
 993                         sb->snd_una_adv = next_hole->start - ack;
 994                       sb->last_bytes_delivered +=
 995                         next_hole->start - hole->end;
 996                     }
 997                   else
 998                     {
 999                       ASSERT (seq_geq (sb->high_sacked, ack));
1000                       sb->snd_una_adv = sb->high_sacked - ack;
1001                       sb->last_bytes_delivered += sb->high_sacked - hole->end;
1002                     }
1003                 }
1004
1005               scoreboard_remove_hole (sb, hole);
1006               hole = next_hole;
1007             }
1008           /* Partial 'head' overlap */
1009           else
1010             {
1011               if (seq_gt (blk->end, hole->start))
1012                 {
1013                   hole->start = blk->end;
1014                 }
1015               blk_index++;
1016             }
1017         }
1018       else
1019         {
1020           /* Hole must be split */
1021           if (seq_lt (blk->end, hole->end))
1022             {
1023               hole_index = scoreboard_hole_index (sb, hole);
1024               next_hole = scoreboard_insert_hole (sb, hole_index, blk->end,
1025                                                   hole->end);
1026
1027               /* Pool might've moved */
1028               hole = scoreboard_get_hole (sb, hole_index);
1029               hole->end = blk->start;
1030               blk_index++;
1031               ASSERT (hole->next == scoreboard_hole_index (sb, next_hole));
1032             }
1033           else if (seq_lt (blk->start, hole->end))
1034             {
1035               hole->end = blk->start;
1036             }
1037           hole = scoreboard_next_hole (sb, hole);
1038         }
1039     }
1040
1041   if (pool_elts (sb->holes) == 1)
1042     {
1043       hole = scoreboard_first_hole (sb);
1044       if (hole->start == ack + sb->snd_una_adv
1045           && hole->end == tc->snd_una_max)
1046         scoreboard_remove_hole (sb, hole);
1047     }
1048
1049   scoreboard_update_bytes (tc, sb);
1050   sb->last_sacked_bytes = sb->sacked_bytes
1051     - (old_sacked_bytes - sb->last_bytes_delivered);
1052   ASSERT (sb->last_sacked_bytes <= sb->sacked_bytes || tcp_in_recovery (tc));
1053   ASSERT (sb->sacked_bytes == 0 || tcp_in_recovery (tc)
1054           || sb->sacked_bytes < tc->snd_una_max - seq_max (tc->snd_una, ack));
1055   ASSERT (sb->last_sacked_bytes + sb->lost_bytes <= tc->snd_una_max
1056           - seq_max (tc->snd_una, ack) || tcp_in_recovery (tc));
1057   ASSERT (sb->head == TCP_INVALID_SACK_HOLE_INDEX || tcp_in_recovery (tc)
1058           || sb->holes[sb->head].start == ack + sb->snd_una_adv);
1059   TCP_EVT_DBG (TCP_EVT_CC_SCOREBOARD, tc);
1060 }
1061
1062 /**
1063  * Try to update snd_wnd based on feedback received from peer.
1064  *
1065  * If successful, and new window is 'effectively' 0, activate persist
1066  * timer.
1067  */
1068 static void
1069 tcp_update_snd_wnd (tcp_connection_t * tc, u32 seq, u32 ack, u32 snd_wnd)
1070 {
1071   /* If (SND.WL1 < SEG.SEQ or (SND.WL1 = SEG.SEQ and SND.WL2 =< SEG.ACK)), set
1072    * SND.WND <- SEG.WND, set SND.WL1 <- SEG.SEQ, and set SND.WL2 <- SEG.ACK */
1073   if (seq_lt (tc->snd_wl1, seq)
1074       || (tc->snd_wl1 == seq && seq_leq (tc->snd_wl2, ack)))
1075     {
1076       tc->snd_wnd = snd_wnd;
1077       tc->snd_wl1 = seq;
1078       tc->snd_wl2 = ack;
1079       TCP_EVT_DBG (TCP_EVT_SND_WND, tc);
1080
1081       if (PREDICT_FALSE (tc->snd_wnd < tc->snd_mss))
1082         {
1083           /* Set persist timer if not set and we just got 0 wnd */
1084           if (!tcp_timer_is_active (tc, TCP_TIMER_PERSIST)
1085               && !tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT))
1086             tcp_persist_timer_set (tc);
1087         }
1088       else
1089         {
1090           tcp_persist_timer_reset (tc);
1091           if (PREDICT_FALSE (!tcp_in_recovery (tc) && tc->rto_boff > 0))
1092             {
1093               tc->rto_boff = 0;
1094               tcp_update_rto (tc);
1095             }
1096         }
1097     }
1098 }
1099
1100 /**
1101  * Init loss recovery/fast recovery.
1102  *
1103  * Triggered by dup acks as opposed to timer timeout. Note that cwnd is
1104  * updated in @ref tcp_cc_handle_event after fast retransmit
1105  */
1106 void
1107 tcp_cc_init_congestion (tcp_connection_t * tc)
1108 {
1109   tcp_fastrecovery_on (tc);
1110   tc->snd_congestion = tc->snd_una_max;
1111   tc->cwnd_acc_bytes = 0;
1112   tc->snd_rxt_bytes = 0;
1113   tc->prev_ssthresh = tc->ssthresh;
1114   tc->prev_cwnd = tc->cwnd;
1115   tc->cc_algo->congestion (tc);
1116   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 4);
1117 }
1118
1119 static void
1120 tcp_cc_recovery_exit (tcp_connection_t * tc)
1121 {
1122   tc->rto_boff = 0;
1123   tcp_update_rto (tc);
1124   tc->snd_rxt_ts = 0;
1125   tc->snd_nxt = tc->snd_una_max;
1126   tc->rtt_ts = 0;
1127   tcp_recovery_off (tc);
1128   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 3);
1129 }
1130
1131 void
1132 tcp_cc_fastrecovery_exit (tcp_connection_t * tc)
1133 {
1134   tc->cc_algo->recovered (tc);
1135   tc->snd_rxt_bytes = 0;
1136   tc->rcv_dupacks = 0;
1137   tc->snd_nxt = tc->snd_una_max;
1138   tc->snd_rxt_bytes = 0;
1139   tc->rtt_ts = 0;
1140
1141   tcp_fastrecovery_off (tc);
1142   tcp_fastrecovery_first_off (tc);
1143
1144   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 3);
1145 }
1146
1147 static void
1148 tcp_cc_congestion_undo (tcp_connection_t * tc)
1149 {
1150   tc->cwnd = tc->prev_cwnd;
1151   tc->ssthresh = tc->prev_ssthresh;
1152   tc->snd_nxt = tc->snd_una_max;
1153   tc->rcv_dupacks = 0;
1154   if (tcp_in_recovery (tc))
1155     tcp_cc_recovery_exit (tc);
1156   else if (tcp_in_fastrecovery (tc))
1157     tcp_cc_fastrecovery_exit (tc);
1158   ASSERT (tc->rto_boff == 0);
1159   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 5);
1160 }
1161
1162 static inline u8
1163 tcp_cc_is_spurious_timeout_rxt (tcp_connection_t * tc)
1164 {
1165   return (tcp_in_recovery (tc) && tc->rto_boff == 1
1166           && tc->snd_rxt_ts
1167           && tcp_opts_tstamp (&tc->rcv_opts)
1168           && timestamp_lt (tc->rcv_opts.tsecr, tc->snd_rxt_ts));
1169 }
1170
1171 static inline u8
1172 tcp_cc_is_spurious_fast_rxt (tcp_connection_t * tc)
1173 {
1174   return (tcp_in_fastrecovery (tc)
1175           && tc->cwnd > tc->ssthresh + 3 * tc->snd_mss);
1176 }
1177
1178 static u8
1179 tcp_cc_is_spurious_retransmit (tcp_connection_t * tc)
1180 {
1181   return (tcp_cc_is_spurious_timeout_rxt (tc)
1182           || tcp_cc_is_spurious_fast_rxt (tc));
1183 }
1184
1185 static int
1186 tcp_cc_recover (tcp_connection_t * tc)
1187 {
1188   ASSERT (tcp_in_cong_recovery (tc));
1189   if (tcp_cc_is_spurious_retransmit (tc))
1190     {
1191       tcp_cc_congestion_undo (tc);
1192       return 1;
1193     }
1194
1195   if (tcp_in_recovery (tc))
1196     tcp_cc_recovery_exit (tc);
1197   else if (tcp_in_fastrecovery (tc))
1198     tcp_cc_fastrecovery_exit (tc);
1199
1200   ASSERT (tc->rto_boff == 0);
1201   ASSERT (!tcp_in_cong_recovery (tc));
1202   ASSERT (tcp_scoreboard_is_sane_post_recovery (tc));
1203   return 0;
1204 }
1205
1206 static void
1207 tcp_cc_update (tcp_connection_t * tc, vlib_buffer_t * b)
1208 {
1209   ASSERT (!tcp_in_cong_recovery (tc) || tcp_is_lost_fin (tc));
1210
1211   /* Congestion avoidance */
1212   tcp_cc_rcv_ack (tc);
1213
1214   /* If a cumulative ack, make sure dupacks is 0 */
1215   tc->rcv_dupacks = 0;
1216
1217   /* When dupacks hits the threshold we only enter fast retransmit if
1218    * cumulative ack covers more than snd_congestion. Should snd_una
1219    * wrap this test may fail under otherwise valid circumstances.
1220    * Therefore, proactively update snd_congestion when wrap detected. */
1221   if (PREDICT_FALSE
1222       (seq_leq (tc->snd_congestion, tc->snd_una - tc->bytes_acked)
1223        && seq_gt (tc->snd_congestion, tc->snd_una)))
1224     tc->snd_congestion = tc->snd_una - 1;
1225 }
1226
1227 static u8
1228 tcp_should_fastrecover_sack (tcp_connection_t * tc)
1229 {
1230   return (TCP_DUPACK_THRESHOLD - 1) * tc->snd_mss < tc->sack_sb.sacked_bytes;
1231 }
1232
1233 static u8
1234 tcp_should_fastrecover (tcp_connection_t * tc)
1235 {
1236   return (tc->rcv_dupacks == TCP_DUPACK_THRESHOLD
1237           || tcp_should_fastrecover_sack (tc));
1238 }
1239
1240 void
1241 tcp_program_fastretransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
1242 {
1243   if (!(tc->flags & TCP_CONN_FRXT_PENDING))
1244     {
1245       vec_add1 (wrk->pending_fast_rxt, tc->c_c_index);
1246       tc->flags |= TCP_CONN_FRXT_PENDING;
1247     }
1248 }
1249
1250 void
1251 tcp_do_fastretransmits (tcp_worker_ctx_t * wrk)
1252 {
1253   u32 *ongoing_fast_rxt, burst_bytes, sent_bytes, thread_index;
1254   u32 max_burst_size, burst_size, n_segs = 0, n_segs_now;
1255   tcp_connection_t *tc;
1256   u64 last_cpu_time;
1257   int i;
1258
1259   if (vec_len (wrk->pending_fast_rxt) == 0
1260       && vec_len (wrk->postponed_fast_rxt) == 0)
1261     return;
1262
1263   thread_index = wrk->vm->thread_index;
1264   last_cpu_time = wrk->vm->clib_time.last_cpu_time;
1265   ongoing_fast_rxt = wrk->ongoing_fast_rxt;
1266   vec_append (ongoing_fast_rxt, wrk->postponed_fast_rxt);
1267   vec_append (ongoing_fast_rxt, wrk->pending_fast_rxt);
1268
1269   _vec_len (wrk->postponed_fast_rxt) = 0;
1270   _vec_len (wrk->pending_fast_rxt) = 0;
1271
1272   max_burst_size = VLIB_FRAME_SIZE / vec_len (ongoing_fast_rxt);
1273   max_burst_size = clib_max (max_burst_size, 1);
1274
1275   for (i = 0; i < vec_len (ongoing_fast_rxt); i++)
1276     {
1277       if (n_segs >= VLIB_FRAME_SIZE)
1278         {
1279           vec_add1 (wrk->postponed_fast_rxt, ongoing_fast_rxt[i]);
1280           continue;
1281         }
1282
1283       tc = tcp_connection_get (ongoing_fast_rxt[i], thread_index);
1284       tc->flags &= ~TCP_CONN_FRXT_PENDING;
1285
1286       if (!tcp_in_fastrecovery (tc))
1287         continue;
1288
1289       burst_size = clib_min (max_burst_size, VLIB_FRAME_SIZE - n_segs);
1290       burst_bytes = transport_connection_tx_pacer_burst (&tc->connection,
1291                                                          last_cpu_time);
1292       burst_size = clib_min (burst_size, burst_bytes / tc->snd_mss);
1293       if (!burst_size)
1294         {
1295           tcp_program_fastretransmit (wrk, tc);
1296           continue;
1297         }
1298
1299       n_segs_now = tcp_fast_retransmit (wrk, tc, burst_size);
1300       sent_bytes = clib_min (n_segs_now * tc->snd_mss, burst_bytes);
1301       transport_connection_tx_pacer_update_bytes (&tc->connection,
1302                                                   sent_bytes);
1303       n_segs += n_segs_now;
1304     }
1305   _vec_len (ongoing_fast_rxt) = 0;
1306   wrk->ongoing_fast_rxt = ongoing_fast_rxt;
1307 }
1308
1309 /**
1310  * One function to rule them all ... and in the darkness bind them
1311  */
1312 static void
1313 tcp_cc_handle_event (tcp_connection_t * tc, u32 is_dack)
1314 {
1315   u32 rxt_delivered;
1316
1317   if (tcp_in_fastrecovery (tc) && tcp_opts_sack_permitted (&tc->rcv_opts))
1318     {
1319       if (tc->bytes_acked)
1320         goto partial_ack;
1321       tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index), tc);
1322       return;
1323     }
1324   /*
1325    * Duplicate ACK. Check if we should enter fast recovery, or if already in
1326    * it account for the bytes that left the network.
1327    */
1328   else if (is_dack && !tcp_in_recovery (tc))
1329     {
1330       TCP_EVT_DBG (TCP_EVT_DUPACK_RCVD, tc, 1);
1331       ASSERT (tc->snd_una != tc->snd_una_max
1332               || tc->sack_sb.last_sacked_bytes);
1333
1334       tc->rcv_dupacks++;
1335
1336       /* Pure duplicate ack. If some data got acked, it's handled lower */
1337       if (tc->rcv_dupacks > TCP_DUPACK_THRESHOLD && !tc->bytes_acked)
1338         {
1339           ASSERT (tcp_in_fastrecovery (tc));
1340           tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
1341           return;
1342         }
1343       else if (tcp_should_fastrecover (tc))
1344         {
1345           u32 pacer_wnd;
1346
1347           ASSERT (!tcp_in_fastrecovery (tc));
1348
1349           /* Heuristic to catch potential late dupacks
1350            * after fast retransmit exits */
1351           if (is_dack && tc->snd_una == tc->snd_congestion
1352               && timestamp_leq (tc->rcv_opts.tsecr, tc->tsecr_last_ack))
1353             {
1354               tc->rcv_dupacks = 0;
1355               return;
1356             }
1357
1358           tcp_cc_init_congestion (tc);
1359           tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
1360
1361           if (tcp_opts_sack_permitted (&tc->rcv_opts))
1362             {
1363               tc->cwnd = tc->ssthresh;
1364               scoreboard_init_high_rxt (&tc->sack_sb, tc->snd_una);
1365             }
1366           else
1367             {
1368               /* Post retransmit update cwnd to ssthresh and account for the
1369                * three segments that have left the network and should've been
1370                * buffered at the receiver XXX */
1371               tc->cwnd = tc->ssthresh + 3 * tc->snd_mss;
1372             }
1373
1374           /* Constrain rate until we get a partial ack */
1375           pacer_wnd = clib_max (0.1 * tc->cwnd, 2 * tc->snd_mss);
1376           tcp_connection_tx_pacer_reset (tc, pacer_wnd,
1377                                          0 /* start bucket */ );
1378           tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index),
1379                                       tc);
1380           return;
1381         }
1382       else if (!tc->bytes_acked
1383                || (tc->bytes_acked && !tcp_in_cong_recovery (tc)))
1384         {
1385           tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
1386           return;
1387         }
1388       else
1389         goto partial_ack;
1390     }
1391   /* Don't allow entry in fast recovery if still in recovery, for now */
1392   else if (0 && is_dack && tcp_in_recovery (tc))
1393     {
1394       /* If of of the two conditions lower hold, reset dupacks because
1395        * we're probably after timeout (RFC6582 heuristics).
1396        * If Cumulative ack does not cover more than congestion threshold,
1397        * and:
1398        * 1) The following doesn't hold: The congestion window is greater
1399        *    than SMSS bytes and the difference between highest_ack
1400        *    and prev_highest_ack is at most 4*SMSS bytes
1401        * 2) Echoed timestamp in the last non-dup ack does not equal the
1402        *    stored timestamp
1403        */
1404       if (seq_leq (tc->snd_una, tc->snd_congestion)
1405           && ((!(tc->cwnd > tc->snd_mss
1406                  && tc->bytes_acked <= 4 * tc->snd_mss))
1407               || (tc->rcv_opts.tsecr != tc->tsecr_last_ack)))
1408         {
1409           tc->rcv_dupacks = 0;
1410           return;
1411         }
1412     }
1413
1414   if (!tc->bytes_acked)
1415     return;
1416
1417 partial_ack:
1418   TCP_EVT_DBG (TCP_EVT_CC_PACK, tc);
1419
1420   /*
1421    * Legitimate ACK. 1) See if we can exit recovery
1422    */
1423
1424   /* Update the pacing rate. For the first partial ack we move from
1425    * the artificially constrained rate to the one after congestion */
1426   tcp_connection_tx_pacer_update (tc);
1427
1428   if (seq_geq (tc->snd_una, tc->snd_congestion))
1429     {
1430       tcp_retransmit_timer_update (tc);
1431
1432       /* If spurious return, we've already updated everything */
1433       if (tcp_cc_recover (tc))
1434         {
1435           tc->tsecr_last_ack = tc->rcv_opts.tsecr;
1436           return;
1437         }
1438
1439       tc->snd_nxt = tc->snd_una_max;
1440
1441       /* Treat as congestion avoidance ack */
1442       tcp_cc_rcv_ack (tc);
1443       return;
1444     }
1445
1446   /*
1447    * Legitimate ACK. 2) If PARTIAL ACK try to retransmit
1448    */
1449
1450   /* XXX limit this only to first partial ack? */
1451   tcp_retransmit_timer_update (tc);
1452
1453   /* RFC6675: If the incoming ACK is a cumulative acknowledgment,
1454    * reset dupacks to 0. Also needed if in congestion recovery */
1455   tc->rcv_dupacks = 0;
1456
1457   /* Post RTO timeout don't try anything fancy */
1458   if (tcp_in_recovery (tc))
1459     {
1460       tcp_cc_rcv_ack (tc);
1461       transport_add_tx_event (&tc->connection);
1462       return;
1463     }
1464
1465   /* Remove retransmitted bytes that have been delivered */
1466   if (tcp_opts_sack_permitted (&tc->rcv_opts))
1467     {
1468       ASSERT (tc->bytes_acked + tc->sack_sb.snd_una_adv
1469               >= tc->sack_sb.last_bytes_delivered
1470               || (tc->flags & TCP_CONN_FINSNT));
1471
1472       /* If we have sacks and we haven't gotten an ack beyond high_rxt,
1473        * remove sacked bytes delivered */
1474       if (seq_lt (tc->snd_una, tc->sack_sb.high_rxt))
1475         {
1476           rxt_delivered = tc->bytes_acked + tc->sack_sb.snd_una_adv
1477             - tc->sack_sb.last_bytes_delivered;
1478           ASSERT (tc->snd_rxt_bytes >= rxt_delivered);
1479           tc->snd_rxt_bytes -= rxt_delivered;
1480         }
1481       else
1482         {
1483           /* Apparently all retransmitted holes have been acked */
1484           tc->snd_rxt_bytes = 0;
1485           tc->sack_sb.high_rxt = tc->snd_una;
1486         }
1487     }
1488   else
1489     {
1490       tcp_fastrecovery_first_on (tc);
1491       /* Reuse last bytes delivered to track total bytes acked */
1492       tc->sack_sb.last_bytes_delivered += tc->bytes_acked;
1493       if (tc->snd_rxt_bytes > tc->bytes_acked)
1494         tc->snd_rxt_bytes -= tc->bytes_acked;
1495       else
1496         tc->snd_rxt_bytes = 0;
1497     }
1498
1499   tc->cc_algo->rcv_cong_ack (tc, TCP_CC_PARTIALACK);
1500
1501   /*
1502    * Since this was a partial ack, try to retransmit some more data
1503    */
1504   tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index), tc);
1505 }
1506
1507 /**
1508  * Process incoming ACK
1509  */
1510 static int
1511 tcp_rcv_ack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b,
1512              tcp_header_t * th, u32 * error)
1513 {
1514   u32 prev_snd_wnd, prev_snd_una;
1515   u8 is_dack;
1516
1517   TCP_EVT_DBG (TCP_EVT_CC_STAT, tc);
1518
1519   /* If the ACK acks something not yet sent (SEG.ACK > SND.NXT) */
1520   if (PREDICT_FALSE (seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt)))
1521     {
1522       /* When we entered recovery, we reset snd_nxt to snd_una. Seems peer
1523        * still has the data so accept the ack */
1524       if (tcp_in_recovery (tc)
1525           && seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_congestion))
1526         {
1527           tc->snd_nxt = vnet_buffer (b)->tcp.ack_number;
1528           if (seq_gt (tc->snd_nxt, tc->snd_una_max))
1529             tc->snd_una_max = tc->snd_nxt;
1530           goto process_ack;
1531         }
1532
1533       /* If we have outstanding data and this is within the window, accept it,
1534        * probably retransmit has timed out. Otherwise ACK segment and then
1535        * drop it */
1536       if (seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_una_max))
1537         {
1538           tcp_program_ack (wrk, tc);
1539           *error = TCP_ERROR_ACK_FUTURE;
1540           TCP_EVT_DBG (TCP_EVT_ACK_RCV_ERR, tc, 0,
1541                        vnet_buffer (b)->tcp.ack_number);
1542           return -1;
1543         }
1544
1545       TCP_EVT_DBG (TCP_EVT_ACK_RCV_ERR, tc, 2,
1546                    vnet_buffer (b)->tcp.ack_number);
1547
1548       tc->snd_nxt = vnet_buffer (b)->tcp.ack_number;
1549     }
1550
1551   /* If old ACK, probably it's an old dupack */
1552   if (PREDICT_FALSE (seq_lt (vnet_buffer (b)->tcp.ack_number, tc->snd_una)))
1553     {
1554       *error = TCP_ERROR_ACK_OLD;
1555       TCP_EVT_DBG (TCP_EVT_ACK_RCV_ERR, tc, 1,
1556                    vnet_buffer (b)->tcp.ack_number);
1557       if (tcp_in_fastrecovery (tc) && tc->rcv_dupacks == TCP_DUPACK_THRESHOLD)
1558         tcp_cc_handle_event (tc, 1);
1559       /* Don't drop yet */
1560       return 0;
1561     }
1562
1563   /*
1564    * Looks okay, process feedback
1565    */
1566 process_ack:
1567   if (tcp_opts_sack_permitted (&tc->rcv_opts))
1568     tcp_rcv_sacks (tc, vnet_buffer (b)->tcp.ack_number);
1569
1570   prev_snd_wnd = tc->snd_wnd;
1571   prev_snd_una = tc->snd_una;
1572   tcp_update_snd_wnd (tc, vnet_buffer (b)->tcp.seq_number,
1573                       vnet_buffer (b)->tcp.ack_number,
1574                       clib_net_to_host_u16 (th->window) << tc->snd_wscale);
1575   tc->bytes_acked = vnet_buffer (b)->tcp.ack_number - tc->snd_una;
1576   tc->snd_una = vnet_buffer (b)->tcp.ack_number + tc->sack_sb.snd_una_adv;
1577   tcp_validate_txf_size (tc, tc->bytes_acked);
1578
1579   if (tc->bytes_acked)
1580     {
1581       tcp_program_dequeue (wrk, tc);
1582       tcp_update_rtt (tc, vnet_buffer (b)->tcp.ack_number);
1583     }
1584
1585   TCP_EVT_DBG (TCP_EVT_ACK_RCVD, tc);
1586
1587   /*
1588    * Check if we have congestion event
1589    */
1590
1591   if (tcp_ack_is_cc_event (tc, b, prev_snd_wnd, prev_snd_una, &is_dack))
1592     {
1593       tcp_cc_handle_event (tc, is_dack);
1594       if (!tcp_in_cong_recovery (tc))
1595         return 0;
1596       *error = TCP_ERROR_ACK_DUP;
1597       if (vnet_buffer (b)->tcp.data_len || tcp_is_fin (th))
1598         return 0;
1599       return -1;
1600     }
1601
1602   /*
1603    * Update congestion control (slow start/congestion avoidance)
1604    */
1605   tcp_cc_update (tc, b);
1606   *error = TCP_ERROR_ACK_OK;
1607   return 0;
1608 }
1609
1610 static void
1611 tcp_program_disconnect (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
1612 {
1613   if (!tcp_disconnect_pending (tc))
1614     {
1615       vec_add1 (wrk->pending_disconnects, tc->c_c_index);
1616       tcp_disconnect_pending_on (tc);
1617     }
1618 }
1619
1620 static void
1621 tcp_handle_disconnects (tcp_worker_ctx_t * wrk)
1622 {
1623   u32 thread_index, *pending_disconnects;
1624   tcp_connection_t *tc;
1625   int i;
1626
1627   if (!vec_len (wrk->pending_disconnects))
1628     return;
1629
1630   thread_index = wrk->vm->thread_index;
1631   pending_disconnects = wrk->pending_disconnects;
1632   for (i = 0; i < vec_len (pending_disconnects); i++)
1633     {
1634       tc = tcp_connection_get (pending_disconnects[i], thread_index);
1635       tcp_disconnect_pending_off (tc);
1636       stream_session_disconnect_notify (&tc->connection);
1637     }
1638   _vec_len (wrk->pending_disconnects) = 0;
1639 }
1640
1641 static void
1642 tcp_rcv_fin (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b,
1643              u32 * error)
1644 {
1645   /* Enter CLOSE-WAIT and notify session. To avoid lingering
1646    * in CLOSE-WAIT, set timer (reuse WAITCLOSE). */
1647   /* Account for the FIN if nothing else was received */
1648   if (vnet_buffer (b)->tcp.data_len == 0)
1649     tc->rcv_nxt += 1;
1650   tcp_program_ack (wrk, tc);
1651   tc->state = TCP_STATE_CLOSE_WAIT;
1652   tcp_program_disconnect (wrk, tc);
1653   tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
1654   TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc);
1655   *error = TCP_ERROR_FIN_RCVD;
1656 }
1657
1658 static u8
1659 tcp_sack_vector_is_sane (sack_block_t * sacks)
1660 {
1661   int i;
1662   for (i = 1; i < vec_len (sacks); i++)
1663     {
1664       if (sacks[i - 1].end == sacks[i].start)
1665         return 0;
1666     }
1667   return 1;
1668 }
1669
1670 /**
1671  * Build SACK list as per RFC2018.
1672  *
1673  * Makes sure the first block contains the segment that generated the current
1674  * ACK and the following ones are the ones most recently reported in SACK
1675  * blocks.
1676  *
1677  * @param tc TCP connection for which the SACK list is updated
1678  * @param start Start sequence number of the newest SACK block
1679  * @param end End sequence of the newest SACK block
1680  */
1681 void
1682 tcp_update_sack_list (tcp_connection_t * tc, u32 start, u32 end)
1683 {
1684   sack_block_t *new_list = 0, *block = 0;
1685   int i;
1686
1687   /* If the first segment is ooo add it to the list. Last write might've moved
1688    * rcv_nxt over the first segment. */
1689   if (seq_lt (tc->rcv_nxt, start))
1690     {
1691       vec_add2 (new_list, block, 1);
1692       block->start = start;
1693       block->end = end;
1694     }
1695
1696   /* Find the blocks still worth keeping. */
1697   for (i = 0; i < vec_len (tc->snd_sacks); i++)
1698     {
1699       /* Discard if rcv_nxt advanced beyond current block */
1700       if (seq_leq (tc->snd_sacks[i].start, tc->rcv_nxt))
1701         continue;
1702
1703       /* Merge or drop if segment overlapped by the new segment */
1704       if (block && (seq_geq (tc->snd_sacks[i].end, new_list[0].start)
1705                     && seq_leq (tc->snd_sacks[i].start, new_list[0].end)))
1706         {
1707           if (seq_lt (tc->snd_sacks[i].start, new_list[0].start))
1708             new_list[0].start = tc->snd_sacks[i].start;
1709           if (seq_lt (new_list[0].end, tc->snd_sacks[i].end))
1710             new_list[0].end = tc->snd_sacks[i].end;
1711           continue;
1712         }
1713
1714       /* Save to new SACK list if we have space. */
1715       if (vec_len (new_list) < TCP_MAX_SACK_BLOCKS)
1716         {
1717           vec_add1 (new_list, tc->snd_sacks[i]);
1718         }
1719       else
1720         {
1721           clib_warning ("sack discarded");
1722         }
1723     }
1724
1725   ASSERT (vec_len (new_list) <= TCP_MAX_SACK_BLOCKS);
1726
1727   /* Replace old vector with new one */
1728   vec_free (tc->snd_sacks);
1729   tc->snd_sacks = new_list;
1730
1731   /* Segments should not 'touch' */
1732   ASSERT (tcp_sack_vector_is_sane (tc->snd_sacks));
1733 }
1734
1735 u32
1736 tcp_sack_list_bytes (tcp_connection_t * tc)
1737 {
1738   u32 bytes = 0, i;
1739   for (i = 0; i < vec_len (tc->snd_sacks); i++)
1740     bytes += tc->snd_sacks[i].end - tc->snd_sacks[i].start;
1741   return bytes;
1742 }
1743
1744 /** Enqueue data for delivery to application */
1745 static int
1746 tcp_session_enqueue_data (tcp_connection_t * tc, vlib_buffer_t * b,
1747                           u16 data_len)
1748 {
1749   int written, error = TCP_ERROR_ENQUEUED;
1750
1751   ASSERT (seq_geq (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt));
1752   ASSERT (data_len);
1753   written = session_enqueue_stream_connection (&tc->connection, b, 0,
1754                                                1 /* queue event */ , 1);
1755
1756   TCP_EVT_DBG (TCP_EVT_INPUT, tc, 0, data_len, written);
1757
1758   /* Update rcv_nxt */
1759   if (PREDICT_TRUE (written == data_len))
1760     {
1761       tc->rcv_nxt += written;
1762     }
1763   /* If more data written than expected, account for out-of-order bytes. */
1764   else if (written > data_len)
1765     {
1766       tc->rcv_nxt += written;
1767       TCP_EVT_DBG (TCP_EVT_CC_INPUT, tc, data_len, written);
1768     }
1769   else if (written > 0)
1770     {
1771       /* We've written something but FIFO is probably full now */
1772       tc->rcv_nxt += written;
1773       error = TCP_ERROR_PARTIALLY_ENQUEUED;
1774     }
1775   else
1776     {
1777       return TCP_ERROR_FIFO_FULL;
1778     }
1779
1780   /* Update SACK list if need be */
1781   if (tcp_opts_sack_permitted (&tc->rcv_opts))
1782     {
1783       /* Remove SACK blocks that have been delivered */
1784       tcp_update_sack_list (tc, tc->rcv_nxt, tc->rcv_nxt);
1785     }
1786
1787   return error;
1788 }
1789
1790 /** Enqueue out-of-order data */
1791 static int
1792 tcp_session_enqueue_ooo (tcp_connection_t * tc, vlib_buffer_t * b,
1793                          u16 data_len)
1794 {
1795   stream_session_t *s0;
1796   int rv, offset;
1797
1798   ASSERT (seq_gt (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt));
1799   ASSERT (data_len);
1800
1801   /* Enqueue out-of-order data with relative offset */
1802   rv = session_enqueue_stream_connection (&tc->connection, b,
1803                                           vnet_buffer (b)->tcp.seq_number -
1804                                           tc->rcv_nxt, 0 /* queue event */ ,
1805                                           0);
1806
1807   /* Nothing written */
1808   if (rv)
1809     {
1810       TCP_EVT_DBG (TCP_EVT_INPUT, tc, 1, data_len, 0);
1811       return TCP_ERROR_FIFO_FULL;
1812     }
1813
1814   TCP_EVT_DBG (TCP_EVT_INPUT, tc, 1, data_len, data_len);
1815
1816   /* Update SACK list if in use */
1817   if (tcp_opts_sack_permitted (&tc->rcv_opts))
1818     {
1819       ooo_segment_t *newest;
1820       u32 start, end;
1821
1822       s0 = session_get (tc->c_s_index, tc->c_thread_index);
1823
1824       /* Get the newest segment from the fifo */
1825       newest = svm_fifo_newest_ooo_segment (s0->server_rx_fifo);
1826       if (newest)
1827         {
1828           offset = ooo_segment_offset (s0->server_rx_fifo, newest);
1829           ASSERT (offset <= vnet_buffer (b)->tcp.seq_number - tc->rcv_nxt);
1830           start = tc->rcv_nxt + offset;
1831           end = start + ooo_segment_length (s0->server_rx_fifo, newest);
1832           tcp_update_sack_list (tc, start, end);
1833           svm_fifo_newest_ooo_segment_reset (s0->server_rx_fifo);
1834           TCP_EVT_DBG (TCP_EVT_CC_SACKS, tc);
1835         }
1836     }
1837
1838   return TCP_ERROR_ENQUEUED_OOO;
1839 }
1840
1841 /**
1842  * Check if ACK could be delayed. If ack can be delayed, it should return
1843  * true for a full frame. If we're always acking return 0.
1844  */
1845 always_inline int
1846 tcp_can_delack (tcp_connection_t * tc)
1847 {
1848   /* Send ack if ... */
1849   if (TCP_ALWAYS_ACK
1850       /* just sent a rcv wnd 0 */
1851       || (tc->flags & TCP_CONN_SENT_RCV_WND0) != 0
1852       /* constrained to send ack */
1853       || (tc->flags & TCP_CONN_SNDACK) != 0
1854       /* we're almost out of tx wnd */
1855       || tcp_available_cc_snd_space (tc) < 4 * tc->snd_mss)
1856     return 0;
1857
1858   return 1;
1859 }
1860
1861 static int
1862 tcp_buffer_discard_bytes (vlib_buffer_t * b, u32 n_bytes_to_drop)
1863 {
1864   u32 discard, first = b->current_length;
1865   vlib_main_t *vm = vlib_get_main ();
1866
1867   /* Handle multi-buffer segments */
1868   if (n_bytes_to_drop > b->current_length)
1869     {
1870       if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
1871         return -1;
1872       do
1873         {
1874           discard = clib_min (n_bytes_to_drop, b->current_length);
1875           vlib_buffer_advance (b, discard);
1876           b = vlib_get_buffer (vm, b->next_buffer);
1877           n_bytes_to_drop -= discard;
1878         }
1879       while (n_bytes_to_drop);
1880       if (n_bytes_to_drop > first)
1881         b->total_length_not_including_first_buffer -= n_bytes_to_drop - first;
1882     }
1883   else
1884     vlib_buffer_advance (b, n_bytes_to_drop);
1885   vnet_buffer (b)->tcp.data_len -= n_bytes_to_drop;
1886   return 0;
1887 }
1888
1889 /**
1890  * Receive buffer for connection and handle acks
1891  *
1892  * It handles both in order or out-of-order data.
1893  */
1894 static int
1895 tcp_segment_rcv (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
1896                  vlib_buffer_t * b)
1897 {
1898   u32 error, n_bytes_to_drop, n_data_bytes;
1899
1900   vlib_buffer_advance (b, vnet_buffer (b)->tcp.data_offset);
1901   n_data_bytes = vnet_buffer (b)->tcp.data_len;
1902   ASSERT (n_data_bytes);
1903
1904   /* Handle out-of-order data */
1905   if (PREDICT_FALSE (vnet_buffer (b)->tcp.seq_number != tc->rcv_nxt))
1906     {
1907       /* Old sequence numbers allowed through because they overlapped
1908        * the rx window */
1909       if (seq_lt (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt))
1910         {
1911           /* Completely in the past (possible retransmit). Ack
1912            * retransmissions since we may not have any data to send */
1913           if (seq_leq (vnet_buffer (b)->tcp.seq_end, tc->rcv_nxt))
1914             {
1915               tcp_program_ack (wrk, tc);
1916               error = TCP_ERROR_SEGMENT_OLD;
1917               goto done;
1918             }
1919
1920           /* Chop off the bytes in the past and see if what is left
1921            * can be enqueued in order */
1922           n_bytes_to_drop = tc->rcv_nxt - vnet_buffer (b)->tcp.seq_number;
1923           n_data_bytes -= n_bytes_to_drop;
1924           vnet_buffer (b)->tcp.seq_number = tc->rcv_nxt;
1925           if (tcp_buffer_discard_bytes (b, n_bytes_to_drop))
1926             {
1927               error = TCP_ERROR_SEGMENT_OLD;
1928               goto done;
1929             }
1930           goto in_order;
1931         }
1932
1933       /* RFC2581: Enqueue and send DUPACK for fast retransmit */
1934       error = tcp_session_enqueue_ooo (tc, b, n_data_bytes);
1935       tcp_program_dupack (wrk, tc);
1936       TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc, vnet_buffer (b)->tcp);
1937       goto done;
1938     }
1939
1940 in_order:
1941
1942   /* In order data, enqueue. Fifo figures out by itself if any out-of-order
1943    * segments can be enqueued after fifo tail offset changes. */
1944   error = tcp_session_enqueue_data (tc, b, n_data_bytes);
1945   if (tcp_can_delack (tc))
1946     {
1947       if (!tcp_timer_is_active (tc, TCP_TIMER_DELACK))
1948         tcp_timer_set (tc, TCP_TIMER_DELACK, TCP_DELACK_TIME);
1949       goto done;
1950     }
1951
1952   tcp_program_ack (wrk, tc);
1953
1954 done:
1955   return error;
1956 }
1957
1958 typedef struct
1959 {
1960   tcp_header_t tcp_header;
1961   tcp_connection_t tcp_connection;
1962 } tcp_rx_trace_t;
1963
1964 static u8 *
1965 format_tcp_rx_trace (u8 * s, va_list * args)
1966 {
1967   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1968   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1969   tcp_rx_trace_t *t = va_arg (*args, tcp_rx_trace_t *);
1970   u32 indent = format_get_indent (s);
1971
1972   s = format (s, "%U\n%U%U",
1973               format_tcp_header, &t->tcp_header, 128,
1974               format_white_space, indent,
1975               format_tcp_connection, &t->tcp_connection, 1);
1976
1977   return s;
1978 }
1979
1980 static u8 *
1981 format_tcp_rx_trace_short (u8 * s, va_list * args)
1982 {
1983   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1984   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1985   tcp_rx_trace_t *t = va_arg (*args, tcp_rx_trace_t *);
1986
1987   s = format (s, "%d -> %d (%U)",
1988               clib_net_to_host_u16 (t->tcp_header.dst_port),
1989               clib_net_to_host_u16 (t->tcp_header.src_port), format_tcp_state,
1990               t->tcp_connection.state);
1991
1992   return s;
1993 }
1994
1995 static void
1996 tcp_set_rx_trace_data (tcp_rx_trace_t * t0, tcp_connection_t * tc0,
1997                        tcp_header_t * th0, vlib_buffer_t * b0, u8 is_ip4)
1998 {
1999   if (tc0)
2000     {
2001       clib_memcpy_fast (&t0->tcp_connection, tc0,
2002                         sizeof (t0->tcp_connection));
2003     }
2004   else
2005     {
2006       th0 = tcp_buffer_hdr (b0);
2007     }
2008   clib_memcpy_fast (&t0->tcp_header, th0, sizeof (t0->tcp_header));
2009 }
2010
2011 static void
2012 tcp_established_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
2013                              vlib_frame_t * frame, u8 is_ip4)
2014 {
2015   u32 *from, n_left;
2016
2017   n_left = frame->n_vectors;
2018   from = vlib_frame_vector_args (frame);
2019
2020   while (n_left >= 1)
2021     {
2022       tcp_connection_t *tc0;
2023       tcp_rx_trace_t *t0;
2024       tcp_header_t *th0;
2025       vlib_buffer_t *b0;
2026       u32 bi0;
2027
2028       bi0 = from[0];
2029       b0 = vlib_get_buffer (vm, bi0);
2030
2031       if (b0->flags & VLIB_BUFFER_IS_TRACED)
2032         {
2033           t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2034           tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index,
2035                                     vm->thread_index);
2036           th0 = tcp_buffer_hdr (b0);
2037           tcp_set_rx_trace_data (t0, tc0, th0, b0, is_ip4);
2038         }
2039
2040       from += 1;
2041       n_left -= 1;
2042     }
2043 }
2044
2045 always_inline void
2046 tcp_node_inc_counter_i (vlib_main_t * vm, u32 tcp4_node, u32 tcp6_node,
2047                         u8 is_ip4, u32 evt, u32 val)
2048 {
2049   if (is_ip4)
2050     vlib_node_increment_counter (vm, tcp4_node, evt, val);
2051   else
2052     vlib_node_increment_counter (vm, tcp6_node, evt, val);
2053 }
2054
2055 #define tcp_maybe_inc_counter(node_id, err, count)                      \
2056 {                                                                       \
2057   if (next0 != tcp_next_drop (is_ip4))                                  \
2058     tcp_node_inc_counter_i (vm, tcp4_##node_id##_node.index,            \
2059                             tcp6_##node_id##_node.index, is_ip4, err,   \
2060                             1);                                         \
2061 }
2062 #define tcp_inc_counter(node_id, err, count)                            \
2063   tcp_node_inc_counter_i (vm, tcp4_##node_id##_node.index,              \
2064                            tcp6_##node_id##_node.index, is_ip4,         \
2065                            err, count)
2066 #define tcp_maybe_inc_err_counter(cnts, err)                            \
2067 {                                                                       \
2068   cnts[err] += (next0 != tcp_next_drop (is_ip4));                       \
2069 }
2070 #define tcp_inc_err_counter(cnts, err, val)                             \
2071 {                                                                       \
2072   cnts[err] += val;                                                     \
2073 }
2074 #define tcp_store_err_counters(node_id, cnts)                           \
2075 {                                                                       \
2076   int i;                                                                \
2077   for (i = 0; i < TCP_N_ERROR; i++)                                     \
2078     if (cnts[i])                                                        \
2079       tcp_inc_counter(node_id, i, cnts[i]);                             \
2080 }
2081
2082
2083 always_inline uword
2084 tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2085                           vlib_frame_t * frame, int is_ip4)
2086 {
2087   u32 thread_index = vm->thread_index, errors = 0;
2088   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
2089   u32 n_left_from, *from, *first_buffer;
2090   u16 err_counters[TCP_N_ERROR] = { 0 };
2091   u8 is_fin = 0;
2092
2093   if (node->flags & VLIB_NODE_FLAG_TRACE)
2094     tcp_established_trace_frame (vm, node, frame, is_ip4);
2095
2096   first_buffer = from = vlib_frame_vector_args (frame);
2097   n_left_from = frame->n_vectors;
2098
2099   while (n_left_from > 0)
2100     {
2101       u32 bi0, error0 = TCP_ERROR_ACK_OK;
2102       vlib_buffer_t *b0;
2103       tcp_header_t *th0 = 0;
2104       tcp_connection_t *tc0;
2105
2106       if (n_left_from > 1)
2107         {
2108           vlib_buffer_t *pb;
2109           pb = vlib_get_buffer (vm, from[1]);
2110           vlib_prefetch_buffer_header (pb, LOAD);
2111           CLIB_PREFETCH (pb->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
2112         }
2113
2114       bi0 = from[0];
2115       from += 1;
2116       n_left_from -= 1;
2117
2118       b0 = vlib_get_buffer (vm, bi0);
2119       tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index,
2120                                 thread_index);
2121
2122       if (PREDICT_FALSE (tc0 == 0))
2123         {
2124           error0 = TCP_ERROR_INVALID_CONNECTION;
2125           goto done;
2126         }
2127
2128       th0 = tcp_buffer_hdr (b0);
2129       /* N.B. buffer is rewritten if segment is ooo. Thus, th0 becomes a
2130        * dangling reference. */
2131       is_fin = tcp_is_fin (th0);
2132
2133       /* SYNs, FINs and data consume sequence numbers */
2134       vnet_buffer (b0)->tcp.seq_end = vnet_buffer (b0)->tcp.seq_number
2135         + tcp_is_syn (th0) + is_fin + vnet_buffer (b0)->tcp.data_len;
2136
2137       /* TODO header prediction fast path */
2138
2139       /* 1-4: check SEQ, RST, SYN */
2140       if (PREDICT_FALSE (tcp_segment_validate (wrk, tc0, b0, th0, &error0)))
2141         {
2142           TCP_EVT_DBG (TCP_EVT_SEG_INVALID, tc0, vnet_buffer (b0)->tcp);
2143           goto done;
2144         }
2145
2146       /* 5: check the ACK field  */
2147       if (PREDICT_FALSE (tcp_rcv_ack (wrk, tc0, b0, th0, &error0)))
2148         goto done;
2149
2150       /* 6: check the URG bit TODO */
2151
2152       /* 7: process the segment text */
2153       if (vnet_buffer (b0)->tcp.data_len)
2154         error0 = tcp_segment_rcv (wrk, tc0, b0);
2155
2156       /* 8: check the FIN bit */
2157       if (PREDICT_FALSE (is_fin))
2158         tcp_rcv_fin (wrk, tc0, b0, &error0);
2159
2160     done:
2161       tcp_inc_err_counter (err_counters, error0, 1);
2162     }
2163
2164   errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_TCP,
2165                                                  thread_index);
2166   err_counters[TCP_ERROR_EVENT_FIFO_FULL] = errors;
2167   tcp_store_err_counters (established, err_counters);
2168   tcp_handle_postponed_dequeues (wrk);
2169   tcp_handle_disconnects (wrk);
2170   vlib_buffer_free (vm, first_buffer, frame->n_vectors);
2171
2172   return frame->n_vectors;
2173 }
2174
2175 static uword
2176 tcp4_established (vlib_main_t * vm, vlib_node_runtime_t * node,
2177                   vlib_frame_t * from_frame)
2178 {
2179   return tcp46_established_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2180 }
2181
2182 static uword
2183 tcp6_established (vlib_main_t * vm, vlib_node_runtime_t * node,
2184                   vlib_frame_t * from_frame)
2185 {
2186   return tcp46_established_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2187 }
2188
2189 /* *INDENT-OFF* */
2190 VLIB_REGISTER_NODE (tcp4_established_node) =
2191 {
2192   .function = tcp4_established,
2193   .name = "tcp4-established",
2194   /* Takes a vector of packets. */
2195   .vector_size = sizeof (u32),
2196   .n_errors = TCP_N_ERROR,
2197   .error_strings = tcp_error_strings,
2198   .n_next_nodes = TCP_ESTABLISHED_N_NEXT,
2199   .next_nodes =
2200   {
2201 #define _(s,n) [TCP_ESTABLISHED_NEXT_##s] = n,
2202     foreach_tcp_state_next
2203 #undef _
2204   },
2205   .format_trace = format_tcp_rx_trace_short,
2206 };
2207 /* *INDENT-ON* */
2208
2209 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_established_node, tcp4_established);
2210
2211 /* *INDENT-OFF* */
2212 VLIB_REGISTER_NODE (tcp6_established_node) =
2213 {
2214   .function = tcp6_established,
2215   .name = "tcp6-established",
2216   /* Takes a vector of packets. */
2217   .vector_size = sizeof (u32),
2218   .n_errors = TCP_N_ERROR,
2219   .error_strings = tcp_error_strings,
2220   .n_next_nodes = TCP_ESTABLISHED_N_NEXT,
2221   .next_nodes =
2222   {
2223 #define _(s,n) [TCP_ESTABLISHED_NEXT_##s] = n,
2224     foreach_tcp_state_next
2225 #undef _
2226   },
2227   .format_trace = format_tcp_rx_trace_short,
2228 };
2229 /* *INDENT-ON* */
2230
2231
2232 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_established_node, tcp6_established);
2233
2234 vlib_node_registration_t tcp4_syn_sent_node;
2235 vlib_node_registration_t tcp6_syn_sent_node;
2236
2237 static u8
2238 tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr)
2239 {
2240   transport_connection_t *tmp = 0;
2241   u64 handle;
2242
2243   if (!tc)
2244     return 1;
2245
2246   /* Proxy case */
2247   if (tc->c_lcl_port == 0 && tc->state == TCP_STATE_LISTEN)
2248     return 1;
2249
2250   u8 is_valid = (tc->c_lcl_port == hdr->dst_port
2251                  && (tc->state == TCP_STATE_LISTEN
2252                      || tc->c_rmt_port == hdr->src_port));
2253
2254   if (!is_valid)
2255     {
2256       handle = session_lookup_half_open_handle (&tc->connection);
2257       tmp = session_lookup_half_open_connection (handle & 0xFFFFFFFF,
2258                                                  tc->c_proto, tc->c_is_ip4);
2259
2260       if (tmp)
2261         {
2262           if (tmp->lcl_port == hdr->dst_port
2263               && tmp->rmt_port == hdr->src_port)
2264             {
2265               TCP_DBG ("half-open is valid!");
2266             }
2267         }
2268     }
2269   return is_valid;
2270 }
2271
2272 /**
2273  * Lookup transport connection
2274  */
2275 static tcp_connection_t *
2276 tcp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index,
2277                        u8 is_ip4)
2278 {
2279   tcp_header_t *tcp;
2280   transport_connection_t *tconn;
2281   tcp_connection_t *tc;
2282   u8 is_filtered = 0;
2283   if (is_ip4)
2284     {
2285       ip4_header_t *ip4;
2286       ip4 = vlib_buffer_get_current (b);
2287       tcp = ip4_next_header (ip4);
2288       tconn = session_lookup_connection_wt4 (fib_index,
2289                                              &ip4->dst_address,
2290                                              &ip4->src_address,
2291                                              tcp->dst_port,
2292                                              tcp->src_port,
2293                                              TRANSPORT_PROTO_TCP,
2294                                              thread_index, &is_filtered);
2295       tc = tcp_get_connection_from_transport (tconn);
2296       ASSERT (tcp_lookup_is_valid (tc, tcp));
2297     }
2298   else
2299     {
2300       ip6_header_t *ip6;
2301       ip6 = vlib_buffer_get_current (b);
2302       tcp = ip6_next_header (ip6);
2303       tconn = session_lookup_connection_wt6 (fib_index,
2304                                              &ip6->dst_address,
2305                                              &ip6->src_address,
2306                                              tcp->dst_port,
2307                                              tcp->src_port,
2308                                              TRANSPORT_PROTO_TCP,
2309                                              thread_index, &is_filtered);
2310       tc = tcp_get_connection_from_transport (tconn);
2311       ASSERT (tcp_lookup_is_valid (tc, tcp));
2312     }
2313   return tc;
2314 }
2315
2316 always_inline uword
2317 tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2318                        vlib_frame_t * from_frame, int is_ip4)
2319 {
2320   tcp_main_t *tm = vnet_get_tcp_main ();
2321   u32 n_left_from, *from, *first_buffer, errors = 0;
2322   u32 my_thread_index = vm->thread_index;
2323   tcp_worker_ctx_t *wrk = tcp_get_worker (my_thread_index);
2324
2325   from = first_buffer = vlib_frame_vector_args (from_frame);
2326   n_left_from = from_frame->n_vectors;
2327
2328   while (n_left_from > 0)
2329     {
2330       u32 bi0, ack0, seq0, error0 = TCP_ERROR_NONE;
2331       tcp_connection_t *tc0, *new_tc0;
2332       tcp_header_t *tcp0 = 0;
2333       tcp_rx_trace_t *t0;
2334       vlib_buffer_t *b0;
2335
2336       bi0 = from[0];
2337       from += 1;
2338       n_left_from -= 1;
2339
2340       b0 = vlib_get_buffer (vm, bi0);
2341       tc0 =
2342         tcp_half_open_connection_get (vnet_buffer (b0)->tcp.connection_index);
2343       if (PREDICT_FALSE (tc0 == 0))
2344         {
2345           error0 = TCP_ERROR_INVALID_CONNECTION;
2346           goto drop;
2347         }
2348
2349       /* Half-open completed recently but the connection was't removed
2350        * yet by the owning thread */
2351       if (PREDICT_FALSE (tc0->flags & TCP_CONN_HALF_OPEN_DONE))
2352         {
2353           /* Make sure the connection actually exists */
2354           ASSERT (tcp_lookup_connection (tc0->c_fib_index, b0,
2355                                          my_thread_index, is_ip4));
2356           goto drop;
2357         }
2358
2359       ack0 = vnet_buffer (b0)->tcp.ack_number;
2360       seq0 = vnet_buffer (b0)->tcp.seq_number;
2361       tcp0 = tcp_buffer_hdr (b0);
2362
2363       /* Crude check to see if the connection handle does not match
2364        * the packet. Probably connection just switched to established */
2365       if (PREDICT_FALSE (tcp0->dst_port != tc0->c_lcl_port
2366                          || tcp0->src_port != tc0->c_rmt_port))
2367         {
2368           error0 = TCP_ERROR_INVALID_CONNECTION;
2369           goto drop;
2370         }
2371
2372       if (PREDICT_FALSE (!tcp_ack (tcp0) && !tcp_rst (tcp0)
2373                          && !tcp_syn (tcp0)))
2374         {
2375           error0 = TCP_ERROR_SEGMENT_INVALID;
2376           goto drop;
2377         }
2378
2379       /* SYNs, FINs and data consume sequence numbers */
2380       vnet_buffer (b0)->tcp.seq_end =
2381         seq0 + tcp_is_syn (tcp0) + tcp_is_fin (tcp0) +
2382         vnet_buffer (b0)->tcp.data_len;
2383
2384       /*
2385        *  1. check the ACK bit
2386        */
2387
2388       /*
2389        *   If the ACK bit is set
2390        *     If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send a reset (unless
2391        *     the RST bit is set, if so drop the segment and return)
2392        *       <SEQ=SEG.ACK><CTL=RST>
2393        *     and discard the segment.  Return.
2394        *     If SND.UNA =< SEG.ACK =< SND.NXT then the ACK is acceptable.
2395        */
2396       if (tcp_ack (tcp0))
2397         {
2398           if (seq_leq (ack0, tc0->iss) || seq_gt (ack0, tc0->snd_nxt))
2399             {
2400               if (!tcp_rst (tcp0))
2401                 tcp_send_reset_w_pkt (tc0, b0, is_ip4);
2402               error0 = TCP_ERROR_RCV_WND;
2403               goto drop;
2404             }
2405
2406           /* Make sure ACK is valid */
2407           if (seq_gt (tc0->snd_una, ack0))
2408             {
2409               error0 = TCP_ERROR_ACK_INVALID;
2410               goto drop;
2411             }
2412         }
2413
2414       /*
2415        * 2. check the RST bit
2416        */
2417
2418       if (tcp_rst (tcp0))
2419         {
2420           /* If ACK is acceptable, signal client that peer is not
2421            * willing to accept connection and drop connection*/
2422           if (tcp_ack (tcp0))
2423             tcp_connection_reset (tc0);
2424           error0 = TCP_ERROR_RST_RCVD;
2425           goto drop;
2426         }
2427
2428       /*
2429        * 3. check the security and precedence (skipped)
2430        */
2431
2432       /*
2433        * 4. check the SYN bit
2434        */
2435
2436       /* No SYN flag. Drop. */
2437       if (!tcp_syn (tcp0))
2438         {
2439           clib_warning ("not synack");
2440           error0 = TCP_ERROR_SEGMENT_INVALID;
2441           goto drop;
2442         }
2443
2444       /* Parse options */
2445       if (tcp_options_parse (tcp0, &tc0->rcv_opts, 1))
2446         {
2447           clib_warning ("options parse fail");
2448           error0 = TCP_ERROR_OPTIONS;
2449           goto drop;
2450         }
2451
2452       /* Valid SYN or SYN-ACK. Move connection from half-open pool to
2453        * current thread pool. */
2454       pool_get (tm->connections[my_thread_index], new_tc0);
2455       clib_memcpy_fast (new_tc0, tc0, sizeof (*new_tc0));
2456       new_tc0->c_c_index = new_tc0 - tm->connections[my_thread_index];
2457       new_tc0->c_thread_index = my_thread_index;
2458       new_tc0->rcv_nxt = vnet_buffer (b0)->tcp.seq_end;
2459       new_tc0->irs = seq0;
2460       new_tc0->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
2461       new_tc0->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID;
2462       new_tc0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
2463
2464       /* If this is not the owning thread, wait for syn retransmit to
2465        * expire and cleanup then */
2466       if (tcp_half_open_connection_cleanup (tc0))
2467         tc0->flags |= TCP_CONN_HALF_OPEN_DONE;
2468
2469       if (tcp_opts_tstamp (&new_tc0->rcv_opts))
2470         {
2471           new_tc0->tsval_recent = new_tc0->rcv_opts.tsval;
2472           new_tc0->tsval_recent_age = tcp_time_now ();
2473         }
2474
2475       if (tcp_opts_wscale (&new_tc0->rcv_opts))
2476         new_tc0->snd_wscale = new_tc0->rcv_opts.wscale;
2477
2478       new_tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window)
2479         << new_tc0->snd_wscale;
2480       new_tc0->snd_wl1 = seq0;
2481       new_tc0->snd_wl2 = ack0;
2482
2483       tcp_connection_init_vars (new_tc0);
2484
2485       /* SYN-ACK: See if we can switch to ESTABLISHED state */
2486       if (PREDICT_TRUE (tcp_ack (tcp0)))
2487         {
2488           /* Our SYN is ACKed: we have iss < ack = snd_una */
2489
2490           /* TODO Dequeue acknowledged segments if we support Fast Open */
2491           new_tc0->snd_una = ack0;
2492           new_tc0->state = TCP_STATE_ESTABLISHED;
2493
2494           /* Make sure las is initialized for the wnd computation */
2495           new_tc0->rcv_las = new_tc0->rcv_nxt;
2496
2497           /* Notify app that we have connection. If session layer can't
2498            * allocate session send reset */
2499           if (session_stream_connect_notify (&new_tc0->connection, 0))
2500             {
2501               clib_warning ("connect notify fail");
2502               tcp_send_reset_w_pkt (new_tc0, b0, is_ip4);
2503               tcp_connection_cleanup (new_tc0);
2504               goto drop;
2505             }
2506
2507           new_tc0->tx_fifo_size =
2508             transport_tx_fifo_size (&new_tc0->connection);
2509           /* Update rtt with the syn-ack sample */
2510           tcp_estimate_initial_rtt (new_tc0);
2511           TCP_EVT_DBG (TCP_EVT_SYNACK_RCVD, new_tc0);
2512           error0 = TCP_ERROR_SYN_ACKS_RCVD;
2513         }
2514       /* SYN: Simultaneous open. Change state to SYN-RCVD and send SYN-ACK */
2515       else
2516         {
2517           new_tc0->state = TCP_STATE_SYN_RCVD;
2518
2519           /* Notify app that we have connection */
2520           if (session_stream_connect_notify (&new_tc0->connection, 0))
2521             {
2522               tcp_connection_cleanup (new_tc0);
2523               tcp_send_reset_w_pkt (tc0, b0, is_ip4);
2524               TCP_EVT_DBG (TCP_EVT_RST_SENT, tc0);
2525               goto drop;
2526             }
2527
2528           new_tc0->tx_fifo_size =
2529             transport_tx_fifo_size (&new_tc0->connection);
2530           new_tc0->rtt_ts = 0;
2531           tcp_init_snd_vars (new_tc0);
2532           tcp_send_synack (new_tc0);
2533           error0 = TCP_ERROR_SYNS_RCVD;
2534           goto drop;
2535         }
2536
2537       /* Read data, if any */
2538       if (PREDICT_FALSE (vnet_buffer (b0)->tcp.data_len))
2539         {
2540           clib_warning ("rcvd data in syn-sent");
2541           error0 = tcp_segment_rcv (wrk, new_tc0, b0);
2542           if (error0 == TCP_ERROR_ACK_OK)
2543             error0 = TCP_ERROR_SYN_ACKS_RCVD;
2544         }
2545       else
2546         {
2547           tcp_program_ack (wrk, new_tc0);
2548         }
2549
2550     drop:
2551
2552       tcp_inc_counter (syn_sent, error0, 1);
2553       if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED) && tcp0 != 0))
2554         {
2555           t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2556           clib_memcpy_fast (&t0->tcp_header, tcp0, sizeof (t0->tcp_header));
2557           clib_memcpy_fast (&t0->tcp_connection, tc0,
2558                             sizeof (t0->tcp_connection));
2559         }
2560     }
2561
2562   errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_TCP,
2563                                                  my_thread_index);
2564   tcp_inc_counter (syn_sent, TCP_ERROR_EVENT_FIFO_FULL, errors);
2565   vlib_buffer_free (vm, first_buffer, from_frame->n_vectors);
2566
2567   return from_frame->n_vectors;
2568 }
2569
2570 static uword
2571 tcp4_syn_sent (vlib_main_t * vm, vlib_node_runtime_t * node,
2572                vlib_frame_t * from_frame)
2573 {
2574   return tcp46_syn_sent_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2575 }
2576
2577 static uword
2578 tcp6_syn_sent_rcv (vlib_main_t * vm, vlib_node_runtime_t * node,
2579                    vlib_frame_t * from_frame)
2580 {
2581   return tcp46_syn_sent_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2582 }
2583
2584 /* *INDENT-OFF* */
2585 VLIB_REGISTER_NODE (tcp4_syn_sent_node) =
2586 {
2587   .function = tcp4_syn_sent,
2588   .name = "tcp4-syn-sent",
2589   /* Takes a vector of packets. */
2590   .vector_size = sizeof (u32),
2591   .n_errors = TCP_N_ERROR,
2592   .error_strings = tcp_error_strings,
2593   .n_next_nodes = TCP_SYN_SENT_N_NEXT,
2594   .next_nodes =
2595   {
2596 #define _(s,n) [TCP_SYN_SENT_NEXT_##s] = n,
2597     foreach_tcp_state_next
2598 #undef _
2599   },
2600   .format_trace = format_tcp_rx_trace_short,
2601 };
2602 /* *INDENT-ON* */
2603
2604 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_syn_sent_node, tcp4_syn_sent);
2605
2606 /* *INDENT-OFF* */
2607 VLIB_REGISTER_NODE (tcp6_syn_sent_node) =
2608 {
2609   .function = tcp6_syn_sent_rcv,
2610   .name = "tcp6-syn-sent",
2611   /* Takes a vector of packets. */
2612   .vector_size = sizeof (u32),
2613   .n_errors = TCP_N_ERROR,
2614   .error_strings = tcp_error_strings,
2615   .n_next_nodes = TCP_SYN_SENT_N_NEXT,
2616   .next_nodes =
2617   {
2618 #define _(s,n) [TCP_SYN_SENT_NEXT_##s] = n,
2619     foreach_tcp_state_next
2620 #undef _
2621   },
2622   .format_trace = format_tcp_rx_trace_short,
2623 };
2624 /* *INDENT-ON* */
2625
2626 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_syn_sent_node, tcp6_syn_sent_rcv);
2627
2628 vlib_node_registration_t tcp4_rcv_process_node;
2629 vlib_node_registration_t tcp6_rcv_process_node;
2630
2631 /**
2632  * Handles reception for all states except LISTEN, SYN-SENT and ESTABLISHED
2633  * as per RFC793 p. 64
2634  */
2635 always_inline uword
2636 tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2637                           vlib_frame_t * from_frame, int is_ip4)
2638 {
2639   u32 thread_index = vm->thread_index, errors = 0, *first_buffer;
2640   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
2641   u32 n_left_from, *from;
2642
2643   from = first_buffer = vlib_frame_vector_args (from_frame);
2644   n_left_from = from_frame->n_vectors;
2645
2646   while (n_left_from > 0)
2647     {
2648       u32 bi0, error0 = TCP_ERROR_NONE;
2649       tcp_header_t *tcp0 = 0;
2650       tcp_connection_t *tc0;
2651       vlib_buffer_t *b0;
2652       u8 is_fin0;
2653
2654       bi0 = from[0];
2655       from += 1;
2656       n_left_from -= 1;
2657
2658       b0 = vlib_get_buffer (vm, bi0);
2659       tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index,
2660                                 thread_index);
2661       if (PREDICT_FALSE (tc0 == 0))
2662         {
2663           error0 = TCP_ERROR_INVALID_CONNECTION;
2664           goto drop;
2665         }
2666
2667       tcp0 = tcp_buffer_hdr (b0);
2668       is_fin0 = tcp_is_fin (tcp0);
2669
2670       /* SYNs, FINs and data consume sequence numbers */
2671       vnet_buffer (b0)->tcp.seq_end = vnet_buffer (b0)->tcp.seq_number
2672         + tcp_is_syn (tcp0) + is_fin0 + vnet_buffer (b0)->tcp.data_len;
2673
2674       if (CLIB_DEBUG)
2675         {
2676           tcp_connection_t *tmp;
2677           tmp = tcp_lookup_connection (tc0->c_fib_index, b0, thread_index,
2678                                        is_ip4);
2679           if (tmp->state != tc0->state)
2680             {
2681               clib_warning ("state changed");
2682               goto drop;
2683             }
2684         }
2685
2686       /*
2687        * Special treatment for CLOSED
2688        */
2689       if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
2690         {
2691           error0 = TCP_ERROR_CONNECTION_CLOSED;
2692           goto drop;
2693         }
2694
2695       /*
2696        * For all other states (except LISTEN)
2697        */
2698
2699       /* 1-4: check SEQ, RST, SYN */
2700       if (PREDICT_FALSE (tcp_segment_validate (wrk, tc0, b0, tcp0, &error0)))
2701         goto drop;
2702
2703       /* 5: check the ACK field  */
2704       switch (tc0->state)
2705         {
2706         case TCP_STATE_SYN_RCVD:
2707           /*
2708            * If the segment acknowledgment is not acceptable, form a
2709            * reset segment,
2710            *  <SEQ=SEG.ACK><CTL=RST>
2711            * and send it.
2712            */
2713           if (!tcp_rcv_ack_is_acceptable (tc0, b0))
2714             {
2715               TCP_DBG ("connection not accepted");
2716               tcp_send_reset_w_pkt (tc0, b0, is_ip4);
2717               error0 = TCP_ERROR_ACK_INVALID;
2718               goto drop;
2719             }
2720
2721           /* Update rtt and rto */
2722           tcp_estimate_initial_rtt (tc0);
2723
2724           /* Switch state to ESTABLISHED */
2725           tc0->state = TCP_STATE_ESTABLISHED;
2726           TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2727
2728           /* Initialize session variables */
2729           tc0->snd_una = vnet_buffer (b0)->tcp.ack_number;
2730           tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window)
2731             << tc0->rcv_opts.wscale;
2732           tc0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number;
2733           tc0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number;
2734
2735           /* Reset SYN-ACK retransmit and SYN_RCV establish timers */
2736           tcp_retransmit_timer_reset (tc0);
2737           tcp_timer_reset (tc0, TCP_TIMER_ESTABLISH);
2738           stream_session_accept_notify (&tc0->connection);
2739           error0 = TCP_ERROR_ACK_OK;
2740           break;
2741         case TCP_STATE_ESTABLISHED:
2742           /* We can get packets in established state here because they
2743            * were enqueued before state change */
2744           if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
2745             goto drop;
2746
2747           break;
2748         case TCP_STATE_FIN_WAIT_1:
2749           /* In addition to the processing for the ESTABLISHED state, if
2750            * our FIN is now acknowledged then enter FIN-WAIT-2 and
2751            * continue processing in that state. */
2752           if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
2753             goto drop;
2754
2755           /* Still have to send the FIN */
2756           if (tc0->flags & TCP_CONN_FINPNDG)
2757             {
2758               /* TX fifo finally drained */
2759               if (!session_tx_fifo_max_dequeue (&tc0->connection))
2760                 tcp_send_fin (tc0);
2761             }
2762           /* If FIN is ACKed */
2763           else if (tc0->snd_una == tc0->snd_una_max)
2764             {
2765               tc0->state = TCP_STATE_FIN_WAIT_2;
2766               TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2767
2768               /* Stop all retransmit timers because we have nothing more
2769                * to send. Enable waitclose though because we're willing to
2770                * wait for peer's FIN but not indefinitely. */
2771               tcp_connection_timers_reset (tc0);
2772               tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
2773
2774               /* Don't try to deq the FIN acked */
2775               if (tc0->burst_acked > 1)
2776                 stream_session_dequeue_drop (&tc0->connection,
2777                                              tc0->burst_acked - 1);
2778               tc0->burst_acked = 0;
2779             }
2780           break;
2781         case TCP_STATE_FIN_WAIT_2:
2782           /* In addition to the processing for the ESTABLISHED state, if
2783            * the retransmission queue is empty, the user's CLOSE can be
2784            * acknowledged ("ok") but do not delete the TCB. */
2785           if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
2786             goto drop;
2787           tc0->burst_acked = 0;
2788           break;
2789         case TCP_STATE_CLOSE_WAIT:
2790           /* Do the same processing as for the ESTABLISHED state. */
2791           if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
2792             goto drop;
2793
2794           if (tc0->flags & TCP_CONN_FINPNDG)
2795             {
2796               /* TX fifo finally drained */
2797               if (!session_tx_fifo_max_dequeue (&tc0->connection))
2798                 {
2799                   tcp_send_fin (tc0);
2800                   tcp_connection_timers_reset (tc0);
2801                   tc0->state = TCP_STATE_LAST_ACK;
2802                   tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
2803                 }
2804             }
2805           break;
2806         case TCP_STATE_CLOSING:
2807           /* In addition to the processing for the ESTABLISHED state, if
2808            * the ACK acknowledges our FIN then enter the TIME-WAIT state,
2809            * otherwise ignore the segment. */
2810           if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
2811             goto drop;
2812
2813           tc0->state = TCP_STATE_TIME_WAIT;
2814           TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2815           tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2816           goto drop;
2817
2818           break;
2819         case TCP_STATE_LAST_ACK:
2820           /* The only thing that [should] arrive in this state is an
2821            * acknowledgment of our FIN. If our FIN is now acknowledged,
2822            * delete the TCB, enter the CLOSED state, and return. */
2823
2824           if (!tcp_rcv_ack_is_acceptable (tc0, b0))
2825             {
2826               error0 = TCP_ERROR_ACK_INVALID;
2827               goto drop;
2828             }
2829           error0 = TCP_ERROR_ACK_OK;
2830           tc0->snd_una = vnet_buffer (b0)->tcp.ack_number;
2831           /* Apparently our ACK for the peer's FIN was lost */
2832           if (is_fin0 && tc0->snd_una != tc0->snd_una_max)
2833             {
2834               tcp_send_fin (tc0);
2835               goto drop;
2836             }
2837
2838           tc0->state = TCP_STATE_CLOSED;
2839           TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2840
2841           /* Don't free the connection from the data path since
2842            * we can't ensure that we have no packets already enqueued
2843            * to output. Rely instead on the waitclose timer */
2844           tcp_connection_timers_reset (tc0);
2845           tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, 1);
2846
2847           goto drop;
2848
2849           break;
2850         case TCP_STATE_TIME_WAIT:
2851           /* The only thing that can arrive in this state is a
2852            * retransmission of the remote FIN. Acknowledge it, and restart
2853            * the 2 MSL timeout. */
2854
2855           if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
2856             goto drop;
2857
2858           tcp_program_ack (wrk, tc0);
2859           tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2860           goto drop;
2861
2862           break;
2863         default:
2864           ASSERT (0);
2865         }
2866
2867       /* 6: check the URG bit TODO */
2868
2869       /* 7: process the segment text */
2870       switch (tc0->state)
2871         {
2872         case TCP_STATE_ESTABLISHED:
2873         case TCP_STATE_FIN_WAIT_1:
2874         case TCP_STATE_FIN_WAIT_2:
2875           if (vnet_buffer (b0)->tcp.data_len)
2876             error0 = tcp_segment_rcv (wrk, tc0, b0);
2877           else if (is_fin0)
2878             tc0->rcv_nxt += 1;
2879           break;
2880         case TCP_STATE_CLOSE_WAIT:
2881         case TCP_STATE_CLOSING:
2882         case TCP_STATE_LAST_ACK:
2883         case TCP_STATE_TIME_WAIT:
2884           /* This should not occur, since a FIN has been received from the
2885            * remote side.  Ignore the segment text. */
2886           break;
2887         }
2888
2889       /* 8: check the FIN bit */
2890       if (!is_fin0)
2891         goto drop;
2892
2893       switch (tc0->state)
2894         {
2895         case TCP_STATE_ESTABLISHED:
2896         case TCP_STATE_SYN_RCVD:
2897           /* Send FIN-ACK notify app and enter CLOSE-WAIT */
2898           tcp_connection_timers_reset (tc0);
2899           tcp_send_fin (tc0);
2900           stream_session_disconnect_notify (&tc0->connection);
2901           tc0->state = TCP_STATE_CLOSE_WAIT;
2902           TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2903           break;
2904         case TCP_STATE_CLOSE_WAIT:
2905         case TCP_STATE_CLOSING:
2906         case TCP_STATE_LAST_ACK:
2907           /* move along .. */
2908           break;
2909         case TCP_STATE_FIN_WAIT_1:
2910           tc0->state = TCP_STATE_CLOSING;
2911           tcp_program_ack (wrk, tc0);
2912           TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2913           /* Wait for ACK but not forever */
2914           tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
2915           break;
2916         case TCP_STATE_FIN_WAIT_2:
2917           /* Got FIN, send ACK! Be more aggressive with resource cleanup */
2918           tc0->state = TCP_STATE_TIME_WAIT;
2919           tcp_connection_timers_reset (tc0);
2920           tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2921           tcp_program_ack (wrk, tc0);
2922           TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2923           break;
2924         case TCP_STATE_TIME_WAIT:
2925           /* Remain in the TIME-WAIT state. Restart the time-wait
2926            * timeout.
2927            */
2928           tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2929           break;
2930         }
2931       error0 = TCP_ERROR_FIN_RCVD;
2932       TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc0);
2933
2934     drop:
2935
2936       tcp_inc_counter (rcv_process, error0, 1);
2937       if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2938         {
2939           tcp_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2940           tcp_set_rx_trace_data (t0, tc0, tcp0, b0, is_ip4);
2941         }
2942     }
2943
2944   errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_TCP,
2945                                                  thread_index);
2946   tcp_inc_counter (rcv_process, TCP_ERROR_EVENT_FIFO_FULL, errors);
2947   tcp_handle_postponed_dequeues (wrk);
2948   vlib_buffer_free (vm, first_buffer, from_frame->n_vectors);
2949
2950   return from_frame->n_vectors;
2951 }
2952
2953 static uword
2954 tcp4_rcv_process (vlib_main_t * vm, vlib_node_runtime_t * node,
2955                   vlib_frame_t * from_frame)
2956 {
2957   return tcp46_rcv_process_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2958 }
2959
2960 static uword
2961 tcp6_rcv_process (vlib_main_t * vm, vlib_node_runtime_t * node,
2962                   vlib_frame_t * from_frame)
2963 {
2964   return tcp46_rcv_process_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2965 }
2966
2967 /* *INDENT-OFF* */
2968 VLIB_REGISTER_NODE (tcp4_rcv_process_node) =
2969 {
2970   .function = tcp4_rcv_process,
2971   .name = "tcp4-rcv-process",
2972   /* Takes a vector of packets. */
2973   .vector_size = sizeof (u32),
2974   .n_errors = TCP_N_ERROR,
2975   .error_strings = tcp_error_strings,
2976   .n_next_nodes = TCP_RCV_PROCESS_N_NEXT,
2977   .next_nodes =
2978   {
2979 #define _(s,n) [TCP_RCV_PROCESS_NEXT_##s] = n,
2980     foreach_tcp_state_next
2981 #undef _
2982   },
2983   .format_trace = format_tcp_rx_trace_short,
2984 };
2985 /* *INDENT-ON* */
2986
2987 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_rcv_process_node, tcp4_rcv_process);
2988
2989 /* *INDENT-OFF* */
2990 VLIB_REGISTER_NODE (tcp6_rcv_process_node) =
2991 {
2992   .function = tcp6_rcv_process,
2993   .name = "tcp6-rcv-process",
2994   /* Takes a vector of packets. */
2995   .vector_size = sizeof (u32),
2996   .n_errors = TCP_N_ERROR,
2997   .error_strings = tcp_error_strings,
2998   .n_next_nodes = TCP_RCV_PROCESS_N_NEXT,
2999   .next_nodes =
3000   {
3001 #define _(s,n) [TCP_RCV_PROCESS_NEXT_##s] = n,
3002     foreach_tcp_state_next
3003 #undef _
3004   },
3005   .format_trace = format_tcp_rx_trace_short,
3006 };
3007 /* *INDENT-ON* */
3008
3009 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_rcv_process_node, tcp6_rcv_process);
3010
3011 vlib_node_registration_t tcp4_listen_node;
3012 vlib_node_registration_t tcp6_listen_node;
3013
3014 /**
3015  * LISTEN state processing as per RFC 793 p. 65
3016  */
3017 always_inline uword
3018 tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
3019                      vlib_frame_t * from_frame, int is_ip4)
3020 {
3021   u32 n_left_from, *from, n_syns = 0, *first_buffer;
3022   u32 my_thread_index = vm->thread_index;
3023
3024   from = first_buffer = vlib_frame_vector_args (from_frame);
3025   n_left_from = from_frame->n_vectors;
3026
3027   while (n_left_from > 0)
3028     {
3029       u32 bi0;
3030       vlib_buffer_t *b0;
3031       tcp_rx_trace_t *t0;
3032       tcp_header_t *th0 = 0;
3033       tcp_connection_t *lc0;
3034       ip4_header_t *ip40;
3035       ip6_header_t *ip60;
3036       tcp_connection_t *child0;
3037       u32 error0 = TCP_ERROR_NONE;
3038
3039       bi0 = from[0];
3040       from += 1;
3041       n_left_from -= 1;
3042
3043       b0 = vlib_get_buffer (vm, bi0);
3044       lc0 = tcp_listener_get (vnet_buffer (b0)->tcp.connection_index);
3045
3046       if (is_ip4)
3047         {
3048           ip40 = vlib_buffer_get_current (b0);
3049           th0 = ip4_next_header (ip40);
3050         }
3051       else
3052         {
3053           ip60 = vlib_buffer_get_current (b0);
3054           th0 = ip6_next_header (ip60);
3055         }
3056
3057       /* Create child session. For syn-flood protection use filter */
3058
3059       /* 1. first check for an RST: handled in dispatch */
3060       /* if (tcp_rst (th0))
3061          goto drop;
3062        */
3063
3064       /* 2. second check for an ACK: handled in dispatch */
3065       /* if (tcp_ack (th0))
3066          {
3067          tcp_send_reset (b0, is_ip4);
3068          goto drop;
3069          }
3070        */
3071
3072       /* 3. check for a SYN (did that already) */
3073
3074       /* Make sure connection wasn't just created */
3075       child0 = tcp_lookup_connection (lc0->c_fib_index, b0, my_thread_index,
3076                                       is_ip4);
3077       if (PREDICT_FALSE (child0->state != TCP_STATE_LISTEN))
3078         {
3079           error0 = TCP_ERROR_CREATE_EXISTS;
3080           goto drop;
3081         }
3082
3083       /* Create child session and send SYN-ACK */
3084       child0 = tcp_connection_new (my_thread_index);
3085       child0->c_lcl_port = th0->dst_port;
3086       child0->c_rmt_port = th0->src_port;
3087       child0->c_is_ip4 = is_ip4;
3088       child0->state = TCP_STATE_SYN_RCVD;
3089       child0->c_fib_index = lc0->c_fib_index;
3090
3091       if (is_ip4)
3092         {
3093           child0->c_lcl_ip4.as_u32 = ip40->dst_address.as_u32;
3094           child0->c_rmt_ip4.as_u32 = ip40->src_address.as_u32;
3095         }
3096       else
3097         {
3098           clib_memcpy_fast (&child0->c_lcl_ip6, &ip60->dst_address,
3099                             sizeof (ip6_address_t));
3100           clib_memcpy_fast (&child0->c_rmt_ip6, &ip60->src_address,
3101                             sizeof (ip6_address_t));
3102         }
3103
3104       if (tcp_options_parse (th0, &child0->rcv_opts, 1))
3105         {
3106           clib_warning ("options parse fail");
3107           goto drop;
3108         }
3109
3110       child0->irs = vnet_buffer (b0)->tcp.seq_number;
3111       child0->rcv_nxt = vnet_buffer (b0)->tcp.seq_number + 1;
3112       child0->rcv_las = child0->rcv_nxt;
3113       child0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
3114
3115       /* RFC1323: TSval timestamps sent on {SYN} and {SYN,ACK}
3116        * segments are used to initialize PAWS. */
3117       if (tcp_opts_tstamp (&child0->rcv_opts))
3118         {
3119           child0->tsval_recent = child0->rcv_opts.tsval;
3120           child0->tsval_recent_age = tcp_time_now ();
3121         }
3122
3123       if (tcp_opts_wscale (&child0->rcv_opts))
3124         child0->snd_wscale = child0->rcv_opts.wscale;
3125
3126       child0->snd_wnd = clib_net_to_host_u16 (th0->window)
3127         << child0->snd_wscale;
3128       child0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number;
3129       child0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number;
3130
3131       tcp_connection_init_vars (child0);
3132       TCP_EVT_DBG (TCP_EVT_SYN_RCVD, child0, 1);
3133
3134       if (stream_session_accept (&child0->connection, lc0->c_s_index,
3135                                  0 /* notify */ ))
3136         {
3137           clib_warning ("session accept fail");
3138           tcp_connection_cleanup (child0);
3139           error0 = TCP_ERROR_CREATE_SESSION_FAIL;
3140           goto drop;
3141         }
3142
3143       child0->tx_fifo_size = transport_tx_fifo_size (&child0->connection);
3144       tcp_send_synack (child0);
3145       tcp_timer_set (child0, TCP_TIMER_ESTABLISH, TCP_SYN_RCVD_TIME);
3146
3147     drop:
3148
3149       if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
3150         {
3151           t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
3152           clib_memcpy_fast (&t0->tcp_header, th0, sizeof (t0->tcp_header));
3153           clib_memcpy_fast (&t0->tcp_connection, lc0,
3154                             sizeof (t0->tcp_connection));
3155         }
3156
3157       n_syns += (error0 == TCP_ERROR_NONE);
3158     }
3159
3160   tcp_inc_counter (listen, TCP_ERROR_SYNS_RCVD, n_syns);
3161   vlib_buffer_free (vm, first_buffer, from_frame->n_vectors);
3162
3163   return from_frame->n_vectors;
3164 }
3165
3166 static uword
3167 tcp4_listen (vlib_main_t * vm, vlib_node_runtime_t * node,
3168              vlib_frame_t * from_frame)
3169 {
3170   return tcp46_listen_inline (vm, node, from_frame, 1 /* is_ip4 */ );
3171 }
3172
3173 static uword
3174 tcp6_listen (vlib_main_t * vm, vlib_node_runtime_t * node,
3175              vlib_frame_t * from_frame)
3176 {
3177   return tcp46_listen_inline (vm, node, from_frame, 0 /* is_ip4 */ );
3178 }
3179
3180 /* *INDENT-OFF* */
3181 VLIB_REGISTER_NODE (tcp4_listen_node) =
3182 {
3183   .function = tcp4_listen,
3184   .name = "tcp4-listen",
3185   /* Takes a vector of packets. */
3186   .vector_size = sizeof (u32),
3187   .n_errors = TCP_N_ERROR,
3188   .error_strings = tcp_error_strings,
3189   .n_next_nodes = TCP_LISTEN_N_NEXT,
3190   .next_nodes =
3191   {
3192 #define _(s,n) [TCP_LISTEN_NEXT_##s] = n,
3193     foreach_tcp_state_next
3194 #undef _
3195   },
3196   .format_trace = format_tcp_rx_trace_short,
3197 };
3198 /* *INDENT-ON* */
3199
3200 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_listen_node, tcp4_listen);
3201
3202 /* *INDENT-OFF* */
3203 VLIB_REGISTER_NODE (tcp6_listen_node) =
3204 {
3205   .function = tcp6_listen,
3206   .name = "tcp6-listen",
3207   /* Takes a vector of packets. */
3208   .vector_size = sizeof (u32),
3209   .n_errors = TCP_N_ERROR,
3210   .error_strings = tcp_error_strings,
3211   .n_next_nodes = TCP_LISTEN_N_NEXT,
3212   .next_nodes =
3213   {
3214 #define _(s,n) [TCP_LISTEN_NEXT_##s] = n,
3215     foreach_tcp_state_next
3216 #undef _
3217   },
3218   .format_trace = format_tcp_rx_trace_short,
3219 };
3220 /* *INDENT-ON* */
3221
3222 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_listen_node, tcp6_listen);
3223
3224 vlib_node_registration_t tcp4_input_node;
3225 vlib_node_registration_t tcp6_input_node;
3226
3227 typedef enum _tcp_input_next
3228 {
3229   TCP_INPUT_NEXT_DROP,
3230   TCP_INPUT_NEXT_LISTEN,
3231   TCP_INPUT_NEXT_RCV_PROCESS,
3232   TCP_INPUT_NEXT_SYN_SENT,
3233   TCP_INPUT_NEXT_ESTABLISHED,
3234   TCP_INPUT_NEXT_RESET,
3235   TCP_INPUT_NEXT_PUNT,
3236   TCP_INPUT_N_NEXT
3237 } tcp_input_next_t;
3238
3239 #define foreach_tcp4_input_next                 \
3240   _ (DROP, "ip4-drop")                          \
3241   _ (LISTEN, "tcp4-listen")                     \
3242   _ (RCV_PROCESS, "tcp4-rcv-process")           \
3243   _ (SYN_SENT, "tcp4-syn-sent")                 \
3244   _ (ESTABLISHED, "tcp4-established")           \
3245   _ (RESET, "tcp4-reset")                       \
3246   _ (PUNT, "ip4-punt")
3247
3248 #define foreach_tcp6_input_next                 \
3249   _ (DROP, "ip6-drop")                          \
3250   _ (LISTEN, "tcp6-listen")                     \
3251   _ (RCV_PROCESS, "tcp6-rcv-process")           \
3252   _ (SYN_SENT, "tcp6-syn-sent")                 \
3253   _ (ESTABLISHED, "tcp6-established")           \
3254   _ (RESET, "tcp6-reset")                       \
3255   _ (PUNT, "ip6-punt")
3256
3257 #define filter_flags (TCP_FLAG_SYN|TCP_FLAG_ACK|TCP_FLAG_RST|TCP_FLAG_FIN)
3258
3259 static void
3260 tcp_input_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
3261                        vlib_buffer_t ** bs, u32 n_bufs, u8 is_ip4)
3262 {
3263   tcp_connection_t *tc;
3264   tcp_header_t *tcp;
3265   tcp_rx_trace_t *t;
3266   int i;
3267
3268   for (i = 0; i < n_bufs; i++)
3269     {
3270       if (bs[i]->flags & VLIB_BUFFER_IS_TRACED)
3271         {
3272           t = vlib_add_trace (vm, node, bs[i], sizeof (*t));
3273           tc = tcp_connection_get (vnet_buffer (bs[i])->tcp.connection_index,
3274                                    vm->thread_index);
3275           tcp = vlib_buffer_get_current (bs[i]);
3276           tcp_set_rx_trace_data (t, tc, tcp, bs[i], is_ip4);
3277         }
3278     }
3279 }
3280
3281 static void
3282 tcp_input_set_error_next (tcp_main_t * tm, u16 * next, u32 * error, u8 is_ip4)
3283 {
3284   if (*error == TCP_ERROR_FILTERED)
3285     {
3286       *next = TCP_INPUT_NEXT_DROP;
3287     }
3288   else if ((is_ip4 && tm->punt_unknown4) || (!is_ip4 && tm->punt_unknown6))
3289     {
3290       *next = TCP_INPUT_NEXT_PUNT;
3291       *error = TCP_ERROR_PUNT;
3292     }
3293   else
3294     {
3295       *next = TCP_INPUT_NEXT_RESET;
3296       *error = TCP_ERROR_NO_LISTENER;
3297     }
3298 }
3299
3300 static inline tcp_connection_t *
3301 tcp_input_lookup_buffer (vlib_buffer_t * b, u8 thread_index, u32 * error,
3302                          u8 is_ip4)
3303 {
3304   u32 fib_index = vnet_buffer (b)->ip.fib_index;
3305   int n_advance_bytes, n_data_bytes;
3306   transport_connection_t *tc;
3307   tcp_header_t *tcp;
3308   u8 is_filtered = 0;
3309
3310   if (is_ip4)
3311     {
3312       ip4_header_t *ip4 = vlib_buffer_get_current (b);
3313       int ip_hdr_bytes = ip4_header_bytes (ip4);
3314       if (PREDICT_FALSE (b->current_length < ip_hdr_bytes + sizeof (*tcp)))
3315         {
3316           *error = TCP_ERROR_LENGTH;
3317           return 0;
3318         }
3319       tcp = ip4_next_header (ip4);
3320       vnet_buffer (b)->tcp.hdr_offset = (u8 *) tcp - (u8 *) ip4;
3321       n_advance_bytes = (ip_hdr_bytes + tcp_header_bytes (tcp));
3322       n_data_bytes = clib_net_to_host_u16 (ip4->length) - n_advance_bytes;
3323
3324       /* Length check. Checksum computed by ipx_local no need to compute again */
3325       if (PREDICT_FALSE (n_data_bytes < 0))
3326         {
3327           *error = TCP_ERROR_LENGTH;
3328           return 0;
3329         }
3330
3331       tc = session_lookup_connection_wt4 (fib_index, &ip4->dst_address,
3332                                           &ip4->src_address, tcp->dst_port,
3333                                           tcp->src_port, TRANSPORT_PROTO_TCP,
3334                                           thread_index, &is_filtered);
3335     }
3336   else
3337     {
3338       ip6_header_t *ip6 = vlib_buffer_get_current (b);
3339       if (PREDICT_FALSE (b->current_length < sizeof (*ip6) + sizeof (*tcp)))
3340         {
3341           *error = TCP_ERROR_LENGTH;
3342           return 0;
3343         }
3344       tcp = ip6_next_header (ip6);
3345       vnet_buffer (b)->tcp.hdr_offset = (u8 *) tcp - (u8 *) ip6;
3346       n_advance_bytes = tcp_header_bytes (tcp);
3347       n_data_bytes = clib_net_to_host_u16 (ip6->payload_length)
3348         - n_advance_bytes;
3349       n_advance_bytes += sizeof (ip6[0]);
3350
3351       if (PREDICT_FALSE (n_data_bytes < 0))
3352         {
3353           *error = TCP_ERROR_LENGTH;
3354           return 0;
3355         }
3356
3357       tc = session_lookup_connection_wt6 (fib_index, &ip6->dst_address,
3358                                           &ip6->src_address, tcp->dst_port,
3359                                           tcp->src_port, TRANSPORT_PROTO_TCP,
3360                                           thread_index, &is_filtered);
3361     }
3362
3363   vnet_buffer (b)->tcp.seq_number = clib_net_to_host_u32 (tcp->seq_number);
3364   vnet_buffer (b)->tcp.ack_number = clib_net_to_host_u32 (tcp->ack_number);
3365   vnet_buffer (b)->tcp.data_offset = n_advance_bytes;
3366   vnet_buffer (b)->tcp.data_len = n_data_bytes;
3367   vnet_buffer (b)->tcp.flags = 0;
3368
3369   *error = is_filtered ? TCP_ERROR_FILTERED : *error;
3370
3371   return tcp_get_connection_from_transport (tc);
3372 }
3373
3374 static inline void
3375 tcp_input_dispatch_buffer (tcp_main_t * tm, tcp_connection_t * tc,
3376                            vlib_buffer_t * b, u16 * next, u32 * error)
3377 {
3378   tcp_header_t *tcp;
3379   u8 flags;
3380
3381   tcp = tcp_buffer_hdr (b);
3382   flags = tcp->flags & filter_flags;
3383   *next = tm->dispatch_table[tc->state][flags].next;
3384   *error = tm->dispatch_table[tc->state][flags].error;
3385
3386   if (PREDICT_FALSE (*error == TCP_ERROR_DISPATCH
3387                      || *next == TCP_INPUT_NEXT_RESET))
3388     {
3389       /* Overload tcp flags to store state */
3390       tcp_state_t state = tc->state;
3391       vnet_buffer (b)->tcp.flags = tc->state;
3392
3393       if (*error == TCP_ERROR_DISPATCH)
3394         clib_warning ("disp error state %U flags %U", format_tcp_state,
3395                       state, format_tcp_flags, (int) flags);
3396     }
3397 }
3398
3399 always_inline uword
3400 tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
3401                     vlib_frame_t * frame, int is_ip4)
3402 {
3403   u32 n_left_from, *from, thread_index = vm->thread_index;
3404   tcp_main_t *tm = vnet_get_tcp_main ();
3405   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
3406   u16 nexts[VLIB_FRAME_SIZE], *next;
3407
3408   tcp_set_time_now (tcp_get_worker (thread_index));
3409
3410   from = vlib_frame_vector_args (frame);
3411   n_left_from = frame->n_vectors;
3412   vlib_get_buffers (vm, from, bufs, n_left_from);
3413
3414   b = bufs;
3415   next = nexts;
3416
3417   while (n_left_from >= 4)
3418     {
3419       u32 error0 = TCP_ERROR_NO_LISTENER, error1 = TCP_ERROR_NO_LISTENER;
3420       tcp_connection_t *tc0, *tc1;
3421
3422       {
3423         vlib_prefetch_buffer_header (b[2], STORE);
3424         CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
3425
3426         vlib_prefetch_buffer_header (b[3], STORE);
3427         CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
3428       }
3429
3430       next[0] = next[1] = TCP_INPUT_NEXT_DROP;
3431
3432       tc0 = tcp_input_lookup_buffer (b[0], thread_index, &error0, is_ip4);
3433       tc1 = tcp_input_lookup_buffer (b[1], thread_index, &error1, is_ip4);
3434
3435       if (PREDICT_TRUE (!tc0 + !tc1 == 0))
3436         {
3437           ASSERT (tcp_lookup_is_valid (tc0, tcp_buffer_hdr (b[0])));
3438           ASSERT (tcp_lookup_is_valid (tc1, tcp_buffer_hdr (b[1])));
3439
3440           vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index;
3441           vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index;
3442
3443           tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], &error0);
3444           tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], &error1);
3445         }
3446       else
3447         {
3448           if (PREDICT_TRUE (tc0 != 0))
3449             {
3450               ASSERT (tcp_lookup_is_valid (tc0, tcp_buffer_hdr (b[0])));
3451               vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index;
3452               tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], &error0);
3453             }
3454           else
3455             tcp_input_set_error_next (tm, &next[0], &error0, is_ip4);
3456
3457           if (PREDICT_TRUE (tc1 != 0))
3458             {
3459               ASSERT (tcp_lookup_is_valid (tc1, tcp_buffer_hdr (b[1])));
3460               vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index;
3461               tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], &error1);
3462             }
3463           else
3464             tcp_input_set_error_next (tm, &next[1], &error1, is_ip4);
3465         }
3466
3467       b += 2;
3468       next += 2;
3469       n_left_from -= 2;
3470     }
3471   while (n_left_from > 0)
3472     {
3473       tcp_connection_t *tc0;
3474       u32 error0 = TCP_ERROR_NO_LISTENER;
3475
3476       if (n_left_from > 1)
3477         {
3478           vlib_prefetch_buffer_header (b[1], STORE);
3479           CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
3480         }
3481
3482       next[0] = TCP_INPUT_NEXT_DROP;
3483       tc0 = tcp_input_lookup_buffer (b[0], thread_index, &error0, is_ip4);
3484       if (PREDICT_TRUE (tc0 != 0))
3485         {
3486           ASSERT (tcp_lookup_is_valid (tc0, tcp_buffer_hdr (b[0])));
3487           vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index;
3488           tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], &error0);
3489         }
3490       else
3491         tcp_input_set_error_next (tm, &next[0], &error0, is_ip4);
3492
3493       b += 1;
3494       next += 1;
3495       n_left_from -= 1;
3496     }
3497
3498   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
3499     tcp_input_trace_frame (vm, node, bufs, frame->n_vectors, is_ip4);
3500
3501   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
3502   return frame->n_vectors;
3503 }
3504
3505 static uword
3506 tcp4_input (vlib_main_t * vm, vlib_node_runtime_t * node,
3507             vlib_frame_t * from_frame)
3508 {
3509   return tcp46_input_inline (vm, node, from_frame, 1 /* is_ip4 */ );
3510 }
3511
3512 static uword
3513 tcp6_input (vlib_main_t * vm, vlib_node_runtime_t * node,
3514             vlib_frame_t * from_frame)
3515 {
3516   return tcp46_input_inline (vm, node, from_frame, 0 /* is_ip4 */ );
3517 }
3518
3519 /* *INDENT-OFF* */
3520 VLIB_REGISTER_NODE (tcp4_input_node) =
3521 {
3522   .function = tcp4_input,
3523   .name = "tcp4-input",
3524   /* Takes a vector of packets. */
3525   .vector_size = sizeof (u32),
3526   .n_errors = TCP_N_ERROR,
3527   .error_strings = tcp_error_strings,
3528   .n_next_nodes = TCP_INPUT_N_NEXT,
3529   .next_nodes =
3530   {
3531 #define _(s,n) [TCP_INPUT_NEXT_##s] = n,
3532     foreach_tcp4_input_next
3533 #undef _
3534   },
3535   .format_buffer = format_tcp_header,
3536   .format_trace = format_tcp_rx_trace,
3537 };
3538 /* *INDENT-ON* */
3539
3540 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_input_node, tcp4_input);
3541
3542 /* *INDENT-OFF* */
3543 VLIB_REGISTER_NODE (tcp6_input_node) =
3544 {
3545   .function = tcp6_input,
3546   .name = "tcp6-input",
3547   /* Takes a vector of packets. */
3548   .vector_size = sizeof (u32),
3549   .n_errors = TCP_N_ERROR,
3550   .error_strings = tcp_error_strings,
3551   .n_next_nodes = TCP_INPUT_N_NEXT,
3552   .next_nodes =
3553   {
3554 #define _(s,n) [TCP_INPUT_NEXT_##s] = n,
3555     foreach_tcp6_input_next
3556 #undef _
3557   },
3558   .format_buffer = format_tcp_header,
3559   .format_trace = format_tcp_rx_trace,
3560 };
3561 /* *INDENT-ON* */
3562
3563 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_input_node, tcp6_input);
3564
3565 static void
3566 tcp_dispatch_table_init (tcp_main_t * tm)
3567 {
3568   int i, j;
3569   for (i = 0; i < ARRAY_LEN (tm->dispatch_table); i++)
3570     for (j = 0; j < ARRAY_LEN (tm->dispatch_table[i]); j++)
3571       {
3572         tm->dispatch_table[i][j].next = TCP_INPUT_NEXT_DROP;
3573         tm->dispatch_table[i][j].error = TCP_ERROR_DISPATCH;
3574       }
3575
3576 #define _(t,f,n,e)                                              \
3577 do {                                                            \
3578     tm->dispatch_table[TCP_STATE_##t][f].next = (n);            \
3579     tm->dispatch_table[TCP_STATE_##t][f].error = (e);           \
3580 } while (0)
3581
3582   /* SYNs for new connections -> tcp-listen. */
3583   _(LISTEN, TCP_FLAG_SYN, TCP_INPUT_NEXT_LISTEN, TCP_ERROR_NONE);
3584   _(LISTEN, TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET, TCP_ERROR_NONE);
3585   _(LISTEN, TCP_FLAG_RST, TCP_INPUT_NEXT_DROP, TCP_ERROR_RST_RCVD);
3586   _(LISTEN, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET,
3587     TCP_ERROR_NONE);
3588   /* ACK for for a SYN-ACK -> tcp-rcv-process. */
3589   _(SYN_RCVD, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3590   _(SYN_RCVD, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3591   _(SYN_RCVD, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
3592     TCP_ERROR_NONE);
3593   _(SYN_RCVD, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3594   _(SYN_RCVD, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
3595     TCP_ERROR_NONE);
3596   /* SYN-ACK for a SYN */
3597   _(SYN_SENT, TCP_FLAG_SYN | TCP_FLAG_ACK, TCP_INPUT_NEXT_SYN_SENT,
3598     TCP_ERROR_NONE);
3599   _(SYN_SENT, TCP_FLAG_ACK, TCP_INPUT_NEXT_SYN_SENT, TCP_ERROR_NONE);
3600   _(SYN_SENT, TCP_FLAG_RST, TCP_INPUT_NEXT_SYN_SENT, TCP_ERROR_NONE);
3601   _(SYN_SENT, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_SYN_SENT,
3602     TCP_ERROR_NONE);
3603   /* ACK for for established connection -> tcp-established. */
3604   _(ESTABLISHED, TCP_FLAG_ACK, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3605   /* FIN for for established connection -> tcp-established. */
3606   _(ESTABLISHED, TCP_FLAG_FIN, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3607   _(ESTABLISHED, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_ESTABLISHED,
3608     TCP_ERROR_NONE);
3609   _(ESTABLISHED, TCP_FLAG_RST, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3610   _(ESTABLISHED, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_ESTABLISHED,
3611     TCP_ERROR_NONE);
3612   _(ESTABLISHED, TCP_FLAG_SYN, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3613   _(ESTABLISHED, TCP_FLAG_SYN | TCP_FLAG_ACK, TCP_INPUT_NEXT_ESTABLISHED,
3614     TCP_ERROR_NONE);
3615   /* ACK or FIN-ACK to our FIN */
3616   _(FIN_WAIT_1, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3617   _(FIN_WAIT_1, TCP_FLAG_ACK | TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS,
3618     TCP_ERROR_NONE);
3619   /* FIN in reply to our FIN from the other side */
3620   _(FIN_WAIT_1, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3621   _(FIN_WAIT_1, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3622   _(CLOSING, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3623   /* FIN confirming that the peer (app) has closed */
3624   _(FIN_WAIT_2, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3625   _(FIN_WAIT_2, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3626   _(FIN_WAIT_2, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
3627     TCP_ERROR_NONE);
3628   _(CLOSE_WAIT, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3629   _(CLOSE_WAIT, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
3630     TCP_ERROR_NONE);
3631   _(LAST_ACK, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3632   _(LAST_ACK, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3633   _(LAST_ACK, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
3634     TCP_ERROR_NONE);
3635   _(LAST_ACK, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3636   _(LAST_ACK, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3637   _(TIME_WAIT, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3638   _(TIME_WAIT, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
3639     TCP_ERROR_NONE);
3640   _(TIME_WAIT, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3641   _(TIME_WAIT, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3642   _(CLOSED, TCP_FLAG_ACK, TCP_INPUT_NEXT_DROP, TCP_ERROR_CONNECTION_CLOSED);
3643   _(CLOSED, TCP_FLAG_RST, TCP_INPUT_NEXT_DROP, TCP_ERROR_CONNECTION_CLOSED);
3644   _(CLOSED, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_DROP,
3645     TCP_ERROR_CONNECTION_CLOSED);
3646 #undef _
3647 }
3648
3649 static clib_error_t *
3650 tcp_input_init (vlib_main_t * vm)
3651 {
3652   clib_error_t *error = 0;
3653   tcp_main_t *tm = vnet_get_tcp_main ();
3654
3655   if ((error = vlib_call_init_function (vm, tcp_init)))
3656     return error;
3657
3658   /* Initialize dispatch table. */
3659   tcp_dispatch_table_init (tm);
3660
3661   return error;
3662 }
3663
3664 VLIB_INIT_FUNCTION (tcp_input_init);
3665
3666 /*
3667  * fd.io coding-style-patch-verification: ON
3668  *
3669  * Local Variables:
3670  * eval: (c-set-style "gnu")
3671  * End:
3672  */