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