src/vnet/tcp/tcp_output.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/tcp/tcp.h>
  17 #include <vnet/lisp-cp/packets.h>
  18 #include <math.h>
  19
  20 vlib_node_registration_t tcp4_output_node;
  21 vlib_node_registration_t tcp6_output_node;
  22
  23 typedef enum _tcp_output_next
  24 {
  25   TCP_OUTPUT_NEXT_DROP,
  26   TCP_OUTPUT_NEXT_IP_LOOKUP,
  27   TCP_OUTPUT_NEXT_IP_REWRITE,
  28   TCP_OUTPUT_NEXT_IP_ARP,
  29   TCP_OUTPUT_N_NEXT
  30 } tcp_output_next_t;
  31
  32 #define foreach_tcp4_output_next                \
  33   _ (DROP, "error-drop")                        \
  34   _ (IP_LOOKUP, "ip4-lookup")                   \
  35   _ (IP_REWRITE, "ip4-rewrite")                 \
  36   _ (IP_ARP, "ip4-arp")
  37
  38 #define foreach_tcp6_output_next                \
  39   _ (DROP, "error-drop")                        \
  40   _ (IP_LOOKUP, "ip6-lookup")                   \
  41   _ (IP_REWRITE, "ip6-rewrite")                 \
  42   _ (IP_ARP, "ip6-discover-neighbor")
  43
  44 static char *tcp_error_strings[] = {
  45 #define tcp_error(n,s) s,
  46 #include <vnet/tcp/tcp_error.def>
  47 #undef tcp_error
  48 };
  49
  50 typedef struct
  51 {
  52   tcp_header_t tcp_header;
  53   tcp_connection_t tcp_connection;
  54 } tcp_tx_trace_t;
  55
  56 u16 dummy_mtu = 1460;
  57
  58 u8 *
  59 format_tcp_tx_trace (u8 * s, va_list * args)
  60 {
  61   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  62   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  63   tcp_tx_trace_t *t = va_arg (*args, tcp_tx_trace_t *);
  64   u32 indent = format_get_indent (s);
  65
  66   s = format (s, "%U\n%U%U",
  67               format_tcp_header, &t->tcp_header, 128,
  68               format_white_space, indent,
  69               format_tcp_connection, &t->tcp_connection, 1);
  70
  71   return s;
  72 }
  73
  74 static u8
  75 tcp_window_compute_scale (u32 window)
  76 {
  77   u8 wnd_scale = 0;
  78   while (wnd_scale < TCP_MAX_WND_SCALE && (window >> wnd_scale) > TCP_WND_MAX)
  79     wnd_scale++;
  80   return wnd_scale;
  81 }
  82
  83 /**
  84  * Update max segment size we're able to process.
  85  *
  86  * The value is constrained by our interface's MTU and IP options. It is
  87  * also what we advertise to our peer.
  88  */
  89 void
  90 tcp_update_rcv_mss (tcp_connection_t * tc)
  91 {
  92   /* TODO find our iface MTU */
  93   tc->mss = dummy_mtu - sizeof (tcp_header_t);
  94 }
  95
  96 /**
  97  * TCP's initial window
  98  */
  99 always_inline u32
 100 tcp_initial_wnd_unscaled (tcp_connection_t * tc)
 101 {
 102   /* RFC 6928 recommends the value lower. However at the time our connections
 103    * are initialized, fifos may not be allocated. Therefore, advertise the
 104    * smallest possible unscaled window size and update once fifos are
 105    * assigned to the session.
 106    */
 107   /*
 108      tcp_update_rcv_mss (tc);
 109      TCP_IW_N_SEGMENTS * tc->mss;
 110    */
 111   return TCP_MIN_RX_FIFO_SIZE;
 112 }
 113
 114 /**
 115  * Compute initial window and scale factor. As per RFC1323, window field in
 116  * SYN and SYN-ACK segments is never scaled.
 117  */
 118 u32
 119 tcp_initial_window_to_advertise (tcp_connection_t * tc)
 120 {
 121   tcp_main_t *tm = &tcp_main;
 122   u32 max_fifo;
 123
 124   /* Initial wnd for SYN. Fifos are not allocated yet.
 125    * Use some predefined value. For SYN-ACK we still want the
 126    * scale to be computed in the same way */
 127   max_fifo = tm->max_rx_fifo ? tm->max_rx_fifo : TCP_MAX_RX_FIFO_SIZE;
 128
 129   tc->rcv_wscale = tcp_window_compute_scale (max_fifo);
 130   tc->rcv_wnd = tcp_initial_wnd_unscaled (tc);
 131
 132   return clib_min (tc->rcv_wnd, TCP_WND_MAX);
 133 }
 134
 135 static void
 136 tcp_update_rcv_wnd (tcp_connection_t * tc)
 137 {
 138   i32 observed_wnd;
 139   u32 available_space, max_fifo, wnd;
 140
 141   /*
 142    * Figure out how much space we have available
 143    */
 144   available_space = transport_max_rx_enqueue (&tc->connection);
 145   max_fifo = transport_rx_fifo_size (&tc->connection);
 146
 147   ASSERT (tc->rcv_opts.mss < max_fifo);
 148   if (available_space < tc->rcv_opts.mss && available_space < max_fifo >> 3)
 149     available_space = 0;
 150
 151   /*
 152    * Use the above and what we know about what we've previously advertised
 153    * to compute the new window
 154    */
 155   observed_wnd = (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
 156   if (observed_wnd < 0)
 157     observed_wnd = 0;
 158
 159   /* Bad. Thou shalt not shrink */
 160   if (available_space < observed_wnd)
 161     {
 162       wnd = observed_wnd;
 163       TCP_EVT_DBG (TCP_EVT_RCV_WND_SHRUNK, tc, observed_wnd, available_space);
 164     }
 165   else
 166     {
 167       wnd = available_space;
 168     }
 169
 170   /* Make sure we have a multiple of rcv_wscale */
 171   if (wnd && tc->rcv_wscale)
 172     {
 173       wnd &= ~(1 << tc->rcv_wscale);
 174       if (wnd == 0)
 175         wnd = 1 << tc->rcv_wscale;
 176     }
 177
 178   tc->rcv_wnd = clib_min (wnd, TCP_WND_MAX << tc->rcv_wscale);
 179 }
 180
 181 /**
 182  * Compute and return window to advertise, scaled as per RFC1323
 183  */
 184 static u32
 185 tcp_window_to_advertise (tcp_connection_t * tc, tcp_state_t state)
 186 {
 187   if (state < TCP_STATE_ESTABLISHED)
 188     return tcp_initial_window_to_advertise (tc);
 189
 190   tcp_update_rcv_wnd (tc);
 191
 192   if (tc->rcv_wnd == 0)
 193     {
 194       tc->flags |= TCP_CONN_SENT_RCV_WND0;
 195     }
 196   else
 197     {
 198       tc->flags &= ~TCP_CONN_SENT_RCV_WND0;
 199     }
 200
 201   return tc->rcv_wnd >> tc->rcv_wscale;
 202 }
 203
 204 /**
 205  * Write TCP options to segment.
 206  */
 207 static u32
 208 tcp_options_write (u8 * data, tcp_options_t * opts)
 209 {
 210   u32 opts_len = 0;
 211   u32 buf, seq_len = 4;
 212
 213   if (tcp_opts_mss (opts))
 214     {
 215       *data++ = TCP_OPTION_MSS;
 216       *data++ = TCP_OPTION_LEN_MSS;
 217       buf = clib_host_to_net_u16 (opts->mss);
 218       clib_memcpy (data, &buf, sizeof (opts->mss));
 219       data += sizeof (opts->mss);
 220       opts_len += TCP_OPTION_LEN_MSS;
 221     }
 222
 223   if (tcp_opts_wscale (opts))
 224     {
 225       *data++ = TCP_OPTION_WINDOW_SCALE;
 226       *data++ = TCP_OPTION_LEN_WINDOW_SCALE;
 227       *data++ = opts->wscale;
 228       opts_len += TCP_OPTION_LEN_WINDOW_SCALE;
 229     }
 230
 231   if (tcp_opts_sack_permitted (opts))
 232     {
 233       *data++ = TCP_OPTION_SACK_PERMITTED;
 234       *data++ = TCP_OPTION_LEN_SACK_PERMITTED;
 235       opts_len += TCP_OPTION_LEN_SACK_PERMITTED;
 236     }
 237
 238   if (tcp_opts_tstamp (opts))
 239     {
 240       *data++ = TCP_OPTION_TIMESTAMP;
 241       *data++ = TCP_OPTION_LEN_TIMESTAMP;
 242       buf = clib_host_to_net_u32 (opts->tsval);
 243       clib_memcpy (data, &buf, sizeof (opts->tsval));
 244       data += sizeof (opts->tsval);
 245       buf = clib_host_to_net_u32 (opts->tsecr);
 246       clib_memcpy (data, &buf, sizeof (opts->tsecr));
 247       data += sizeof (opts->tsecr);
 248       opts_len += TCP_OPTION_LEN_TIMESTAMP;
 249     }
 250
 251   if (tcp_opts_sack (opts))
 252     {
 253       int i;
 254       u32 n_sack_blocks = clib_min (vec_len (opts->sacks),
 255                                     TCP_OPTS_MAX_SACK_BLOCKS);
 256
 257       if (n_sack_blocks != 0)
 258         {
 259           *data++ = TCP_OPTION_SACK_BLOCK;
 260           *data++ = 2 + n_sack_blocks * TCP_OPTION_LEN_SACK_BLOCK;
 261           for (i = 0; i < n_sack_blocks; i++)
 262             {
 263               buf = clib_host_to_net_u32 (opts->sacks[i].start);
 264               clib_memcpy (data, &buf, seq_len);
 265               data += seq_len;
 266               buf = clib_host_to_net_u32 (opts->sacks[i].end);
 267               clib_memcpy (data, &buf, seq_len);
 268               data += seq_len;
 269             }
 270           opts_len += 2 + n_sack_blocks * TCP_OPTION_LEN_SACK_BLOCK;
 271         }
 272     }
 273
 274   /* Terminate TCP options */
 275   if (opts_len % 4)
 276     {
 277       *data++ = TCP_OPTION_EOL;
 278       opts_len += TCP_OPTION_LEN_EOL;
 279     }
 280
 281   /* Pad with zeroes to a u32 boundary */
 282   while (opts_len % 4)
 283     {
 284       *data++ = TCP_OPTION_NOOP;
 285       opts_len += TCP_OPTION_LEN_NOOP;
 286     }
 287   return opts_len;
 288 }
 289
 290 static int
 291 tcp_make_syn_options (tcp_options_t * opts, u8 wnd_scale)
 292 {
 293   u8 len = 0;
 294
 295   opts->flags |= TCP_OPTS_FLAG_MSS;
 296   opts->mss = dummy_mtu;        /*XXX discover that */
 297   len += TCP_OPTION_LEN_MSS;
 298
 299   opts->flags |= TCP_OPTS_FLAG_WSCALE;
 300   opts->wscale = wnd_scale;
 301   len += TCP_OPTION_LEN_WINDOW_SCALE;
 302
 303   opts->flags |= TCP_OPTS_FLAG_TSTAMP;
 304   opts->tsval = tcp_time_now ();
 305   opts->tsecr = 0;
 306   len += TCP_OPTION_LEN_TIMESTAMP;
 307
 308   if (TCP_USE_SACKS)
 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_synack_options (tcp_connection_t * tc, tcp_options_t * opts)
 321 {
 322   u8 len = 0;
 323
 324   opts->flags |= TCP_OPTS_FLAG_MSS;
 325   opts->mss = tc->mss;
 326   len += TCP_OPTION_LEN_MSS;
 327
 328   if (tcp_opts_wscale (&tc->rcv_opts))
 329     {
 330       opts->flags |= TCP_OPTS_FLAG_WSCALE;
 331       opts->wscale = tc->rcv_wscale;
 332       len += TCP_OPTION_LEN_WINDOW_SCALE;
 333     }
 334
 335   if (tcp_opts_tstamp (&tc->rcv_opts))
 336     {
 337       opts->flags |= TCP_OPTS_FLAG_TSTAMP;
 338       opts->tsval = tcp_time_now ();
 339       opts->tsecr = tc->tsval_recent;
 340       len += TCP_OPTION_LEN_TIMESTAMP;
 341     }
 342
 343   if (tcp_opts_sack_permitted (&tc->rcv_opts))
 344     {
 345       opts->flags |= TCP_OPTS_FLAG_SACK_PERMITTED;
 346       len += TCP_OPTION_LEN_SACK_PERMITTED;
 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 static int
 355 tcp_make_established_options (tcp_connection_t * tc, tcp_options_t * opts)
 356 {
 357   u8 len = 0;
 358
 359   opts->flags = 0;
 360
 361   if (tcp_opts_tstamp (&tc->rcv_opts))
 362     {
 363       opts->flags |= TCP_OPTS_FLAG_TSTAMP;
 364       opts->tsval = tcp_time_now ();
 365       opts->tsecr = tc->tsval_recent;
 366       len += TCP_OPTION_LEN_TIMESTAMP;
 367     }
 368   if (tcp_opts_sack_permitted (&tc->rcv_opts))
 369     {
 370       if (vec_len (tc->snd_sacks))
 371         {
 372           opts->flags |= TCP_OPTS_FLAG_SACK;
 373           opts->sacks = tc->snd_sacks;
 374           opts->n_sack_blocks = clib_min (vec_len (tc->snd_sacks),
 375                                           TCP_OPTS_MAX_SACK_BLOCKS);
 376           len += 2 + TCP_OPTION_LEN_SACK_BLOCK * opts->n_sack_blocks;
 377         }
 378     }
 379
 380   /* Align to needed boundary */
 381   len += (TCP_OPTS_ALIGN - len % TCP_OPTS_ALIGN) % TCP_OPTS_ALIGN;
 382   return len;
 383 }
 384
 385 always_inline int
 386 tcp_make_options (tcp_connection_t * tc, tcp_options_t * opts,
 387                   tcp_state_t state)
 388 {
 389   switch (state)
 390     {
 391     case TCP_STATE_ESTABLISHED:
 392     case TCP_STATE_FIN_WAIT_1:
 393     case TCP_STATE_CLOSED:
 394     case TCP_STATE_CLOSE_WAIT:
 395       return tcp_make_established_options (tc, opts);
 396     case TCP_STATE_SYN_RCVD:
 397       return tcp_make_synack_options (tc, opts);
 398     case TCP_STATE_SYN_SENT:
 399       return tcp_make_syn_options (opts, tc->rcv_wscale);
 400     default:
 401       clib_warning ("State not handled! %d", state);
 402       return 0;
 403     }
 404 }
 405
 406 /**
 407  * Update burst send vars
 408  *
 409  * - Updates snd_mss to reflect the effective segment size that we can send
 410  * by taking into account all TCP options, including SACKs.
 411  * - Cache 'on the wire' options for reuse
 412  * - Updates receive window which can be reused for a burst.
 413  *
 414  * This should *only* be called when doing bursts
 415  */
 416 void
 417 tcp_update_burst_snd_vars (tcp_connection_t * tc)
 418 {
 419   tcp_main_t *tm = &tcp_main;
 420
 421   /* Compute options to be used for connection. These may be reused when
 422    * sending data or to compute the effective mss (snd_mss) */
 423   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts,
 424                                        TCP_STATE_ESTABLISHED);
 425
 426   /* XXX check if MTU has been updated */
 427   tc->snd_mss = clib_min (tc->mss, tc->rcv_opts.mss) - tc->snd_opts_len;
 428   ASSERT (tc->snd_mss > 0);
 429
 430   tcp_options_write (tm->wrk_ctx[tc->c_thread_index].cached_opts,
 431                      &tc->snd_opts);
 432
 433   tcp_update_rcv_wnd (tc);
 434 }
 435
 436 void
 437 tcp_init_mss (tcp_connection_t * tc)
 438 {
 439   u16 default_min_mss = 536;
 440   tcp_update_rcv_mss (tc);
 441
 442   /* TODO cache mss and consider PMTU discovery */
 443   tc->snd_mss = clib_min (tc->rcv_opts.mss, tc->mss);
 444
 445   if (tc->snd_mss < 45)
 446     {
 447       clib_warning ("snd mss is 0");
 448       /* Assume that at least the min default mss works */
 449       tc->snd_mss = default_min_mss;
 450       tc->rcv_opts.mss = default_min_mss;
 451     }
 452
 453   /* We should have enough space for 40 bytes of options */
 454   ASSERT (tc->snd_mss > 45);
 455
 456   /* If we use timestamp option, account for it */
 457   if (tcp_opts_tstamp (&tc->rcv_opts))
 458     tc->snd_mss -= TCP_OPTION_LEN_TIMESTAMP;
 459 }
 460
 461 static int
 462 tcp_alloc_tx_buffers (tcp_main_t * tm, u8 thread_index, u16 * n_bufs,
 463                       u32 wanted)
 464 {
 465   tcp_worker_ctx_t *ctx = &tm->wrk_ctx[thread_index];
 466   vlib_main_t *vm = vlib_get_main ();
 467   u32 n_alloc;
 468
 469   ASSERT (wanted > *n_bufs);
 470   vec_validate_aligned (ctx->tx_buffers, wanted - 1, CLIB_CACHE_LINE_BYTES);
 471   n_alloc = vlib_buffer_alloc (vm, &ctx->tx_buffers[*n_bufs],
 472                                wanted - *n_bufs);
 473   *n_bufs += n_alloc;
 474   _vec_len (ctx->tx_buffers) = *n_bufs;
 475   return n_alloc;
 476 }
 477
 478 always_inline int
 479 tcp_get_free_buffer_index (tcp_main_t * tm, u32 * bidx)
 480 {
 481   u32 thread_index = vlib_get_thread_index ();
 482   tcp_worker_ctx_t *ctx = &tm->wrk_ctx[thread_index];
 483   u16 n_bufs = vec_len (ctx->tx_buffers);
 484
 485   TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL (thread_index);
 486
 487   if (PREDICT_FALSE (!n_bufs))
 488     {
 489       if (!tcp_alloc_tx_buffers (tm, thread_index, &n_bufs, VLIB_FRAME_SIZE))
 490         {
 491           *bidx = ~0;
 492           return -1;
 493         }
 494     }
 495   *bidx = ctx->tx_buffers[--n_bufs];
 496   _vec_len (ctx->tx_buffers) = n_bufs;
 497   return 0;
 498 }
 499
 500 static void *
 501 tcp_reuse_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 502 {
 503   if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 504     vlib_buffer_free_one (vm, b->next_buffer);
 505   /* Zero all flags but free list index and trace flag */
 506   b->flags &= VLIB_BUFFER_NEXT_PRESENT - 1;
 507   b->current_data = 0;
 508   b->current_length = 0;
 509   b->total_length_not_including_first_buffer = 0;
 510   vnet_buffer (b)->tcp.flags = 0;
 511
 512   /* Leave enough space for headers */
 513   return vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
 514 }
 515
 516 static void *
 517 tcp_init_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 518 {
 519   ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
 520   b->flags &= VLIB_BUFFER_NON_DEFAULT_FREELIST;
 521   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 522   b->total_length_not_including_first_buffer = 0;
 523   b->current_data = 0;
 524   vnet_buffer (b)->tcp.flags = 0;
 525   VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
 526   /* Leave enough space for headers */
 527   return vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
 528 }
 529
 530 /**
 531  * Prepare ACK
 532  */
 533 static void
 534 tcp_make_ack_i (tcp_connection_t * tc, vlib_buffer_t * b, tcp_state_t state,
 535                 u8 flags)
 536 {
 537   tcp_options_t _snd_opts, *snd_opts = &_snd_opts;
 538   u8 tcp_opts_len, tcp_hdr_opts_len;
 539   tcp_header_t *th;
 540   u16 wnd;
 541
 542   wnd = tcp_window_to_advertise (tc, state);
 543
 544   /* Make and write options */
 545   tcp_opts_len = tcp_make_established_options (tc, snd_opts);
 546   tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
 547
 548   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->snd_nxt,
 549                              tc->rcv_nxt, tcp_hdr_opts_len, flags, wnd);
 550
 551   tcp_options_write ((u8 *) (th + 1), snd_opts);
 552   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 553 }
 554
 555 /**
 556  * Convert buffer to ACK
 557  */
 558 void
 559 tcp_make_ack (tcp_connection_t * tc, vlib_buffer_t * b)
 560 {
 561   vlib_main_t *vm = vlib_get_main ();
 562
 563   tcp_reuse_buffer (vm, b);
 564   tcp_make_ack_i (tc, b, TCP_STATE_ESTABLISHED, TCP_FLAG_ACK);
 565   TCP_EVT_DBG (TCP_EVT_ACK_SENT, tc);
 566   vnet_buffer (b)->tcp.flags = TCP_BUF_FLAG_ACK;
 567   tc->rcv_las = tc->rcv_nxt;
 568 }
 569
 570 /**
 571  * Convert buffer to FIN-ACK
 572  */
 573 void
 574 tcp_make_fin (tcp_connection_t * tc, vlib_buffer_t * b)
 575 {
 576   vlib_main_t *vm = vlib_get_main ();
 577   u8 flags = 0;
 578
 579   tcp_reuse_buffer (vm, b);
 580
 581   flags = TCP_FLAG_FIN | TCP_FLAG_ACK;
 582   tcp_make_ack_i (tc, b, TCP_STATE_ESTABLISHED, flags);
 583
 584   /* Reset flags, make sure ack is sent */
 585   vnet_buffer (b)->tcp.flags &= ~TCP_BUF_FLAG_DUPACK;
 586 }
 587
 588 /**
 589  * Convert buffer to SYN
 590  */
 591 void
 592 tcp_make_syn (tcp_connection_t * tc, vlib_buffer_t * b)
 593 {
 594   u8 tcp_hdr_opts_len, tcp_opts_len;
 595   tcp_header_t *th;
 596   u16 initial_wnd;
 597   tcp_options_t snd_opts;
 598
 599   initial_wnd = tcp_initial_window_to_advertise (tc);
 600
 601   /* Make and write options */
 602   clib_memset (&snd_opts, 0, sizeof (snd_opts));
 603   tcp_opts_len = tcp_make_syn_options (&snd_opts, tc->rcv_wscale);
 604   tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
 605
 606   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->iss,
 607                              tc->rcv_nxt, tcp_hdr_opts_len, TCP_FLAG_SYN,
 608                              initial_wnd);
 609   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 610   tcp_options_write ((u8 *) (th + 1), &snd_opts);
 611 }
 612
 613 /**
 614  * Convert buffer to SYN-ACK
 615  */
 616 void
 617 tcp_make_synack (tcp_connection_t * tc, vlib_buffer_t * b)
 618 {
 619   vlib_main_t *vm = vlib_get_main ();
 620   tcp_options_t _snd_opts, *snd_opts = &_snd_opts;
 621   u8 tcp_opts_len, tcp_hdr_opts_len;
 622   tcp_header_t *th;
 623   u16 initial_wnd;
 624
 625   clib_memset (snd_opts, 0, sizeof (*snd_opts));
 626   tcp_reuse_buffer (vm, b);
 627
 628   initial_wnd = tcp_initial_window_to_advertise (tc);
 629   tcp_opts_len = tcp_make_synack_options (tc, snd_opts);
 630   tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
 631
 632   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->iss,
 633                              tc->rcv_nxt, tcp_hdr_opts_len,
 634                              TCP_FLAG_SYN | TCP_FLAG_ACK, initial_wnd);
 635   tcp_options_write ((u8 *) (th + 1), snd_opts);
 636
 637   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 638   vnet_buffer (b)->tcp.flags = TCP_BUF_FLAG_ACK;
 639
 640   /* Init retransmit timer. Use update instead of set because of
 641    * retransmissions */
 642   tcp_retransmit_timer_force_update (tc);
 643   TCP_EVT_DBG (TCP_EVT_SYNACK_SENT, tc);
 644 }
 645
 646 always_inline void
 647 tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 648                             u8 is_ip4, u32 fib_index, u8 flush)
 649 {
 650   tcp_main_t *tm = vnet_get_tcp_main ();
 651   u32 thread_index = vlib_get_thread_index ();
 652   u32 *to_next, next_index;
 653   vlib_frame_t *f;
 654
 655   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 656   b->error = 0;
 657
 658   vnet_buffer (b)->sw_if_index[VLIB_TX] = fib_index;
 659   vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
 660
 661   /* Send to IP lookup */
 662   next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
 663   tcp_trajectory_add_start (b, 1);
 664
 665   f = tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4];
 666   if (!f)
 667     {
 668       f = vlib_get_frame_to_node (vm, next_index);
 669       ASSERT (f);
 670       tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = f;
 671     }
 672
 673   to_next = vlib_frame_vector_args (f);
 674   to_next[f->n_vectors] = bi;
 675   f->n_vectors += 1;
 676   if (flush || f->n_vectors == VLIB_FRAME_SIZE)
 677     {
 678       vlib_put_frame_to_node (vm, next_index, f);
 679       tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = 0;
 680     }
 681 }
 682
 683 static void
 684 tcp_enqueue_to_ip_lookup_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 685                               u8 is_ip4, u32 fib_index)
 686 {
 687   tcp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 1);
 688 }
 689
 690 static void
 691 tcp_enqueue_to_ip_lookup (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 692                           u8 is_ip4, u32 fib_index)
 693 {
 694   tcp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 0);
 695   if (vm->thread_index == 0 && vlib_num_workers ())
 696     session_flush_frames_main_thread (vm);
 697 }
 698
 699 always_inline void
 700 tcp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 701                          u8 is_ip4, u8 flush)
 702 {
 703   tcp_main_t *tm = vnet_get_tcp_main ();
 704   u32 thread_index = vlib_get_thread_index ();
 705   u32 *to_next, next_index;
 706   vlib_frame_t *f;
 707
 708   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 709   b->error = 0;
 710
 711   /* Decide where to send the packet */
 712   next_index = is_ip4 ? tcp4_output_node.index : tcp6_output_node.index;
 713   tcp_trajectory_add_start (b, 2);
 714
 715   /* Get frame to v4/6 output node */
 716   f = tm->wrk_ctx[thread_index].tx_frames[!is_ip4];
 717   if (!f)
 718     {
 719       f = vlib_get_frame_to_node (vm, next_index);
 720       ASSERT (f);
 721       tm->wrk_ctx[thread_index].tx_frames[!is_ip4] = f;
 722     }
 723   to_next = vlib_frame_vector_args (f);
 724   to_next[f->n_vectors] = bi;
 725   f->n_vectors += 1;
 726   if (flush || f->n_vectors == VLIB_FRAME_SIZE)
 727     {
 728       vlib_put_frame_to_node (vm, next_index, f);
 729       tm->wrk_ctx[thread_index].tx_frames[!is_ip4] = 0;
 730     }
 731 }
 732
 733 static void
 734 tcp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi, u8 is_ip4)
 735 {
 736   tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 0);
 737 }
 738
 739 static void
 740 tcp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 741                            u8 is_ip4)
 742 {
 743   tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
 744 }
 745
 746 static int
 747 tcp_make_reset_in_place (vlib_main_t * vm, vlib_buffer_t * b0,
 748                          tcp_state_t state, u8 thread_index, u8 is_ip4)
 749 {
 750   ip4_header_t *ih4;
 751   ip6_header_t *ih6;
 752   tcp_header_t *th0;
 753   ip4_address_t src_ip40, dst_ip40;
 754   ip6_address_t src_ip60, dst_ip60;
 755   u16 src_port, dst_port;
 756   u32 tmp;
 757   u32 seq, ack;
 758   u8 flags;
 759
 760   /* Find IP and TCP headers */
 761   th0 = tcp_buffer_hdr (b0);
 762
 763   /* Save src and dst ip */
 764   if (is_ip4)
 765     {
 766       ih4 = vlib_buffer_get_current (b0);
 767       ASSERT ((ih4->ip_version_and_header_length & 0xF0) == 0x40);
 768       src_ip40.as_u32 = ih4->src_address.as_u32;
 769       dst_ip40.as_u32 = ih4->dst_address.as_u32;
 770     }
 771   else
 772     {
 773       ih6 = vlib_buffer_get_current (b0);
 774       ASSERT ((ih6->ip_version_traffic_class_and_flow_label & 0xF0) == 0x60);
 775       clib_memcpy (&src_ip60, &ih6->src_address, sizeof (ip6_address_t));
 776       clib_memcpy (&dst_ip60, &ih6->dst_address, sizeof (ip6_address_t));
 777     }
 778
 779   src_port = th0->src_port;
 780   dst_port = th0->dst_port;
 781
 782   /* Try to determine what/why we're actually resetting */
 783   if (state == TCP_STATE_CLOSED)
 784     {
 785       if (!tcp_syn (th0))
 786         return -1;
 787
 788       tmp = clib_net_to_host_u32 (th0->seq_number);
 789
 790       /* Got a SYN for no listener. */
 791       flags = TCP_FLAG_RST | TCP_FLAG_ACK;
 792       ack = clib_host_to_net_u32 (tmp + 1);
 793       seq = 0;
 794     }
 795   else
 796     {
 797       flags = TCP_FLAG_RST;
 798       seq = th0->ack_number;
 799       ack = 0;
 800     }
 801
 802   tcp_reuse_buffer (vm, b0);
 803   tcp_trajectory_add_start (b0, 4);
 804   th0 = vlib_buffer_push_tcp_net_order (b0, dst_port, src_port, seq, ack,
 805                                         sizeof (tcp_header_t), flags, 0);
 806
 807   if (is_ip4)
 808     {
 809       ih4 = vlib_buffer_push_ip4 (vm, b0, &dst_ip40, &src_ip40,
 810                                   IP_PROTOCOL_TCP, 1);
 811       th0->checksum = ip4_tcp_udp_compute_checksum (vm, b0, ih4);
 812     }
 813   else
 814     {
 815       int bogus = ~0;
 816       ih6 = vlib_buffer_push_ip6 (vm, b0, &dst_ip60, &src_ip60,
 817                                   IP_PROTOCOL_TCP);
 818       th0->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b0, ih6, &bogus);
 819       ASSERT (!bogus);
 820     }
 821
 822   return 0;
 823 }
 824
 825 /**
 826  *  Send reset without reusing existing buffer
 827  *
 828  *  It extracts connection info out of original packet
 829  */
 830 void
 831 tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
 832 {
 833   vlib_buffer_t *b;
 834   u32 bi, sw_if_index, fib_index;
 835   tcp_main_t *tm = vnet_get_tcp_main ();
 836   vlib_main_t *vm = vlib_get_main ();
 837   u8 tcp_hdr_len, flags = 0;
 838   tcp_header_t *th, *pkt_th;
 839   u32 seq, ack;
 840   ip4_header_t *ih4, *pkt_ih4;
 841   ip6_header_t *ih6, *pkt_ih6;
 842   fib_protocol_t fib_proto;
 843
 844   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
 845     return;
 846
 847   b = vlib_get_buffer (vm, bi);
 848   sw_if_index = vnet_buffer (pkt)->sw_if_index[VLIB_RX];
 849   fib_proto = is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
 850   fib_index = fib_table_get_index_for_sw_if_index (fib_proto, sw_if_index);
 851   tcp_init_buffer (vm, b);
 852
 853   /* Make and write options */
 854   tcp_hdr_len = sizeof (tcp_header_t);
 855
 856   if (is_ip4)
 857     {
 858       pkt_ih4 = vlib_buffer_get_current (pkt);
 859       pkt_th = ip4_next_header (pkt_ih4);
 860     }
 861   else
 862     {
 863       pkt_ih6 = vlib_buffer_get_current (pkt);
 864       pkt_th = ip6_next_header (pkt_ih6);
 865     }
 866
 867   if (tcp_ack (pkt_th))
 868     {
 869       flags = TCP_FLAG_RST;
 870       seq = pkt_th->ack_number;
 871       ack = (tc && tc->state >= TCP_STATE_SYN_RCVD) ? tc->rcv_nxt : 0;
 872     }
 873   else
 874     {
 875       flags = TCP_FLAG_RST | TCP_FLAG_ACK;
 876       seq = 0;
 877       ack = clib_host_to_net_u32 (vnet_buffer (pkt)->tcp.seq_end);
 878     }
 879
 880   th = vlib_buffer_push_tcp_net_order (b, pkt_th->dst_port, pkt_th->src_port,
 881                                        seq, ack, tcp_hdr_len, flags, 0);
 882
 883   /* Swap src and dst ip */
 884   if (is_ip4)
 885     {
 886       ASSERT ((pkt_ih4->ip_version_and_header_length & 0xF0) == 0x40);
 887       ih4 = vlib_buffer_push_ip4 (vm, b, &pkt_ih4->dst_address,
 888                                   &pkt_ih4->src_address, IP_PROTOCOL_TCP, 1);
 889       th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ih4);
 890     }
 891   else
 892     {
 893       int bogus = ~0;
 894       ASSERT ((pkt_ih6->ip_version_traffic_class_and_flow_label & 0xF0) ==
 895               0x60);
 896       ih6 = vlib_buffer_push_ip6 (vm, b, &pkt_ih6->dst_address,
 897                                   &pkt_ih6->src_address, IP_PROTOCOL_TCP);
 898       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
 899       ASSERT (!bogus);
 900     }
 901
 902   tcp_enqueue_to_ip_lookup_now (vm, b, bi, is_ip4, fib_index);
 903   TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
 904 }
 905
 906 /**
 907  * Build and set reset packet for connection
 908  */
 909 void
 910 tcp_send_reset (tcp_connection_t * tc)
 911 {
 912   vlib_main_t *vm = vlib_get_main ();
 913   tcp_main_t *tm = vnet_get_tcp_main ();
 914   vlib_buffer_t *b;
 915   u32 bi;
 916   tcp_header_t *th;
 917   u16 tcp_hdr_opts_len, advertise_wnd, opts_write_len;
 918   u8 flags;
 919
 920   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
 921     return;
 922   b = vlib_get_buffer (vm, bi);
 923   tcp_init_buffer (vm, b);
 924
 925   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
 926   tcp_hdr_opts_len = tc->snd_opts_len + sizeof (tcp_header_t);
 927   advertise_wnd = tcp_window_to_advertise (tc, TCP_STATE_ESTABLISHED);
 928   flags = TCP_FLAG_RST;
 929   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->snd_nxt,
 930                              tc->rcv_nxt, tcp_hdr_opts_len, flags,
 931                              advertise_wnd);
 932   opts_write_len = tcp_options_write ((u8 *) (th + 1), &tc->snd_opts);
 933   ASSERT (opts_write_len == tc->snd_opts_len);
 934   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
 935   if (tc->c_is_ip4)
 936     {
 937       ip4_header_t *ih4;
 938       ih4 = vlib_buffer_push_ip4 (vm, b, &tc->c_lcl_ip.ip4,
 939                                   &tc->c_rmt_ip.ip4, IP_PROTOCOL_TCP, 0);
 940       th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ih4);
 941     }
 942   else
 943     {
 944       int bogus = ~0;
 945       ip6_header_t *ih6;
 946       ih6 = vlib_buffer_push_ip6 (vm, b, &tc->c_lcl_ip.ip6,
 947                                   &tc->c_rmt_ip.ip6, IP_PROTOCOL_TCP);
 948       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
 949       ASSERT (!bogus);
 950     }
 951   tcp_enqueue_to_ip_lookup_now (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
 952   TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
 953 }
 954
 955 static void
 956 tcp_push_ip_hdr (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b)
 957 {
 958   tcp_header_t *th = vlib_buffer_get_current (b);
 959   vlib_main_t *vm = vlib_get_main ();
 960   if (tc->c_is_ip4)
 961     {
 962       ip4_header_t *ih;
 963       ih = vlib_buffer_push_ip4 (vm, b, &tc->c_lcl_ip4,
 964                                  &tc->c_rmt_ip4, IP_PROTOCOL_TCP, 1);
 965       th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ih);
 966     }
 967   else
 968     {
 969       ip6_header_t *ih;
 970       int bogus = ~0;
 971
 972       ih = vlib_buffer_push_ip6 (vm, b, &tc->c_lcl_ip6,
 973                                  &tc->c_rmt_ip6, IP_PROTOCOL_TCP);
 974       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih, &bogus);
 975       ASSERT (!bogus);
 976     }
 977 }
 978
 979 /**
 980  *  Send SYN
 981  *
 982  *  Builds a SYN packet for a half-open connection and sends it to ipx_lookup.
 983  *  The packet is not forwarded through tcpx_output to avoid doing lookups
 984  *  in the half_open pool.
 985  */
 986 void
 987 tcp_send_syn (tcp_connection_t * tc)
 988 {
 989   vlib_buffer_t *b;
 990   u32 bi;
 991   tcp_main_t *tm = vnet_get_tcp_main ();
 992   vlib_main_t *vm = vlib_get_main ();
 993
 994   /*
 995    * Setup retransmit and establish timers before requesting buffer
 996    * such that we can return if we've ran out.
 997    */
 998   tcp_timer_set (tc, TCP_TIMER_ESTABLISH, TCP_ESTABLISH_TIME);
 999   tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
1000                     tc->rto * TCP_TO_TIMER_TICK);
1001
1002   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1003     return;
1004
1005   b = vlib_get_buffer (vm, bi);
1006   tcp_init_buffer (vm, b);
1007   tcp_make_syn (tc, b);
1008
1009   /* Measure RTT with this */
1010   tc->rtt_ts = tcp_time_now ();
1011   tc->rtt_seq = tc->snd_nxt;
1012   tc->rto_boff = 0;
1013
1014   tcp_push_ip_hdr (tm, tc, b);
1015   tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
1016   TCP_EVT_DBG (TCP_EVT_SYN_SENT, tc);
1017 }
1018
1019 /**
1020  * Flush tx frame populated by retransmits and timer pops
1021  */
1022 void
1023 tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
1024 {
1025   if (tcp_main.wrk_ctx[thread_index].tx_frames[!is_ip4])
1026     {
1027       u32 next_index;
1028       next_index = is_ip4 ? tcp4_output_node.index : tcp6_output_node.index;
1029       vlib_put_frame_to_node (vm, next_index,
1030                               tcp_main.
1031                               wrk_ctx[thread_index].tx_frames[!is_ip4]);
1032       tcp_main.wrk_ctx[thread_index].tx_frames[!is_ip4] = 0;
1033     }
1034 }
1035
1036 /**
1037  * Flush ip lookup tx frames populated by timer pops
1038  */
1039 static void
1040 tcp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
1041 {
1042   if (tcp_main.wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4])
1043     {
1044       u32 next_index;
1045       next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
1046       vlib_put_frame_to_node (vm, next_index,
1047                               tcp_main.
1048                               wrk_ctx[thread_index].ip_lookup_tx_frames
1049                               [!is_ip4]);
1050       tcp_main.wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = 0;
1051     }
1052 }
1053
1054 /**
1055  * Flush v4 and v6 tcp and ip-lookup tx frames for thread index
1056  */
1057 void
1058 tcp_flush_frames_to_output (u8 thread_index)
1059 {
1060   vlib_main_t *vm = vlib_get_main ();
1061   tcp_flush_frame_to_output (vm, thread_index, 1);
1062   tcp_flush_frame_to_output (vm, thread_index, 0);
1063   tcp_flush_frame_to_ip_lookup (vm, thread_index, 1);
1064   tcp_flush_frame_to_ip_lookup (vm, thread_index, 0);
1065 }
1066
1067 /**
1068  *  Send FIN
1069  */
1070 void
1071 tcp_send_fin (tcp_connection_t * tc)
1072 {
1073   tcp_main_t *tm = vnet_get_tcp_main ();
1074   vlib_main_t *vm = vlib_get_main ();
1075   vlib_buffer_t *b;
1076   u32 bi;
1077   u8 fin_snt = 0;
1078
1079   fin_snt = tc->flags & TCP_CONN_FINSNT;
1080   if (fin_snt)
1081     tc->snd_nxt = tc->snd_una;
1082
1083   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1084     {
1085       /* Out of buffers so program fin retransmit ASAP */
1086       tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
1087       goto post_enqueue;
1088     }
1089
1090   tcp_retransmit_timer_force_update (tc);
1091   b = vlib_get_buffer (vm, bi);
1092   tcp_init_buffer (vm, b);
1093   tcp_make_fin (tc, b);
1094   tcp_enqueue_to_output_now (vm, b, bi, tc->c_is_ip4);
1095   TCP_EVT_DBG (TCP_EVT_FIN_SENT, tc);
1096
1097 post_enqueue:
1098   if (!fin_snt)
1099     {
1100       tc->flags |= TCP_CONN_FINSNT;
1101       tc->flags &= ~TCP_CONN_FINPNDG;
1102       /* Account for the FIN */
1103       tc->snd_una_max += 1;
1104       tc->snd_nxt = tc->snd_una_max;
1105     }
1106   else
1107     {
1108       tc->snd_nxt = tc->snd_una_max;
1109     }
1110 }
1111
1112 always_inline u8
1113 tcp_make_state_flags (tcp_connection_t * tc, tcp_state_t next_state)
1114 {
1115   switch (next_state)
1116     {
1117     case TCP_STATE_ESTABLISHED:
1118     case TCP_STATE_CLOSE_WAIT:
1119       return TCP_FLAG_ACK;
1120     case TCP_STATE_SYN_RCVD:
1121       return TCP_FLAG_SYN | TCP_FLAG_ACK;
1122     case TCP_STATE_SYN_SENT:
1123       return TCP_FLAG_SYN;
1124     case TCP_STATE_LAST_ACK:
1125     case TCP_STATE_FIN_WAIT_1:
1126       if (tc->snd_nxt + 1 < tc->snd_una_max)
1127         return TCP_FLAG_ACK;
1128       else
1129         return TCP_FLAG_FIN;
1130     default:
1131       clib_warning ("Shouldn't be here!");
1132     }
1133   return 0;
1134 }
1135
1136 /**
1137  * Push TCP header and update connection variables
1138  */
1139 always_inline void
1140 tcp_push_hdr_i (tcp_connection_t * tc, vlib_buffer_t * b,
1141                 tcp_state_t next_state, u8 compute_opts, u8 maybe_burst)
1142 {
1143   u32 advertise_wnd, data_len;
1144   u8 tcp_hdr_opts_len, flags;
1145   tcp_main_t *tm = &tcp_main;
1146   tcp_header_t *th;
1147
1148   data_len = b->current_length;
1149   if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
1150     data_len += b->total_length_not_including_first_buffer;
1151
1152   vnet_buffer (b)->tcp.flags = 0;
1153   vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
1154
1155   if (compute_opts)
1156     tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
1157
1158   tcp_hdr_opts_len = tc->snd_opts_len + sizeof (tcp_header_t);
1159
1160   if (maybe_burst)
1161     advertise_wnd = tc->rcv_wnd >> tc->rcv_wscale;
1162   else
1163     advertise_wnd = tcp_window_to_advertise (tc, next_state);
1164
1165   flags = tcp_make_state_flags (tc, next_state);
1166
1167   th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->snd_nxt,
1168                              tc->rcv_nxt, tcp_hdr_opts_len, flags,
1169                              advertise_wnd);
1170
1171   if (maybe_burst)
1172     {
1173       clib_memcpy ((u8 *) (th + 1),
1174                    tm->wrk_ctx[tc->c_thread_index].cached_opts,
1175                    tc->snd_opts_len);
1176     }
1177   else
1178     {
1179       u8 len = tcp_options_write ((u8 *) (th + 1), &tc->snd_opts);
1180       ASSERT (len == tc->snd_opts_len);
1181     }
1182
1183   /*
1184    * Update connection variables
1185    */
1186
1187   tc->snd_nxt += data_len;
1188   tc->rcv_las = tc->rcv_nxt;
1189
1190   TCP_EVT_DBG (TCP_EVT_PKTIZE, tc);
1191 }
1192
1193 u32
1194 tcp_push_header (tcp_connection_t * tc, vlib_buffer_t * b)
1195 {
1196   tcp_push_hdr_i (tc, b, TCP_STATE_ESTABLISHED, /* compute opts */ 0,
1197                   /* burst */ 1);
1198   tc->snd_una_max = tc->snd_nxt;
1199   ASSERT (seq_leq (tc->snd_una_max, tc->snd_una + tc->snd_wnd
1200                    + tcp_fastrecovery_sent_1_smss (tc) * tc->snd_mss));
1201   tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
1202   /* If not tracking an ACK, start tracking */
1203   if (tc->rtt_ts == 0 && !tcp_in_cong_recovery (tc))
1204     {
1205       tc->rtt_ts = tcp_time_now ();
1206       tc->rtt_seq = tc->snd_nxt;
1207     }
1208   if (PREDICT_FALSE (!tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)))
1209     {
1210       tcp_retransmit_timer_set (tc);
1211       tc->rto_boff = 0;
1212     }
1213   tcp_trajectory_add_start (b, 3);
1214   return 0;
1215 }
1216
1217 void
1218 tcp_send_ack (tcp_connection_t * tc)
1219 {
1220   tcp_main_t *tm = vnet_get_tcp_main ();
1221   vlib_main_t *vm = vlib_get_main ();
1222
1223   vlib_buffer_t *b;
1224   u32 bi;
1225
1226   /* Get buffer */
1227   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1228     return;
1229   b = vlib_get_buffer (vm, bi);
1230   tcp_init_buffer (vm, b);
1231
1232   /* Fill in the ACK */
1233   tcp_make_ack (tc, b);
1234   tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1235 }
1236
1237 /**
1238  * Delayed ack timer handler
1239  *
1240  * Sends delayed ACK when timer expires
1241  */
1242 void
1243 tcp_timer_delack_handler (u32 index)
1244 {
1245   u32 thread_index = vlib_get_thread_index ();
1246   tcp_connection_t *tc;
1247
1248   tc = tcp_connection_get (index, thread_index);
1249   tc->timers[TCP_TIMER_DELACK] = TCP_TIMER_HANDLE_INVALID;
1250   tcp_send_ack (tc);
1251 }
1252
1253 /**
1254  * Build a retransmit segment
1255  *
1256  * @return the number of bytes in the segment or 0 if there's nothing to
1257  *         retransmit
1258  */
1259 static u32
1260 tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
1261                                 u32 max_deq_bytes, vlib_buffer_t ** b)
1262 {
1263   tcp_main_t *tm = vnet_get_tcp_main ();
1264   vlib_main_t *vm = vlib_get_main ();
1265   int n_bytes = 0;
1266   u32 start, bi, available_bytes, seg_size;
1267   u8 *data;
1268
1269   ASSERT (tc->state >= TCP_STATE_ESTABLISHED);
1270   ASSERT (max_deq_bytes != 0);
1271
1272   /*
1273    * Make sure we can retransmit something
1274    */
1275   available_bytes = session_tx_fifo_max_dequeue (&tc->connection);
1276   ASSERT (available_bytes >= offset);
1277   available_bytes -= offset;
1278   if (!available_bytes)
1279     return 0;
1280   max_deq_bytes = clib_min (tc->snd_mss, max_deq_bytes);
1281   max_deq_bytes = clib_min (available_bytes, max_deq_bytes);
1282
1283   /* Start is beyond snd_congestion */
1284   start = tc->snd_una + offset;
1285   if (seq_geq (start, tc->snd_congestion))
1286     goto done;
1287
1288   /* Don't overshoot snd_congestion */
1289   if (seq_gt (start + max_deq_bytes, tc->snd_congestion))
1290     {
1291       max_deq_bytes = tc->snd_congestion - start;
1292       if (max_deq_bytes == 0)
1293         goto done;
1294     }
1295
1296   seg_size = max_deq_bytes + MAX_HDRS_LEN;
1297
1298   /*
1299    * Prepare options
1300    */
1301   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
1302
1303   /*
1304    * Allocate and fill in buffer(s)
1305    */
1306
1307   /* Easy case, buffer size greater than mss */
1308   if (PREDICT_TRUE (seg_size <= tm->bytes_per_buffer))
1309     {
1310       if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1311         return 0;
1312       *b = vlib_get_buffer (vm, bi);
1313       data = tcp_init_buffer (vm, *b);
1314       n_bytes = stream_session_peek_bytes (&tc->connection, data, offset,
1315                                            max_deq_bytes);
1316       ASSERT (n_bytes == max_deq_bytes);
1317       b[0]->current_length = n_bytes;
1318       tcp_push_hdr_i (tc, *b, tc->state, /* compute opts */ 0, /* burst */ 0);
1319       if (seq_gt (tc->snd_nxt, tc->snd_una_max))
1320         tc->snd_una_max = tc->snd_nxt;
1321     }
1322   /* Split mss into multiple buffers */
1323   else
1324     {
1325       u32 chain_bi = ~0, n_bufs_per_seg;
1326       u32 thread_index = vlib_get_thread_index ();
1327       u16 n_peeked, len_to_deq, available_bufs;
1328       vlib_buffer_t *chain_b, *prev_b;
1329       int i;
1330
1331       /* Make sure we have enough buffers */
1332       n_bufs_per_seg = ceil ((double) seg_size / tm->bytes_per_buffer);
1333       available_bufs = vec_len (tm->wrk_ctx[thread_index].tx_buffers);
1334       if (n_bufs_per_seg > available_bufs)
1335         {
1336           tcp_alloc_tx_buffers (tm, thread_index, &available_bufs,
1337                                 VLIB_FRAME_SIZE);
1338
1339           if (n_bufs_per_seg > available_bufs)
1340             {
1341               *b = 0;
1342               return 0;
1343             }
1344         }
1345
1346       tcp_get_free_buffer_index (tm, &bi);
1347       ASSERT (bi != (u32) ~ 0);
1348       *b = vlib_get_buffer (vm, bi);
1349       data = tcp_init_buffer (vm, *b);
1350       n_bytes = stream_session_peek_bytes (&tc->connection, data, offset,
1351                                            tm->bytes_per_buffer -
1352                                            MAX_HDRS_LEN);
1353       b[0]->current_length = n_bytes;
1354       b[0]->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
1355       b[0]->total_length_not_including_first_buffer = 0;
1356       max_deq_bytes -= n_bytes;
1357
1358       chain_b = *b;
1359       for (i = 1; i < n_bufs_per_seg; i++)
1360         {
1361           prev_b = chain_b;
1362           len_to_deq = clib_min (max_deq_bytes, tm->bytes_per_buffer);
1363           tcp_get_free_buffer_index (tm, &chain_bi);
1364           ASSERT (chain_bi != (u32) ~ 0);
1365           chain_b = vlib_get_buffer (vm, chain_bi);
1366           chain_b->current_data = 0;
1367           data = vlib_buffer_get_current (chain_b);
1368           n_peeked = stream_session_peek_bytes (&tc->connection, data,
1369                                                 offset + n_bytes, len_to_deq);
1370           ASSERT (n_peeked == len_to_deq);
1371           n_bytes += n_peeked;
1372           chain_b->current_length = n_peeked;
1373           chain_b->next_buffer = 0;
1374
1375           /* update previous buffer */
1376           prev_b->next_buffer = chain_bi;
1377           prev_b->flags |= VLIB_BUFFER_NEXT_PRESENT;
1378
1379           max_deq_bytes -= n_peeked;
1380           b[0]->total_length_not_including_first_buffer += n_peeked;
1381         }
1382
1383       tcp_push_hdr_i (tc, *b, tc->state, /* compute opts */ 0, /* burst */ 0);
1384       if (seq_gt (tc->snd_nxt, tc->snd_una_max))
1385         tc->snd_una_max = tc->snd_nxt;
1386     }
1387
1388   ASSERT (n_bytes > 0);
1389   ASSERT (((*b)->current_data + (*b)->current_length) <=
1390           tm->bytes_per_buffer);
1391
1392   if (tcp_in_fastrecovery (tc))
1393     tc->snd_rxt_bytes += n_bytes;
1394
1395 done:
1396   TCP_EVT_DBG (TCP_EVT_CC_RTX, tc, offset, n_bytes);
1397   return n_bytes;
1398 }
1399
1400 /**
1401  * Reset congestion control, switch cwnd to loss window and try again.
1402  */
1403 static void
1404 tcp_rxt_timeout_cc (tcp_connection_t * tc)
1405 {
1406   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 6);
1407   tc->prev_ssthresh = tc->ssthresh;
1408   tc->prev_cwnd = tc->cwnd;
1409
1410   /* Cleanly recover cc (also clears up fast retransmit) */
1411   if (tcp_in_fastrecovery (tc))
1412     tcp_cc_fastrecovery_exit (tc);
1413
1414   /* Start again from the beginning */
1415   tc->cc_algo->congestion (tc);
1416   tc->cwnd = tcp_loss_wnd (tc);
1417   tc->snd_congestion = tc->snd_una_max;
1418   tc->rtt_ts = 0;
1419   tc->cwnd_acc_bytes = 0;
1420
1421   tcp_recovery_on (tc);
1422 }
1423
1424 static inline void
1425 tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
1426 {
1427   tcp_main_t *tm = vnet_get_tcp_main ();
1428   vlib_main_t *vm = vlib_get_main ();
1429   u32 thread_index = vlib_get_thread_index ();
1430   tcp_connection_t *tc;
1431   vlib_buffer_t *b = 0;
1432   u32 bi, n_bytes;
1433
1434   if (is_syn)
1435     {
1436       tc = tcp_half_open_connection_get (index);
1437       /* Note: the connection may have transitioned to ESTABLISHED... */
1438       if (PREDICT_FALSE (tc == 0))
1439         return;
1440       tc->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID;
1441     }
1442   else
1443     {
1444       tc = tcp_connection_get (index, thread_index);
1445       /* Note: the connection may have been closed and pool_put */
1446       if (PREDICT_FALSE (tc == 0))
1447         return;
1448       tc->timers[TCP_TIMER_RETRANSMIT] = TCP_TIMER_HANDLE_INVALID;
1449     }
1450
1451   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 1);
1452
1453   if (tc->state >= TCP_STATE_ESTABLISHED)
1454     {
1455       /* Lost FIN, retransmit and return */
1456       if (tcp_is_lost_fin (tc))
1457         {
1458           tcp_send_fin (tc);
1459           tc->rto_boff += 1;
1460           tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1461           return;
1462         }
1463
1464       /* Shouldn't be here. This condition is tricky because it has to take
1465        * into account boff > 0 due to persist timeout. */
1466       if ((tc->rto_boff == 0 && tc->snd_una == tc->snd_una_max)
1467           || (tc->rto_boff > 0 && seq_geq (tc->snd_una, tc->snd_congestion)
1468               && !tcp_flight_size (tc)))
1469         {
1470           ASSERT (!tcp_in_recovery (tc));
1471           tc->rto_boff = 0;
1472           return;
1473         }
1474
1475       /* We're not in recovery so make sure rto_boff is 0. Can be non 0 due
1476        * to persist timer timeout */
1477       if (!tcp_in_recovery (tc) && tc->rto_boff > 0)
1478         {
1479           tc->rto_boff = 0;
1480           tcp_update_rto (tc);
1481         }
1482
1483       /* Increment RTO backoff (also equal to number of retries) and go back
1484        * to first un-acked byte  */
1485       tc->rto_boff += 1;
1486
1487       /* First retransmit timeout */
1488       if (tc->rto_boff == 1)
1489         tcp_rxt_timeout_cc (tc);
1490
1491       /* If we've sent beyond snd_congestion, update it */
1492       if (seq_gt (tc->snd_una_max, tc->snd_congestion))
1493         tc->snd_congestion = tc->snd_una_max;
1494
1495       tc->snd_una_max = tc->snd_nxt = tc->snd_una;
1496       tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1497
1498       /* Send one segment. Note that n_bytes may be zero due to buffer
1499        * shortfall */
1500       n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
1501
1502       /* TODO be less aggressive about this */
1503       scoreboard_clear (&tc->sack_sb);
1504
1505       if (n_bytes == 0)
1506         {
1507           tcp_retransmit_timer_force_update (tc);
1508           return;
1509         }
1510
1511       bi = vlib_get_buffer_index (vm, b);
1512
1513       /* For first retransmit, record timestamp (Eifel detection RFC3522) */
1514       if (tc->rto_boff == 1)
1515         tc->snd_rxt_ts = tcp_time_now ();
1516
1517       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1518       tcp_retransmit_timer_force_update (tc);
1519     }
1520   /* Retransmit for SYN */
1521   else if (tc->state == TCP_STATE_SYN_SENT)
1522     {
1523       /* Half-open connection actually moved to established but we were
1524        * waiting for syn retransmit to pop to call cleanup from the right
1525        * thread. */
1526       if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
1527         {
1528           if (tcp_half_open_connection_cleanup (tc))
1529             {
1530               clib_warning ("could not remove half-open connection");
1531               ASSERT (0);
1532             }
1533           return;
1534         }
1535
1536       /* Try without increasing RTO a number of times. If this fails,
1537        * start growing RTO exponentially */
1538       tc->rto_boff += 1;
1539       if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
1540         tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1541
1542       tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
1543                         tc->rto * TCP_TO_TIMER_TICK);
1544
1545       if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1546         return;
1547
1548       b = vlib_get_buffer (vm, bi);
1549       tcp_init_buffer (vm, b);
1550       tcp_make_syn (tc, b);
1551
1552       tc->rtt_ts = 0;
1553       TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 0);
1554
1555       /* This goes straight to ipx_lookup. Retransmit timer set already */
1556       tcp_push_ip_hdr (tm, tc, b);
1557       tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
1558     }
1559   /* Retransmit SYN-ACK */
1560   else if (tc->state == TCP_STATE_SYN_RCVD)
1561     {
1562       tc->rto_boff += 1;
1563       if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
1564         tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1565       tc->rtt_ts = 0;
1566
1567       if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1568         {
1569           tcp_retransmit_timer_force_update (tc);
1570           return;
1571         }
1572
1573       b = vlib_get_buffer (vm, bi);
1574       tcp_init_buffer (vm, b);
1575       tcp_make_synack (tc, b);
1576       TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 1);
1577
1578       /* Retransmit timer already updated, just enqueue to output */
1579       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1580     }
1581   else
1582     {
1583       ASSERT (tc->state == TCP_STATE_CLOSED);
1584       return;
1585     }
1586 }
1587
1588 void
1589 tcp_timer_retransmit_handler (u32 index)
1590 {
1591   tcp_timer_retransmit_handler_i (index, 0);
1592 }
1593
1594 void
1595 tcp_timer_retransmit_syn_handler (u32 index)
1596 {
1597   tcp_timer_retransmit_handler_i (index, 1);
1598 }
1599
1600 /**
1601  * Got 0 snd_wnd from peer, try to do something about it.
1602  *
1603  */
1604 void
1605 tcp_timer_persist_handler (u32 index)
1606 {
1607   tcp_main_t *tm = vnet_get_tcp_main ();
1608   vlib_main_t *vm = vlib_get_main ();
1609   u32 thread_index = vlib_get_thread_index ();
1610   tcp_connection_t *tc;
1611   vlib_buffer_t *b;
1612   u32 bi, max_snd_bytes, available_bytes, offset;
1613   int n_bytes = 0;
1614   u8 *data;
1615
1616   tc = tcp_connection_get_if_valid (index, thread_index);
1617
1618   if (!tc)
1619     return;
1620
1621   /* Make sure timer handle is set to invalid */
1622   tc->timers[TCP_TIMER_PERSIST] = TCP_TIMER_HANDLE_INVALID;
1623
1624   /* Problem already solved or worse */
1625   if (tc->state == TCP_STATE_CLOSED || tc->state > TCP_STATE_ESTABLISHED
1626       || tc->snd_wnd > tc->snd_mss || tcp_in_recovery (tc))
1627     return;
1628
1629   available_bytes = session_tx_fifo_max_dequeue (&tc->connection);
1630   offset = tc->snd_una_max - tc->snd_una;
1631
1632   /* Reprogram persist if no new bytes available to send. We may have data
1633    * next time */
1634   if (!available_bytes)
1635     {
1636       tcp_persist_timer_set (tc);
1637       return;
1638     }
1639
1640   if (available_bytes <= offset)
1641     {
1642       ASSERT (tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT));
1643       return;
1644     }
1645
1646   /* Increment RTO backoff */
1647   tc->rto_boff += 1;
1648   tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1649
1650   /*
1651    * Try to force the first unsent segment (or buffer)
1652    */
1653   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1654     {
1655       tcp_persist_timer_set (tc);
1656       return;
1657     }
1658   b = vlib_get_buffer (vm, bi);
1659   data = tcp_init_buffer (vm, b);
1660
1661   tcp_validate_txf_size (tc, offset);
1662   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
1663   max_snd_bytes = clib_min (tc->snd_mss, tm->bytes_per_buffer - MAX_HDRS_LEN);
1664   n_bytes = stream_session_peek_bytes (&tc->connection, data, offset,
1665                                        max_snd_bytes);
1666   b->current_length = n_bytes;
1667   ASSERT (n_bytes != 0 && (tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)
1668                            || tc->snd_nxt == tc->snd_una_max
1669                            || tc->rto_boff > 1));
1670
1671   tcp_push_hdr_i (tc, b, tc->state, /* compute opts */ 0, /* burst */ 0);
1672   tc->snd_una_max = tc->snd_nxt;
1673   tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
1674   tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1675
1676   /* Just sent new data, enable retransmit */
1677   tcp_retransmit_timer_update (tc);
1678 }
1679
1680 /**
1681  * Retransmit first unacked segment
1682  */
1683 void
1684 tcp_retransmit_first_unacked (tcp_connection_t * tc)
1685 {
1686   vlib_main_t *vm = vlib_get_main ();
1687   vlib_buffer_t *b;
1688   u32 bi, old_snd_nxt, n_bytes;
1689
1690   old_snd_nxt = tc->snd_nxt;
1691   tc->snd_nxt = tc->snd_una;
1692
1693   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
1694   n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
1695   if (!n_bytes)
1696     return;
1697   bi = vlib_get_buffer_index (vm, b);
1698   tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1699
1700   tc->snd_nxt = old_snd_nxt;
1701 }
1702
1703 /**
1704  * Do fast retransmit with SACKs
1705  */
1706 void
1707 tcp_fast_retransmit_sack (tcp_connection_t * tc)
1708 {
1709   vlib_main_t *vm = vlib_get_main ();
1710   u32 n_written = 0, offset, max_bytes, n_segs = 0;
1711   vlib_buffer_t *b = 0;
1712   sack_scoreboard_hole_t *hole;
1713   sack_scoreboard_t *sb;
1714   u32 bi, old_snd_nxt;
1715   int snd_space;
1716   u8 snd_limited = 0, can_rescue = 0;
1717
1718   ASSERT (tcp_in_fastrecovery (tc));
1719
1720   old_snd_nxt = tc->snd_nxt;
1721   sb = &tc->sack_sb;
1722   snd_space = tcp_available_cc_snd_space (tc);
1723
1724   if (snd_space < tc->snd_mss)
1725     goto done;
1726
1727   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 0);
1728   hole = scoreboard_get_hole (sb, sb->cur_rxt_hole);
1729   while (hole && snd_space > 0 && n_segs++ < VLIB_FRAME_SIZE)
1730     {
1731       hole = scoreboard_next_rxt_hole (sb, hole,
1732                                        tcp_fastrecovery_sent_1_smss (tc),
1733                                        &can_rescue, &snd_limited);
1734       if (!hole)
1735         {
1736           if (!can_rescue || !(seq_lt (sb->rescue_rxt, tc->snd_una)
1737                                || seq_gt (sb->rescue_rxt,
1738                                           tc->snd_congestion)))
1739             break;
1740
1741           /* If rescue rxt undefined or less than snd_una then one segment of
1742            * up to SMSS octets that MUST include the highest outstanding
1743            * unSACKed sequence number SHOULD be returned, and RescueRxt set to
1744            * RecoveryPoint. HighRxt MUST NOT be updated.
1745            */
1746           max_bytes = clib_min (tc->snd_mss,
1747                                 tc->snd_congestion - tc->snd_una);
1748           max_bytes = clib_min (max_bytes, snd_space);
1749           offset = tc->snd_congestion - tc->snd_una - max_bytes;
1750           sb->rescue_rxt = tc->snd_congestion;
1751           tc->snd_nxt = tc->snd_una + offset;
1752           n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes,
1753                                                       &b);
1754           if (!n_written)
1755             goto done;
1756
1757           bi = vlib_get_buffer_index (vm, b);
1758           tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1759           break;
1760         }
1761
1762       max_bytes = clib_min (hole->end - sb->high_rxt, snd_space);
1763       max_bytes = snd_limited ? clib_min (max_bytes, tc->snd_mss) : max_bytes;
1764       if (max_bytes == 0)
1765         break;
1766       offset = sb->high_rxt - tc->snd_una;
1767       tc->snd_nxt = sb->high_rxt;
1768       n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes, &b);
1769
1770       /* Nothing left to retransmit */
1771       if (n_written == 0)
1772         break;
1773
1774       bi = vlib_get_buffer_index (vm, b);
1775       sb->high_rxt += n_written;
1776       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1777       ASSERT (n_written <= snd_space);
1778       snd_space -= n_written;
1779     }
1780
1781 done:
1782   /* If window allows, send 1 SMSS of new data */
1783   tc->snd_nxt = old_snd_nxt;
1784 }
1785
1786 /**
1787  * Fast retransmit without SACK info
1788  */
1789 void
1790 tcp_fast_retransmit_no_sack (tcp_connection_t * tc)
1791 {
1792   vlib_main_t *vm = vlib_get_main ();
1793   u32 n_written = 0, offset = 0, bi, old_snd_nxt;
1794   int snd_space;
1795   vlib_buffer_t *b;
1796
1797   ASSERT (tcp_in_fastrecovery (tc));
1798   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 0);
1799
1800   /* Start resending from first un-acked segment */
1801   old_snd_nxt = tc->snd_nxt;
1802   tc->snd_nxt = tc->snd_una;
1803   snd_space = tcp_available_cc_snd_space (tc);
1804
1805   while (snd_space > 0)
1806     {
1807       offset += n_written;
1808       n_written = tcp_prepare_retransmit_segment (tc, offset, snd_space, &b);
1809
1810       /* Nothing left to retransmit */
1811       if (n_written == 0)
1812         break;
1813
1814       bi = vlib_get_buffer_index (vm, b);
1815       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1816       snd_space -= n_written;
1817     }
1818
1819   /* Restore snd_nxt. If window allows, send 1 SMSS of new data */
1820   tc->snd_nxt = old_snd_nxt;
1821 }
1822
1823 /**
1824  * Do fast retransmit
1825  */
1826 void
1827 tcp_fast_retransmit (tcp_connection_t * tc)
1828 {
1829   if (tcp_opts_sack_permitted (&tc->rcv_opts))
1830     tcp_fast_retransmit_sack (tc);
1831   else
1832     tcp_fast_retransmit_no_sack (tc);
1833 }
1834
1835 static u32
1836 tcp_session_has_ooo_data (tcp_connection_t * tc)
1837 {
1838   stream_session_t *s = session_get (tc->c_s_index, tc->c_thread_index);
1839   return svm_fifo_has_ooo_data (s->server_rx_fifo);
1840 }
1841
1842 static void
1843 tcp_output_handle_link_local (tcp_connection_t * tc0, vlib_buffer_t * b0,
1844                               u16 * next0, u32 * error0)
1845 {
1846   ip_adjacency_t *adj;
1847   adj_index_t ai;
1848
1849   /* Not thread safe but as long as the connection exists the adj should
1850    * not be removed */
1851   ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &tc0->c_rmt_ip,
1852                      tc0->sw_if_index);
1853   if (ai == ADJ_INDEX_INVALID)
1854     {
1855       vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
1856       *next0 = TCP_OUTPUT_NEXT_DROP;
1857       *error0 = TCP_ERROR_LINK_LOCAL_RW;
1858       return;
1859     }
1860
1861   adj = adj_get (ai);
1862   if (PREDICT_TRUE (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE))
1863     *next0 = TCP_OUTPUT_NEXT_IP_REWRITE;
1864   else if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP)
1865     *next0 = TCP_OUTPUT_NEXT_IP_ARP;
1866   else
1867     {
1868       *next0 = TCP_OUTPUT_NEXT_DROP;
1869       *error0 = TCP_ERROR_LINK_LOCAL_RW;
1870     }
1871   vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ai;
1872 }
1873
1874 static void
1875 tcp46_output_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
1876                           u32 * to_next, u32 n_bufs)
1877 {
1878   u32 n_trace = vlib_get_trace_count (vm, node);
1879   tcp_connection_t *tc;
1880   tcp_tx_trace_t *t;
1881   vlib_buffer_t *b;
1882   tcp_header_t *th;
1883   int i;
1884
1885   for (i = 0; i < clib_min (n_trace, n_bufs); i++)
1886     {
1887       b = vlib_get_buffer (vm, to_next[i]);
1888       th = vlib_buffer_get_current (b);
1889       tc = tcp_connection_get (vnet_buffer (b)->tcp.connection_index,
1890                                vm->thread_index);
1891       t = vlib_add_trace (vm, node, b, sizeof (*t));
1892       clib_memcpy (&t->tcp_header, th, sizeof (t->tcp_header));
1893       clib_memcpy (&t->tcp_connection, tc, sizeof (t->tcp_connection));
1894     }
1895 }
1896
1897 always_inline void
1898 tcp_output_push_ip (vlib_main_t * vm, vlib_buffer_t * b0,
1899                     tcp_connection_t * tc0, u8 is_ip4)
1900 {
1901   tcp_header_t *th0 = 0;
1902
1903   th0 = vlib_buffer_get_current (b0);
1904   TCP_EVT_DBG (TCP_EVT_OUTPUT, tc0, th0->flags, b0->current_length);
1905   if (is_ip4)
1906     {
1907       vlib_buffer_push_ip4 (vm, b0, &tc0->c_lcl_ip4, &tc0->c_rmt_ip4,
1908                             IP_PROTOCOL_TCP, 1);
1909       b0->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
1910       vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1911       th0->checksum = 0;
1912     }
1913   else
1914     {
1915       ip6_header_t *ih0;
1916       ih0 = vlib_buffer_push_ip6 (vm, b0, &tc0->c_lcl_ip6,
1917                                   &tc0->c_rmt_ip6, IP_PROTOCOL_TCP);
1918       b0->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
1919       vnet_buffer (b0)->l3_hdr_offset = (u8 *) ih0 - b0->data;
1920       vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1921       th0->checksum = 0;
1922     }
1923 }
1924
1925 always_inline void
1926 tcp_output_handle_packet (tcp_connection_t * tc0, vlib_buffer_t * b0,
1927                           u32 * error0, u16 * next0, u8 is_ip4)
1928 {
1929
1930   if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
1931     {
1932       *error0 = TCP_ERROR_INVALID_CONNECTION;
1933       *next0 = TCP_OUTPUT_NEXT_DROP;
1934       return;
1935     }
1936
1937   vnet_buffer (b0)->sw_if_index[VLIB_TX] = tc0->c_fib_index;
1938   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
1939
1940   if (!is_ip4)
1941     {
1942       if (PREDICT_FALSE (ip6_address_is_link_local_unicast (&tc0->c_rmt_ip6)))
1943         tcp_output_handle_link_local (tc0, b0, next0, error0);
1944     }
1945
1946   /* Filter out DUPACKs if there are no OOO segments left */
1947   if (PREDICT_FALSE (vnet_buffer (b0)->tcp.flags & TCP_BUF_FLAG_DUPACK))
1948     {
1949       /* N.B. Should not filter burst of dupacks. Two issues:
1950        * 1) dupacks open cwnd on remote peer when congested
1951        * 2) acks leaving should have the latest rcv_wnd since the
1952        *    burst may have eaten up all of it, so only the old ones
1953        *     could be filtered.
1954        */
1955       if (!tcp_session_has_ooo_data (tc0))
1956         {
1957           *error0 = TCP_ERROR_FILTERED_DUPACKS;
1958           *next0 = TCP_OUTPUT_NEXT_DROP;
1959           return;
1960         }
1961     }
1962
1963   /* Stop DELACK timer and fix flags */
1964   tc0->flags &= ~(TCP_CONN_SNDACK);
1965   if (!TCP_ALWAYS_ACK)
1966     tcp_timer_reset (tc0, TCP_TIMER_DELACK);
1967 }
1968
1969 always_inline uword
1970 tcp46_output_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
1971                      vlib_frame_t * frame, int is_ip4)
1972 {
1973   u32 n_left_from, *from, thread_index = vm->thread_index;
1974   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
1975   u16 nexts[VLIB_FRAME_SIZE], *next;
1976
1977   from = vlib_frame_vector_args (frame);
1978   n_left_from = frame->n_vectors;
1979   tcp_set_time_now (thread_index);
1980
1981   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
1982     tcp46_output_trace_frame (vm, node, from, n_left_from);
1983
1984   vlib_get_buffers (vm, from, bufs, n_left_from);
1985   b = bufs;
1986   next = nexts;
1987
1988   while (n_left_from >= 4)
1989     {
1990       u32 error0 = TCP_ERROR_PKTS_SENT, error1 = TCP_ERROR_PKTS_SENT;
1991       tcp_connection_t *tc0, *tc1;
1992
1993       {
1994         vlib_prefetch_buffer_header (b[2], STORE);
1995         CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
1996
1997         vlib_prefetch_buffer_header (b[3], STORE);
1998         CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
1999       }
2000
2001       next[0] = next[1] = TCP_OUTPUT_NEXT_IP_LOOKUP;
2002
2003       tc0 = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
2004                                 thread_index);
2005       tc1 = tcp_connection_get (vnet_buffer (b[1])->tcp.connection_index,
2006                                 thread_index);
2007
2008       tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2009       tcp_output_push_ip (vm, b[1], tc1, is_ip4);
2010
2011       tcp_output_handle_packet (tc0, b[0], &error0, &next[0], is_ip4);
2012       tcp_output_handle_packet (tc1, b[1], &error1, &next[1], is_ip4);
2013
2014       b += 2;
2015       next += 2;
2016       n_left_from -= 2;
2017     }
2018   while (n_left_from > 0)
2019     {
2020       u32 error0 = TCP_ERROR_PKTS_SENT;
2021       tcp_connection_t *tc0;
2022
2023       if (n_left_from > 1)
2024         {
2025           vlib_prefetch_buffer_header (b[1], STORE);
2026           CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2027         }
2028
2029       next[0] = TCP_OUTPUT_NEXT_IP_LOOKUP;
2030       tc0 = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
2031                                 thread_index);
2032
2033       tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2034       tcp_output_handle_packet (tc0, b[0], &error0, &next[0], is_ip4);
2035
2036       b += 1;
2037       next += 1;
2038       n_left_from -= 1;
2039     }
2040
2041   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
2042   return frame->n_vectors;
2043 }
2044
2045 static uword
2046 tcp4_output (vlib_main_t * vm, vlib_node_runtime_t * node,
2047              vlib_frame_t * from_frame)
2048 {
2049   return tcp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2050 }
2051
2052 static uword
2053 tcp6_output (vlib_main_t * vm, vlib_node_runtime_t * node,
2054              vlib_frame_t * from_frame)
2055 {
2056   return tcp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2057 }
2058
2059 /* *INDENT-OFF* */
2060 VLIB_REGISTER_NODE (tcp4_output_node) =
2061 {
2062   .function = tcp4_output,.name = "tcp4-output",
2063     /* Takes a vector of packets. */
2064     .vector_size = sizeof (u32),
2065     .n_errors = TCP_N_ERROR,
2066     .error_strings = tcp_error_strings,
2067     .n_next_nodes = TCP_OUTPUT_N_NEXT,
2068     .next_nodes = {
2069 #define _(s,n) [TCP_OUTPUT_NEXT_##s] = n,
2070     foreach_tcp4_output_next
2071 #undef _
2072     },
2073     .format_buffer = format_tcp_header,
2074     .format_trace = format_tcp_tx_trace,
2075 };
2076 /* *INDENT-ON* */
2077
2078 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_output_node, tcp4_output);
2079
2080 /* *INDENT-OFF* */
2081 VLIB_REGISTER_NODE (tcp6_output_node) =
2082 {
2083   .function = tcp6_output,
2084   .name = "tcp6-output",
2085     /* Takes a vector of packets. */
2086   .vector_size = sizeof (u32),
2087   .n_errors = TCP_N_ERROR,
2088   .error_strings = tcp_error_strings,
2089   .n_next_nodes = TCP_OUTPUT_N_NEXT,
2090   .next_nodes = {
2091 #define _(s,n) [TCP_OUTPUT_NEXT_##s] = n,
2092     foreach_tcp6_output_next
2093 #undef _
2094   },
2095   .format_buffer = format_tcp_header,
2096   .format_trace = format_tcp_tx_trace,
2097 };
2098 /* *INDENT-ON* */
2099
2100 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_output_node, tcp6_output);
2101
2102 typedef enum _tcp_reset_next
2103 {
2104   TCP_RESET_NEXT_DROP,
2105   TCP_RESET_NEXT_IP_LOOKUP,
2106   TCP_RESET_N_NEXT
2107 } tcp_reset_next_t;
2108
2109 #define foreach_tcp4_reset_next         \
2110   _(DROP, "error-drop")                 \
2111   _(IP_LOOKUP, "ip4-lookup")
2112
2113 #define foreach_tcp6_reset_next         \
2114   _(DROP, "error-drop")                 \
2115   _(IP_LOOKUP, "ip6-lookup")
2116
2117 static uword
2118 tcp46_send_reset_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2119                          vlib_frame_t * from_frame, u8 is_ip4)
2120 {
2121   u32 n_left_from, next_index, *from, *to_next;
2122   u32 my_thread_index = vm->thread_index;
2123
2124   from = vlib_frame_vector_args (from_frame);
2125   n_left_from = from_frame->n_vectors;
2126
2127   next_index = node->cached_next_index;
2128
2129   while (n_left_from > 0)
2130     {
2131       u32 n_left_to_next;
2132
2133       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2134
2135       while (n_left_from > 0 && n_left_to_next > 0)
2136         {
2137           u32 bi0;
2138           vlib_buffer_t *b0;
2139           tcp_tx_trace_t *t0;
2140           tcp_header_t *th0;
2141           u32 error0 = TCP_ERROR_RST_SENT, next0 = TCP_RESET_NEXT_IP_LOOKUP;
2142
2143           bi0 = from[0];
2144           to_next[0] = bi0;
2145           from += 1;
2146           to_next += 1;
2147           n_left_from -= 1;
2148           n_left_to_next -= 1;
2149
2150           b0 = vlib_get_buffer (vm, bi0);
2151
2152           if (tcp_make_reset_in_place (vm, b0, vnet_buffer (b0)->tcp.flags,
2153                                        my_thread_index, is_ip4))
2154             {
2155               error0 = TCP_ERROR_LOOKUP_DROPS;
2156               next0 = TCP_RESET_NEXT_DROP;
2157               goto done;
2158             }
2159
2160           /* Prepare to send to IP lookup */
2161           vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
2162           next0 = TCP_RESET_NEXT_IP_LOOKUP;
2163
2164         done:
2165           b0->error = node->errors[error0];
2166           b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
2167           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2168             {
2169               th0 = vlib_buffer_get_current (b0);
2170               if (is_ip4)
2171                 th0 = ip4_next_header ((ip4_header_t *) th0);
2172               else
2173                 th0 = ip6_next_header ((ip6_header_t *) th0);
2174               t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2175               clib_memcpy (&t0->tcp_header, th0, sizeof (t0->tcp_header));
2176             }
2177
2178           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2179                                            n_left_to_next, bi0, next0);
2180         }
2181       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2182     }
2183   return from_frame->n_vectors;
2184 }
2185
2186 static uword
2187 tcp4_send_reset (vlib_main_t * vm, vlib_node_runtime_t * node,
2188                  vlib_frame_t * from_frame)
2189 {
2190   return tcp46_send_reset_inline (vm, node, from_frame, 1);
2191 }
2192
2193 static uword
2194 tcp6_send_reset (vlib_main_t * vm, vlib_node_runtime_t * node,
2195                  vlib_frame_t * from_frame)
2196 {
2197   return tcp46_send_reset_inline (vm, node, from_frame, 0);
2198 }
2199
2200 /* *INDENT-OFF* */
2201 VLIB_REGISTER_NODE (tcp4_reset_node) = {
2202   .function = tcp4_send_reset,
2203   .name = "tcp4-reset",
2204   .vector_size = sizeof (u32),
2205   .n_errors = TCP_N_ERROR,
2206   .error_strings = tcp_error_strings,
2207   .n_next_nodes = TCP_RESET_N_NEXT,
2208   .next_nodes = {
2209 #define _(s,n) [TCP_RESET_NEXT_##s] = n,
2210     foreach_tcp4_reset_next
2211 #undef _
2212   },
2213   .format_trace = format_tcp_tx_trace,
2214 };
2215 /* *INDENT-ON* */
2216
2217 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_reset_node, tcp4_send_reset);
2218
2219 /* *INDENT-OFF* */
2220 VLIB_REGISTER_NODE (tcp6_reset_node) = {
2221   .function = tcp6_send_reset,
2222   .name = "tcp6-reset",
2223   .vector_size = sizeof (u32),
2224   .n_errors = TCP_N_ERROR,
2225   .error_strings = tcp_error_strings,
2226   .n_next_nodes = TCP_RESET_N_NEXT,
2227   .next_nodes = {
2228 #define _(s,n) [TCP_RESET_NEXT_##s] = n,
2229     foreach_tcp6_reset_next
2230 #undef _
2231   },
2232   .format_trace = format_tcp_tx_trace,
2233 };
2234 /* *INDENT-ON* */
2235
2236 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_reset_node, tcp6_send_reset);
2237
2238 /*
2239  * fd.io coding-style-patch-verification: ON
2240  *
2241  * Local Variables:
2242  * eval: (c-set-style "gnu")
2243  * End:
2244  */