src/vnet/tcp/tcp_output.c

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