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