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