src/vnet/tcp/tcp_output.c

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