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