src/vnet/tcp/tcp_output.c

   1 /*
   2  * Copyright (c) 2016-2019 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 <vnet/tcp/tcp.h>
  17 #include <vnet/tcp/tcp_inlines.h>
  18 #include <math.h>
  19 #include <vnet/ip/ip4_inlines.h>
  20 #include <vnet/ip/ip6_inlines.h>
  21
  22 typedef enum _tcp_output_next
  23 {
  24   TCP_OUTPUT_NEXT_DROP,
  25   TCP_OUTPUT_NEXT_IP_LOOKUP,
  26   TCP_OUTPUT_NEXT_IP_REWRITE,
  27   TCP_OUTPUT_NEXT_IP_ARP,
  28   TCP_OUTPUT_N_NEXT
  29 } tcp_output_next_t;
  30
  31 #define foreach_tcp4_output_next                \
  32   _ (DROP, "error-drop")                        \
  33   _ (IP_LOOKUP, "ip4-lookup")                   \
  34   _ (IP_REWRITE, "ip4-rewrite")                 \
  35   _ (IP_ARP, "ip4-arp")
  36
  37 #define foreach_tcp6_output_next                \
  38   _ (DROP, "error-drop")                        \
  39   _ (IP_LOOKUP, "ip6-lookup")                   \
  40   _ (IP_REWRITE, "ip6-rewrite")                 \
  41   _ (IP_ARP, "ip6-discover-neighbor")
  42
  43 static char *tcp_error_strings[] = {
  44 #define tcp_error(n,s) s,
  45 #include <vnet/tcp/tcp_error.def>
  46 #undef tcp_error
  47 };
  48
  49 typedef struct
  50 {
  51   tcp_header_t tcp_header;
  52   tcp_connection_t tcp_connection;
  53 } tcp_tx_trace_t;
  54
  55 static u8 *
  56 format_tcp_tx_trace (u8 * s, va_list * args)
  57 {
  58   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  59   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  60   tcp_tx_trace_t *t = va_arg (*args, tcp_tx_trace_t *);
  61   tcp_connection_t *tc = &t->tcp_connection;
  62   u32 indent = format_get_indent (s);
  63
  64   s = format (s, "%U state %U\n%U%U", format_tcp_connection_id, tc,
  65               format_tcp_state, tc->state, format_white_space, indent,
  66               format_tcp_header, &t->tcp_header, 128);
  67
  68   return s;
  69 }
  70
  71 #ifndef CLIB_MARCH_VARIANT
  72 static u8
  73 tcp_window_compute_scale (u32 window)
  74 {
  75   u8 wnd_scale = 0;
  76   while (wnd_scale < TCP_MAX_WND_SCALE && (window >> wnd_scale) > TCP_WND_MAX)
  77     wnd_scale++;
  78   return wnd_scale;
  79 }
  80
  81 /**
  82  * TCP's initial window
  83  */
  84 always_inline u32
  85 tcp_initial_wnd_unscaled (tcp_connection_t * tc)
  86 {
  87   /* RFC 6928 recommends the value lower. However at the time our connections
  88    * are initialized, fifos may not be allocated. Therefore, advertise the
  89    * smallest possible unscaled window size and update once fifos are
  90    * assigned to the session.
  91    */
  92   /*
  93      tcp_update_rcv_mss (tc);
  94      TCP_IW_N_SEGMENTS * tc->mss;
  95    */
  96   return tcp_cfg.min_rx_fifo;
  97 }
  98
  99 /**
 100  * Compute initial window and scale factor. As per RFC1323, window field in
 101  * SYN and SYN-ACK segments is never scaled.
 102  */
 103 u32
 104 tcp_initial_window_to_advertise (tcp_connection_t * tc)
 105 {
 106   /* Compute rcv wscale only if peer advertised support for it */
 107   if (tc->state != TCP_STATE_SYN_RCVD || tcp_opts_wscale (&tc->rcv_opts))
 108     tc->rcv_wscale = tcp_window_compute_scale (tcp_cfg.max_rx_fifo);
 109
 110   tc->rcv_wnd = tcp_initial_wnd_unscaled (tc);
 111
 112   return clib_min (tc->rcv_wnd, TCP_WND_MAX);
 113 }
 114
 115 static inline void
 116 tcp_update_rcv_wnd (tcp_connection_t * tc)
 117 {
 118   u32 available_space, wnd;
 119   i32 observed_wnd;
 120
 121   /*
 122    * Figure out how much space we have available
 123    */
 124   available_space = transport_max_rx_enqueue (&tc->connection);
 125
 126   /*
 127    * Use the above and what we know about what we've previously advertised
 128    * to compute the new window
 129    */
 130   observed_wnd = (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
 131
 132   /* Check if we are about to retract the window. Do the comparison before
 133    * rounding to avoid errors. Per RFC7323 sec. 2.4 we could remove this */
 134   if (PREDICT_FALSE ((i32) available_space < observed_wnd))
 135     {
 136       wnd = round_down_pow2 (clib_max (observed_wnd, 0), 1 << tc->rcv_wscale);
 137       TCP_EVT (TCP_EVT_RCV_WND_SHRUNK, tc, observed_wnd, available_space);
 138     }
 139   else
 140     {
 141       /* Make sure we have a multiple of 1 << rcv_wscale. We round down to
 142        * avoid advertising a window larger than what can be buffered */
 143       wnd = round_down_pow2 (available_space, 1 << tc->rcv_wscale);
 144     }
 145
 146   if (PREDICT_FALSE (wnd < tc->rcv_opts.mss))
 147     wnd = 0;
 148
 149   tc->rcv_wnd = clib_min (wnd, TCP_WND_MAX << tc->rcv_wscale);
 150 }
 151
 152 /**
 153  * Compute and return window to advertise, scaled as per RFC1323
 154  */
 155 static inline u32
 156 tcp_window_to_advertise (tcp_connection_t * tc, tcp_state_t state)
 157 {
 158   if (state < TCP_STATE_ESTABLISHED)
 159     return tcp_initial_window_to_advertise (tc);
 160
 161   tcp_update_rcv_wnd (tc);
 162   return tc->rcv_wnd >> tc->rcv_wscale;
 163 }
 164
 165 static int
 166 tcp_make_syn_options (tcp_connection_t * tc, tcp_options_t * opts)
 167 {
 168   u8 len = 0;
 169
 170   opts->flags |= TCP_OPTS_FLAG_MSS;
 171   opts->mss = tc->mss;
 172   len += TCP_OPTION_LEN_MSS;
 173
 174   opts->flags |= TCP_OPTS_FLAG_WSCALE;
 175   opts->wscale = tc->rcv_wscale;
 176   len += TCP_OPTION_LEN_WINDOW_SCALE;
 177
 178   opts->flags |= TCP_OPTS_FLAG_TSTAMP;
 179   opts->tsval = tcp_time_tstamp (tc->c_thread_index);
 180   opts->tsecr = 0;
 181   len += TCP_OPTION_LEN_TIMESTAMP;
 182
 183   if (TCP_USE_SACKS)
 184     {
 185       opts->flags |= TCP_OPTS_FLAG_SACK_PERMITTED;
 186       len += TCP_OPTION_LEN_SACK_PERMITTED;
 187     }
 188
 189   /* Align to needed boundary */
 190   len += (TCP_OPTS_ALIGN - len % TCP_OPTS_ALIGN) % TCP_OPTS_ALIGN;
 191   return len;
 192 }
 193
 194 static int
 195 tcp_make_synack_options (tcp_connection_t * tc, tcp_options_t * opts)
 196 {
 197   u8 len = 0;
 198
 199   opts->flags |= TCP_OPTS_FLAG_MSS;
 200   opts->mss = tc->mss;
 201   len += TCP_OPTION_LEN_MSS;
 202
 203   if (tcp_opts_wscale (&tc->rcv_opts))
 204     {
 205       opts->flags |= TCP_OPTS_FLAG_WSCALE;
 206       opts->wscale = tc->rcv_wscale;
 207       len += TCP_OPTION_LEN_WINDOW_SCALE;
 208     }
 209
 210   if (tcp_opts_tstamp (&tc->rcv_opts))
 211     {
 212       opts->flags |= TCP_OPTS_FLAG_TSTAMP;
 213       opts->tsval = tcp_time_tstamp (tc->c_thread_index);
 214       opts->tsecr = tc->tsval_recent;
 215       len += TCP_OPTION_LEN_TIMESTAMP;
 216     }
 217
 218   if (tcp_opts_sack_permitted (&tc->rcv_opts))
 219     {
 220       opts->flags |= TCP_OPTS_FLAG_SACK_PERMITTED;
 221       len += TCP_OPTION_LEN_SACK_PERMITTED;
 222     }
 223
 224   /* Align to needed boundary */
 225   len += (TCP_OPTS_ALIGN - len % TCP_OPTS_ALIGN) % TCP_OPTS_ALIGN;
 226   return len;
 227 }
 228
 229 static int
 230 tcp_make_established_options (tcp_connection_t * tc, tcp_options_t * opts)
 231 {
 232   u8 len = 0;
 233
 234   opts->flags = 0;
 235
 236   if (tcp_opts_tstamp (&tc->rcv_opts))
 237     {
 238       opts->flags |= TCP_OPTS_FLAG_TSTAMP;
 239       opts->tsval = tcp_tstamp (tc);
 240       opts->tsecr = tc->tsval_recent;
 241       len += TCP_OPTION_LEN_TIMESTAMP;
 242     }
 243   if (tcp_opts_sack_permitted (&tc->rcv_opts))
 244     {
 245       if (vec_len (tc->snd_sacks))
 246         {
 247           opts->flags |= TCP_OPTS_FLAG_SACK;
 248           if (tc->snd_sack_pos >= vec_len (tc->snd_sacks))
 249             tc->snd_sack_pos = 0;
 250           opts->sacks = &tc->snd_sacks[tc->snd_sack_pos];
 251           opts->n_sack_blocks = vec_len (tc->snd_sacks) - tc->snd_sack_pos;
 252           opts->n_sack_blocks = clib_min (opts->n_sack_blocks,
 253                                           TCP_OPTS_MAX_SACK_BLOCKS);
 254           tc->snd_sack_pos += opts->n_sack_blocks;
 255           len += 2 + TCP_OPTION_LEN_SACK_BLOCK * opts->n_sack_blocks;
 256         }
 257     }
 258
 259   /* Align to needed boundary */
 260   len += (TCP_OPTS_ALIGN - len % TCP_OPTS_ALIGN) % TCP_OPTS_ALIGN;
 261   return len;
 262 }
 263
 264 always_inline int
 265 tcp_make_options (tcp_connection_t * tc, tcp_options_t * opts,
 266                   tcp_state_t state)
 267 {
 268   switch (state)
 269     {
 270     case TCP_STATE_ESTABLISHED:
 271     case TCP_STATE_CLOSE_WAIT:
 272     case TCP_STATE_FIN_WAIT_1:
 273     case TCP_STATE_LAST_ACK:
 274     case TCP_STATE_CLOSING:
 275     case TCP_STATE_FIN_WAIT_2:
 276     case TCP_STATE_TIME_WAIT:
 277     case TCP_STATE_CLOSED:
 278       return tcp_make_established_options (tc, opts);
 279     case TCP_STATE_SYN_RCVD:
 280       return tcp_make_synack_options (tc, opts);
 281     case TCP_STATE_SYN_SENT:
 282       return tcp_make_syn_options (tc, opts);
 283     default:
 284       clib_warning ("State not handled! %d", state);
 285       return 0;
 286     }
 287 }
 288
 289 /**
 290  * Update burst send vars
 291  *
 292  * - Updates snd_mss to reflect the effective segment size that we can send
 293  * by taking into account all TCP options, including SACKs.
 294  * - Cache 'on the wire' options for reuse
 295  * - Updates receive window which can be reused for a burst.
 296  *
 297  * This should *only* be called when doing bursts
 298  */
 299 void
 300 tcp_update_burst_snd_vars (tcp_connection_t * tc)
 301 {
 302   tcp_main_t *tm = &tcp_main;
 303
 304   /* Compute options to be used for connection. These may be reused when
 305    * sending data or to compute the effective mss (snd_mss) */
 306   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts,
 307                                        TCP_STATE_ESTABLISHED);
 308
 309   /* XXX check if MTU has been updated */
 310   tc->snd_mss = clib_min (tc->mss, tc->rcv_opts.mss) - tc->snd_opts_len;
 311   ASSERT (tc->snd_mss > 0);
 312
 313   tcp_options_write (tm->wrk_ctx[tc->c_thread_index].cached_opts,
 314                      &tc->snd_opts);
 315
 316   tcp_update_rcv_wnd (tc);
 317
 318   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
 319     tcp_bt_check_app_limited (tc);
 320
 321   if (tc->snd_una == tc->snd_nxt)
 322     {
 323       tcp_cc_event (tc, TCP_CC_EVT_START_TX);
 324       tcp_connection_tx_pacer_reset (tc, tc->cwnd, TRANSPORT_PACER_MIN_BURST);
 325     }
 326
 327   if (tc->flags & TCP_CONN_PSH_PENDING)
 328     {
 329       u32 max_deq = transport_max_tx_dequeue (&tc->connection);
 330       /* Last byte marked for push */
 331       tc->psh_seq = tc->snd_una + max_deq - 1;
 332     }
 333 }
 334
 335 #endif /* CLIB_MARCH_VARIANT */
 336
 337 static void *
 338 tcp_reuse_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 339 {
 340   if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 341     vlib_buffer_free_one (vm, b->next_buffer);
 342   /* Zero all flags but free list index and trace flag */
 343   b->flags &= VLIB_BUFFER_NEXT_PRESENT - 1;
 344   b->current_data = 0;
 345   b->current_length = 0;
 346   b->total_length_not_including_first_buffer = 0;
 347   vnet_buffer (b)->tcp.flags = 0;
 348
 349   /* Leave enough space for headers */
 350   return vlib_buffer_make_headroom (b, TRANSPORT_MAX_HDRS_LEN);
 351 }
 352
 353 #ifndef CLIB_MARCH_VARIANT
 354 static void *
 355 tcp_init_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 356 {
 357   ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
 358   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 359   b->total_length_not_including_first_buffer = 0;
 360   b->current_data = 0;
 361   vnet_buffer (b)->tcp.flags = 0;
 362   VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
 363   /* Leave enough space for headers */
 364   return vlib_buffer_make_headroom (b, TRANSPORT_MAX_HDRS_LEN);
 365 }
 366
 367
 368 /* Compute TCP checksum in software when offloading is disabled for a connection */
 369 u16
 370 ip6_tcp_compute_checksum_custom (vlib_main_t * vm, vlib_buffer_t * p0,
 371                                  ip46_address_t * src, ip46_address_t * dst)
 372 {
 373   ip_csum_t sum0;
 374   u16 payload_length_host_byte_order;
 375   u32 i;
 376
 377   /* Initialize checksum with ip header. */
 378   sum0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, p0)) +
 379     clib_host_to_net_u16 (IP_PROTOCOL_TCP);
 380   payload_length_host_byte_order = vlib_buffer_length_in_chain (vm, p0);
 381
 382   for (i = 0; i < ARRAY_LEN (src->ip6.as_uword); i++)
 383     {
 384       sum0 = ip_csum_with_carry
 385         (sum0, clib_mem_unaligned (&src->ip6.as_uword[i], uword));
 386       sum0 = ip_csum_with_carry
 387         (sum0, clib_mem_unaligned (&dst->ip6.as_uword[i], uword));
 388     }
 389
 390   return ip_calculate_l4_checksum (vm, p0, sum0,
 391                                    payload_length_host_byte_order, NULL, 0,
 392                                    NULL);
 393 }
 394
 395 u16
 396 ip4_tcp_compute_checksum_custom (vlib_main_t * vm, vlib_buffer_t * p0,
 397                                  ip46_address_t * src, ip46_address_t * dst)
 398 {
 399   ip_csum_t sum0;
 400   u32 payload_length_host_byte_order;
 401
 402   payload_length_host_byte_order = vlib_buffer_length_in_chain (vm, p0);
 403   sum0 =
 404     clib_host_to_net_u32 (payload_length_host_byte_order +
 405                           (IP_PROTOCOL_TCP << 16));
 406
 407   sum0 = ip_csum_with_carry (sum0, clib_mem_unaligned (&src->ip4, u32));
 408   sum0 = ip_csum_with_carry (sum0, clib_mem_unaligned (&dst->ip4, u32));
 409
 410   return ip_calculate_l4_checksum (vm, p0, sum0,
 411                                    payload_length_host_byte_order, NULL, 0,
 412                                    NULL);
 413 }
 414
 415 static inline u16
 416 tcp_compute_checksum (tcp_connection_t * tc, vlib_buffer_t * b)
 417 {
 418   u16 checksum = 0;
 419   if (PREDICT_FALSE (tc->cfg_flags & TCP_CFG_F_NO_CSUM_OFFLOAD))
 420     {
 421       tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 422       vlib_main_t *vm = wrk->vm;
 423
 424       if (tc->c_is_ip4)
 425         checksum = ip4_tcp_compute_checksum_custom
 426           (vm, b, &tc->c_lcl_ip, &tc->c_rmt_ip);
 427       else
 428         checksum = ip6_tcp_compute_checksum_custom
 429           (vm, b, &tc->c_lcl_ip, &tc->c_rmt_ip);
 430     }
 431   else
 432     {
 433       vnet_buffer_offload_flags_set (b, VNET_BUFFER_OFFLOAD_F_TCP_CKSUM);
 434     }
 435   return checksum;
 436 }
 437
 438 /**
 439  * Prepare ACK
 440  */
 441 static inline void
 442 tcp_make_ack_i (tcp_connection_t * tc, vlib_buffer_t * b, tcp_state_t state,
 443                 u8 flags)
 444 {
 445   tcp_options_t _snd_opts, *snd_opts = &_snd_opts;
 446   u8 tcp_opts_len, tcp_hdr_opts_len;
 447   tcp_header_t *th;
 448   u16 wnd;
 449
 450   wnd = tcp_window_to_advertise (tc, state);
 451
 452   /* Make and write options */
 453   tcp_opts_len = tcp_make_established_options (tc, snd_opts);
 454   tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
 455
 456   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->snd_nxt,
 457                              tc->rcv_nxt, tcp_hdr_opts_len, flags, wnd);
 458
 459   tcp_options_write ((u8 *) (th + 1), snd_opts);
 460
 461   th->checksum = tcp_compute_checksum (tc, b);
 462
 463   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 464
 465   if (wnd == 0)
 466     {
 467       transport_rx_fifo_req_deq_ntf (&tc->connection);
 468       tcp_zero_rwnd_sent_on (tc);
 469     }
 470   else
 471     tcp_zero_rwnd_sent_off (tc);
 472 }
 473
 474 /**
 475  * Convert buffer to ACK
 476  */
 477 static inline void
 478 tcp_make_ack (tcp_connection_t * tc, vlib_buffer_t * b)
 479 {
 480   tcp_make_ack_i (tc, b, TCP_STATE_ESTABLISHED, TCP_FLAG_ACK);
 481   TCP_EVT (TCP_EVT_ACK_SENT, tc);
 482   tc->rcv_las = tc->rcv_nxt;
 483 }
 484
 485 /**
 486  * Convert buffer to FIN-ACK
 487  */
 488 static void
 489 tcp_make_fin (tcp_connection_t * tc, vlib_buffer_t * b)
 490 {
 491   tcp_make_ack_i (tc, b, TCP_STATE_ESTABLISHED, TCP_FLAG_FIN | TCP_FLAG_ACK);
 492 }
 493
 494 /**
 495  * Convert buffer to SYN
 496  */
 497 void
 498 tcp_make_syn (tcp_connection_t * tc, vlib_buffer_t * b)
 499 {
 500   u8 tcp_hdr_opts_len, tcp_opts_len;
 501   tcp_header_t *th;
 502   u16 initial_wnd;
 503   tcp_options_t snd_opts;
 504
 505   initial_wnd = tcp_initial_window_to_advertise (tc);
 506
 507   /* Make and write options */
 508   clib_memset (&snd_opts, 0, sizeof (snd_opts));
 509   tcp_opts_len = tcp_make_syn_options (tc, &snd_opts);
 510   tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
 511
 512   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->iss,
 513                              tc->rcv_nxt, tcp_hdr_opts_len, TCP_FLAG_SYN,
 514                              initial_wnd);
 515   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 516   tcp_options_write ((u8 *) (th + 1), &snd_opts);
 517   th->checksum = tcp_compute_checksum (tc, b);
 518 }
 519
 520 /**
 521  * Convert buffer to SYN-ACK
 522  */
 523 static void
 524 tcp_make_synack (tcp_connection_t * tc, vlib_buffer_t * b)
 525 {
 526   tcp_options_t _snd_opts, *snd_opts = &_snd_opts;
 527   u8 tcp_opts_len, tcp_hdr_opts_len;
 528   tcp_header_t *th;
 529   u16 initial_wnd;
 530
 531   clib_memset (snd_opts, 0, sizeof (*snd_opts));
 532   initial_wnd = tcp_initial_window_to_advertise (tc);
 533   tcp_opts_len = tcp_make_synack_options (tc, snd_opts);
 534   tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
 535
 536   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->iss,
 537                              tc->rcv_nxt, tcp_hdr_opts_len,
 538                              TCP_FLAG_SYN | TCP_FLAG_ACK, initial_wnd);
 539   tcp_options_write ((u8 *) (th + 1), snd_opts);
 540
 541   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 542   th->checksum = tcp_compute_checksum (tc, b);
 543 }
 544
 545 static void
 546 tcp_enqueue_to_ip_lookup (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
 547                           u8 is_ip4, u32 fib_index)
 548 {
 549   tcp_main_t *tm = &tcp_main;
 550   vlib_main_t *vm = wrk->vm;
 551
 552   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 553   b->error = 0;
 554
 555   vnet_buffer (b)->sw_if_index[VLIB_TX] = fib_index;
 556   vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
 557
 558   tcp_trajectory_add_start (b, 1);
 559
 560   session_add_pending_tx_buffer (vm->thread_index, bi,
 561                                  tm->ipl_next_node[!is_ip4]);
 562
 563   if (vm->thread_index == 0 && vlib_num_workers ())
 564     session_queue_run_on_main_thread (wrk->vm);
 565 }
 566
 567 static void
 568 tcp_enqueue_to_output (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
 569                        u8 is_ip4)
 570 {
 571   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 572   b->error = 0;
 573
 574   session_add_pending_tx_buffer (wrk->vm->thread_index, bi,
 575                                  wrk->tco_next_node[!is_ip4]);
 576 }
 577
 578 #endif /* CLIB_MARCH_VARIANT */
 579
 580 static int
 581 tcp_make_reset_in_place (vlib_main_t * vm, vlib_buffer_t * b, u8 is_ip4)
 582 {
 583   ip4_header_t *ih4;
 584   ip6_header_t *ih6;
 585   tcp_header_t *th;
 586   ip4_address_t src_ip4, dst_ip4;
 587   ip6_address_t src_ip6, dst_ip6;
 588   u16 src_port, dst_port;
 589   u32 tmp, len, seq, ack;
 590   u8 flags;
 591
 592   /* Find IP and TCP headers */
 593   th = tcp_buffer_hdr (b);
 594
 595   /* Save src and dst ip */
 596   if (is_ip4)
 597     {
 598       ih4 = vlib_buffer_get_current (b);
 599       ASSERT ((ih4->ip_version_and_header_length & 0xF0) == 0x40);
 600       src_ip4.as_u32 = ih4->src_address.as_u32;
 601       dst_ip4.as_u32 = ih4->dst_address.as_u32;
 602     }
 603   else
 604     {
 605       ih6 = vlib_buffer_get_current (b);
 606       ASSERT ((ih6->ip_version_traffic_class_and_flow_label & 0xF0) == 0x60);
 607       clib_memcpy_fast (&src_ip6, &ih6->src_address, sizeof (ip6_address_t));
 608       clib_memcpy_fast (&dst_ip6, &ih6->dst_address, sizeof (ip6_address_t));
 609     }
 610
 611   src_port = th->src_port;
 612   dst_port = th->dst_port;
 613   flags = TCP_FLAG_RST;
 614
 615   /*
 616    * RFC 793. If the ACK bit is off, sequence number zero is used,
 617    *   <SEQ=0><ACK=SEG.SEQ+SEG.LEN><CTL=RST,ACK>
 618    * If the ACK bit is on,
 619    *   <SEQ=SEG.ACK><CTL=RST>
 620    */
 621   if (tcp_ack (th))
 622     {
 623       seq = th->ack_number;
 624       ack = 0;
 625     }
 626   else
 627     {
 628       flags |= TCP_FLAG_ACK;
 629       tmp = clib_net_to_host_u32 (th->seq_number);
 630       len = vnet_buffer (b)->tcp.data_len + tcp_is_syn (th) + tcp_is_fin (th);
 631       ack = clib_host_to_net_u32 (tmp + len);
 632       seq = 0;
 633     }
 634
 635   tcp_reuse_buffer (vm, b);
 636   tcp_trajectory_add_start (b, 4);
 637   th = vlib_buffer_push_tcp_net_order (b, dst_port, src_port, seq, ack,
 638                                        sizeof (tcp_header_t), flags, 0);
 639
 640   if (is_ip4)
 641     {
 642       ih4 = vlib_buffer_push_ip4 (vm, b, &dst_ip4, &src_ip4,
 643                                   IP_PROTOCOL_TCP, 1);
 644       th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ih4);
 645     }
 646   else
 647     {
 648       int bogus = ~0;
 649       ih6 = vlib_buffer_push_ip6 (vm, b, &dst_ip6, &src_ip6, IP_PROTOCOL_TCP);
 650       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
 651       ASSERT (!bogus);
 652     }
 653
 654   return 0;
 655 }
 656
 657 #ifndef CLIB_MARCH_VARIANT
 658 /**
 659  *  Send reset without reusing existing buffer
 660  *
 661  *  It extracts connection info out of original packet
 662  */
 663 void
 664 tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt,
 665                       u32 thread_index, u8 is_ip4)
 666 {
 667   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
 668   vlib_main_t *vm = wrk->vm;
 669   vlib_buffer_t *b;
 670   u32 bi, sw_if_index, fib_index;
 671   u8 tcp_hdr_len, flags = 0;
 672   tcp_header_t *th, *pkt_th;
 673   u32 seq, ack;
 674   ip4_header_t *ih4, *pkt_ih4;
 675   ip6_header_t *ih6, *pkt_ih6;
 676   fib_protocol_t fib_proto;
 677
 678   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
 679     {
 680       tcp_worker_stats_inc (wrk, no_buffer, 1);
 681       return;
 682     }
 683
 684   b = vlib_get_buffer (vm, bi);
 685   sw_if_index = vnet_buffer (pkt)->sw_if_index[VLIB_RX];
 686   fib_proto = is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
 687   fib_index = fib_table_get_index_for_sw_if_index (fib_proto, sw_if_index);
 688   tcp_init_buffer (vm, b);
 689
 690   /* Make and write options */
 691   tcp_hdr_len = sizeof (tcp_header_t);
 692
 693   if (is_ip4)
 694     {
 695       pkt_ih4 = vlib_buffer_get_current (pkt);
 696       pkt_th = ip4_next_header (pkt_ih4);
 697     }
 698   else
 699     {
 700       pkt_ih6 = vlib_buffer_get_current (pkt);
 701       pkt_th = ip6_next_header (pkt_ih6);
 702     }
 703
 704   if (tcp_ack (pkt_th))
 705     {
 706       flags = TCP_FLAG_RST;
 707       seq = pkt_th->ack_number;
 708       ack = (tc->state >= TCP_STATE_SYN_RCVD) ? tc->rcv_nxt : 0;
 709     }
 710   else
 711     {
 712       flags = TCP_FLAG_RST | TCP_FLAG_ACK;
 713       seq = 0;
 714       ack = clib_host_to_net_u32 (vnet_buffer (pkt)->tcp.seq_end);
 715     }
 716
 717   th = vlib_buffer_push_tcp_net_order (b, pkt_th->dst_port, pkt_th->src_port,
 718                                        seq, ack, tcp_hdr_len, flags, 0);
 719
 720   /* Swap src and dst ip */
 721   if (is_ip4)
 722     {
 723       ASSERT ((pkt_ih4->ip_version_and_header_length & 0xF0) == 0x40);
 724       ih4 = vlib_buffer_push_ip4 (vm, b, &pkt_ih4->dst_address,
 725                                   &pkt_ih4->src_address, IP_PROTOCOL_TCP,
 726                                   tcp_csum_offload (tc));
 727       th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ih4);
 728     }
 729   else
 730     {
 731       int bogus = ~0;
 732       ASSERT ((pkt_ih6->ip_version_traffic_class_and_flow_label & 0xF0) ==
 733               0x60);
 734       ih6 = vlib_buffer_push_ip6_custom (vm, b, &pkt_ih6->dst_address,
 735                                          &pkt_ih6->src_address,
 736                                          IP_PROTOCOL_TCP,
 737                                          tc->ipv6_flow_label);
 738       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
 739       ASSERT (!bogus);
 740     }
 741
 742   tcp_enqueue_to_ip_lookup (wrk, b, bi, is_ip4, fib_index);
 743   TCP_EVT (TCP_EVT_RST_SENT, tc);
 744   vlib_node_increment_counter (vm, tcp_node_index (output, tc->c_is_ip4),
 745                                TCP_ERROR_RST_SENT, 1);
 746 }
 747
 748 /**
 749  * Build and set reset packet for connection
 750  */
 751 void
 752 tcp_send_reset (tcp_connection_t * tc)
 753 {
 754   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 755   vlib_main_t *vm = wrk->vm;
 756   vlib_buffer_t *b;
 757   u32 bi;
 758   tcp_header_t *th;
 759   u16 tcp_hdr_opts_len, advertise_wnd, opts_write_len;
 760   u8 flags;
 761
 762   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
 763     {
 764       tcp_worker_stats_inc (wrk, no_buffer, 1);
 765       return;
 766     }
 767   b = vlib_get_buffer (vm, bi);
 768   tcp_init_buffer (vm, b);
 769
 770   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
 771   tcp_hdr_opts_len = tc->snd_opts_len + sizeof (tcp_header_t);
 772   advertise_wnd = tc->rcv_wnd >> tc->rcv_wscale;
 773   flags = TCP_FLAG_RST;
 774   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->snd_nxt,
 775                              tc->rcv_nxt, tcp_hdr_opts_len, flags,
 776                              advertise_wnd);
 777   opts_write_len = tcp_options_write ((u8 *) (th + 1), &tc->snd_opts);
 778   th->checksum = tcp_compute_checksum (tc, b);
 779   ASSERT (opts_write_len == tc->snd_opts_len);
 780   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 781   tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
 782   TCP_EVT (TCP_EVT_RST_SENT, tc);
 783   vlib_node_increment_counter (vm, tcp_node_index (output, tc->c_is_ip4),
 784                                TCP_ERROR_RST_SENT, 1);
 785 }
 786
 787 static void
 788 tcp_push_ip_hdr (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
 789                  vlib_buffer_t * b)
 790 {
 791   if (tc->c_is_ip4)
 792     {
 793       vlib_buffer_push_ip4 (wrk->vm, b, &tc->c_lcl_ip4, &tc->c_rmt_ip4,
 794                             IP_PROTOCOL_TCP, tcp_csum_offload (tc));
 795     }
 796   else
 797     {
 798       vlib_buffer_push_ip6_custom (wrk->vm, b, &tc->c_lcl_ip6, &tc->c_rmt_ip6,
 799                                    IP_PROTOCOL_TCP, tc->ipv6_flow_label);
 800     }
 801 }
 802
 803 /**
 804  *  Send SYN
 805  *
 806  *  Builds a SYN packet for a half-open connection and sends it to ipx_lookup.
 807  *  The packet is not forwarded through tcpx_output to avoid doing lookups
 808  *  in the half_open pool.
 809  */
 810 void
 811 tcp_send_syn (tcp_connection_t * tc)
 812 {
 813   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 814   vlib_main_t *vm = wrk->vm;
 815   vlib_buffer_t *b;
 816   u32 bi;
 817
 818   /*
 819    * Setup retransmit and establish timers before requesting buffer
 820    * such that we can return if we've ran out.
 821    */
 822   tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN,
 823                     tc->rto * TCP_TO_TIMER_TICK);
 824
 825   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
 826     {
 827       tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN, 1);
 828       tcp_worker_stats_inc (wrk, no_buffer, 1);
 829       return;
 830     }
 831
 832   b = vlib_get_buffer (vm, bi);
 833   tcp_init_buffer (vm, b);
 834   tcp_make_syn (tc, b);
 835
 836   /* Measure RTT with this */
 837   tc->rtt_ts = tcp_time_now_us (vlib_num_workers ()? 1 : 0);
 838   tc->rtt_seq = tc->snd_nxt;
 839   tc->rto_boff = 0;
 840
 841   tcp_push_ip_hdr (wrk, tc, b);
 842   tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
 843   TCP_EVT (TCP_EVT_SYN_SENT, tc);
 844 }
 845
 846 void
 847 tcp_send_synack (tcp_connection_t * tc)
 848 {
 849   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 850   vlib_main_t *vm = wrk->vm;
 851   vlib_buffer_t *b;
 852   u32 bi;
 853
 854   ASSERT (tc->snd_una != tc->snd_nxt);
 855   tcp_retransmit_timer_update (&wrk->timer_wheel, tc);
 856
 857   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
 858     {
 859       tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT, 1);
 860       tcp_worker_stats_inc (wrk, no_buffer, 1);
 861       return;
 862     }
 863
 864   tc->rtt_ts = tcp_time_now_us (tc->c_thread_index);
 865   b = vlib_get_buffer (vm, bi);
 866   tcp_init_buffer (vm, b);
 867   tcp_make_synack (tc, b);
 868   tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
 869   TCP_EVT (TCP_EVT_SYNACK_SENT, tc);
 870 }
 871
 872 /**
 873  *  Send FIN
 874  */
 875 void
 876 tcp_send_fin (tcp_connection_t * tc)
 877 {
 878   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 879   vlib_main_t *vm = wrk->vm;
 880   vlib_buffer_t *b;
 881   u32 bi;
 882   u8 fin_snt = 0;
 883
 884   fin_snt = tc->flags & TCP_CONN_FINSNT;
 885   if (fin_snt)
 886     tc->snd_nxt -= 1;
 887
 888   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
 889     {
 890       /* Out of buffers so program fin retransmit ASAP */
 891       tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT, 1);
 892       if (fin_snt)
 893         tc->snd_nxt += 1;
 894       else
 895         /* Make sure retransmit retries a fin not data */
 896         tc->flags |= TCP_CONN_FINSNT;
 897       tcp_worker_stats_inc (wrk, no_buffer, 1);
 898       return;
 899     }
 900
 901   /* If we have non-dupacks programmed, no need to send them */
 902   if ((tc->flags & TCP_CONN_SNDACK) && !tc->pending_dupacks)
 903     tc->flags &= ~TCP_CONN_SNDACK;
 904
 905   b = vlib_get_buffer (vm, bi);
 906   tcp_init_buffer (vm, b);
 907   tcp_make_fin (tc, b);
 908   tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
 909   TCP_EVT (TCP_EVT_FIN_SENT, tc);
 910   /* Account for the FIN */
 911   tc->snd_nxt += 1;
 912   tcp_retransmit_timer_update (&wrk->timer_wheel, tc);
 913   if (!fin_snt)
 914     {
 915       tc->flags |= TCP_CONN_FINSNT;
 916       tc->flags &= ~TCP_CONN_FINPNDG;
 917     }
 918 }
 919
 920 /**
 921  * Push TCP header and update connection variables. Should only be called
 922  * for segments with data, not for 'control' packets.
 923  */
 924 always_inline void
 925 tcp_push_hdr_i (tcp_connection_t * tc, vlib_buffer_t * b, u32 snd_nxt,
 926                 u8 compute_opts, u8 maybe_burst, u8 update_snd_nxt)
 927 {
 928   u8 tcp_hdr_opts_len, flags = TCP_FLAG_ACK;
 929   u32 advertise_wnd, data_len;
 930   tcp_main_t *tm = &tcp_main;
 931   tcp_header_t *th;
 932
 933   data_len = b->current_length;
 934   if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 935     data_len += b->total_length_not_including_first_buffer;
 936
 937   vnet_buffer (b)->tcp.flags = 0;
 938   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 939
 940   if (compute_opts)
 941     tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
 942
 943   tcp_hdr_opts_len = tc->snd_opts_len + sizeof (tcp_header_t);
 944
 945   if (maybe_burst)
 946     advertise_wnd = tc->rcv_wnd >> tc->rcv_wscale;
 947   else
 948     advertise_wnd = tcp_window_to_advertise (tc, TCP_STATE_ESTABLISHED);
 949
 950   if (PREDICT_FALSE (tc->flags & TCP_CONN_PSH_PENDING))
 951     {
 952       if (seq_geq (tc->psh_seq, snd_nxt)
 953           && seq_lt (tc->psh_seq, snd_nxt + data_len))
 954         flags |= TCP_FLAG_PSH;
 955     }
 956   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, snd_nxt,
 957                              tc->rcv_nxt, tcp_hdr_opts_len, flags,
 958                              advertise_wnd);
 959
 960   if (maybe_burst)
 961     {
 962       clib_memcpy_fast ((u8 *) (th + 1),
 963                         tm->wrk_ctx[tc->c_thread_index].cached_opts,
 964                         tc->snd_opts_len);
 965     }
 966   else
 967     {
 968       u8 len = tcp_options_write ((u8 *) (th + 1), &tc->snd_opts);
 969       ASSERT (len == tc->snd_opts_len);
 970     }
 971
 972   /*
 973    * Update connection variables
 974    */
 975
 976   if (update_snd_nxt)
 977     tc->snd_nxt += data_len;
 978   tc->rcv_las = tc->rcv_nxt;
 979
 980   tc->bytes_out += data_len;
 981   tc->data_segs_out += 1;
 982
 983   th->checksum = tcp_compute_checksum (tc, b);
 984
 985   TCP_EVT (TCP_EVT_PKTIZE, tc);
 986 }
 987
 988 always_inline u32
 989 tcp_buffer_len (vlib_buffer_t * b)
 990 {
 991   u32 data_len = b->current_length;
 992   if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 993     data_len += b->total_length_not_including_first_buffer;
 994   return data_len;
 995 }
 996
 997 u32
 998 tcp_session_push_header (transport_connection_t * tconn, vlib_buffer_t * b)
 999 {
1000   tcp_connection_t *tc = (tcp_connection_t *) tconn;
1001
1002   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
1003     tcp_bt_track_tx (tc, tcp_buffer_len (b));
1004
1005   tcp_push_hdr_i (tc, b, tc->snd_nxt, /* compute opts */ 0, /* burst */ 1,
1006                   /* update_snd_nxt */ 1);
1007
1008   tcp_validate_txf_size (tc, tc->snd_nxt - tc->snd_una);
1009   /* If not tracking an ACK, start tracking */
1010   if (tc->rtt_ts == 0 && !tcp_in_cong_recovery (tc))
1011     {
1012       tc->rtt_ts = tcp_time_now_us (tc->c_thread_index);
1013       tc->rtt_seq = tc->snd_nxt;
1014     }
1015   if (PREDICT_FALSE (!tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)))
1016     {
1017       tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
1018       tcp_retransmit_timer_set (&wrk->timer_wheel, tc);
1019       tc->rto_boff = 0;
1020     }
1021   tcp_trajectory_add_start (b, 3);
1022   return 0;
1023 }
1024
1025 void
1026 tcp_send_ack (tcp_connection_t * tc)
1027 {
1028   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
1029   vlib_main_t *vm = wrk->vm;
1030   vlib_buffer_t *b;
1031   u32 bi;
1032
1033   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
1034     {
1035       tcp_update_rcv_wnd (tc);
1036       tcp_worker_stats_inc (wrk, no_buffer, 1);
1037       return;
1038     }
1039   b = vlib_get_buffer (vm, bi);
1040   tcp_init_buffer (vm, b);
1041   tcp_make_ack (tc, b);
1042   tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1043 }
1044
1045 void
1046 tcp_program_ack (tcp_connection_t * tc)
1047 {
1048   if (!(tc->flags & TCP_CONN_SNDACK))
1049     {
1050       session_add_self_custom_tx_evt (&tc->connection, 1);
1051       tc->flags |= TCP_CONN_SNDACK;
1052     }
1053 }
1054
1055 void
1056 tcp_program_dupack (tcp_connection_t * tc)
1057 {
1058   if (!(tc->flags & TCP_CONN_SNDACK))
1059     {
1060       session_add_self_custom_tx_evt (&tc->connection, 1);
1061       tc->flags |= TCP_CONN_SNDACK;
1062     }
1063   if (tc->pending_dupacks < 255)
1064     tc->pending_dupacks += 1;
1065 }
1066
1067 void
1068 tcp_program_retransmit (tcp_connection_t * tc)
1069 {
1070   if (!(tc->flags & TCP_CONN_RXT_PENDING))
1071     {
1072       session_add_self_custom_tx_evt (&tc->connection, 0);
1073       tc->flags |= TCP_CONN_RXT_PENDING;
1074     }
1075 }
1076
1077 /**
1078  * Send window update ack
1079  *
1080  * Ensures that it will be sent only once, after a zero rwnd has been
1081  * advertised in a previous ack, and only if rwnd has grown beyond a
1082  * configurable value.
1083  */
1084 void
1085 tcp_send_window_update_ack (tcp_connection_t * tc)
1086 {
1087   if (tcp_zero_rwnd_sent (tc))
1088     {
1089       tcp_update_rcv_wnd (tc);
1090       if (tc->rcv_wnd >= tcp_cfg.rwnd_min_update_ack * tc->snd_mss)
1091         {
1092           tcp_zero_rwnd_sent_off (tc);
1093           tcp_program_ack (tc);
1094         }
1095     }
1096 }
1097
1098 /**
1099  * Allocate a new buffer and build a new tcp segment
1100  *
1101  * @param wrk           tcp worker
1102  * @param tc            connection for which the segment will be allocated
1103  * @param offset        offset of the first byte in the tx fifo
1104  * @param max_deq_byte  segment size
1105  * @param[out] b        pointer to buffer allocated
1106  *
1107  * @return      the number of bytes in the segment or 0 if buffer cannot be
1108  *              allocated or no data available
1109  */
1110 static int
1111 tcp_prepare_segment (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
1112                      u32 offset, u32 max_deq_bytes, vlib_buffer_t ** b)
1113 {
1114   u32 bytes_per_buffer = vnet_get_tcp_main ()->bytes_per_buffer;
1115   vlib_main_t *vm = wrk->vm;
1116   u32 bi, seg_size;
1117   int n_bytes = 0;
1118   u8 *data;
1119
1120   seg_size = max_deq_bytes + TRANSPORT_MAX_HDRS_LEN;
1121
1122   /*
1123    * Prepare options
1124    */
1125   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
1126
1127   /*
1128    * Allocate and fill in buffer(s)
1129    */
1130
1131   /* Easy case, buffer size greater than mss */
1132   if (PREDICT_TRUE (seg_size <= bytes_per_buffer))
1133     {
1134       if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
1135         {
1136           tcp_worker_stats_inc (wrk, no_buffer, 1);
1137           return 0;
1138         }
1139       *b = vlib_get_buffer (vm, bi);
1140       data = tcp_init_buffer (vm, *b);
1141       n_bytes = session_tx_fifo_peek_bytes (&tc->connection, data, offset,
1142                                             max_deq_bytes);
1143       ASSERT (n_bytes == max_deq_bytes);
1144       b[0]->current_length = n_bytes;
1145       tcp_push_hdr_i (tc, *b, tc->snd_una + offset, /* compute opts */ 0,
1146                       /* burst */ 0, /* update_snd_nxt */ 0);
1147     }
1148   /* Split mss into multiple buffers */
1149   else
1150     {
1151       u32 chain_bi = ~0, n_bufs_per_seg, n_bufs;
1152       u16 n_peeked, len_to_deq;
1153       vlib_buffer_t *chain_b, *prev_b;
1154       int i;
1155
1156       /* Make sure we have enough buffers */
1157       n_bufs_per_seg = ceil ((double) seg_size / bytes_per_buffer);
1158       vec_validate_aligned (wrk->tx_buffers, n_bufs_per_seg - 1,
1159                             CLIB_CACHE_LINE_BYTES);
1160       n_bufs = vlib_buffer_alloc (vm, wrk->tx_buffers, n_bufs_per_seg);
1161       if (PREDICT_FALSE (n_bufs != n_bufs_per_seg))
1162         {
1163           if (n_bufs)
1164             vlib_buffer_free (vm, wrk->tx_buffers, n_bufs);
1165           tcp_worker_stats_inc (wrk, no_buffer, 1);
1166           return 0;
1167         }
1168
1169       *b = vlib_get_buffer (vm, wrk->tx_buffers[--n_bufs]);
1170       data = tcp_init_buffer (vm, *b);
1171       n_bytes = session_tx_fifo_peek_bytes (&tc->connection, data, offset,
1172                                             bytes_per_buffer -
1173                                             TRANSPORT_MAX_HDRS_LEN);
1174       b[0]->current_length = n_bytes;
1175       b[0]->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
1176       b[0]->total_length_not_including_first_buffer = 0;
1177       max_deq_bytes -= n_bytes;
1178
1179       chain_b = *b;
1180       for (i = 1; i < n_bufs_per_seg; i++)
1181         {
1182           prev_b = chain_b;
1183           len_to_deq = clib_min (max_deq_bytes, bytes_per_buffer);
1184           chain_bi = wrk->tx_buffers[--n_bufs];
1185           chain_b = vlib_get_buffer (vm, chain_bi);
1186           chain_b->current_data = 0;
1187           data = vlib_buffer_get_current (chain_b);
1188           n_peeked = session_tx_fifo_peek_bytes (&tc->connection, data,
1189                                                  offset + n_bytes,
1190                                                  len_to_deq);
1191           ASSERT (n_peeked == len_to_deq);
1192           n_bytes += n_peeked;
1193           chain_b->current_length = n_peeked;
1194           chain_b->next_buffer = 0;
1195
1196           /* update previous buffer */
1197           prev_b->next_buffer = chain_bi;
1198           prev_b->flags |= VLIB_BUFFER_NEXT_PRESENT;
1199
1200           max_deq_bytes -= n_peeked;
1201           b[0]->total_length_not_including_first_buffer += n_peeked;
1202         }
1203
1204       tcp_push_hdr_i (tc, *b, tc->snd_una + offset, /* compute opts */ 0,
1205                       /* burst */ 0, /* update_snd_nxt */ 0);
1206
1207       if (PREDICT_FALSE (n_bufs))
1208         {
1209           clib_warning ("not all buffers consumed");
1210           vlib_buffer_free (vm, wrk->tx_buffers, n_bufs);
1211         }
1212     }
1213
1214   ASSERT (n_bytes > 0);
1215   ASSERT (((*b)->current_data + (*b)->current_length) <= bytes_per_buffer);
1216
1217   return n_bytes;
1218 }
1219
1220 /**
1221  * Build a retransmit segment
1222  *
1223  * @return the number of bytes in the segment or 0 if there's nothing to
1224  *         retransmit
1225  */
1226 static u32
1227 tcp_prepare_retransmit_segment (tcp_worker_ctx_t * wrk,
1228                                 tcp_connection_t * tc, u32 offset,
1229                                 u32 max_deq_bytes, vlib_buffer_t ** b)
1230 {
1231   u32 start, available_bytes;
1232   int n_bytes = 0;
1233
1234   ASSERT (tc->state >= TCP_STATE_ESTABLISHED);
1235   ASSERT (max_deq_bytes != 0);
1236
1237   /*
1238    * Make sure we can retransmit something
1239    */
1240   available_bytes = transport_max_tx_dequeue (&tc->connection);
1241   ASSERT (available_bytes >= offset);
1242   available_bytes -= offset;
1243   if (!available_bytes)
1244     return 0;
1245
1246   max_deq_bytes = clib_min (tc->snd_mss, max_deq_bytes);
1247   max_deq_bytes = clib_min (available_bytes, max_deq_bytes);
1248
1249   start = tc->snd_una + offset;
1250   ASSERT (seq_leq (start + max_deq_bytes, tc->snd_nxt));
1251
1252   n_bytes = tcp_prepare_segment (wrk, tc, offset, max_deq_bytes, b);
1253   if (!n_bytes)
1254     return 0;
1255
1256   tc->snd_rxt_bytes += n_bytes;
1257
1258   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
1259     tcp_bt_track_rxt (tc, start, start + n_bytes);
1260
1261   tc->bytes_retrans += n_bytes;
1262   tc->segs_retrans += 1;
1263   tcp_worker_stats_inc (wrk, rxt_segs, 1);
1264   TCP_EVT (TCP_EVT_CC_RTX, tc, offset, n_bytes);
1265
1266   return n_bytes;
1267 }
1268
1269 static void
1270 tcp_check_sack_reneging (tcp_connection_t * tc)
1271 {
1272   sack_scoreboard_t *sb = &tc->sack_sb;
1273   sack_scoreboard_hole_t *hole;
1274
1275   hole = scoreboard_first_hole (sb);
1276   if (!sb->is_reneging && (!hole || hole->start == tc->snd_una))
1277     return;
1278
1279   scoreboard_clear_reneging (sb, tc->snd_una, tc->snd_nxt);
1280 }
1281
1282 /**
1283  * Reset congestion control, switch cwnd to loss window and try again.
1284  */
1285 static void
1286 tcp_cc_init_rxt_timeout (tcp_connection_t * tc)
1287 {
1288   TCP_EVT (TCP_EVT_CC_EVT, tc, 6);
1289
1290   tc->prev_ssthresh = tc->ssthresh;
1291   tc->prev_cwnd = tc->cwnd;
1292
1293   /* If we entrered loss without fast recovery, notify cc algo of the
1294    * congestion event such that it can update ssthresh and its state */
1295   if (!tcp_in_fastrecovery (tc))
1296     tcp_cc_congestion (tc);
1297
1298   /* Let cc algo decide loss cwnd and ssthresh post unrecovered loss */
1299   tcp_cc_loss (tc);
1300
1301   tc->rtt_ts = 0;
1302   tc->cwnd_acc_bytes = 0;
1303   tc->tr_occurences += 1;
1304   tc->sack_sb.reorder = TCP_DUPACK_THRESHOLD;
1305   tcp_recovery_on (tc);
1306 }
1307
1308 void
1309 tcp_timer_retransmit_handler (tcp_connection_t * tc)
1310 {
1311   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
1312   vlib_main_t *vm = wrk->vm;
1313   vlib_buffer_t *b = 0;
1314   u32 bi, n_bytes;
1315
1316   tcp_worker_stats_inc (wrk, tr_events, 1);
1317
1318   /* Should be handled by a different handler */
1319   if (PREDICT_FALSE (tc->state == TCP_STATE_SYN_SENT))
1320     return;
1321
1322   /* Wait-close and retransmit could pop at the same time */
1323   if (tc->state == TCP_STATE_CLOSED)
1324     return;
1325
1326   if (tc->state >= TCP_STATE_ESTABLISHED)
1327     {
1328       TCP_EVT (TCP_EVT_CC_EVT, tc, 2);
1329
1330       /* Lost FIN, retransmit and return */
1331       if (tc->flags & TCP_CONN_FINSNT)
1332         {
1333           tcp_send_fin (tc);
1334           tc->rto_boff += 1;
1335           tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1336           return;
1337         }
1338
1339       /* Shouldn't be here */
1340       if (tc->snd_una == tc->snd_nxt)
1341         {
1342           ASSERT (!tcp_in_recovery (tc));
1343           tc->rto_boff = 0;
1344           return;
1345         }
1346
1347       /* We're not in recovery so make sure rto_boff is 0. Can be non 0 due
1348        * to persist timer timeout */
1349       if (!tcp_in_recovery (tc) && tc->rto_boff > 0)
1350         {
1351           tc->rto_boff = 0;
1352           tcp_update_rto (tc);
1353         }
1354
1355       /* Peer is dead or network connectivity is lost. Close connection.
1356        * RFC 1122 section 4.2.3.5 recommends a value of at least 100s. For
1357        * a min rto of 0.2s we need to retry about 8 times. */
1358       if (tc->rto_boff >= TCP_RTO_BOFF_MAX)
1359         {
1360           tcp_send_reset (tc);
1361           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1362           session_transport_closing_notify (&tc->connection);
1363           session_transport_closed_notify (&tc->connection);
1364           tcp_connection_timers_reset (tc);
1365           tcp_program_cleanup (wrk, tc);
1366           tcp_worker_stats_inc (wrk, tr_abort, 1);
1367           return;
1368         }
1369
1370       if (tcp_opts_sack_permitted (&tc->rcv_opts))
1371         tcp_check_sack_reneging (tc);
1372
1373       /* Update send congestion to make sure that rxt has data to send */
1374       tc->snd_congestion = tc->snd_nxt;
1375
1376       /* Send the first unacked segment. If we're short on buffers, return
1377        * as soon as possible */
1378       n_bytes = clib_min (tc->snd_mss, tc->snd_nxt - tc->snd_una);
1379       n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, n_bytes, &b);
1380       if (!n_bytes)
1381         {
1382           tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT, 1);
1383           return;
1384         }
1385
1386       bi = vlib_get_buffer_index (vm, b);
1387       tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1388
1389       tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1390       tcp_retransmit_timer_update (&wrk->timer_wheel, tc);
1391
1392       tc->rto_boff += 1;
1393       if (tc->rto_boff == 1)
1394         {
1395           tcp_cc_init_rxt_timeout (tc);
1396           /* Record timestamp. Eifel detection algorithm RFC3522 */
1397           tc->snd_rxt_ts = tcp_tstamp (tc);
1398         }
1399
1400       if (tcp_opts_sack_permitted (&tc->rcv_opts))
1401         scoreboard_init_rxt (&tc->sack_sb, tc->snd_una + n_bytes);
1402
1403       tcp_program_retransmit (tc);
1404     }
1405   /* Retransmit SYN-ACK */
1406   else if (tc->state == TCP_STATE_SYN_RCVD)
1407     {
1408       TCP_EVT (TCP_EVT_CC_EVT, tc, 2);
1409
1410       tc->rtt_ts = 0;
1411
1412       /* Passive open establish timeout */
1413       if (tc->rto > TCP_ESTABLISH_TIME >> 1)
1414         {
1415           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1416           tcp_connection_timers_reset (tc);
1417           tcp_program_cleanup (wrk, tc);
1418           tcp_worker_stats_inc (wrk, tr_abort, 1);
1419           return;
1420         }
1421
1422       if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
1423         {
1424           tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT, 1);
1425           tcp_worker_stats_inc (wrk, no_buffer, 1);
1426           return;
1427         }
1428
1429       tc->rto_boff += 1;
1430       if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
1431         tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1432
1433       ASSERT (tc->snd_una != tc->snd_nxt);
1434       tcp_retransmit_timer_update (&wrk->timer_wheel, tc);
1435
1436       b = vlib_get_buffer (vm, bi);
1437       tcp_init_buffer (vm, b);
1438       tcp_make_synack (tc, b);
1439       TCP_EVT (TCP_EVT_SYN_RXT, tc, 1);
1440
1441       /* Retransmit timer already updated, just enqueue to output */
1442       tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1443     }
1444   else
1445     {
1446       ASSERT (tc->state == TCP_STATE_CLOSED);
1447       return;
1448     }
1449 }
1450
1451 /**
1452  * SYN retransmit timer handler. Active open only.
1453  */
1454 void
1455 tcp_timer_retransmit_syn_handler (tcp_connection_t * tc)
1456 {
1457   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
1458   vlib_main_t *vm = wrk->vm;
1459   vlib_buffer_t *b = 0;
1460   u32 bi;
1461
1462   /* Note: the connection may have transitioned to ESTABLISHED... */
1463   if (PREDICT_FALSE (tc->state != TCP_STATE_SYN_SENT))
1464     return;
1465
1466   /* Half-open connection actually moved to established but we were
1467    * waiting for syn retransmit to pop to call cleanup from the right
1468    * thread. */
1469   if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
1470     {
1471       if (tcp_half_open_connection_cleanup (tc))
1472         TCP_DBG ("could not remove half-open connection");
1473       return;
1474     }
1475
1476   TCP_EVT (TCP_EVT_CC_EVT, tc, 2);
1477   tc->rtt_ts = 0;
1478
1479   /* Active open establish timeout */
1480   if (tc->rto >= TCP_ESTABLISH_TIME >> 1)
1481     {
1482       session_stream_connect_notify (&tc->connection, SESSION_E_TIMEDOUT);
1483       tcp_connection_cleanup (tc);
1484       return;
1485     }
1486
1487   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
1488     {
1489       tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN, 1);
1490       tcp_worker_stats_inc (wrk, no_buffer, 1);
1491       return;
1492     }
1493
1494   /* Try without increasing RTO a number of times. If this fails,
1495    * start growing RTO exponentially */
1496   tc->rto_boff += 1;
1497   if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
1498     tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1499
1500   b = vlib_get_buffer (vm, bi);
1501   tcp_init_buffer (vm, b);
1502   tcp_make_syn (tc, b);
1503
1504   TCP_EVT (TCP_EVT_SYN_RXT, tc, 0);
1505
1506   /* This goes straight to ipx_lookup */
1507   tcp_push_ip_hdr (wrk, tc, b);
1508   tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
1509
1510   tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN,
1511                     tc->rto * TCP_TO_TIMER_TICK);
1512 }
1513
1514 /**
1515  * Got 0 snd_wnd from peer, try to do something about it.
1516  *
1517  */
1518 void
1519 tcp_timer_persist_handler (tcp_connection_t * tc)
1520 {
1521   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
1522   u32 bi, max_snd_bytes, available_bytes, offset;
1523   tcp_main_t *tm = vnet_get_tcp_main ();
1524   vlib_main_t *vm = wrk->vm;
1525   vlib_buffer_t *b;
1526   int n_bytes = 0;
1527   u8 *data;
1528
1529   /* Problem already solved or worse */
1530   if (tc->state == TCP_STATE_CLOSED || tc->snd_wnd > tc->snd_mss
1531       || (tc->flags & TCP_CONN_FINSNT))
1532     goto update_scheduler;
1533
1534   available_bytes = transport_max_tx_dequeue (&tc->connection);
1535   offset = tc->snd_nxt - tc->snd_una;
1536
1537   /* Reprogram persist if no new bytes available to send. We may have data
1538    * next time */
1539   if (!available_bytes)
1540     {
1541       tcp_persist_timer_set (&wrk->timer_wheel, tc);
1542       return;
1543     }
1544
1545   if (available_bytes <= offset)
1546     goto update_scheduler;
1547
1548   /* Increment RTO backoff */
1549   tc->rto_boff += 1;
1550   tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1551
1552   /*
1553    * Try to force the first unsent segment (or buffer)
1554    */
1555   if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
1556     {
1557       tcp_persist_timer_set (&wrk->timer_wheel, tc);
1558       tcp_worker_stats_inc (wrk, no_buffer, 1);
1559       return;
1560     }
1561
1562   b = vlib_get_buffer (vm, bi);
1563   data = tcp_init_buffer (vm, b);
1564
1565   tcp_validate_txf_size (tc, offset);
1566   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
1567   max_snd_bytes = clib_min (tc->snd_mss,
1568                             tm->bytes_per_buffer - TRANSPORT_MAX_HDRS_LEN);
1569   n_bytes = session_tx_fifo_peek_bytes (&tc->connection, data, offset,
1570                                         max_snd_bytes);
1571   b->current_length = n_bytes;
1572   ASSERT (n_bytes != 0 && (tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)
1573                            || tc->snd_una == tc->snd_nxt
1574                            || tc->rto_boff > 1));
1575
1576   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
1577     {
1578       tcp_bt_check_app_limited (tc);
1579       tcp_bt_track_tx (tc, n_bytes);
1580     }
1581
1582   tcp_push_hdr_i (tc, b, tc->snd_nxt, /* compute opts */ 0,
1583                   /* burst */ 0, /* update_snd_nxt */ 1);
1584   tcp_validate_txf_size (tc, tc->snd_nxt - tc->snd_una);
1585   tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1586
1587   /* Just sent new data, enable retransmit */
1588   tcp_retransmit_timer_update (&wrk->timer_wheel, tc);
1589
1590   return;
1591
1592 update_scheduler:
1593
1594   if (tcp_is_descheduled (tc))
1595     transport_connection_reschedule (&tc->connection);
1596 }
1597
1598 /**
1599  * Retransmit first unacked segment
1600  */
1601 int
1602 tcp_retransmit_first_unacked (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
1603 {
1604   vlib_main_t *vm = wrk->vm;
1605   vlib_buffer_t *b;
1606   u32 bi, n_bytes;
1607
1608   TCP_EVT (TCP_EVT_CC_EVT, tc, 1);
1609
1610   n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
1611   if (!n_bytes)
1612     return -1;
1613
1614   bi = vlib_get_buffer_index (vm, b);
1615   tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1616
1617   return 0;
1618 }
1619
1620 static int
1621 tcp_transmit_unsent (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
1622                      u32 burst_size)
1623 {
1624   u32 offset, n_segs = 0, n_written, bi, available_wnd;
1625   vlib_main_t *vm = wrk->vm;
1626   vlib_buffer_t *b = 0;
1627
1628   offset = tc->snd_nxt - tc->snd_una;
1629   available_wnd = tc->snd_wnd - offset;
1630   burst_size = clib_min (burst_size, available_wnd / tc->snd_mss);
1631
1632   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
1633     tcp_bt_check_app_limited (tc);
1634
1635   while (n_segs < burst_size)
1636     {
1637       n_written = tcp_prepare_segment (wrk, tc, offset, tc->snd_mss, &b);
1638       if (!n_written)
1639         goto done;
1640
1641       bi = vlib_get_buffer_index (vm, b);
1642       tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1643       offset += n_written;
1644       n_segs += 1;
1645
1646       if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
1647         tcp_bt_track_tx (tc, n_written);
1648
1649       tc->snd_nxt += n_written;
1650     }
1651
1652 done:
1653   return n_segs;
1654 }
1655
1656 /**
1657  * Estimate send space using proportional rate reduction (RFC6937)
1658  */
1659 int
1660 tcp_fastrecovery_prr_snd_space (tcp_connection_t * tc)
1661 {
1662   u32 pipe, prr_out;
1663   int space;
1664
1665   pipe = tcp_flight_size (tc);
1666   prr_out = tc->snd_rxt_bytes + (tc->snd_nxt - tc->snd_congestion);
1667
1668   if (pipe > tc->ssthresh)
1669     {
1670       space = ((int) tc->prr_delivered * ((f64) tc->ssthresh / tc->prev_cwnd))
1671         - prr_out;
1672     }
1673   else
1674     {
1675       int limit;
1676       limit = clib_max ((int) (tc->prr_delivered - prr_out), 0) + tc->snd_mss;
1677       space = clib_min (tc->ssthresh - pipe, limit);
1678     }
1679   space = clib_max (space, prr_out ? 0 : tc->snd_mss);
1680   return space;
1681 }
1682
1683 static inline u8
1684 tcp_retransmit_should_retry_head (tcp_connection_t * tc,
1685                                   sack_scoreboard_t * sb)
1686 {
1687   u32 tx_adv_sack = sb->high_sacked - tc->snd_congestion;
1688   f64 rr = (f64) tc->ssthresh / tc->prev_cwnd;
1689
1690   if (tcp_fastrecovery_first (tc))
1691     return 1;
1692
1693   return (tx_adv_sack > (tc->snd_una - tc->prr_start) * rr);
1694 }
1695
1696 static inline u8
1697 tcp_max_tx_deq (tcp_connection_t * tc)
1698 {
1699   return (transport_max_tx_dequeue (&tc->connection)
1700           - (tc->snd_nxt - tc->snd_una));
1701 }
1702
1703 #define scoreboard_rescue_rxt_valid(_sb, _tc)                   \
1704     (seq_geq (_sb->rescue_rxt, _tc->snd_una)                    \
1705         && seq_leq (_sb->rescue_rxt, _tc->snd_congestion))
1706
1707 /**
1708  * Do retransmit with SACKs
1709  */
1710 static int
1711 tcp_retransmit_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
1712                      u32 burst_size)
1713 {
1714   u32 n_written = 0, offset, max_bytes, n_segs = 0;
1715   u8 snd_limited = 0, can_rescue = 0;
1716   u32 bi, max_deq, burst_bytes;
1717   sack_scoreboard_hole_t *hole;
1718   vlib_main_t *vm = wrk->vm;
1719   vlib_buffer_t *b = 0;
1720   sack_scoreboard_t *sb;
1721   int snd_space;
1722
1723   ASSERT (tcp_in_cong_recovery (tc));
1724
1725   burst_bytes = transport_connection_tx_pacer_burst (&tc->connection);
1726   burst_size = clib_min (burst_size, burst_bytes / tc->snd_mss);
1727   if (!burst_size)
1728     {
1729       tcp_program_retransmit (tc);
1730       return 0;
1731     }
1732
1733   if (tcp_in_recovery (tc))
1734     snd_space = tcp_available_cc_snd_space (tc);
1735   else
1736     snd_space = tcp_fastrecovery_prr_snd_space (tc);
1737
1738   if (snd_space < tc->snd_mss)
1739     goto done;
1740
1741   sb = &tc->sack_sb;
1742
1743   /* Check if snd_una is a lost retransmit */
1744   if (pool_elts (sb->holes)
1745       && seq_gt (sb->high_sacked, tc->snd_congestion)
1746       && tc->rxt_head != tc->snd_una
1747       && tcp_retransmit_should_retry_head (tc, sb))
1748     {
1749       max_bytes = clib_min (tc->snd_mss, tc->snd_congestion - tc->snd_una);
1750       n_written = tcp_prepare_retransmit_segment (wrk, tc, 0, max_bytes, &b);
1751       if (!n_written)
1752         {
1753           tcp_program_retransmit (tc);
1754           goto done;
1755         }
1756       bi = vlib_get_buffer_index (vm, b);
1757       tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1758       n_segs = 1;
1759
1760       tc->rxt_head = tc->snd_una;
1761       tc->rxt_delivered += n_written;
1762       tc->prr_delivered += n_written;
1763       ASSERT (tc->rxt_delivered <= tc->snd_rxt_bytes);
1764     }
1765
1766   tcp_fastrecovery_first_off (tc);
1767
1768   TCP_EVT (TCP_EVT_CC_EVT, tc, 0);
1769   hole = scoreboard_get_hole (sb, sb->cur_rxt_hole);
1770
1771   max_deq = transport_max_tx_dequeue (&tc->connection);
1772   max_deq -= tc->snd_nxt - tc->snd_una;
1773
1774   while (snd_space > 0 && n_segs < burst_size)
1775     {
1776       hole = scoreboard_next_rxt_hole (sb, hole, max_deq != 0, &can_rescue,
1777                                        &snd_limited);
1778       if (!hole)
1779         {
1780           /* We are out of lost holes to retransmit so send some new data. */
1781           if (max_deq > tc->snd_mss)
1782             {
1783               u32 n_segs_new;
1784               int av_wnd;
1785
1786               /* Make sure we don't exceed available window and leave space
1787                * for one more packet, to avoid zero window acks */
1788               av_wnd = (int) tc->snd_wnd - (tc->snd_nxt - tc->snd_una);
1789               av_wnd = clib_max (av_wnd - tc->snd_mss, 0);
1790               snd_space = clib_min (snd_space, av_wnd);
1791               snd_space = clib_min (max_deq, snd_space);
1792               burst_size = clib_min (burst_size - n_segs,
1793                                      snd_space / tc->snd_mss);
1794               burst_size = clib_min (burst_size, TCP_RXT_MAX_BURST);
1795               n_segs_new = tcp_transmit_unsent (wrk, tc, burst_size);
1796               if (max_deq > n_segs_new * tc->snd_mss)
1797                 tcp_program_retransmit (tc);
1798
1799               n_segs += n_segs_new;
1800               goto done;
1801             }
1802
1803           if (tcp_in_recovery (tc) || !can_rescue
1804               || scoreboard_rescue_rxt_valid (sb, tc))
1805             break;
1806
1807           /* If rescue rxt undefined or less than snd_una then one segment of
1808            * up to SMSS octets that MUST include the highest outstanding
1809            * unSACKed sequence number SHOULD be returned, and RescueRxt set to
1810            * RecoveryPoint. HighRxt MUST NOT be updated.
1811            */
1812           hole = scoreboard_last_hole (sb);
1813           max_bytes = clib_min (tc->snd_mss, hole->end - hole->start);
1814           max_bytes = clib_min (max_bytes, snd_space);
1815           offset = hole->end - tc->snd_una - max_bytes;
1816           n_written = tcp_prepare_retransmit_segment (wrk, tc, offset,
1817                                                       max_bytes, &b);
1818           if (!n_written)
1819             goto done;
1820
1821           sb->rescue_rxt = tc->snd_congestion;
1822           bi = vlib_get_buffer_index (vm, b);
1823           tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1824           n_segs += 1;
1825           break;
1826         }
1827
1828       max_bytes = clib_min (hole->end - sb->high_rxt, snd_space);
1829       max_bytes = snd_limited ? clib_min (max_bytes, tc->snd_mss) : max_bytes;
1830       if (max_bytes == 0)
1831         break;
1832
1833       offset = sb->high_rxt - tc->snd_una;
1834       n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, max_bytes,
1835                                                   &b);
1836       ASSERT (n_written <= snd_space);
1837
1838       /* Nothing left to retransmit */
1839       if (n_written == 0)
1840         break;
1841
1842       bi = vlib_get_buffer_index (vm, b);
1843       tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1844
1845       sb->high_rxt += n_written;
1846       ASSERT (seq_leq (sb->high_rxt, tc->snd_nxt));
1847
1848       snd_space -= n_written;
1849       n_segs += 1;
1850     }
1851
1852   if (hole)
1853     tcp_program_retransmit (tc);
1854
1855 done:
1856
1857   transport_connection_tx_pacer_reset_bucket (&tc->connection, 0);
1858   return n_segs;
1859 }
1860
1861 /**
1862  * Fast retransmit without SACK info
1863  */
1864 static int
1865 tcp_retransmit_no_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
1866                         u32 burst_size)
1867 {
1868   u32 n_written = 0, offset = 0, bi, max_deq, n_segs_now, max_bytes;
1869   u32 burst_bytes, sent_bytes;
1870   vlib_main_t *vm = wrk->vm;
1871   int snd_space, n_segs = 0;
1872   u8 cc_limited = 0;
1873   vlib_buffer_t *b;
1874
1875   ASSERT (tcp_in_cong_recovery (tc));
1876   TCP_EVT (TCP_EVT_CC_EVT, tc, 0);
1877
1878   burst_bytes = transport_connection_tx_pacer_burst (&tc->connection);
1879   burst_size = clib_min (burst_size, burst_bytes / tc->snd_mss);
1880   if (!burst_size)
1881     {
1882       tcp_program_retransmit (tc);
1883       return 0;
1884     }
1885
1886   snd_space = tcp_available_cc_snd_space (tc);
1887   cc_limited = snd_space < burst_bytes;
1888
1889   if (!tcp_fastrecovery_first (tc))
1890     goto send_unsent;
1891
1892   /* RFC 6582: [If a partial ack], retransmit the first unacknowledged
1893    * segment. */
1894   while (snd_space > 0 && n_segs < burst_size)
1895     {
1896       max_bytes = clib_min (tc->snd_mss,
1897                             tc->snd_congestion - tc->snd_una - offset);
1898       if (!max_bytes)
1899         break;
1900       n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, max_bytes,
1901                                                   &b);
1902
1903       /* Nothing left to retransmit */
1904       if (n_written == 0)
1905         break;
1906
1907       bi = vlib_get_buffer_index (vm, b);
1908       tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
1909       snd_space -= n_written;
1910       offset += n_written;
1911       n_segs += 1;
1912     }
1913
1914   if (n_segs == burst_size)
1915     goto done;
1916
1917 send_unsent:
1918
1919   /* RFC 6582: Send a new segment if permitted by the new value of cwnd. */
1920   if (snd_space < tc->snd_mss || tc->snd_mss == 0)
1921     goto done;
1922
1923   max_deq = transport_max_tx_dequeue (&tc->connection);
1924   max_deq -= tc->snd_nxt - tc->snd_una;
1925   if (max_deq)
1926     {
1927       snd_space = clib_min (max_deq, snd_space);
1928       burst_size = clib_min (burst_size - n_segs, snd_space / tc->snd_mss);
1929       n_segs_now = tcp_transmit_unsent (wrk, tc, burst_size);
1930       if (n_segs_now && max_deq > n_segs_now * tc->snd_mss)
1931         tcp_program_retransmit (tc);
1932       n_segs += n_segs_now;
1933     }
1934
1935 done:
1936   tcp_fastrecovery_first_off (tc);
1937
1938   sent_bytes = clib_min (n_segs * tc->snd_mss, burst_bytes);
1939   sent_bytes = cc_limited ? burst_bytes : sent_bytes;
1940   transport_connection_tx_pacer_update_bytes (&tc->connection, sent_bytes);
1941
1942   return n_segs;
1943 }
1944
1945 static int
1946 tcp_send_acks (tcp_connection_t * tc, u32 max_burst_size)
1947 {
1948   int j, n_acks;
1949
1950   if (!tc->pending_dupacks)
1951     {
1952       if (tcp_in_cong_recovery (tc) || !tcp_max_tx_deq (tc)
1953           || tc->state != TCP_STATE_ESTABLISHED)
1954         {
1955           tcp_send_ack (tc);
1956           return 1;
1957         }
1958       return 0;
1959     }
1960
1961   /* If we're supposed to send dupacks but have no ooo data
1962    * send only one ack */
1963   if (!vec_len (tc->snd_sacks))
1964     {
1965       tcp_send_ack (tc);
1966       tc->dupacks_out += 1;
1967       tc->pending_dupacks = 0;
1968       return 1;
1969     }
1970
1971   /* Start with first sack block */
1972   tc->snd_sack_pos = 0;
1973
1974   /* Generate enough dupacks to cover all sack blocks. Do not generate
1975    * more sacks than the number of packets received. But do generate at
1976    * least 3, i.e., the number needed to signal congestion, if needed. */
1977   n_acks = vec_len (tc->snd_sacks) / TCP_OPTS_MAX_SACK_BLOCKS;
1978   n_acks = clib_min (n_acks, tc->pending_dupacks);
1979   n_acks = clib_max (n_acks, clib_min (tc->pending_dupacks, 3));
1980   for (j = 0; j < clib_min (n_acks, max_burst_size); j++)
1981     tcp_send_ack (tc);
1982
1983   if (n_acks < max_burst_size)
1984     {
1985       tc->pending_dupacks = 0;
1986       tc->snd_sack_pos = 0;
1987       tc->dupacks_out += n_acks;
1988       return n_acks;
1989     }
1990   else
1991     {
1992       TCP_DBG ("constrained by burst size");
1993       tc->pending_dupacks = n_acks - max_burst_size;
1994       tc->dupacks_out += max_burst_size;
1995       tcp_program_dupack (tc);
1996       return max_burst_size;
1997     }
1998 }
1999
2000 static int
2001 tcp_do_retransmit (tcp_connection_t * tc, u32 max_burst_size)
2002 {
2003   tcp_worker_ctx_t *wrk;
2004   u32 n_segs;
2005
2006   if (PREDICT_FALSE (tc->state == TCP_STATE_CLOSED))
2007     return 0;
2008
2009   wrk = tcp_get_worker (tc->c_thread_index);
2010
2011   if (tcp_opts_sack_permitted (&tc->rcv_opts))
2012     n_segs = tcp_retransmit_sack (wrk, tc, max_burst_size);
2013   else
2014     n_segs = tcp_retransmit_no_sack (wrk, tc, max_burst_size);
2015
2016   return n_segs;
2017 }
2018
2019 int
2020 tcp_session_custom_tx (void *conn, transport_send_params_t * sp)
2021 {
2022   tcp_connection_t *tc = (tcp_connection_t *) conn;
2023   u32 n_segs = 0;
2024
2025   if (tcp_in_cong_recovery (tc) && (tc->flags & TCP_CONN_RXT_PENDING))
2026     {
2027       tc->flags &= ~TCP_CONN_RXT_PENDING;
2028       n_segs = tcp_do_retransmit (tc, sp->max_burst_size);
2029     }
2030
2031   if (!(tc->flags & TCP_CONN_SNDACK))
2032     return n_segs;
2033
2034   tc->flags &= ~TCP_CONN_SNDACK;
2035
2036   /* We have retransmitted packets and no dupack */
2037   if (n_segs && !tc->pending_dupacks)
2038     return n_segs;
2039
2040   if (sp->max_burst_size <= n_segs)
2041     {
2042       tcp_program_ack (tc);
2043       return n_segs;
2044     }
2045
2046   n_segs += tcp_send_acks (tc, sp->max_burst_size - n_segs);
2047
2048   return n_segs;
2049 }
2050 #endif /* CLIB_MARCH_VARIANT */
2051
2052 static void
2053 tcp_output_handle_link_local (tcp_connection_t * tc0, vlib_buffer_t * b0,
2054                               u16 * next0, u32 * error0)
2055 {
2056   ip_adjacency_t *adj;
2057   adj_index_t ai;
2058
2059   /* Not thread safe but as long as the connection exists the adj should
2060    * not be removed */
2061   ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &tc0->c_rmt_ip,
2062                      tc0->sw_if_index);
2063   if (ai == ADJ_INDEX_INVALID)
2064     {
2065       vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
2066       *next0 = TCP_OUTPUT_NEXT_DROP;
2067       *error0 = TCP_ERROR_LINK_LOCAL_RW;
2068       return;
2069     }
2070
2071   adj = adj_get (ai);
2072   if (PREDICT_TRUE (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE))
2073     *next0 = TCP_OUTPUT_NEXT_IP_REWRITE;
2074   else if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP)
2075     *next0 = TCP_OUTPUT_NEXT_IP_ARP;
2076   else
2077     {
2078       *next0 = TCP_OUTPUT_NEXT_DROP;
2079       *error0 = TCP_ERROR_LINK_LOCAL_RW;
2080     }
2081   vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ai;
2082 }
2083
2084 static void
2085 tcp46_output_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
2086                           u32 * to_next, u32 n_bufs)
2087 {
2088   tcp_connection_t *tc;
2089   tcp_tx_trace_t *t;
2090   vlib_buffer_t *b;
2091   tcp_header_t *th;
2092   int i;
2093
2094   for (i = 0; i < n_bufs; i++)
2095     {
2096       b = vlib_get_buffer (vm, to_next[i]);
2097       if (!(b->flags & VLIB_BUFFER_IS_TRACED))
2098         continue;
2099       th = vlib_buffer_get_current (b);
2100       tc = tcp_connection_get (vnet_buffer (b)->tcp.connection_index,
2101                                vm->thread_index);
2102       t = vlib_add_trace (vm, node, b, sizeof (*t));
2103       clib_memcpy_fast (&t->tcp_header, th, sizeof (t->tcp_header));
2104       clib_memcpy_fast (&t->tcp_connection, tc, sizeof (t->tcp_connection));
2105     }
2106 }
2107
2108 always_inline void
2109 tcp_output_push_ip (vlib_main_t * vm, vlib_buffer_t * b0,
2110                     tcp_connection_t * tc0, u8 is_ip4)
2111 {
2112   TCP_EVT (TCP_EVT_OUTPUT, tc0,
2113            ((tcp_header_t *) vlib_buffer_get_current (b0))->flags,
2114            b0->current_length);
2115
2116   if (is_ip4)
2117     vlib_buffer_push_ip4 (vm, b0, &tc0->c_lcl_ip4, &tc0->c_rmt_ip4,
2118                           IP_PROTOCOL_TCP, tcp_csum_offload (tc0));
2119   else
2120     vlib_buffer_push_ip6_custom (vm, b0, &tc0->c_lcl_ip6, &tc0->c_rmt_ip6,
2121                                  IP_PROTOCOL_TCP, tc0->ipv6_flow_label);
2122 }
2123
2124 always_inline void
2125 tcp_check_if_gso (tcp_connection_t * tc, vlib_buffer_t * b)
2126 {
2127   if (PREDICT_TRUE (!(tc->cfg_flags & TCP_CFG_F_TSO)))
2128     return;
2129
2130   u16 data_len = b->current_length - sizeof (tcp_header_t) - tc->snd_opts_len;
2131
2132   if (PREDICT_FALSE (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID))
2133     data_len += b->total_length_not_including_first_buffer;
2134
2135   if (PREDICT_TRUE (data_len <= tc->snd_mss))
2136     return;
2137   else
2138     {
2139       ASSERT ((b->flags & VNET_BUFFER_F_L3_HDR_OFFSET_VALID) != 0);
2140       ASSERT ((b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID) != 0);
2141       b->flags |= VNET_BUFFER_F_GSO;
2142       vnet_buffer2 (b)->gso_l4_hdr_sz =
2143         sizeof (tcp_header_t) + tc->snd_opts_len;
2144       vnet_buffer2 (b)->gso_size = tc->snd_mss;
2145     }
2146 }
2147
2148 always_inline void
2149 tcp_output_handle_packet (tcp_connection_t * tc0, vlib_buffer_t * b0,
2150                           vlib_node_runtime_t * error_node, u16 * next0,
2151                           u8 is_ip4)
2152 {
2153   /* If next_index is not drop use it */
2154   if (tc0->next_node_index)
2155     {
2156       *next0 = tc0->next_node_index;
2157       vnet_buffer (b0)->tcp.next_node_opaque = tc0->next_node_opaque;
2158     }
2159   else
2160     {
2161       *next0 = TCP_OUTPUT_NEXT_IP_LOOKUP;
2162     }
2163
2164   vnet_buffer (b0)->sw_if_index[VLIB_TX] = tc0->c_fib_index;
2165   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
2166
2167   if (!is_ip4)
2168     {
2169       u32 error0 = 0;
2170
2171       if (PREDICT_FALSE (ip6_address_is_link_local_unicast (&tc0->c_rmt_ip6)))
2172         tcp_output_handle_link_local (tc0, b0, next0, &error0);
2173
2174       if (PREDICT_FALSE (error0))
2175         {
2176           b0->error = error_node->errors[error0];
2177           return;
2178         }
2179     }
2180
2181   tc0->segs_out += 1;
2182 }
2183
2184 always_inline uword
2185 tcp46_output_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2186                      vlib_frame_t * frame, int is_ip4)
2187 {
2188   u32 n_left_from, *from, thread_index = vm->thread_index;
2189   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
2190   u16 nexts[VLIB_FRAME_SIZE], *next;
2191
2192   from = vlib_frame_vector_args (frame);
2193   n_left_from = frame->n_vectors;
2194   tcp_update_time_now (tcp_get_worker (thread_index));
2195
2196   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
2197     tcp46_output_trace_frame (vm, node, from, n_left_from);
2198
2199   vlib_get_buffers (vm, from, bufs, n_left_from);
2200   b = bufs;
2201   next = nexts;
2202
2203   while (n_left_from >= 4)
2204     {
2205       tcp_connection_t *tc0, *tc1;
2206
2207       {
2208         vlib_prefetch_buffer_header (b[2], STORE);
2209         CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2210
2211         vlib_prefetch_buffer_header (b[3], STORE);
2212         CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2213       }
2214
2215       tc0 = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
2216                                 thread_index);
2217       tc1 = tcp_connection_get (vnet_buffer (b[1])->tcp.connection_index,
2218                                 thread_index);
2219
2220       if (PREDICT_TRUE (!tc0 + !tc1 == 0))
2221         {
2222           tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2223           tcp_output_push_ip (vm, b[1], tc1, is_ip4);
2224
2225           tcp_check_if_gso (tc0, b[0]);
2226           tcp_check_if_gso (tc1, b[1]);
2227
2228           tcp_output_handle_packet (tc0, b[0], node, &next[0], is_ip4);
2229           tcp_output_handle_packet (tc1, b[1], node, &next[1], is_ip4);
2230         }
2231       else
2232         {
2233           if (tc0 != 0)
2234             {
2235               tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2236               tcp_check_if_gso (tc0, b[0]);
2237               tcp_output_handle_packet (tc0, b[0], node, &next[0], is_ip4);
2238             }
2239           else
2240             {
2241               b[0]->error = node->errors[TCP_ERROR_INVALID_CONNECTION];
2242               next[0] = TCP_OUTPUT_NEXT_DROP;
2243             }
2244           if (tc1 != 0)
2245             {
2246               tcp_output_push_ip (vm, b[1], tc1, is_ip4);
2247               tcp_check_if_gso (tc1, b[1]);
2248               tcp_output_handle_packet (tc1, b[1], node, &next[1], is_ip4);
2249             }
2250           else
2251             {
2252               b[1]->error = node->errors[TCP_ERROR_INVALID_CONNECTION];
2253               next[1] = TCP_OUTPUT_NEXT_DROP;
2254             }
2255         }
2256
2257       b += 2;
2258       next += 2;
2259       n_left_from -= 2;
2260     }
2261   while (n_left_from > 0)
2262     {
2263       tcp_connection_t *tc0;
2264
2265       if (n_left_from > 1)
2266         {
2267           vlib_prefetch_buffer_header (b[1], STORE);
2268           CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2269         }
2270
2271       tc0 = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
2272                                 thread_index);
2273
2274       if (PREDICT_TRUE (tc0 != 0))
2275         {
2276           tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2277           tcp_check_if_gso (tc0, b[0]);
2278           tcp_output_handle_packet (tc0, b[0], node, &next[0], is_ip4);
2279         }
2280       else
2281         {
2282           b[0]->error = node->errors[TCP_ERROR_INVALID_CONNECTION];
2283           next[0] = TCP_OUTPUT_NEXT_DROP;
2284         }
2285
2286       b += 1;
2287       next += 1;
2288       n_left_from -= 1;
2289     }
2290
2291   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
2292   vlib_node_increment_counter (vm, tcp_node_index (output, is_ip4),
2293                                TCP_ERROR_PKTS_SENT, frame->n_vectors);
2294   return frame->n_vectors;
2295 }
2296
2297 VLIB_NODE_FN (tcp4_output_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
2298                                  vlib_frame_t * from_frame)
2299 {
2300   return tcp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2301 }
2302
2303 VLIB_NODE_FN (tcp6_output_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
2304                                  vlib_frame_t * from_frame)
2305 {
2306   return tcp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2307 }
2308
2309 /* *INDENT-OFF* */
2310 VLIB_REGISTER_NODE (tcp4_output_node) =
2311 {
2312   .name = "tcp4-output",
2313   /* Takes a vector of packets. */
2314   .vector_size = sizeof (u32),
2315   .n_errors = TCP_N_ERROR,
2316   .protocol_hint = VLIB_NODE_PROTO_HINT_TCP,
2317   .error_strings = tcp_error_strings,
2318   .n_next_nodes = TCP_OUTPUT_N_NEXT,
2319   .next_nodes = {
2320 #define _(s,n) [TCP_OUTPUT_NEXT_##s] = n,
2321     foreach_tcp4_output_next
2322 #undef _
2323   },
2324   .format_buffer = format_tcp_header,
2325   .format_trace = format_tcp_tx_trace,
2326 };
2327 /* *INDENT-ON* */
2328
2329 /* *INDENT-OFF* */
2330 VLIB_REGISTER_NODE (tcp6_output_node) =
2331 {
2332   .name = "tcp6-output",
2333     /* Takes a vector of packets. */
2334   .vector_size = sizeof (u32),
2335   .n_errors = TCP_N_ERROR,
2336   .protocol_hint = VLIB_NODE_PROTO_HINT_TCP,
2337   .error_strings = tcp_error_strings,
2338   .n_next_nodes = TCP_OUTPUT_N_NEXT,
2339   .next_nodes = {
2340 #define _(s,n) [TCP_OUTPUT_NEXT_##s] = n,
2341     foreach_tcp6_output_next
2342 #undef _
2343   },
2344   .format_buffer = format_tcp_header,
2345   .format_trace = format_tcp_tx_trace,
2346 };
2347 /* *INDENT-ON* */
2348
2349 typedef enum _tcp_reset_next
2350 {
2351   TCP_RESET_NEXT_DROP,
2352   TCP_RESET_NEXT_IP_LOOKUP,
2353   TCP_RESET_N_NEXT
2354 } tcp_reset_next_t;
2355
2356 #define foreach_tcp4_reset_next         \
2357   _(DROP, "error-drop")                 \
2358   _(IP_LOOKUP, "ip4-lookup")
2359
2360 #define foreach_tcp6_reset_next         \
2361   _(DROP, "error-drop")                 \
2362   _(IP_LOOKUP, "ip6-lookup")
2363
2364 static uword
2365 tcp46_send_reset_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2366                          vlib_frame_t * from_frame, u8 is_ip4)
2367 {
2368   u32 error0 = TCP_ERROR_RST_SENT, next0 = TCP_RESET_NEXT_IP_LOOKUP;
2369   u32 n_left_from, next_index, *from, *to_next;
2370
2371   from = vlib_frame_vector_args (from_frame);
2372   n_left_from = from_frame->n_vectors;
2373
2374   next_index = node->cached_next_index;
2375
2376   while (n_left_from > 0)
2377     {
2378       u32 n_left_to_next;
2379
2380       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2381
2382       while (n_left_from > 0 && n_left_to_next > 0)
2383         {
2384           vlib_buffer_t *b0;
2385           tcp_tx_trace_t *t0;
2386           tcp_header_t *th0;
2387           u32 bi0;
2388
2389           bi0 = from[0];
2390           to_next[0] = bi0;
2391           from += 1;
2392           to_next += 1;
2393           n_left_from -= 1;
2394           n_left_to_next -= 1;
2395
2396           b0 = vlib_get_buffer (vm, bi0);
2397           tcp_make_reset_in_place (vm, b0, is_ip4);
2398
2399           /* Prepare to send to IP lookup */
2400           vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
2401
2402           b0->error = node->errors[error0];
2403           b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
2404           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2405             {
2406               th0 = vlib_buffer_get_current (b0);
2407               if (is_ip4)
2408                 th0 = ip4_next_header ((ip4_header_t *) th0);
2409               else
2410                 th0 = ip6_next_header ((ip6_header_t *) th0);
2411               t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2412               clib_memcpy_fast (&t0->tcp_header, th0,
2413                                 sizeof (t0->tcp_header));
2414             }
2415
2416           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2417                                            n_left_to_next, bi0, next0);
2418         }
2419       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2420     }
2421   return from_frame->n_vectors;
2422 }
2423
2424 VLIB_NODE_FN (tcp4_reset_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
2425                                 vlib_frame_t * from_frame)
2426 {
2427   return tcp46_send_reset_inline (vm, node, from_frame, 1);
2428 }
2429
2430 VLIB_NODE_FN (tcp6_reset_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
2431                                 vlib_frame_t * from_frame)
2432 {
2433   return tcp46_send_reset_inline (vm, node, from_frame, 0);
2434 }
2435
2436 /* *INDENT-OFF* */
2437 VLIB_REGISTER_NODE (tcp4_reset_node) = {
2438   .name = "tcp4-reset",
2439   .vector_size = sizeof (u32),
2440   .n_errors = TCP_N_ERROR,
2441   .error_strings = tcp_error_strings,
2442   .n_next_nodes = TCP_RESET_N_NEXT,
2443   .next_nodes = {
2444 #define _(s,n) [TCP_RESET_NEXT_##s] = n,
2445     foreach_tcp4_reset_next
2446 #undef _
2447   },
2448   .format_trace = format_tcp_tx_trace,
2449 };
2450 /* *INDENT-ON* */
2451
2452 /* *INDENT-OFF* */
2453 VLIB_REGISTER_NODE (tcp6_reset_node) = {
2454   .name = "tcp6-reset",
2455   .vector_size = sizeof (u32),
2456   .n_errors = TCP_N_ERROR,
2457   .error_strings = tcp_error_strings,
2458   .n_next_nodes = TCP_RESET_N_NEXT,
2459   .next_nodes = {
2460 #define _(s,n) [TCP_RESET_NEXT_##s] = n,
2461     foreach_tcp6_reset_next
2462 #undef _
2463   },
2464   .format_trace = format_tcp_tx_trace,
2465 };
2466 /* *INDENT-ON* */
2467
2468 /*
2469  * fd.io coding-style-patch-verification: ON
2470  *
2471  * Local Variables:
2472  * eval: (c-set-style "gnu")
2473  * End:
2474  */