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_us (tc->c_thread_index);
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     {
1413       /* TODO be less aggressive about this */
1414       scoreboard_clear (&tc->sack_sb);
1415       tcp_cc_fastrecovery_exit (tc);
1416     }
1417
1418   /* Start again from the beginning */
1419   tc->cc_algo->congestion (tc);
1420   tc->cwnd = tcp_loss_wnd (tc);
1421   tc->snd_congestion = tc->snd_una_max;
1422   tc->rtt_ts = 0;
1423   tc->cwnd_acc_bytes = 0;
1424
1425   tcp_recovery_on (tc);
1426 }
1427
1428 static inline void
1429 tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
1430 {
1431   tcp_main_t *tm = vnet_get_tcp_main ();
1432   vlib_main_t *vm = vlib_get_main ();
1433   u32 thread_index = vlib_get_thread_index ();
1434   tcp_connection_t *tc;
1435   vlib_buffer_t *b = 0;
1436   u32 bi, n_bytes;
1437
1438   if (is_syn)
1439     {
1440       tc = tcp_half_open_connection_get (index);
1441       /* Note: the connection may have transitioned to ESTABLISHED... */
1442       if (PREDICT_FALSE (tc == 0))
1443         return;
1444       tc->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID;
1445     }
1446   else
1447     {
1448       tc = tcp_connection_get (index, thread_index);
1449       /* Note: the connection may have been closed and pool_put */
1450       if (PREDICT_FALSE (tc == 0))
1451         return;
1452       tc->timers[TCP_TIMER_RETRANSMIT] = TCP_TIMER_HANDLE_INVALID;
1453     }
1454
1455   if (tc->state >= TCP_STATE_ESTABLISHED)
1456     {
1457       TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
1458
1459       /* Lost FIN, retransmit and return */
1460       if (tcp_is_lost_fin (tc))
1461         {
1462           tcp_send_fin (tc);
1463           tc->rto_boff += 1;
1464           tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1465           return;
1466         }
1467
1468       /* Shouldn't be here. This condition is tricky because it has to take
1469        * into account boff > 0 due to persist timeout. */
1470       if ((tc->rto_boff == 0 && tc->snd_una == tc->snd_una_max)
1471           || (tc->rto_boff > 0 && seq_geq (tc->snd_una, tc->snd_congestion)
1472               && !tcp_flight_size (tc)))
1473         {
1474           ASSERT (!tcp_in_recovery (tc));
1475           tc->rto_boff = 0;
1476           return;
1477         }
1478
1479       /* We're not in recovery so make sure rto_boff is 0. Can be non 0 due
1480        * to persist timer timeout */
1481       if (!tcp_in_recovery (tc) && tc->rto_boff > 0)
1482         {
1483           tc->rto_boff = 0;
1484           tcp_update_rto (tc);
1485         }
1486
1487       /* Increment RTO backoff (also equal to number of retries) and go back
1488        * to first un-acked byte  */
1489       tc->rto_boff += 1;
1490
1491       /* First retransmit timeout */
1492       if (tc->rto_boff == 1)
1493         tcp_rxt_timeout_cc (tc);
1494       else
1495         scoreboard_clear (&tc->sack_sb);
1496
1497       /* If we've sent beyond snd_congestion, update it */
1498       if (seq_gt (tc->snd_una_max, tc->snd_congestion))
1499         tc->snd_congestion = tc->snd_una_max;
1500
1501       tc->snd_una_max = tc->snd_nxt = tc->snd_una;
1502       tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1503
1504       /* Send one segment. Note that n_bytes may be zero due to buffer
1505        * shortfall */
1506       n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
1507
1508       if (n_bytes == 0)
1509         {
1510           tcp_retransmit_timer_force_update (tc);
1511           return;
1512         }
1513
1514       bi = vlib_get_buffer_index (vm, b);
1515
1516       /* For first retransmit, record timestamp (Eifel detection RFC3522) */
1517       if (tc->rto_boff == 1)
1518         tc->snd_rxt_ts = tcp_time_now ();
1519
1520       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1521       tcp_retransmit_timer_force_update (tc);
1522     }
1523   /* Retransmit for SYN */
1524   else if (tc->state == TCP_STATE_SYN_SENT)
1525     {
1526       /* Half-open connection actually moved to established but we were
1527        * waiting for syn retransmit to pop to call cleanup from the right
1528        * thread. */
1529       if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
1530         {
1531           if (tcp_half_open_connection_cleanup (tc))
1532             {
1533               clib_warning ("could not remove half-open connection");
1534               ASSERT (0);
1535             }
1536           return;
1537         }
1538
1539       TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
1540
1541       /* Try without increasing RTO a number of times. If this fails,
1542        * start growing RTO exponentially */
1543       tc->rto_boff += 1;
1544       if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
1545         tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1546
1547       tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
1548                         tc->rto * TCP_TO_TIMER_TICK);
1549
1550       if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1551         return;
1552
1553       b = vlib_get_buffer (vm, bi);
1554       tcp_init_buffer (vm, b);
1555       tcp_make_syn (tc, b);
1556
1557       tc->rtt_ts = 0;
1558       TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 0);
1559
1560       /* This goes straight to ipx_lookup. Retransmit timer set already */
1561       tcp_push_ip_hdr (tm, tc, b);
1562       tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
1563     }
1564   /* Retransmit SYN-ACK */
1565   else if (tc->state == TCP_STATE_SYN_RCVD)
1566     {
1567       TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
1568
1569       tc->rto_boff += 1;
1570       if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
1571         tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1572       tc->rtt_ts = 0;
1573
1574       if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1575         {
1576           tcp_retransmit_timer_force_update (tc);
1577           return;
1578         }
1579
1580       b = vlib_get_buffer (vm, bi);
1581       tcp_init_buffer (vm, b);
1582       tcp_make_synack (tc, b);
1583       TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 1);
1584
1585       /* Retransmit timer already updated, just enqueue to output */
1586       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1587     }
1588   else
1589     {
1590       ASSERT (tc->state == TCP_STATE_CLOSED);
1591       return;
1592     }
1593 }
1594
1595 void
1596 tcp_timer_retransmit_handler (u32 index)
1597 {
1598   tcp_timer_retransmit_handler_i (index, 0);
1599 }
1600
1601 void
1602 tcp_timer_retransmit_syn_handler (u32 index)
1603 {
1604   tcp_timer_retransmit_handler_i (index, 1);
1605 }
1606
1607 /**
1608  * Got 0 snd_wnd from peer, try to do something about it.
1609  *
1610  */
1611 void
1612 tcp_timer_persist_handler (u32 index)
1613 {
1614   tcp_main_t *tm = vnet_get_tcp_main ();
1615   vlib_main_t *vm = vlib_get_main ();
1616   u32 thread_index = vlib_get_thread_index ();
1617   tcp_connection_t *tc;
1618   vlib_buffer_t *b;
1619   u32 bi, max_snd_bytes, available_bytes, offset;
1620   int n_bytes = 0;
1621   u8 *data;
1622
1623   tc = tcp_connection_get_if_valid (index, thread_index);
1624
1625   if (!tc)
1626     return;
1627
1628   /* Make sure timer handle is set to invalid */
1629   tc->timers[TCP_TIMER_PERSIST] = TCP_TIMER_HANDLE_INVALID;
1630
1631   /* Problem already solved or worse */
1632   if (tc->state == TCP_STATE_CLOSED || tc->state > TCP_STATE_ESTABLISHED
1633       || tc->snd_wnd > tc->snd_mss || tcp_in_recovery (tc))
1634     return;
1635
1636   available_bytes = session_tx_fifo_max_dequeue (&tc->connection);
1637   offset = tc->snd_una_max - tc->snd_una;
1638
1639   /* Reprogram persist if no new bytes available to send. We may have data
1640    * next time */
1641   if (!available_bytes)
1642     {
1643       tcp_persist_timer_set (tc);
1644       return;
1645     }
1646
1647   if (available_bytes <= offset)
1648     {
1649       ASSERT (tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT));
1650       return;
1651     }
1652
1653   /* Increment RTO backoff */
1654   tc->rto_boff += 1;
1655   tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
1656
1657   /*
1658    * Try to force the first unsent segment (or buffer)
1659    */
1660   if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
1661     {
1662       tcp_persist_timer_set (tc);
1663       return;
1664     }
1665   b = vlib_get_buffer (vm, bi);
1666   data = tcp_init_buffer (vm, b);
1667
1668   tcp_validate_txf_size (tc, offset);
1669   tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
1670   max_snd_bytes = clib_min (tc->snd_mss, tm->bytes_per_buffer - MAX_HDRS_LEN);
1671   n_bytes = stream_session_peek_bytes (&tc->connection, data, offset,
1672                                        max_snd_bytes);
1673   b->current_length = n_bytes;
1674   ASSERT (n_bytes != 0 && (tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)
1675                            || tc->snd_nxt == tc->snd_una_max
1676                            || tc->rto_boff > 1));
1677
1678   tcp_push_hdr_i (tc, b, tc->state, /* compute opts */ 0, /* burst */ 0);
1679   tc->snd_una_max = tc->snd_nxt;
1680   tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
1681   tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1682
1683   /* Just sent new data, enable retransmit */
1684   tcp_retransmit_timer_update (tc);
1685 }
1686
1687 /**
1688  * Retransmit first unacked segment
1689  */
1690 int
1691 tcp_retransmit_first_unacked (tcp_connection_t * tc)
1692 {
1693   vlib_main_t *vm = vlib_get_main ();
1694   vlib_buffer_t *b;
1695   u32 bi, old_snd_nxt, n_bytes;
1696
1697   old_snd_nxt = tc->snd_nxt;
1698   tc->snd_nxt = tc->snd_una;
1699
1700   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 1);
1701
1702   n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
1703   if (!n_bytes)
1704     return -1;
1705
1706   bi = vlib_get_buffer_index (vm, b);
1707   tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1708   tc->snd_nxt = old_snd_nxt;
1709
1710   return 0;
1711 }
1712
1713 /**
1714  * Do fast retransmit with SACKs
1715  */
1716 int
1717 tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
1718 {
1719   vlib_main_t *vm = vlib_get_main ();
1720   u32 n_written = 0, offset, max_bytes, n_segs = 0;
1721   vlib_buffer_t *b = 0;
1722   sack_scoreboard_hole_t *hole;
1723   sack_scoreboard_t *sb;
1724   u32 bi, old_snd_nxt;
1725   int snd_space;
1726   u8 snd_limited = 0, can_rescue = 0;
1727
1728   ASSERT (tcp_in_fastrecovery (tc));
1729
1730   old_snd_nxt = tc->snd_nxt;
1731   sb = &tc->sack_sb;
1732   snd_space = tcp_available_cc_snd_space (tc);
1733   hole = scoreboard_get_hole (sb, sb->cur_rxt_hole);
1734
1735   if (snd_space < tc->snd_mss)
1736     {
1737       tcp_program_fastretransmit (tc);
1738       goto done;
1739     }
1740
1741   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 0);
1742   while (snd_space > 0 && n_segs < burst_size)
1743     {
1744       hole = scoreboard_next_rxt_hole (sb, hole,
1745                                        tcp_fastrecovery_sent_1_smss (tc),
1746                                        &can_rescue, &snd_limited);
1747       if (!hole)
1748         {
1749           if (!can_rescue || !(seq_lt (sb->rescue_rxt, tc->snd_una)
1750                                || seq_gt (sb->rescue_rxt,
1751                                           tc->snd_congestion)))
1752             {
1753               if (tcp_fastrecovery_first (tc))
1754                 break;
1755
1756               /* We tend to lose the first segment. Try re-resending
1757                * it but only once and after we've tried everything */
1758               hole = scoreboard_first_hole (sb);
1759               if (hole && hole->start == tc->snd_una)
1760                 {
1761                   tcp_retransmit_first_unacked (tc);
1762                   tcp_fastrecovery_first_on (tc);
1763                   n_segs += 1;
1764                 }
1765               break;
1766             }
1767
1768           /* If rescue rxt undefined or less than snd_una then one segment of
1769            * up to SMSS octets that MUST include the highest outstanding
1770            * unSACKed sequence number SHOULD be returned, and RescueRxt set to
1771            * RecoveryPoint. HighRxt MUST NOT be updated.
1772            */
1773           max_bytes = clib_min (tc->snd_mss,
1774                                 tc->snd_congestion - tc->snd_una);
1775           max_bytes = clib_min (max_bytes, snd_space);
1776           offset = tc->snd_congestion - tc->snd_una - max_bytes;
1777           sb->rescue_rxt = tc->snd_congestion;
1778           tc->snd_nxt = tc->snd_una + offset;
1779           n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes,
1780                                                       &b);
1781           if (!n_written)
1782             goto done;
1783
1784           bi = vlib_get_buffer_index (vm, b);
1785           tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1786           n_segs += 1;
1787           break;
1788         }
1789
1790       max_bytes = clib_min (hole->end - sb->high_rxt, snd_space);
1791       max_bytes = snd_limited ? clib_min (max_bytes, tc->snd_mss) : max_bytes;
1792       if (max_bytes == 0)
1793         break;
1794       offset = sb->high_rxt - tc->snd_una;
1795       tc->snd_nxt = sb->high_rxt;
1796       n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes, &b);
1797
1798       /* Nothing left to retransmit */
1799       if (n_written == 0)
1800         break;
1801
1802       bi = vlib_get_buffer_index (vm, b);
1803       sb->high_rxt += n_written;
1804       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1805       ASSERT (n_written <= snd_space);
1806       snd_space -= n_written;
1807       n_segs += 1;
1808     }
1809
1810   if (hole)
1811     tcp_program_fastretransmit (tc);
1812
1813 done:
1814   /* If window allows, send 1 SMSS of new data */
1815   tc->snd_nxt = old_snd_nxt;
1816   return n_segs;
1817 }
1818
1819 /**
1820  * Fast retransmit without SACK info
1821  */
1822 int
1823 tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
1824 {
1825   vlib_main_t *vm = vlib_get_main ();
1826   u32 n_written = 0, offset = 0, bi, old_snd_nxt;
1827   int snd_space, n_segs = 0;
1828   vlib_buffer_t *b;
1829
1830   ASSERT (tcp_in_fastrecovery (tc));
1831   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 0);
1832
1833   /* Start resending from first un-acked segment */
1834   old_snd_nxt = tc->snd_nxt;
1835   tc->snd_nxt = tc->snd_una;
1836   snd_space = tcp_available_cc_snd_space (tc);
1837
1838   while (snd_space > 0 && n_segs < burst_size)
1839     {
1840       offset += n_written;
1841       n_written = tcp_prepare_retransmit_segment (tc, offset, snd_space, &b);
1842
1843       /* Nothing left to retransmit */
1844       if (n_written == 0)
1845         break;
1846
1847       bi = vlib_get_buffer_index (vm, b);
1848       tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
1849       snd_space -= n_written;
1850       n_segs += 1;
1851     }
1852
1853   /* More data to resend */
1854   if (seq_lt (tc->snd_nxt, tc->snd_congestion))
1855     tcp_program_fastretransmit (tc);
1856
1857   /* Restore snd_nxt. If window allows, send 1 SMSS of new data */
1858   tc->snd_nxt = old_snd_nxt;
1859
1860   return n_segs;
1861 }
1862
1863 /**
1864  * Do fast retransmit
1865  */
1866 int
1867 tcp_fast_retransmit (tcp_connection_t * tc, u32 burst_size)
1868 {
1869   if (tcp_opts_sack_permitted (&tc->rcv_opts))
1870     return tcp_fast_retransmit_sack (tc, burst_size);
1871   else
1872     return tcp_fast_retransmit_no_sack (tc, burst_size);
1873 }
1874
1875 static u32
1876 tcp_session_has_ooo_data (tcp_connection_t * tc)
1877 {
1878   stream_session_t *s = session_get (tc->c_s_index, tc->c_thread_index);
1879   return svm_fifo_has_ooo_data (s->server_rx_fifo);
1880 }
1881
1882 static void
1883 tcp_output_handle_link_local (tcp_connection_t * tc0, vlib_buffer_t * b0,
1884                               u16 * next0, u32 * error0)
1885 {
1886   ip_adjacency_t *adj;
1887   adj_index_t ai;
1888
1889   /* Not thread safe but as long as the connection exists the adj should
1890    * not be removed */
1891   ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &tc0->c_rmt_ip,
1892                      tc0->sw_if_index);
1893   if (ai == ADJ_INDEX_INVALID)
1894     {
1895       vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
1896       *next0 = TCP_OUTPUT_NEXT_DROP;
1897       *error0 = TCP_ERROR_LINK_LOCAL_RW;
1898       return;
1899     }
1900
1901   adj = adj_get (ai);
1902   if (PREDICT_TRUE (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE))
1903     *next0 = TCP_OUTPUT_NEXT_IP_REWRITE;
1904   else if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP)
1905     *next0 = TCP_OUTPUT_NEXT_IP_ARP;
1906   else
1907     {
1908       *next0 = TCP_OUTPUT_NEXT_DROP;
1909       *error0 = TCP_ERROR_LINK_LOCAL_RW;
1910     }
1911   vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ai;
1912 }
1913
1914 static void
1915 tcp46_output_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
1916                           u32 * to_next, u32 n_bufs)
1917 {
1918   u32 n_trace = vlib_get_trace_count (vm, node);
1919   tcp_connection_t *tc;
1920   tcp_tx_trace_t *t;
1921   vlib_buffer_t *b;
1922   tcp_header_t *th;
1923   int i;
1924
1925   for (i = 0; i < clib_min (n_trace, n_bufs); i++)
1926     {
1927       b = vlib_get_buffer (vm, to_next[i]);
1928       th = vlib_buffer_get_current (b);
1929       tc = tcp_connection_get (vnet_buffer (b)->tcp.connection_index,
1930                                vm->thread_index);
1931       t = vlib_add_trace (vm, node, b, sizeof (*t));
1932       clib_memcpy (&t->tcp_header, th, sizeof (t->tcp_header));
1933       clib_memcpy (&t->tcp_connection, tc, sizeof (t->tcp_connection));
1934     }
1935 }
1936
1937 always_inline void
1938 tcp_output_push_ip (vlib_main_t * vm, vlib_buffer_t * b0,
1939                     tcp_connection_t * tc0, u8 is_ip4)
1940 {
1941   tcp_header_t *th0 = 0;
1942
1943   th0 = vlib_buffer_get_current (b0);
1944   TCP_EVT_DBG (TCP_EVT_OUTPUT, tc0, th0->flags, b0->current_length);
1945   if (is_ip4)
1946     {
1947       vlib_buffer_push_ip4 (vm, b0, &tc0->c_lcl_ip4, &tc0->c_rmt_ip4,
1948                             IP_PROTOCOL_TCP, 1);
1949       b0->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
1950       vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1951       th0->checksum = 0;
1952     }
1953   else
1954     {
1955       ip6_header_t *ih0;
1956       ih0 = vlib_buffer_push_ip6 (vm, b0, &tc0->c_lcl_ip6,
1957                                   &tc0->c_rmt_ip6, IP_PROTOCOL_TCP);
1958       b0->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
1959       vnet_buffer (b0)->l3_hdr_offset = (u8 *) ih0 - b0->data;
1960       vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1961       th0->checksum = 0;
1962     }
1963 }
1964
1965 always_inline void
1966 tcp_output_handle_packet (tcp_connection_t * tc0, vlib_buffer_t * b0,
1967                           u32 * error0, u16 * next0, u8 is_ip4)
1968 {
1969
1970   if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
1971     {
1972       *error0 = TCP_ERROR_INVALID_CONNECTION;
1973       *next0 = TCP_OUTPUT_NEXT_DROP;
1974       return;
1975     }
1976
1977   vnet_buffer (b0)->sw_if_index[VLIB_TX] = tc0->c_fib_index;
1978   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
1979
1980   if (!is_ip4)
1981     {
1982       if (PREDICT_FALSE (ip6_address_is_link_local_unicast (&tc0->c_rmt_ip6)))
1983         tcp_output_handle_link_local (tc0, b0, next0, error0);
1984     }
1985
1986   /* Filter out DUPACKs if there are no OOO segments left */
1987   if (PREDICT_FALSE (vnet_buffer (b0)->tcp.flags & TCP_BUF_FLAG_DUPACK))
1988     {
1989       /* N.B. Should not filter burst of dupacks. Two issues:
1990        * 1) dupacks open cwnd on remote peer when congested
1991        * 2) acks leaving should have the latest rcv_wnd since the
1992        *    burst may have eaten up all of it, so only the old ones
1993        *     could be filtered.
1994        */
1995       if (!tcp_session_has_ooo_data (tc0))
1996         {
1997           *error0 = TCP_ERROR_FILTERED_DUPACKS;
1998           *next0 = TCP_OUTPUT_NEXT_DROP;
1999           return;
2000         }
2001     }
2002
2003   /* Stop DELACK timer and fix flags */
2004   tc0->flags &= ~(TCP_CONN_SNDACK);
2005   if (!TCP_ALWAYS_ACK)
2006     tcp_timer_reset (tc0, TCP_TIMER_DELACK);
2007 }
2008
2009 always_inline uword
2010 tcp46_output_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2011                      vlib_frame_t * frame, int is_ip4)
2012 {
2013   u32 n_left_from, *from, thread_index = vm->thread_index;
2014   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
2015   u16 nexts[VLIB_FRAME_SIZE], *next;
2016
2017   from = vlib_frame_vector_args (frame);
2018   n_left_from = frame->n_vectors;
2019   tcp_set_time_now (thread_index);
2020
2021   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
2022     tcp46_output_trace_frame (vm, node, from, n_left_from);
2023
2024   vlib_get_buffers (vm, from, bufs, n_left_from);
2025   b = bufs;
2026   next = nexts;
2027
2028   while (n_left_from >= 4)
2029     {
2030       u32 error0 = TCP_ERROR_PKTS_SENT, error1 = TCP_ERROR_PKTS_SENT;
2031       tcp_connection_t *tc0, *tc1;
2032
2033       {
2034         vlib_prefetch_buffer_header (b[2], STORE);
2035         CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2036
2037         vlib_prefetch_buffer_header (b[3], STORE);
2038         CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2039       }
2040
2041       next[0] = next[1] = TCP_OUTPUT_NEXT_IP_LOOKUP;
2042
2043       tc0 = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
2044                                 thread_index);
2045       tc1 = tcp_connection_get (vnet_buffer (b[1])->tcp.connection_index,
2046                                 thread_index);
2047
2048       tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2049       tcp_output_push_ip (vm, b[1], tc1, is_ip4);
2050
2051       tcp_output_handle_packet (tc0, b[0], &error0, &next[0], is_ip4);
2052       tcp_output_handle_packet (tc1, b[1], &error1, &next[1], is_ip4);
2053
2054       b += 2;
2055       next += 2;
2056       n_left_from -= 2;
2057     }
2058   while (n_left_from > 0)
2059     {
2060       u32 error0 = TCP_ERROR_PKTS_SENT;
2061       tcp_connection_t *tc0;
2062
2063       if (n_left_from > 1)
2064         {
2065           vlib_prefetch_buffer_header (b[1], STORE);
2066           CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
2067         }
2068
2069       next[0] = TCP_OUTPUT_NEXT_IP_LOOKUP;
2070       tc0 = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
2071                                 thread_index);
2072
2073       tcp_output_push_ip (vm, b[0], tc0, is_ip4);
2074       tcp_output_handle_packet (tc0, b[0], &error0, &next[0], is_ip4);
2075
2076       b += 1;
2077       next += 1;
2078       n_left_from -= 1;
2079     }
2080
2081   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
2082   return frame->n_vectors;
2083 }
2084
2085 static uword
2086 tcp4_output (vlib_main_t * vm, vlib_node_runtime_t * node,
2087              vlib_frame_t * from_frame)
2088 {
2089   return tcp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2090 }
2091
2092 static uword
2093 tcp6_output (vlib_main_t * vm, vlib_node_runtime_t * node,
2094              vlib_frame_t * from_frame)
2095 {
2096   return tcp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2097 }
2098
2099 /* *INDENT-OFF* */
2100 VLIB_REGISTER_NODE (tcp4_output_node) =
2101 {
2102   .function = tcp4_output,.name = "tcp4-output",
2103     /* Takes a vector of packets. */
2104     .vector_size = sizeof (u32),
2105     .n_errors = TCP_N_ERROR,
2106     .error_strings = tcp_error_strings,
2107     .n_next_nodes = TCP_OUTPUT_N_NEXT,
2108     .next_nodes = {
2109 #define _(s,n) [TCP_OUTPUT_NEXT_##s] = n,
2110     foreach_tcp4_output_next
2111 #undef _
2112     },
2113     .format_buffer = format_tcp_header,
2114     .format_trace = format_tcp_tx_trace,
2115 };
2116 /* *INDENT-ON* */
2117
2118 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_output_node, tcp4_output);
2119
2120 /* *INDENT-OFF* */
2121 VLIB_REGISTER_NODE (tcp6_output_node) =
2122 {
2123   .function = tcp6_output,
2124   .name = "tcp6-output",
2125     /* Takes a vector of packets. */
2126   .vector_size = sizeof (u32),
2127   .n_errors = TCP_N_ERROR,
2128   .error_strings = tcp_error_strings,
2129   .n_next_nodes = TCP_OUTPUT_N_NEXT,
2130   .next_nodes = {
2131 #define _(s,n) [TCP_OUTPUT_NEXT_##s] = n,
2132     foreach_tcp6_output_next
2133 #undef _
2134   },
2135   .format_buffer = format_tcp_header,
2136   .format_trace = format_tcp_tx_trace,
2137 };
2138 /* *INDENT-ON* */
2139
2140 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_output_node, tcp6_output);
2141
2142 typedef enum _tcp_reset_next
2143 {
2144   TCP_RESET_NEXT_DROP,
2145   TCP_RESET_NEXT_IP_LOOKUP,
2146   TCP_RESET_N_NEXT
2147 } tcp_reset_next_t;
2148
2149 #define foreach_tcp4_reset_next         \
2150   _(DROP, "error-drop")                 \
2151   _(IP_LOOKUP, "ip4-lookup")
2152
2153 #define foreach_tcp6_reset_next         \
2154   _(DROP, "error-drop")                 \
2155   _(IP_LOOKUP, "ip6-lookup")
2156
2157 static uword
2158 tcp46_send_reset_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
2159                          vlib_frame_t * from_frame, u8 is_ip4)
2160 {
2161   u32 n_left_from, next_index, *from, *to_next;
2162   u32 my_thread_index = vm->thread_index;
2163
2164   from = vlib_frame_vector_args (from_frame);
2165   n_left_from = from_frame->n_vectors;
2166
2167   next_index = node->cached_next_index;
2168
2169   while (n_left_from > 0)
2170     {
2171       u32 n_left_to_next;
2172
2173       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2174
2175       while (n_left_from > 0 && n_left_to_next > 0)
2176         {
2177           u32 bi0;
2178           vlib_buffer_t *b0;
2179           tcp_tx_trace_t *t0;
2180           tcp_header_t *th0;
2181           u32 error0 = TCP_ERROR_RST_SENT, next0 = TCP_RESET_NEXT_IP_LOOKUP;
2182
2183           bi0 = from[0];
2184           to_next[0] = bi0;
2185           from += 1;
2186           to_next += 1;
2187           n_left_from -= 1;
2188           n_left_to_next -= 1;
2189
2190           b0 = vlib_get_buffer (vm, bi0);
2191
2192           if (tcp_make_reset_in_place (vm, b0, vnet_buffer (b0)->tcp.flags,
2193                                        my_thread_index, is_ip4))
2194             {
2195               error0 = TCP_ERROR_LOOKUP_DROPS;
2196               next0 = TCP_RESET_NEXT_DROP;
2197               goto done;
2198             }
2199
2200           /* Prepare to send to IP lookup */
2201           vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
2202           next0 = TCP_RESET_NEXT_IP_LOOKUP;
2203
2204         done:
2205           b0->error = node->errors[error0];
2206           b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
2207           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2208             {
2209               th0 = vlib_buffer_get_current (b0);
2210               if (is_ip4)
2211                 th0 = ip4_next_header ((ip4_header_t *) th0);
2212               else
2213                 th0 = ip6_next_header ((ip6_header_t *) th0);
2214               t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2215               clib_memcpy (&t0->tcp_header, th0, sizeof (t0->tcp_header));
2216             }
2217
2218           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2219                                            n_left_to_next, bi0, next0);
2220         }
2221       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2222     }
2223   return from_frame->n_vectors;
2224 }
2225
2226 static uword
2227 tcp4_send_reset (vlib_main_t * vm, vlib_node_runtime_t * node,
2228                  vlib_frame_t * from_frame)
2229 {
2230   return tcp46_send_reset_inline (vm, node, from_frame, 1);
2231 }
2232
2233 static uword
2234 tcp6_send_reset (vlib_main_t * vm, vlib_node_runtime_t * node,
2235                  vlib_frame_t * from_frame)
2236 {
2237   return tcp46_send_reset_inline (vm, node, from_frame, 0);
2238 }
2239
2240 /* *INDENT-OFF* */
2241 VLIB_REGISTER_NODE (tcp4_reset_node) = {
2242   .function = tcp4_send_reset,
2243   .name = "tcp4-reset",
2244   .vector_size = sizeof (u32),
2245   .n_errors = TCP_N_ERROR,
2246   .error_strings = tcp_error_strings,
2247   .n_next_nodes = TCP_RESET_N_NEXT,
2248   .next_nodes = {
2249 #define _(s,n) [TCP_RESET_NEXT_##s] = n,
2250     foreach_tcp4_reset_next
2251 #undef _
2252   },
2253   .format_trace = format_tcp_tx_trace,
2254 };
2255 /* *INDENT-ON* */
2256
2257 VLIB_NODE_FUNCTION_MULTIARCH (tcp4_reset_node, tcp4_send_reset);
2258
2259 /* *INDENT-OFF* */
2260 VLIB_REGISTER_NODE (tcp6_reset_node) = {
2261   .function = tcp6_send_reset,
2262   .name = "tcp6-reset",
2263   .vector_size = sizeof (u32),
2264   .n_errors = TCP_N_ERROR,
2265   .error_strings = tcp_error_strings,
2266   .n_next_nodes = TCP_RESET_N_NEXT,
2267   .next_nodes = {
2268 #define _(s,n) [TCP_RESET_NEXT_##s] = n,
2269     foreach_tcp6_reset_next
2270 #undef _
2271   },
2272   .format_trace = format_tcp_tx_trace,
2273 };
2274 /* *INDENT-ON* */
2275
2276 VLIB_NODE_FUNCTION_MULTIARCH (tcp6_reset_node, tcp6_send_reset);
2277
2278 /*
2279  * fd.io coding-style-patch-verification: ON
2280  *
2281  * Local Variables:
2282  * eval: (c-set-style "gnu")
2283  * End:
2284  */