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