FD.io VPP  v18.01-8-g0eacf49
Vector Packet Processing
tcp_input.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 <vppinfra/sparse_vec.h>
17 #include <vnet/tcp/tcp_packet.h>
18 #include <vnet/tcp/tcp.h>
19 #include <vnet/session/session.h>
20 #include <math.h>
21 
22 static char *tcp_error_strings[] = {
23 #define tcp_error(n,s) s,
24 #include <vnet/tcp/tcp_error.def>
25 #undef tcp_error
26 };
27 
28 /* All TCP nodes have the same outgoing arcs */
29 #define foreach_tcp_state_next \
30  _ (DROP4, "ip4-drop") \
31  _ (DROP6, "ip6-drop") \
32  _ (TCP4_OUTPUT, "tcp4-output") \
33  _ (TCP6_OUTPUT, "tcp6-output")
34 
35 typedef enum _tcp_established_next
36 {
37 #define _(s,n) TCP_ESTABLISHED_NEXT_##s,
39 #undef _
42 
43 typedef enum _tcp_rcv_process_next
44 {
45 #define _(s,n) TCP_RCV_PROCESS_NEXT_##s,
47 #undef _
50 
51 typedef enum _tcp_syn_sent_next
52 {
53 #define _(s,n) TCP_SYN_SENT_NEXT_##s,
55 #undef _
58 
59 typedef enum _tcp_listen_next
60 {
61 #define _(s,n) TCP_LISTEN_NEXT_##s,
63 #undef _
66 
67 /* Generic, state independent indices */
68 typedef enum _tcp_state_next
69 {
70 #define _(s,n) TCP_NEXT_##s,
72 #undef _
75 
76 #define tcp_next_output(is_ip4) (is_ip4 ? TCP_NEXT_TCP4_OUTPUT \
77  : TCP_NEXT_TCP6_OUTPUT)
78 
79 #define tcp_next_drop(is_ip4) (is_ip4 ? TCP_NEXT_DROP4 \
80  : TCP_NEXT_DROP6)
81 
84 
85 /**
86  * Validate segment sequence number. As per RFC793:
87  *
88  * Segment Receive Test
89  * Length Window
90  * ------- ------- -------------------------------------------
91  * 0 0 SEG.SEQ = RCV.NXT
92  * 0 >0 RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
93  * >0 0 not acceptable
94  * >0 >0 RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
95  * or RCV.NXT =< SEG.SEQ+SEG.LEN-1 < RCV.NXT+RCV.WND
96  *
97  * This ultimately consists in checking if segment falls within the window.
98  * The one important difference compared to RFC793 is that we use rcv_las,
99  * or the rcv_nxt at last ack sent instead of rcv_nxt since that's the
100  * peer's reference when computing our receive window.
101  *
102  * This:
103  * seq_leq (end_seq, tc->rcv_las + tc->rcv_wnd) && seq_geq (seq, tc->rcv_las)
104  * however, is too strict when we have retransmits. Instead we just check that
105  * the seq is not beyond the right edge and that the end of the segment is not
106  * less than the left edge.
107  *
108  * N.B. rcv_nxt and rcv_wnd are both updated in this node if acks are sent, so
109  * use rcv_nxt in the right edge window test instead of rcv_las.
110  *
111  */
114 {
115  return (seq_geq (end_seq, tc->rcv_las)
116  && seq_leq (seq, tc->rcv_nxt + tc->rcv_wnd));
117 }
118 
119 /**
120  * Parse TCP header options.
121  *
122  * @param th TCP header
123  * @param to TCP options data structure to be populated
124  * @return -1 if parsing failed
125  */
126 int
128 {
129  const u8 *data;
130  u8 opt_len, opts_len, kind;
131  int j;
132  sack_block_t b;
133 
134  opts_len = (tcp_doff (th) << 2) - sizeof (tcp_header_t);
135  data = (const u8 *) (th + 1);
136 
137  /* Zero out all flags but those set in SYN */
138  to->flags &= (TCP_OPTS_FLAG_SACK_PERMITTED | TCP_OPTS_FLAG_WSCALE);
139 
140  for (; opts_len > 0; opts_len -= opt_len, data += opt_len)
141  {
142  kind = data[0];
143 
144  /* Get options length */
145  if (kind == TCP_OPTION_EOL)
146  break;
147  else if (kind == TCP_OPTION_NOOP)
148  {
149  opt_len = 1;
150  continue;
151  }
152  else
153  {
154  /* broken options */
155  if (opts_len < 2)
156  return -1;
157  opt_len = data[1];
158 
159  /* weird option length */
160  if (opt_len < 2 || opt_len > opts_len)
161  return -1;
162  }
163 
164  /* Parse options */
165  switch (kind)
166  {
167  case TCP_OPTION_MSS:
168  if ((opt_len == TCP_OPTION_LEN_MSS) && tcp_syn (th))
169  {
170  to->flags |= TCP_OPTS_FLAG_MSS;
171  to->mss = clib_net_to_host_u16 (*(u16 *) (data + 2));
172  }
173  break;
175  if ((opt_len == TCP_OPTION_LEN_WINDOW_SCALE) && tcp_syn (th))
176  {
177  to->flags |= TCP_OPTS_FLAG_WSCALE;
178  to->wscale = data[2];
179  if (to->wscale > TCP_MAX_WND_SCALE)
180  {
181  clib_warning ("Illegal window scaling value: %d",
182  to->wscale);
184  }
185  }
186  break;
188  if (opt_len == TCP_OPTION_LEN_TIMESTAMP)
189  {
190  to->flags |= TCP_OPTS_FLAG_TSTAMP;
191  to->tsval = clib_net_to_host_u32 (*(u32 *) (data + 2));
192  to->tsecr = clib_net_to_host_u32 (*(u32 *) (data + 6));
193  }
194  break;
196  if (opt_len == TCP_OPTION_LEN_SACK_PERMITTED && tcp_syn (th))
197  to->flags |= TCP_OPTS_FLAG_SACK_PERMITTED;
198  break;
200  /* If SACK permitted was not advertised or a SYN, break */
201  if ((to->flags & TCP_OPTS_FLAG_SACK_PERMITTED) == 0 || tcp_syn (th))
202  break;
203 
204  /* If too short or not correctly formatted, break */
205  if (opt_len < 10 || ((opt_len - 2) % TCP_OPTION_LEN_SACK_BLOCK))
206  break;
207 
208  to->flags |= TCP_OPTS_FLAG_SACK;
209  to->n_sack_blocks = (opt_len - 2) / TCP_OPTION_LEN_SACK_BLOCK;
210  vec_reset_length (to->sacks);
211  for (j = 0; j < to->n_sack_blocks; j++)
212  {
213  b.start = clib_net_to_host_u32 (*(u32 *) (data + 2 + 8 * j));
214  b.end = clib_net_to_host_u32 (*(u32 *) (data + 6 + 8 * j));
215  vec_add1 (to->sacks, b);
216  }
217  break;
218  default:
219  /* Nothing to see here */
220  continue;
221  }
222  }
223  return 0;
224 }
225 
226 /**
227  * RFC1323: Check against wrapped sequence numbers (PAWS). If we have
228  * timestamp to echo and it's less than tsval_recent, drop segment
229  * but still send an ACK in order to retain TCP's mechanism for detecting
230  * and recovering from half-open connections
231  *
232  * Or at least that's what the theory says. It seems that this might not work
233  * very well with packet reordering and fast retransmit. XXX
234  */
235 always_inline int
237 {
238  return tcp_opts_tstamp (&tc->rcv_opts) && tc->tsval_recent
239  && timestamp_lt (tc->rcv_opts.tsval, tc->tsval_recent);
240 }
241 
242 /**
243  * Update tsval recent
244  */
245 always_inline void
247 {
248  /*
249  * RFC1323: If Last.ACK.sent falls within the range of sequence numbers
250  * of an incoming segment:
251  * SEG.SEQ <= Last.ACK.sent < SEG.SEQ + SEG.LEN
252  * then the TSval from the segment is copied to TS.Recent;
253  * otherwise, the TSval is ignored.
254  */
255  if (tcp_opts_tstamp (&tc->rcv_opts) && seq_leq (seq, tc->rcv_las)
256  && seq_leq (tc->rcv_las, seq_end))
257  {
258  ASSERT (timestamp_leq (tc->tsval_recent, tc->rcv_opts.tsval));
259  tc->tsval_recent = tc->rcv_opts.tsval;
260  tc->tsval_recent_age = tcp_time_now ();
261  }
262 }
263 
264 /**
265  * Validate incoming segment as per RFC793 p. 69 and RFC1323 p. 19
266  *
267  * It first verifies if segment has a wrapped sequence number (PAWS) and then
268  * does the processing associated to the first four steps (ignoring security
269  * and precedence): sequence number, rst bit and syn bit checks.
270  *
271  * @return 0 if segments passes validation.
272  */
273 static int
275  vlib_buffer_t * b0, tcp_header_t * th0, u32 * next0)
276 {
277  if (PREDICT_FALSE (!tcp_ack (th0) && !tcp_rst (th0) && !tcp_syn (th0)))
278  return -1;
279 
280  if (PREDICT_FALSE (tcp_options_parse (th0, &tc0->rcv_opts)))
281  {
282  clib_warning ("options parse error");
283  return -1;
284  }
285 
286  if (tcp_segment_check_paws (tc0))
287  {
288  if (CLIB_DEBUG > 2)
289  {
290  clib_warning ("paws failed\n%U", format_tcp_connection, tc0, 2);
291  clib_warning ("seq %u seq_end %u ack %u",
292  vnet_buffer (b0)->tcp.seq_number - tc0->irs,
293  vnet_buffer (b0)->tcp.seq_end - tc0->irs,
294  vnet_buffer (b0)->tcp.ack_number - tc0->iss);
295  }
296  TCP_EVT_DBG (TCP_EVT_PAWS_FAIL, tc0, vnet_buffer (b0)->tcp.seq_number,
297  vnet_buffer (b0)->tcp.seq_end);
298 
299  /* If it just so happens that a segment updates tsval_recent for a
300  * segment over 24 days old, invalidate tsval_recent. */
301  if (timestamp_lt (tc0->tsval_recent_age + TCP_PAWS_IDLE,
302  tcp_time_now ()))
303  {
304  /* Age isn't reset until we get a valid tsval (bsd inspired) */
305  tc0->tsval_recent = 0;
306  clib_warning ("paws failed - really old segment. REALLY?");
307  }
308  else
309  {
310  /* Drop after ack if not rst */
311  if (!tcp_rst (th0))
312  {
313  tcp_make_ack (tc0, b0);
314  *next0 = tcp_next_output (tc0->c_is_ip4);
315  TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc0);
316  return -1;
317  }
318  }
319  }
320 
321  /* 1st: check sequence number */
322  if (!tcp_segment_in_rcv_wnd (tc0, vnet_buffer (b0)->tcp.seq_number,
323  vnet_buffer (b0)->tcp.seq_end))
324  {
325  /* If our window is 0 and the packet is in sequence, let it pass
326  * through for ack processing. It should be dropped later.*/
327  if (tc0->rcv_wnd == 0
328  && tc0->rcv_nxt == vnet_buffer (b0)->tcp.seq_number)
329  {
330  /* TODO Should segment be tagged? */
331  }
332  else
333  {
334  /* If not RST, send dup ack */
335  if (!tcp_rst (th0))
336  {
337  tcp_make_ack (tc0, b0);
338  *next0 = tcp_next_output (tc0->c_is_ip4);
339  TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc0);
340  }
341  return -1;
342  }
343  }
344 
345  /* 2nd: check the RST bit */
346  if (tcp_rst (th0))
347  {
348  tcp_connection_reset (tc0);
349  return -1;
350  }
351 
352  /* 3rd: check security and precedence (skip) */
353 
354  /* 4th: check the SYN bit */
355  if (tcp_syn (th0))
356  {
357  /* TODO implement RFC 5961 */
358  if (tc0->state == TCP_STATE_SYN_RCVD)
359  {
360  tcp_make_synack (tc0, b0);
361  TCP_EVT_DBG (TCP_EVT_SYN_RCVD, tc0, 0);
362  }
363  else
364  {
365  tcp_make_ack (tc0, b0);
366  TCP_EVT_DBG (TCP_EVT_SYNACK_RCVD, tc0);
367  }
368  *next0 = tcp_next_output (tc0->c_is_ip4);
369  return -1;
370  }
371 
372  /* If segment in window, save timestamp */
373  tcp_update_timestamp (tc0, vnet_buffer (b0)->tcp.seq_number,
374  vnet_buffer (b0)->tcp.seq_end);
375  return 0;
376 }
377 
378 always_inline int
380 {
381  /* SND.UNA =< SEG.ACK =< SND.NXT */
382  return (seq_leq (tc0->snd_una, vnet_buffer (tb0)->tcp.ack_number)
383  && seq_leq (vnet_buffer (tb0)->tcp.ack_number, tc0->snd_nxt));
384 }
385 
386 /**
387  * Compute smoothed RTT as per VJ's '88 SIGCOMM and RFC6298
388  *
389  * Note that although the original article, srtt and rttvar are scaled
390  * to minimize round-off errors, here we don't. Instead, we rely on
391  * better precision time measurements.
392  *
393  * TODO support us rtt resolution
394  */
395 static void
397 {
398  int err, diff;
399 
400  if (tc->srtt != 0)
401  {
402  err = mrtt - tc->srtt;
403 
404  /* XXX Drop in RTT results in RTTVAR increase and bigger RTO.
405  * The increase should be bound */
406  tc->srtt = clib_max ((int) tc->srtt + (err >> 3), 1);
407  diff = (clib_abs (err) - (int) tc->rttvar) >> 2;
408  tc->rttvar = clib_max ((int) tc->rttvar + diff, 1);
409  }
410  else
411  {
412  /* First measurement. */
413  tc->srtt = mrtt;
414  tc->rttvar = mrtt >> 1;
415  }
416 }
417 
418 void
420 {
421  tc->rto = clib_min (tc->srtt + (tc->rttvar << 2), TCP_RTO_MAX);
422  tc->rto = clib_max (tc->rto, TCP_RTO_MIN);
423 }
424 
425 /**
426  * Update RTT estimate and RTO timer
427  *
428  * Measure RTT: We have two sources of RTT measurements: TSOPT and ACK
429  * timing. Middle boxes are known to fiddle with TCP options so we
430  * should give higher priority to ACK timing.
431  *
432  * This should be called only if previously sent bytes have been acked.
433  *
434  * return 1 if valid rtt 0 otherwise
435  */
436 static int
438 {
439  u32 mrtt = 0;
440 
441  /* Karn's rule, part 1. Don't use retransmitted segments to estimate
442  * RTT because they're ambiguous. */
443  if (tcp_in_cong_recovery (tc) || tc->sack_sb.sacked_bytes)
444  goto done;
445 
446  if (tc->rtt_ts && seq_geq (ack, tc->rtt_seq))
447  {
448  mrtt = tcp_time_now () - tc->rtt_ts;
449  }
450  /* As per RFC7323 TSecr can be used for RTTM only if the segment advances
451  * snd_una, i.e., the left side of the send window:
452  * seq_lt (tc->snd_una, ack). This is a condition for calling update_rtt */
453  else if (tcp_opts_tstamp (&tc->rcv_opts) && tc->rcv_opts.tsecr)
454  {
455  mrtt = tcp_time_now () - tc->rcv_opts.tsecr;
456  }
457 
458  /* Ignore dubious measurements */
459  if (mrtt == 0 || mrtt > TCP_RTT_MAX)
460  goto done;
461 
462  tcp_estimate_rtt (tc, mrtt);
463 
464 done:
465 
466  /* Allow measuring of a new RTT */
467  tc->rtt_ts = 0;
468 
469  /* If we got here something must've been ACKed so make sure boff is 0,
470  * even if mrrt is not valid since we update the rto lower */
471  tc->rto_boff = 0;
472  tcp_update_rto (tc);
473 
474  return 0;
475 }
476 
477 /**
478  * Dequeue bytes that have been acked and while at it update RTT estimates.
479  */
480 static void
482 {
483  /* Dequeue the newly ACKed add SACKed bytes */
484  stream_session_dequeue_drop (&tc->connection,
485  tc->bytes_acked + tc->sack_sb.snd_una_adv);
486 
487  tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
488 
489  /* Update rtt and rto */
490  tcp_update_rtt (tc, ack);
491 
492  /* If everything has been acked, stop retransmit timer
493  * otherwise update. */
495 }
496 
497 /**
498  * Check if duplicate ack as per RFC5681 Sec. 2
499  */
500 static u8
502  u32 prev_snd_una)
503 {
504  return ((vnet_buffer (b)->tcp.ack_number == prev_snd_una)
505  && seq_gt (tc->snd_una_max, tc->snd_una)
506  && (vnet_buffer (b)->tcp.seq_end == vnet_buffer (b)->tcp.seq_number)
507  && (prev_snd_wnd == tc->snd_wnd));
508 }
509 
510 /**
511  * Checks if ack is a congestion control event.
512  */
513 static u8
515  u32 prev_snd_wnd, u32 prev_snd_una, u8 * is_dack)
516 {
517  /* Check if ack is duplicate. Per RFC 6675, ACKs that SACK new data are
518  * defined to be 'duplicate' */
519  *is_dack = tc->sack_sb.last_sacked_bytes
520  || tcp_ack_is_dupack (tc, b, prev_snd_wnd, prev_snd_una);
521 
522  return ((*is_dack || tcp_in_cong_recovery (tc)) && !tcp_is_lost_fin (tc));
523 }
524 
525 void
527 {
528  sack_scoreboard_hole_t *next, *prev;
529 
530  if (hole->next != TCP_INVALID_SACK_HOLE_INDEX)
531  {
532  next = pool_elt_at_index (sb->holes, hole->next);
533  next->prev = hole->prev;
534  }
535  else
536  {
537  sb->tail = hole->prev;
538  }
539 
540  if (hole->prev != TCP_INVALID_SACK_HOLE_INDEX)
541  {
542  prev = pool_elt_at_index (sb->holes, hole->prev);
543  prev->next = hole->next;
544  }
545  else
546  {
547  sb->head = hole->next;
548  }
549 
550  if (scoreboard_hole_index (sb, hole) == sb->cur_rxt_hole)
551  sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
552 
553  /* Poison the entry */
554  if (CLIB_DEBUG > 0)
555  memset (hole, 0xfe, sizeof (*hole));
556 
557  pool_put (sb->holes, hole);
558 }
559 
562  u32 start, u32 end)
563 {
564  sack_scoreboard_hole_t *hole, *next, *prev;
565  u32 hole_index;
566 
567  pool_get (sb->holes, hole);
568  memset (hole, 0, sizeof (*hole));
569 
570  hole->start = start;
571  hole->end = end;
572  hole_index = scoreboard_hole_index (sb, hole);
573 
574  prev = scoreboard_get_hole (sb, prev_index);
575  if (prev)
576  {
577  hole->prev = prev_index;
578  hole->next = prev->next;
579 
580  if ((next = scoreboard_next_hole (sb, hole)))
581  next->prev = hole_index;
582  else
583  sb->tail = hole_index;
584 
585  prev->next = hole_index;
586  }
587  else
588  {
589  sb->head = hole_index;
590  hole->prev = TCP_INVALID_SACK_HOLE_INDEX;
591  hole->next = TCP_INVALID_SACK_HOLE_INDEX;
592  }
593 
594  return hole;
595 }
596 
597 void
599 {
600  sack_scoreboard_hole_t *hole, *prev;
601  u32 bytes = 0, blks = 0;
602 
603  sb->lost_bytes = 0;
604  sb->sacked_bytes = 0;
605  hole = scoreboard_last_hole (sb);
606  if (!hole)
607  return;
608 
609  if (seq_gt (sb->high_sacked, hole->end))
610  {
611  bytes = sb->high_sacked - hole->end;
612  blks = 1;
613  }
614 
615  while ((prev = scoreboard_prev_hole (sb, hole))
616  && (bytes < (TCP_DUPACK_THRESHOLD - 1) * tc->snd_mss
617  && blks < TCP_DUPACK_THRESHOLD))
618  {
619  bytes += hole->start - prev->end;
620  blks++;
621  hole = prev;
622  }
623 
624  while (hole)
625  {
626  sb->lost_bytes += scoreboard_hole_bytes (hole);
627  hole->is_lost = 1;
628  prev = hole;
629  hole = scoreboard_prev_hole (sb, hole);
630  if (hole)
631  bytes += prev->start - hole->end;
632  }
633  sb->sacked_bytes = bytes;
634 }
635 
636 /**
637  * Figure out the next hole to retransmit
638  *
639  * Follows logic proposed in RFC6675 Sec. 4, NextSeg()
640  */
643  sack_scoreboard_hole_t * start,
644  u8 have_sent_1_smss,
645  u8 * can_rescue, u8 * snd_limited)
646 {
647  sack_scoreboard_hole_t *hole = 0;
648 
649  hole = start ? start : scoreboard_first_hole (sb);
650  while (hole && seq_leq (hole->end, sb->high_rxt) && hole->is_lost)
651  hole = scoreboard_next_hole (sb, hole);
652 
653  /* Nothing, return */
654  if (!hole)
655  {
656  sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
657  return 0;
658  }
659 
660  /* Rule (1): if higher than rxt, less than high_sacked and lost */
661  if (hole->is_lost && seq_lt (hole->start, sb->high_sacked))
662  {
663  sb->cur_rxt_hole = scoreboard_hole_index (sb, hole);
664  }
665  else
666  {
667  /* Rule (2): output takes care of transmitting new data */
668  if (!have_sent_1_smss)
669  {
670  hole = 0;
671  sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
672  }
673  /* Rule (3): if hole not lost */
674  else if (seq_lt (hole->start, sb->high_sacked))
675  {
676  *snd_limited = 1;
677  sb->cur_rxt_hole = scoreboard_hole_index (sb, hole);
678  }
679  /* Rule (4): if hole beyond high_sacked */
680  else
681  {
682  ASSERT (seq_geq (hole->start, sb->high_sacked));
683  *snd_limited = 1;
684  *can_rescue = 1;
685  /* HighRxt MUST NOT be updated */
686  return 0;
687  }
688  }
689 
690  if (hole && seq_lt (sb->high_rxt, hole->start))
691  sb->high_rxt = hole->start;
692 
693  return hole;
694 }
695 
696 void
698 {
700  hole = scoreboard_first_hole (sb);
701  if (hole)
702  {
703  seq = seq_gt (seq, hole->start) ? seq : hole->start;
704  sb->cur_rxt_hole = sb->head;
705  }
706  sb->high_rxt = seq;
707 }
708 
709 /**
710  * Test that scoreboard is sane after recovery
711  *
712  * Returns 1 if scoreboard is empty or if first hole beyond
713  * snd_una.
714  */
715 u8
717 {
719  hole = scoreboard_first_hole (&tc->sack_sb);
720  return (!hole || seq_geq (hole->start, tc->snd_una));
721 }
722 
723 void
725 {
726  sack_scoreboard_t *sb = &tc->sack_sb;
727  sack_block_t *blk, tmp;
728  sack_scoreboard_hole_t *hole, *next_hole, *last_hole;
729  u32 blk_index = 0, old_sacked_bytes, hole_index;
730  int i, j;
731 
732  sb->last_sacked_bytes = 0;
733  sb->snd_una_adv = 0;
734  old_sacked_bytes = sb->sacked_bytes;
735  sb->last_bytes_delivered = 0;
736 
737  if (!tcp_opts_sack (&tc->rcv_opts)
738  && sb->head == TCP_INVALID_SACK_HOLE_INDEX)
739  return;
740 
741  /* Remove invalid blocks */
742  blk = tc->rcv_opts.sacks;
743  while (blk < vec_end (tc->rcv_opts.sacks))
744  {
745  if (seq_lt (blk->start, blk->end)
746  && seq_gt (blk->start, tc->snd_una)
747  && seq_gt (blk->start, ack) && seq_leq (blk->end, tc->snd_una_max))
748  {
749  blk++;
750  continue;
751  }
752  vec_del1 (tc->rcv_opts.sacks, blk - tc->rcv_opts.sacks);
753  }
754 
755  /* Add block for cumulative ack */
756  if (seq_gt (ack, tc->snd_una))
757  {
758  tmp.start = tc->snd_una;
759  tmp.end = ack;
760  vec_add1 (tc->rcv_opts.sacks, tmp);
761  }
762 
763  if (vec_len (tc->rcv_opts.sacks) == 0)
764  return;
765 
766  tcp_scoreboard_trace_add (tc, ack);
767 
768  /* Make sure blocks are ordered */
769  for (i = 0; i < vec_len (tc->rcv_opts.sacks); i++)
770  for (j = i + 1; j < vec_len (tc->rcv_opts.sacks); j++)
771  if (seq_lt (tc->rcv_opts.sacks[j].start, tc->rcv_opts.sacks[i].start))
772  {
773  tmp = tc->rcv_opts.sacks[i];
774  tc->rcv_opts.sacks[i] = tc->rcv_opts.sacks[j];
775  tc->rcv_opts.sacks[j] = tmp;
776  }
777 
778  if (sb->head == TCP_INVALID_SACK_HOLE_INDEX)
779  {
780  /* If no holes, insert the first that covers all outstanding bytes */
782  tc->snd_una, tc->snd_una_max);
783  sb->tail = scoreboard_hole_index (sb, last_hole);
784  tmp = tc->rcv_opts.sacks[vec_len (tc->rcv_opts.sacks) - 1];
785  sb->high_sacked = tmp.end;
786  }
787  else
788  {
789  /* If we have holes but snd_una_max is beyond the last hole, update
790  * last hole end */
791  tmp = tc->rcv_opts.sacks[vec_len (tc->rcv_opts.sacks) - 1];
792  last_hole = scoreboard_last_hole (sb);
793  if (seq_gt (tc->snd_una_max, last_hole->end))
794  {
795  if (seq_geq (last_hole->start, sb->high_sacked))
796  {
797  last_hole->end = tc->snd_una_max;
798  }
799  /* New hole after high sacked block */
800  else if (seq_lt (sb->high_sacked, tc->snd_una_max))
801  {
802  scoreboard_insert_hole (sb, sb->tail, sb->high_sacked,
803  tc->snd_una_max);
804  }
805  }
806  /* Keep track of max byte sacked for when the last hole
807  * is acked */
808  if (seq_gt (tmp.end, sb->high_sacked))
809  sb->high_sacked = tmp.end;
810  }
811 
812  /* Walk the holes with the SACK blocks */
813  hole = pool_elt_at_index (sb->holes, sb->head);
814  while (hole && blk_index < vec_len (tc->rcv_opts.sacks))
815  {
816  blk = &tc->rcv_opts.sacks[blk_index];
817  if (seq_leq (blk->start, hole->start))
818  {
819  /* Block covers hole. Remove hole */
820  if (seq_geq (blk->end, hole->end))
821  {
822  next_hole = scoreboard_next_hole (sb, hole);
823 
824  /* Byte accounting: snd_una needs to be advanced */
825  if (blk->end == ack)
826  {
827  if (next_hole)
828  {
829  if (seq_lt (ack, next_hole->start))
830  sb->snd_una_adv = next_hole->start - ack;
831  sb->last_bytes_delivered +=
832  next_hole->start - hole->end;
833  }
834  else
835  {
836  ASSERT (seq_geq (sb->high_sacked, ack));
837  sb->snd_una_adv = sb->high_sacked - ack;
838  sb->last_bytes_delivered += sb->high_sacked - hole->end;
839  }
840  }
841 
842  scoreboard_remove_hole (sb, hole);
843  hole = next_hole;
844  }
845  /* Partial 'head' overlap */
846  else
847  {
848  if (seq_gt (blk->end, hole->start))
849  {
850  hole->start = blk->end;
851  }
852  blk_index++;
853  }
854  }
855  else
856  {
857  /* Hole must be split */
858  if (seq_lt (blk->end, hole->end))
859  {
860  hole_index = scoreboard_hole_index (sb, hole);
861  next_hole = scoreboard_insert_hole (sb, hole_index, blk->end,
862  hole->end);
863 
864  /* Pool might've moved */
865  hole = scoreboard_get_hole (sb, hole_index);
866  hole->end = blk->start;
867  blk_index++;
868  ASSERT (hole->next == scoreboard_hole_index (sb, next_hole));
869  }
870  else if (seq_lt (blk->start, hole->end))
871  {
872  hole->end = blk->start;
873  }
874  hole = scoreboard_next_hole (sb, hole);
875  }
876  }
877 
878  scoreboard_update_bytes (tc, sb);
879  sb->last_sacked_bytes = sb->sacked_bytes
880  - (old_sacked_bytes - sb->last_bytes_delivered);
881  ASSERT (sb->last_sacked_bytes <= sb->sacked_bytes);
882  ASSERT (sb->sacked_bytes == 0
883  || sb->sacked_bytes < tc->snd_una_max - seq_max (tc->snd_una, ack));
884  ASSERT (sb->last_sacked_bytes + sb->lost_bytes <= tc->snd_una_max
885  - seq_max (tc->snd_una, ack));
887  || sb->holes[sb->head].start == ack + sb->snd_una_adv);
888 }
889 
890 /**
891  * Try to update snd_wnd based on feedback received from peer.
892  *
893  * If successful, and new window is 'effectively' 0, activate persist
894  * timer.
895  */
896 static void
897 tcp_update_snd_wnd (tcp_connection_t * tc, u32 seq, u32 ack, u32 snd_wnd)
898 {
899  /* If (SND.WL1 < SEG.SEQ or (SND.WL1 = SEG.SEQ and SND.WL2 =< SEG.ACK)), set
900  * SND.WND <- SEG.WND, set SND.WL1 <- SEG.SEQ, and set SND.WL2 <- SEG.ACK */
901  if (seq_lt (tc->snd_wl1, seq)
902  || (tc->snd_wl1 == seq && seq_leq (tc->snd_wl2, ack)))
903  {
904  tc->snd_wnd = snd_wnd;
905  tc->snd_wl1 = seq;
906  tc->snd_wl2 = ack;
907  TCP_EVT_DBG (TCP_EVT_SND_WND, tc);
908 
909  if (tc->snd_wnd < tc->snd_mss)
910  {
911  /* Set persist timer if not set and we just got 0 wnd */
912  if (!tcp_timer_is_active (tc, TCP_TIMER_PERSIST)
913  && !tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT))
915  }
916  else
917  {
919  if (!tcp_in_recovery (tc) && tc->rto_boff > 0)
920  {
921  tc->rto_boff = 0;
922  tcp_update_rto (tc);
923  }
924  }
925  }
926 }
927 
928 void
930 {
931  tcp_fastrecovery_on (tc);
932  tc->snd_congestion = tc->snd_una_max;
933  tc->cc_algo->congestion (tc);
934  TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 4);
935 }
936 
937 static void
939 {
940  /* Deflate rto */
941  tc->rto_boff = 0;
942  tcp_update_rto (tc);
943  tc->snd_rxt_ts = 0;
944  tc->snd_nxt = tc->snd_una_max;
945  tcp_recovery_off (tc);
946  TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 3);
947 }
948 
949 void
951 {
952  tc->cc_algo->recovered (tc);
953  tc->snd_rxt_bytes = 0;
954  tc->rcv_dupacks = 0;
955  tc->snd_nxt = tc->snd_una_max;
958  TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 3);
959 }
960 
961 static void
963 {
964  tc->cwnd = tc->prev_cwnd;
965  tc->ssthresh = tc->prev_ssthresh;
966  tc->snd_nxt = tc->snd_una_max;
967  tc->rcv_dupacks = 0;
968  if (tcp_in_recovery (tc))
970  ASSERT (tc->rto_boff == 0);
971  TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 5);
972  /* TODO extend for fastrecovery */
973 }
974 
975 static u8
977 {
978  return (tcp_in_recovery (tc) && tc->rto_boff == 1
979  && tc->snd_rxt_ts
980  && tcp_opts_tstamp (&tc->rcv_opts)
981  && timestamp_lt (tc->rcv_opts.tsecr, tc->snd_rxt_ts));
982 }
983 
984 int
986 {
989  {
991  return 1;
992  }
993 
994  if (tcp_in_recovery (tc))
996  else if (tcp_in_fastrecovery (tc))
998 
999  ASSERT (tc->rto_boff == 0);
1000  ASSERT (!tcp_in_cong_recovery (tc));
1002  return 0;
1003 }
1004 
1005 static void
1007 {
1009 
1010  /* Congestion avoidance */
1011  tc->cc_algo->rcv_ack (tc);
1012  tc->tsecr_last_ack = tc->rcv_opts.tsecr;
1013 
1014  /* If a cumulative ack, make sure dupacks is 0 */
1015  tc->rcv_dupacks = 0;
1016 
1017  /* When dupacks hits the threshold we only enter fast retransmit if
1018  * cumulative ack covers more than snd_congestion. Should snd_una
1019  * wrap this test may fail under otherwise valid circumstances.
1020  * Therefore, proactively update snd_congestion when wrap detected. */
1021  if (PREDICT_FALSE
1022  (seq_leq (tc->snd_congestion, tc->snd_una - tc->bytes_acked)
1023  && seq_gt (tc->snd_congestion, tc->snd_una)))
1024  tc->snd_congestion = tc->snd_una - 1;
1025 }
1026 
1027 static u8
1029 {
1030  return (TCP_DUPACK_THRESHOLD - 1) * tc->snd_mss < tc->sack_sb.sacked_bytes;
1031 }
1032 
1033 static u8
1035 {
1036  return (tc->rcv_dupacks == TCP_DUPACK_THRESHOLD
1037  || tcp_should_fastrecover_sack (tc));
1038 }
1039 
1040 /**
1041  * One function to rule them all ... and in the darkness bind them
1042  */
1043 static void
1045 {
1046  u32 rxt_delivered;
1047 
1048  /*
1049  * Duplicate ACK. Check if we should enter fast recovery, or if already in
1050  * it account for the bytes that left the network.
1051  */
1052  if (is_dack)
1053  {
1054  ASSERT (tc->snd_una != tc->snd_una_max
1055  || tc->sack_sb.last_sacked_bytes);
1056 
1057  tc->rcv_dupacks++;
1058 
1059  if (tc->rcv_dupacks > TCP_DUPACK_THRESHOLD && !tc->bytes_acked)
1060  {
1061  ASSERT (tcp_in_fastrecovery (tc));
1062  /* Pure duplicate ack. If some data got acked, it's handled lower */
1063  tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
1064  return;
1065  }
1066  else if (tcp_should_fastrecover (tc))
1067  {
1068  /* Things are already bad */
1069  if (tcp_in_cong_recovery (tc))
1070  {
1071  tc->rcv_dupacks = 0;
1072  goto partial_ack_test;
1073  }
1074 
1075  /* If of of the two conditions lower hold, reset dupacks because
1076  * we're probably after timeout (RFC6582 heuristics).
1077  * If Cumulative ack does not cover more than congestion threshold,
1078  * and:
1079  * 1) The following doesn't hold: The congestion window is greater
1080  * than SMSS bytes and the difference between highest_ack
1081  * and prev_highest_ack is at most 4*SMSS bytes
1082  * 2) Echoed timestamp in the last non-dup ack does not equal the
1083  * stored timestamp
1084  */
1085  if (seq_leq (tc->snd_una, tc->snd_congestion)
1086  && ((!(tc->cwnd > tc->snd_mss
1087  && tc->bytes_acked <= 4 * tc->snd_mss))
1088  || (tc->rcv_opts.tsecr != tc->tsecr_last_ack)))
1089  {
1090  tc->rcv_dupacks = 0;
1091  return;
1092  }
1093 
1095  tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
1096 
1097  /* The first segment MUST be retransmitted */
1099 
1100  /* Post retransmit update cwnd to ssthresh and account for the
1101  * three segments that have left the network and should've been
1102  * buffered at the receiver XXX */
1103  tc->cwnd = tc->ssthresh + tc->rcv_dupacks * tc->snd_mss;
1104  ASSERT (tc->cwnd >= tc->snd_mss);
1105 
1106  /* If cwnd allows, send more data */
1107  if (tcp_opts_sack_permitted (&tc->rcv_opts))
1108  {
1109  scoreboard_init_high_rxt (&tc->sack_sb,
1110  tc->snd_una + tc->snd_mss);
1112  }
1113  else
1114  {
1116  }
1117 
1118  return;
1119  }
1120  else if (!tc->bytes_acked
1121  || (tc->bytes_acked && !tcp_in_cong_recovery (tc)))
1122  {
1123  tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
1124  return;
1125  }
1126  else
1127  goto partial_ack;
1128  }
1129 
1130 partial_ack_test:
1131 
1132  if (!tc->bytes_acked)
1133  return;
1134 
1135 partial_ack:
1136  /*
1137  * Legitimate ACK. 1) See if we can exit recovery
1138  */
1139  /* XXX limit this only to first partial ack? */
1141 
1142  if (seq_geq (tc->snd_una, tc->snd_congestion))
1143  {
1144  /* If spurious return, we've already updated everything */
1145  if (tcp_cc_recover (tc))
1146  {
1147  tc->tsecr_last_ack = tc->rcv_opts.tsecr;
1148  return;
1149  }
1150 
1151  tc->snd_nxt = tc->snd_una_max;
1152 
1153  /* Treat as congestion avoidance ack */
1154  tc->cc_algo->rcv_ack (tc);
1155  tc->tsecr_last_ack = tc->rcv_opts.tsecr;
1156  return;
1157  }
1158 
1159  /*
1160  * Legitimate ACK. 2) If PARTIAL ACK try to retransmit
1161  */
1162  TCP_EVT_DBG (TCP_EVT_CC_PACK, tc);
1163 
1164  /* RFC6675: If the incoming ACK is a cumulative acknowledgment,
1165  * reset dupacks to 0 */
1166  tc->rcv_dupacks = 0;
1167 
1169 
1170  /* Post RTO timeout don't try anything fancy */
1171  if (tcp_in_recovery (tc))
1172  return;
1173 
1174  /* Remove retransmitted bytes that have been delivered */
1175  ASSERT (tc->bytes_acked + tc->sack_sb.snd_una_adv
1176  >= tc->sack_sb.last_bytes_delivered
1177  || (tc->flags & TCP_CONN_FINSNT));
1178 
1179  if (seq_lt (tc->snd_una, tc->sack_sb.high_rxt))
1180  {
1181  /* If we have sacks and we haven't gotten an ack beyond high_rxt,
1182  * remove sacked bytes delivered */
1183  rxt_delivered = tc->bytes_acked + tc->sack_sb.snd_una_adv
1184  - tc->sack_sb.last_bytes_delivered;
1185  ASSERT (tc->snd_rxt_bytes >= rxt_delivered);
1186  tc->snd_rxt_bytes -= rxt_delivered;
1187  }
1188  else
1189  {
1190  /* Either all retransmitted holes have been acked, or we're
1191  * "in the blind" and retransmitting segment by segment */
1192  tc->snd_rxt_bytes = 0;
1193  }
1194 
1195  tc->cc_algo->rcv_cong_ack (tc, TCP_CC_PARTIALACK);
1196 
1197  /*
1198  * Since this was a partial ack, try to retransmit some more data
1199  */
1200  tcp_fast_retransmit (tc);
1201 }
1202 
1203 void
1205 {
1206  tc->cc_algo = tcp_cc_algo_get (TCP_CC_NEWRENO);
1207  tc->cc_algo->init (tc);
1208 }
1209 
1210 /**
1211  * Process incoming ACK
1212  */
1213 static int
1215  tcp_header_t * th, u32 * next, u32 * error)
1216 {
1217  u32 prev_snd_wnd, prev_snd_una;
1218  u8 is_dack;
1219 
1220  TCP_EVT_DBG (TCP_EVT_CC_STAT, tc);
1221 
1222  /* If the ACK acks something not yet sent (SEG.ACK > SND.NXT) */
1223  if (PREDICT_FALSE (seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt)))
1224  {
1225  /* If we have outstanding data and this is within the window, accept it,
1226  * probably retransmit has timed out. Otherwise ACK segment and then
1227  * drop it */
1228  if (seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_una_max))
1229  {
1230  tcp_make_ack (tc, b);
1231  *next = tcp_next_output (tc->c_is_ip4);
1232  *error = TCP_ERROR_ACK_INVALID;
1233  TCP_EVT_DBG (TCP_EVT_ACK_RCV_ERR, tc, 0,
1234  vnet_buffer (b)->tcp.ack_number);
1235  return -1;
1236  }
1237 
1238  TCP_EVT_DBG (TCP_EVT_ACK_RCV_ERR, tc, 2,
1239  vnet_buffer (b)->tcp.ack_number);
1240 
1241  tc->snd_nxt = vnet_buffer (b)->tcp.ack_number;
1242  *error = TCP_ERROR_ACK_FUTURE;
1243  }
1244 
1245  /* If old ACK, probably it's an old dupack */
1246  if (PREDICT_FALSE (seq_lt (vnet_buffer (b)->tcp.ack_number, tc->snd_una)))
1247  {
1248  *error = TCP_ERROR_ACK_OLD;
1249  TCP_EVT_DBG (TCP_EVT_ACK_RCV_ERR, tc, 1,
1250  vnet_buffer (b)->tcp.ack_number);
1251  if (tcp_in_fastrecovery (tc) && tc->rcv_dupacks == TCP_DUPACK_THRESHOLD)
1252  {
1253  TCP_EVT_DBG (TCP_EVT_DUPACK_RCVD, tc);
1254  tcp_cc_handle_event (tc, 1);
1255  }
1256  /* Don't drop yet */
1257  return 0;
1258  }
1259 
1260  /*
1261  * Looks okay, process feedback
1262  */
1263 
1264  if (tcp_opts_sack_permitted (&tc->rcv_opts))
1265  tcp_rcv_sacks (tc, vnet_buffer (b)->tcp.ack_number);
1266 
1267  prev_snd_wnd = tc->snd_wnd;
1268  prev_snd_una = tc->snd_una;
1269  tcp_update_snd_wnd (tc, vnet_buffer (b)->tcp.seq_number,
1270  vnet_buffer (b)->tcp.ack_number,
1271  clib_net_to_host_u16 (th->window) << tc->snd_wscale);
1272  tc->bytes_acked = vnet_buffer (b)->tcp.ack_number - tc->snd_una;
1273  tc->snd_una = vnet_buffer (b)->tcp.ack_number + tc->sack_sb.snd_una_adv;
1274  tcp_validate_txf_size (tc, tc->bytes_acked);
1275 
1276  if (tc->bytes_acked)
1277  tcp_dequeue_acked (tc, vnet_buffer (b)->tcp.ack_number);
1278 
1279  TCP_EVT_DBG (TCP_EVT_ACK_RCVD, tc);
1280 
1281  /*
1282  * Check if we have congestion event
1283  */
1284 
1285  if (tcp_ack_is_cc_event (tc, b, prev_snd_wnd, prev_snd_una, &is_dack))
1286  {
1287  tcp_cc_handle_event (tc, is_dack);
1288  if (!tcp_in_cong_recovery (tc))
1289  return 0;
1290  *error = TCP_ERROR_ACK_DUP;
1291  TCP_EVT_DBG (TCP_EVT_DUPACK_RCVD, tc, 1);
1292  return vnet_buffer (b)->tcp.data_len ? 0 : -1;
1293  }
1294 
1295  /*
1296  * Update congestion control (slow start/congestion avoidance)
1297  */
1298  tcp_cc_update (tc, b);
1299 
1300  return 0;
1301 }
1302 
1303 static u8
1305 {
1306  int i;
1307  for (i = 1; i < vec_len (sacks); i++)
1308  {
1309  if (sacks[i - 1].end == sacks[i].start)
1310  return 0;
1311  }
1312  return 1;
1313 }
1314 
1315 /**
1316  * Build SACK list as per RFC2018.
1317  *
1318  * Makes sure the first block contains the segment that generated the current
1319  * ACK and the following ones are the ones most recently reported in SACK
1320  * blocks.
1321  *
1322  * @param tc TCP connection for which the SACK list is updated
1323  * @param start Start sequence number of the newest SACK block
1324  * @param end End sequence of the newest SACK block
1325  */
1326 void
1328 {
1329  sack_block_t *new_list = 0, *block = 0;
1330  int i;
1331 
1332  /* If the first segment is ooo add it to the list. Last write might've moved
1333  * rcv_nxt over the first segment. */
1334  if (seq_lt (tc->rcv_nxt, start))
1335  {
1336  vec_add2 (new_list, block, 1);
1337  block->start = start;
1338  block->end = end;
1339  }
1340 
1341  /* Find the blocks still worth keeping. */
1342  for (i = 0; i < vec_len (tc->snd_sacks); i++)
1343  {
1344  /* Discard if rcv_nxt advanced beyond current block */
1345  if (seq_leq (tc->snd_sacks[i].start, tc->rcv_nxt))
1346  continue;
1347 
1348  /* Merge or drop if segment overlapped by the new segment */
1349  if (block && (seq_geq (tc->snd_sacks[i].end, new_list[0].start)
1350  && seq_leq (tc->snd_sacks[i].start, new_list[0].end)))
1351  {
1352  if (seq_lt (tc->snd_sacks[i].start, new_list[0].start))
1353  new_list[0].start = tc->snd_sacks[i].start;
1354  if (seq_lt (new_list[0].end, tc->snd_sacks[i].end))
1355  new_list[0].end = tc->snd_sacks[i].end;
1356  continue;
1357  }
1358 
1359  /* Save to new SACK list if we have space. */
1360  if (vec_len (new_list) < TCP_MAX_SACK_BLOCKS)
1361  {
1362  vec_add1 (new_list, tc->snd_sacks[i]);
1363  }
1364  else
1365  {
1366  clib_warning ("sack discarded");
1367  }
1368  }
1369 
1370  ASSERT (vec_len (new_list) <= TCP_MAX_SACK_BLOCKS);
1371 
1372  /* Replace old vector with new one */
1373  vec_free (tc->snd_sacks);
1374  tc->snd_sacks = new_list;
1375 
1376  /* Segments should not 'touch' */
1377  ASSERT (tcp_sack_vector_is_sane (tc->snd_sacks));
1378 }
1379 
1380 /** Enqueue data for delivery to application */
1381 always_inline int
1383  u16 data_len)
1384 {
1385  int written, error = TCP_ERROR_ENQUEUED;
1386 
1387  ASSERT (seq_geq (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt));
1388 
1389  /* Pure ACK. Update rcv_nxt and be done. */
1390  if (PREDICT_FALSE (data_len == 0))
1391  {
1392  return TCP_ERROR_PURE_ACK;
1393  }
1394 
1395  written = session_enqueue_stream_connection (&tc->connection, b, 0,
1396  1 /* queue event */ , 1);
1397 
1398  TCP_EVT_DBG (TCP_EVT_INPUT, tc, 0, data_len, written);
1399 
1400  /* Update rcv_nxt */
1401  if (PREDICT_TRUE (written == data_len))
1402  {
1403  tc->rcv_nxt += written;
1404  }
1405  /* If more data written than expected, account for out-of-order bytes. */
1406  else if (written > data_len)
1407  {
1408  tc->rcv_nxt += written;
1409 
1410  /* Send ACK confirming the update */
1411  tc->flags |= TCP_CONN_SNDACK;
1412  }
1413  else if (written > 0)
1414  {
1415  /* We've written something but FIFO is probably full now */
1416  tc->rcv_nxt += written;
1417 
1418  /* Depending on how fast the app is, all remaining buffers in burst will
1419  * not be enqueued. Inform peer */
1420  tc->flags |= TCP_CONN_SNDACK;
1421 
1422  error = TCP_ERROR_PARTIALLY_ENQUEUED;
1423  }
1424  else
1425  {
1426  tc->flags |= TCP_CONN_SNDACK;
1427  return TCP_ERROR_FIFO_FULL;
1428  }
1429 
1430  /* Update SACK list if need be */
1431  if (tcp_opts_sack_permitted (&tc->rcv_opts))
1432  {
1433  /* Remove SACK blocks that have been delivered */
1434  tcp_update_sack_list (tc, tc->rcv_nxt, tc->rcv_nxt);
1435  }
1436 
1437  return error;
1438 }
1439 
1440 /** Enqueue out-of-order data */
1441 always_inline int
1443  u16 data_len)
1444 {
1445  stream_session_t *s0;
1446  int rv, offset;
1447 
1448  ASSERT (seq_gt (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt));
1449 
1450  /* Pure ACK. Do nothing */
1451  if (PREDICT_FALSE (data_len == 0))
1452  {
1453  return TCP_ERROR_PURE_ACK;
1454  }
1455 
1456  /* Enqueue out-of-order data with relative offset */
1457  rv = session_enqueue_stream_connection (&tc->connection, b,
1458  vnet_buffer (b)->tcp.seq_number -
1459  tc->rcv_nxt, 0 /* queue event */ ,
1460  0);
1461 
1462  /* Nothing written */
1463  if (rv)
1464  {
1465  TCP_EVT_DBG (TCP_EVT_INPUT, tc, 1, data_len, 0);
1466  return TCP_ERROR_FIFO_FULL;
1467  }
1468 
1469  TCP_EVT_DBG (TCP_EVT_INPUT, tc, 1, data_len, data_len);
1470 
1471  /* Update SACK list if in use */
1472  if (tcp_opts_sack_permitted (&tc->rcv_opts))
1473  {
1474  ooo_segment_t *newest;
1475  u32 start, end;
1476 
1477  s0 = session_get (tc->c_s_index, tc->c_thread_index);
1478 
1479  /* Get the newest segment from the fifo */
1480  newest = svm_fifo_newest_ooo_segment (s0->server_rx_fifo);
1481  if (newest)
1482  {
1483  offset = ooo_segment_offset (s0->server_rx_fifo, newest);
1484  ASSERT (offset <= vnet_buffer (b)->tcp.seq_number - tc->rcv_nxt);
1485  start = tc->rcv_nxt + offset;
1486  end = start + ooo_segment_length (s0->server_rx_fifo, newest);
1487  tcp_update_sack_list (tc, start, end);
1488  svm_fifo_newest_ooo_segment_reset (s0->server_rx_fifo);
1489  }
1490  }
1491 
1492  return TCP_ERROR_ENQUEUED;
1493 }
1494 
1495 /**
1496  * Check if ACK could be delayed. If ack can be delayed, it should return
1497  * true for a full frame. If we're always acking return 0.
1498  */
1499 always_inline int
1501 {
1502  /* Send ack if ... */
1503  if (TCP_ALWAYS_ACK
1504  /* just sent a rcv wnd 0 */
1505  || (tc->flags & TCP_CONN_SENT_RCV_WND0) != 0
1506  /* constrained to send ack */
1507  || (tc->flags & TCP_CONN_SNDACK) != 0
1508  /* we're almost out of tx wnd */
1509  || tcp_available_snd_space (tc) < 4 * tc->snd_mss)
1510  return 0;
1511 
1512  return 1;
1513 }
1514 
1515 static int
1517 {
1518  u32 discard, first = b->current_length;
1520 
1521  /* Handle multi-buffer segments */
1522  if (n_bytes_to_drop > b->current_length)
1523  {
1524  if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
1525  return -1;
1526  do
1527  {
1528  discard = clib_min (n_bytes_to_drop, b->current_length);
1529  vlib_buffer_advance (b, discard);
1530  b = vlib_get_buffer (vm, b->next_buffer);
1531  n_bytes_to_drop -= discard;
1532  }
1533  while (n_bytes_to_drop);
1534  if (n_bytes_to_drop > first)
1535  b->total_length_not_including_first_buffer -= n_bytes_to_drop - first;
1536  }
1537  else
1538  vlib_buffer_advance (b, n_bytes_to_drop);
1539  vnet_buffer (b)->tcp.data_len -= n_bytes_to_drop;
1540  return 0;
1541 }
1542 
1543 static int
1545  u32 * next0)
1546 {
1547  u32 error = 0, n_bytes_to_drop, n_data_bytes;
1548 
1549  vlib_buffer_advance (b, vnet_buffer (b)->tcp.data_offset);
1550  n_data_bytes = vnet_buffer (b)->tcp.data_len;
1551  ASSERT (n_data_bytes);
1552 
1553  /* Handle out-of-order data */
1554  if (PREDICT_FALSE (vnet_buffer (b)->tcp.seq_number != tc->rcv_nxt))
1555  {
1556  /* Old sequence numbers allowed through because they overlapped
1557  * the rx window */
1558  if (seq_lt (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt))
1559  {
1560  error = TCP_ERROR_SEGMENT_OLD;
1561  *next0 = tcp_next_drop (tc->c_is_ip4);
1562 
1563  /* Completely in the past (possible retransmit) */
1564  if (seq_leq (vnet_buffer (b)->tcp.seq_end, tc->rcv_nxt))
1565  {
1566  /* Ack retransmissions since we may not have any data to send */
1567  tcp_make_ack (tc, b);
1568  *next0 = tcp_next_output (tc->c_is_ip4);
1569  goto done;
1570  }
1571 
1572  /* Chop off the bytes in the past */
1573  n_bytes_to_drop = tc->rcv_nxt - vnet_buffer (b)->tcp.seq_number;
1574  n_data_bytes -= n_bytes_to_drop;
1575  vnet_buffer (b)->tcp.seq_number = tc->rcv_nxt;
1576  if (tcp_buffer_discard_bytes (b, n_bytes_to_drop))
1577  goto done;
1578 
1579  goto in_order;
1580  }
1581 
1582  error = tcp_session_enqueue_ooo (tc, b, n_data_bytes);
1583 
1584  /* N.B. Should not filter burst of dupacks. Two issues 1) dupacks open
1585  * cwnd on remote peer when congested 2) acks leaving should have the
1586  * latest rcv_wnd since the burst may eaten up all of it, so only the
1587  * old ones could be filtered.
1588  */
1589 
1590  /* RFC2581: Send DUPACK for fast retransmit */
1591  tcp_make_ack (tc, b);
1592  *next0 = tcp_next_output (tc->c_is_ip4);
1593 
1594  /* Mark as DUPACK. We may filter these in output if
1595  * the burst fills the holes. */
1596  if (n_data_bytes)
1597  vnet_buffer (b)->tcp.flags = TCP_BUF_FLAG_DUPACK;
1598 
1599  TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc);
1600  goto done;
1601  }
1602 
1603 in_order:
1604 
1605  /* In order data, enqueue. Fifo figures out by itself if any out-of-order
1606  * segments can be enqueued after fifo tail offset changes. */
1607  error = tcp_session_enqueue_data (tc, b, n_data_bytes);
1608 
1609  /* Check if ACK can be delayed */
1610  if (tcp_can_delack (tc))
1611  {
1612  if (!tcp_timer_is_active (tc, TCP_TIMER_DELACK))
1613  tcp_timer_set (tc, TCP_TIMER_DELACK, TCP_DELACK_TIME);
1614  goto done;
1615  }
1616 
1617  *next0 = tcp_next_output (tc->c_is_ip4);
1618  tcp_make_ack (tc, b);
1619 
1620 done:
1621  return error;
1622 }
1623 
1624 typedef struct
1625 {
1628 } tcp_rx_trace_t;
1629 
1630 u8 *
1631 format_tcp_rx_trace (u8 * s, va_list * args)
1632 {
1633  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1634  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1635  tcp_rx_trace_t *t = va_arg (*args, tcp_rx_trace_t *);
1636  u32 indent = format_get_indent (s);
1637 
1638  s = format (s, "%U\n%U%U",
1639  format_tcp_header, &t->tcp_header, 128,
1640  format_white_space, indent,
1642 
1643  return s;
1644 }
1645 
1646 u8 *
1647 format_tcp_rx_trace_short (u8 * s, va_list * args)
1648 {
1649  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1650  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1651  tcp_rx_trace_t *t = va_arg (*args, tcp_rx_trace_t *);
1652 
1653  s = format (s, "%d -> %d (%U)",
1654  clib_net_to_host_u16 (t->tcp_header.src_port),
1655  clib_net_to_host_u16 (t->tcp_header.dst_port), format_tcp_state,
1656  t->tcp_connection.state);
1657 
1658  return s;
1659 }
1660 
1661 void
1663  tcp_header_t * th0, vlib_buffer_t * b0, u8 is_ip4)
1664 {
1665  if (tc0)
1666  {
1667  clib_memcpy (&t0->tcp_connection, tc0, sizeof (t0->tcp_connection));
1668  }
1669  else
1670  {
1671  th0 = tcp_buffer_hdr (b0);
1672  }
1673  clib_memcpy (&t0->tcp_header, th0, sizeof (t0->tcp_header));
1674 }
1675 
1676 always_inline void
1677 tcp_node_inc_counter (vlib_main_t * vm, u32 tcp4_node, u32 tcp6_node,
1678  u8 is_ip4, u8 evt, u8 val)
1679 {
1680  if (PREDICT_TRUE (!val))
1681  return;
1682 
1683  if (is_ip4)
1684  vlib_node_increment_counter (vm, tcp4_node, evt, val);
1685  else
1686  vlib_node_increment_counter (vm, tcp6_node, evt, val);
1687 }
1688 
1691  vlib_frame_t * from_frame, int is_ip4)
1692 {
1693  u32 n_left_from, next_index, *from, *to_next;
1694  u32 my_thread_index = vm->thread_index, errors = 0;
1695  tcp_main_t *tm = vnet_get_tcp_main ();
1696  u8 is_fin = 0;
1697 
1698  from = vlib_frame_vector_args (from_frame);
1699  n_left_from = from_frame->n_vectors;
1700 
1701  next_index = node->cached_next_index;
1702 
1703  while (n_left_from > 0)
1704  {
1705  u32 n_left_to_next;
1706 
1707  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1708  while (n_left_from > 0 && n_left_to_next > 0)
1709  {
1710  u32 bi0;
1711  vlib_buffer_t *b0;
1712  tcp_header_t *th0 = 0;
1713  tcp_connection_t *tc0;
1714  u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_ENQUEUED;
1715 
1716  bi0 = from[0];
1717  to_next[0] = bi0;
1718  from += 1;
1719  to_next += 1;
1720  n_left_from -= 1;
1721  n_left_to_next -= 1;
1722 
1723  b0 = vlib_get_buffer (vm, bi0);
1724  tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index,
1725  my_thread_index);
1726 
1727  if (PREDICT_FALSE (tc0 == 0))
1728  {
1729  error0 = TCP_ERROR_INVALID_CONNECTION;
1730  goto done;
1731  }
1732 
1733  th0 = tcp_buffer_hdr (b0);
1734  /* N.B. buffer is rewritten if segment is ooo. Thus, th0 becomes a
1735  * dangling reference. */
1736  is_fin = tcp_is_fin (th0);
1737 
1738  /* SYNs, FINs and data consume sequence numbers */
1739  vnet_buffer (b0)->tcp.seq_end = vnet_buffer (b0)->tcp.seq_number
1740  + tcp_is_syn (th0) + is_fin + vnet_buffer (b0)->tcp.data_len;
1741 
1742  /* TODO header prediction fast path */
1743 
1744  /* 1-4: check SEQ, RST, SYN */
1745  if (PREDICT_FALSE (tcp_segment_validate (vm, tc0, b0, th0, &next0)))
1746  {
1747  error0 = TCP_ERROR_SEGMENT_INVALID;
1748  TCP_EVT_DBG (TCP_EVT_SEG_INVALID, tc0,
1749  vnet_buffer (b0)->tcp.seq_number,
1750  vnet_buffer (b0)->tcp.seq_end);
1751  goto done;
1752  }
1753 
1754  /* 5: check the ACK field */
1755  if (tcp_rcv_ack (tc0, b0, th0, &next0, &error0))
1756  goto done;
1757 
1758  /* 6: check the URG bit TODO */
1759 
1760  /* 7: process the segment text */
1761  if (vnet_buffer (b0)->tcp.data_len)
1762  error0 = tcp_segment_rcv (tm, tc0, b0, &next0);
1763 
1764  /* 8: check the FIN bit */
1765  if (PREDICT_FALSE (is_fin))
1766  {
1767  /* Enter CLOSE-WAIT and notify session. To avoid lingering
1768  * in CLOSE-WAIT, set timer (reuse WAITCLOSE). */
1769  /* Account for the FIN if nothing else was received */
1770  if (vnet_buffer (b0)->tcp.data_len == 0)
1771  tc0->rcv_nxt += 1;
1772  tcp_make_ack (tc0, b0);
1773  next0 = tcp_next_output (tc0->c_is_ip4);
1774  tc0->state = TCP_STATE_CLOSE_WAIT;
1775  stream_session_disconnect_notify (&tc0->connection);
1776  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
1777  TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc0);
1778  }
1779 
1780  done:
1781  b0->error = node->errors[error0];
1783  {
1784  tcp_rx_trace_t *t0 =
1785  vlib_add_trace (vm, node, b0, sizeof (*t0));
1786  tcp_set_rx_trace_data (t0, tc0, th0, b0, is_ip4);
1787  }
1788 
1789  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1790  n_left_to_next, bi0, next0);
1791  }
1792 
1793  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1794  }
1795 
1797  my_thread_index);
1798  tcp_node_inc_counter (vm, is_ip4, tcp4_established_node.index,
1799  tcp6_established_node.index,
1800  TCP_ERROR_EVENT_FIFO_FULL, errors);
1801  tcp_flush_frame_to_output (vm, my_thread_index, is_ip4);
1802 
1803  return from_frame->n_vectors;
1804 }
1805 
1806 static uword
1808  vlib_frame_t * from_frame)
1809 {
1810  return tcp46_established_inline (vm, node, from_frame, 1 /* is_ip4 */ );
1811 }
1812 
1813 static uword
1815  vlib_frame_t * from_frame)
1816 {
1817  return tcp46_established_inline (vm, node, from_frame, 0 /* is_ip4 */ );
1818 }
1819 
1820 /* *INDENT-OFF* */
1822 {
1823  .function = tcp4_established,
1824  .name = "tcp4-established",
1825  /* Takes a vector of packets. */
1826  .vector_size = sizeof (u32),
1827  .n_errors = TCP_N_ERROR,
1828  .error_strings = tcp_error_strings,
1829  .n_next_nodes = TCP_ESTABLISHED_N_NEXT,
1830  .next_nodes =
1831  {
1832 #define _(s,n) [TCP_ESTABLISHED_NEXT_##s] = n,
1834 #undef _
1835  },
1836  .format_trace = format_tcp_rx_trace_short,
1837 };
1838 /* *INDENT-ON* */
1839 
1841 
1842 /* *INDENT-OFF* */
1844 {
1845  .function = tcp6_established,
1846  .name = "tcp6-established",
1847  /* Takes a vector of packets. */
1848  .vector_size = sizeof (u32),
1849  .n_errors = TCP_N_ERROR,
1850  .error_strings = tcp_error_strings,
1851  .n_next_nodes = TCP_ESTABLISHED_N_NEXT,
1852  .next_nodes =
1853  {
1854 #define _(s,n) [TCP_ESTABLISHED_NEXT_##s] = n,
1856 #undef _
1857  },
1858  .format_trace = format_tcp_rx_trace_short,
1859 };
1860 /* *INDENT-ON* */
1861 
1862 
1864 
1867 
1868 static u8
1870 {
1871  transport_connection_t *tmp = 0;
1872  u64 handle;
1873 
1874  if (!tc)
1875  return 1;
1876 
1877  /* Proxy case */
1878  if (tc->c_lcl_port == 0 && tc->state == TCP_STATE_LISTEN)
1879  return 1;
1880 
1881  u8 is_valid = (tc->c_lcl_port == hdr->dst_port
1882  && (tc->state == TCP_STATE_LISTEN
1883  || tc->c_rmt_port == hdr->src_port));
1884 
1885  if (!is_valid)
1886  {
1887  handle = session_lookup_half_open_handle (&tc->connection);
1888  tmp = session_lookup_half_open_connection (handle & 0xFFFFFFFF,
1889  tc->c_proto, tc->c_is_ip4);
1890 
1891  if (tmp)
1892  {
1893  if (tmp->lcl_port == hdr->dst_port
1894  && tmp->rmt_port == hdr->src_port)
1895  {
1896  TCP_DBG ("half-open is valid!");
1897  }
1898  }
1899  }
1900  return is_valid;
1901 }
1902 
1903 /**
1904  * Lookup transport connection
1905  */
1906 static tcp_connection_t *
1907 tcp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index,
1908  u8 is_ip4)
1909 {
1910  tcp_header_t *tcp;
1911  transport_connection_t *tconn;
1912  tcp_connection_t *tc;
1913  u8 is_filtered = 0;
1914  if (is_ip4)
1915  {
1916  ip4_header_t *ip4;
1917  ip4 = vlib_buffer_get_current (b);
1918  tcp = ip4_next_header (ip4);
1919  tconn = session_lookup_connection_wt4 (fib_index,
1920  &ip4->dst_address,
1921  &ip4->src_address,
1922  tcp->dst_port,
1923  tcp->src_port,
1925  thread_index, &is_filtered);
1926  tc = tcp_get_connection_from_transport (tconn);
1927  ASSERT (tcp_lookup_is_valid (tc, tcp));
1928  }
1929  else
1930  {
1931  ip6_header_t *ip6;
1932  ip6 = vlib_buffer_get_current (b);
1933  tcp = ip6_next_header (ip6);
1934  tconn = session_lookup_connection_wt6 (fib_index,
1935  &ip6->dst_address,
1936  &ip6->src_address,
1937  tcp->dst_port,
1938  tcp->src_port,
1940  thread_index, &is_filtered);
1941  tc = tcp_get_connection_from_transport (tconn);
1942  ASSERT (tcp_lookup_is_valid (tc, tcp));
1943  }
1944  return tc;
1945 }
1946 
1949  vlib_frame_t * from_frame, int is_ip4)
1950 {
1951  tcp_main_t *tm = vnet_get_tcp_main ();
1952  u32 n_left_from, next_index, *from, *to_next;
1953  u32 my_thread_index = vm->thread_index, errors = 0;
1954 
1955  from = vlib_frame_vector_args (from_frame);
1956  n_left_from = from_frame->n_vectors;
1957 
1958  next_index = node->cached_next_index;
1959 
1960  while (n_left_from > 0)
1961  {
1962  u32 n_left_to_next;
1963 
1964  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1965 
1966  while (n_left_from > 0 && n_left_to_next > 0)
1967  {
1968  u32 bi0, ack0, seq0;
1969  vlib_buffer_t *b0;
1970  tcp_rx_trace_t *t0;
1971  tcp_header_t *tcp0 = 0;
1972  tcp_connection_t *tc0;
1973  tcp_connection_t *new_tc0;
1974  u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_ENQUEUED;
1975 
1976  bi0 = from[0];
1977  to_next[0] = bi0;
1978  from += 1;
1979  to_next += 1;
1980  n_left_from -= 1;
1981  n_left_to_next -= 1;
1982 
1983  b0 = vlib_get_buffer (vm, bi0);
1984  tc0 =
1986  tcp.connection_index);
1987  if (PREDICT_FALSE (tc0 == 0))
1988  {
1989  error0 = TCP_ERROR_INVALID_CONNECTION;
1990  goto drop;
1991  }
1992 
1993  /* Half-open completed recently but the connection was't removed
1994  * yet by the owning thread */
1995  if (PREDICT_FALSE (tc0->flags & TCP_CONN_HALF_OPEN_DONE))
1996  {
1997  /* Make sure the connection actually exists */
1998  ASSERT (tcp_lookup_connection (tc0->c_fib_index, b0,
1999  my_thread_index, is_ip4));
2000  goto drop;
2001  }
2002 
2003  ack0 = vnet_buffer (b0)->tcp.ack_number;
2004  seq0 = vnet_buffer (b0)->tcp.seq_number;
2005  tcp0 = tcp_buffer_hdr (b0);
2006 
2007  /* Crude check to see if the connection handle does not match
2008  * the packet. Probably connection just switched to established */
2009  if (PREDICT_FALSE (tcp0->dst_port != tc0->c_lcl_port
2010  || tcp0->src_port != tc0->c_rmt_port))
2011  goto drop;
2012 
2013  if (PREDICT_FALSE
2014  (!tcp_ack (tcp0) && !tcp_rst (tcp0) && !tcp_syn (tcp0)))
2015  goto drop;
2016 
2017  /* SYNs, FINs and data consume sequence numbers */
2018  vnet_buffer (b0)->tcp.seq_end = seq0 + tcp_is_syn (tcp0)
2019  + tcp_is_fin (tcp0) + vnet_buffer (b0)->tcp.data_len;
2020 
2021  /*
2022  * 1. check the ACK bit
2023  */
2024 
2025  /*
2026  * If the ACK bit is set
2027  * If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send a reset (unless
2028  * the RST bit is set, if so drop the segment and return)
2029  * <SEQ=SEG.ACK><CTL=RST>
2030  * and discard the segment. Return.
2031  * If SND.UNA =< SEG.ACK =< SND.NXT then the ACK is acceptable.
2032  */
2033  if (tcp_ack (tcp0))
2034  {
2035  if (seq_leq (ack0, tc0->iss) || seq_gt (ack0, tc0->snd_nxt))
2036  {
2037  clib_warning ("ack not in rcv wnd");
2038  if (!tcp_rst (tcp0))
2039  tcp_send_reset_w_pkt (tc0, b0, is_ip4);
2040  goto drop;
2041  }
2042 
2043  /* Make sure ACK is valid */
2044  if (seq_gt (tc0->snd_una, ack0))
2045  {
2046  clib_warning ("ack invalid");
2047  goto drop;
2048  }
2049  }
2050 
2051  /*
2052  * 2. check the RST bit
2053  */
2054 
2055  if (tcp_rst (tcp0))
2056  {
2057  /* If ACK is acceptable, signal client that peer is not
2058  * willing to accept connection and drop connection*/
2059  if (tcp_ack (tcp0))
2060  tcp_connection_reset (tc0);
2061  goto drop;
2062  }
2063 
2064  /*
2065  * 3. check the security and precedence (skipped)
2066  */
2067 
2068  /*
2069  * 4. check the SYN bit
2070  */
2071 
2072  /* No SYN flag. Drop. */
2073  if (!tcp_syn (tcp0))
2074  {
2075  clib_warning ("not synack");
2076  goto drop;
2077  }
2078 
2079  /* Parse options */
2080  if (tcp_options_parse (tcp0, &tc0->rcv_opts))
2081  {
2082  clib_warning ("options parse fail");
2083  goto drop;
2084  }
2085 
2086  /* Valid SYN or SYN-ACK. Move connection from half-open pool to
2087  * current thread pool. */
2088  pool_get (tm->connections[my_thread_index], new_tc0);
2089  clib_memcpy (new_tc0, tc0, sizeof (*new_tc0));
2090  new_tc0->c_c_index = new_tc0 - tm->connections[my_thread_index];
2091  new_tc0->c_thread_index = my_thread_index;
2092  new_tc0->rcv_nxt = vnet_buffer (b0)->tcp.seq_end;
2093  new_tc0->irs = seq0;
2094  new_tc0->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
2095  new_tc0->timers[TCP_TIMER_RETRANSMIT_SYN] =
2097 
2098  /* If this is not the owning thread, wait for syn retransmit to
2099  * expire and cleanup then */
2101  tc0->flags |= TCP_CONN_HALF_OPEN_DONE;
2102 
2103  if (tcp_opts_tstamp (&new_tc0->rcv_opts))
2104  {
2105  new_tc0->tsval_recent = new_tc0->rcv_opts.tsval;
2106  new_tc0->tsval_recent_age = tcp_time_now ();
2107  }
2108 
2109  if (tcp_opts_wscale (&new_tc0->rcv_opts))
2110  new_tc0->snd_wscale = new_tc0->rcv_opts.wscale;
2111 
2112  /* RFC1323: SYN and SYN-ACK wnd not scaled */
2113  new_tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window);
2114  new_tc0->snd_wl1 = seq0;
2115  new_tc0->snd_wl2 = ack0;
2116 
2117  tcp_connection_init_vars (new_tc0);
2118 
2119  /* SYN-ACK: See if we can switch to ESTABLISHED state */
2120  if (PREDICT_TRUE (tcp_ack (tcp0)))
2121  {
2122  /* Our SYN is ACKed: we have iss < ack = snd_una */
2123 
2124  /* TODO Dequeue acknowledged segments if we support Fast Open */
2125  new_tc0->snd_una = ack0;
2126  new_tc0->state = TCP_STATE_ESTABLISHED;
2127 
2128  /* Make sure las is initialized for the wnd computation */
2129  new_tc0->rcv_las = new_tc0->rcv_nxt;
2130 
2131  /* Notify app that we have connection. If session layer can't
2132  * allocate session send reset */
2133  if (session_stream_connect_notify (&new_tc0->connection, 0))
2134  {
2135  clib_warning ("connect notify fail");
2136  tcp_send_reset_w_pkt (new_tc0, b0, is_ip4);
2137  tcp_connection_cleanup (new_tc0);
2138  goto drop;
2139  }
2140 
2141  /* Make sure after data segment processing ACK is sent */
2142  new_tc0->flags |= TCP_CONN_SNDACK;
2143 
2144  /* Update rtt with the syn-ack sample */
2145  tcp_update_rtt (new_tc0, vnet_buffer (b0)->tcp.ack_number);
2146  TCP_EVT_DBG (TCP_EVT_SYNACK_RCVD, new_tc0);
2147  }
2148  /* SYN: Simultaneous open. Change state to SYN-RCVD and send SYN-ACK */
2149  else
2150  {
2151  new_tc0->state = TCP_STATE_SYN_RCVD;
2152 
2153  /* Notify app that we have connection */
2154  if (session_stream_connect_notify (&new_tc0->connection, 0))
2155  {
2156  tcp_connection_cleanup (new_tc0);
2157  tcp_send_reset_w_pkt (tc0, b0, is_ip4);
2158  TCP_EVT_DBG (TCP_EVT_RST_SENT, tc0);
2159  goto drop;
2160  }
2161 
2162  tc0->rtt_ts = 0;
2163  tcp_init_snd_vars (tc0);
2164  tcp_make_synack (new_tc0, b0);
2165  next0 = tcp_next_output (is_ip4);
2166 
2167  goto drop;
2168  }
2169 
2170  /* Read data, if any */
2171  if (PREDICT_FALSE (vnet_buffer (b0)->tcp.data_len))
2172  {
2173  ASSERT (0);
2174  error0 = tcp_segment_rcv (tm, new_tc0, b0, &next0);
2175  if (error0 == TCP_ERROR_PURE_ACK)
2176  error0 = TCP_ERROR_SYN_ACKS_RCVD;
2177  }
2178  else
2179  {
2180  tcp_make_ack (new_tc0, b0);
2181  next0 = tcp_next_output (new_tc0->c_is_ip4);
2182  }
2183 
2184  drop:
2185 
2186  b0->error = error0 ? node->errors[error0] : 0;
2187  if (PREDICT_FALSE
2188  ((b0->flags & VLIB_BUFFER_IS_TRACED) && tcp0 != 0))
2189  {
2190  t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2191  clib_memcpy (&t0->tcp_header, tcp0, sizeof (t0->tcp_header));
2192  clib_memcpy (&t0->tcp_connection, tc0,
2193  sizeof (t0->tcp_connection));
2194  }
2195 
2196  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2197  n_left_to_next, bi0, next0);
2198  }
2199 
2200  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2201  }
2202 
2204  my_thread_index);
2205  tcp_node_inc_counter (vm, is_ip4, tcp4_syn_sent_node.index,
2206  tcp6_syn_sent_node.index,
2207  TCP_ERROR_EVENT_FIFO_FULL, errors);
2208  return from_frame->n_vectors;
2209 }
2210 
2211 static uword
2213  vlib_frame_t * from_frame)
2214 {
2215  return tcp46_syn_sent_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2216 }
2217 
2218 static uword
2220  vlib_frame_t * from_frame)
2221 {
2222  return tcp46_syn_sent_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2223 }
2224 
2225 /* *INDENT-OFF* */
2227 {
2228  .function = tcp4_syn_sent,
2229  .name = "tcp4-syn-sent",
2230  /* Takes a vector of packets. */
2231  .vector_size = sizeof (u32),
2232  .n_errors = TCP_N_ERROR,
2233  .error_strings = tcp_error_strings,
2234  .n_next_nodes = TCP_SYN_SENT_N_NEXT,
2235  .next_nodes =
2236  {
2237 #define _(s,n) [TCP_SYN_SENT_NEXT_##s] = n,
2239 #undef _
2240  },
2241  .format_trace = format_tcp_rx_trace_short,
2242 };
2243 /* *INDENT-ON* */
2244 
2246 
2247 /* *INDENT-OFF* */
2249 {
2250  .function = tcp6_syn_sent_rcv,
2251  .name = "tcp6-syn-sent",
2252  /* Takes a vector of packets. */
2253  .vector_size = sizeof (u32),
2254  .n_errors = TCP_N_ERROR,
2255  .error_strings = tcp_error_strings,
2256  .n_next_nodes = TCP_SYN_SENT_N_NEXT,
2257  .next_nodes =
2258  {
2259 #define _(s,n) [TCP_SYN_SENT_NEXT_##s] = n,
2261 #undef _
2262  },
2263  .format_trace = format_tcp_rx_trace_short,
2264 };
2265 /* *INDENT-ON* */
2266 
2268 
2271 
2272 /**
2273  * Handles reception for all states except LISTEN, SYN-SENT and ESTABLISHED
2274  * as per RFC793 p. 64
2275  */
2278  vlib_frame_t * from_frame, int is_ip4)
2279 {
2280  tcp_main_t *tm = vnet_get_tcp_main ();
2281  u32 n_left_from, next_index, *from, *to_next;
2282  u32 my_thread_index = vm->thread_index, errors = 0;
2283 
2284  from = vlib_frame_vector_args (from_frame);
2285  n_left_from = from_frame->n_vectors;
2286 
2287  next_index = node->cached_next_index;
2288 
2289  while (n_left_from > 0)
2290  {
2291  u32 n_left_to_next;
2292 
2293  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2294 
2295  while (n_left_from > 0 && n_left_to_next > 0)
2296  {
2297  u32 bi0;
2298  vlib_buffer_t *b0;
2299  tcp_header_t *tcp0 = 0;
2300  tcp_connection_t *tc0;
2301  u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_ENQUEUED;
2302  u8 is_fin0;
2303 
2304  bi0 = from[0];
2305  to_next[0] = bi0;
2306  from += 1;
2307  to_next += 1;
2308  n_left_from -= 1;
2309  n_left_to_next -= 1;
2310 
2311  b0 = vlib_get_buffer (vm, bi0);
2312  tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index,
2313  my_thread_index);
2314  if (PREDICT_FALSE (tc0 == 0))
2315  {
2316  error0 = TCP_ERROR_INVALID_CONNECTION;
2317  goto drop;
2318  }
2319 
2320  tcp0 = tcp_buffer_hdr (b0);
2321  is_fin0 = tcp_is_fin (tcp0);
2322 
2323  /* SYNs, FINs and data consume sequence numbers */
2324  vnet_buffer (b0)->tcp.seq_end = vnet_buffer (b0)->tcp.seq_number
2325  + tcp_is_syn (tcp0) + is_fin0 + vnet_buffer (b0)->tcp.data_len;
2326 
2327  if (CLIB_DEBUG)
2328  {
2329  tcp_connection_t *tmp;
2330  tmp =
2331  tcp_lookup_connection (tc0->c_fib_index, b0, my_thread_index,
2332  is_ip4);
2333  if (tmp->state != tc0->state)
2334  {
2335  clib_warning ("state changed");
2336  ASSERT (0);
2337  goto drop;
2338  }
2339  }
2340 
2341  /*
2342  * Special treatment for CLOSED
2343  */
2344  switch (tc0->state)
2345  {
2346  case TCP_STATE_CLOSED:
2347  goto drop;
2348  break;
2349  }
2350 
2351  /*
2352  * For all other states (except LISTEN)
2353  */
2354 
2355  /* 1-4: check SEQ, RST, SYN */
2356  if (PREDICT_FALSE (tcp_segment_validate (vm, tc0, b0, tcp0,
2357  &next0)))
2358  {
2359  error0 = TCP_ERROR_SEGMENT_INVALID;
2360  goto drop;
2361  }
2362 
2363  /* 5: check the ACK field */
2364  switch (tc0->state)
2365  {
2366  case TCP_STATE_SYN_RCVD:
2367  /*
2368  * If the segment acknowledgment is not acceptable, form a
2369  * reset segment,
2370  * <SEQ=SEG.ACK><CTL=RST>
2371  * and send it.
2372  */
2373  if (!tcp_rcv_ack_is_acceptable (tc0, b0))
2374  {
2375  TCP_DBG ("connection not accepted");
2376  tcp_send_reset_w_pkt (tc0, b0, is_ip4);
2377  goto drop;
2378  }
2379 
2380  /* Update rtt and rto */
2381  tcp_update_rtt (tc0, vnet_buffer (b0)->tcp.ack_number);
2382 
2383  /* Switch state to ESTABLISHED */
2384  tc0->state = TCP_STATE_ESTABLISHED;
2385 
2386  /* Initialize session variables */
2387  tc0->snd_una = vnet_buffer (b0)->tcp.ack_number;
2388  tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window)
2389  << tc0->rcv_opts.wscale;
2390  tc0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number;
2391  tc0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number;
2392  stream_session_accept_notify (&tc0->connection);
2393 
2394  /* Reset SYN-ACK retransmit and SYN_RCV establish timers */
2396  tcp_timer_reset (tc0, TCP_TIMER_ESTABLISH);
2397  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2398  break;
2399  case TCP_STATE_ESTABLISHED:
2400  /* We can get packets in established state here because they
2401  * were enqueued before state change */
2402  if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
2403  goto drop;
2404 
2405  break;
2406  case TCP_STATE_FIN_WAIT_1:
2407  /* In addition to the processing for the ESTABLISHED state, if
2408  * our FIN is now acknowledged then enter FIN-WAIT-2 and
2409  * continue processing in that state. */
2410  if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
2411  goto drop;
2412 
2413  /* Still have to send the FIN */
2414  if (tc0->flags & TCP_CONN_FINPNDG)
2415  {
2416  /* TX fifo finally drained */
2417  if (!stream_session_tx_fifo_max_dequeue (&tc0->connection))
2418  tcp_send_fin (tc0);
2419  }
2420  /* If FIN is ACKed */
2421  else if (tc0->snd_una == tc0->snd_una_max)
2422  {
2423  tc0->state = TCP_STATE_FIN_WAIT_2;
2424  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2425 
2426  /* Stop all retransmit timers because we have nothing more
2427  * to send. Enable waitclose though because we're willing to
2428  * wait for peer's FIN but not indefinitely. */
2430  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
2431  }
2432  break;
2433  case TCP_STATE_FIN_WAIT_2:
2434  /* In addition to the processing for the ESTABLISHED state, if
2435  * the retransmission queue is empty, the user's CLOSE can be
2436  * acknowledged ("ok") but do not delete the TCB. */
2437  if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
2438  goto drop;
2439  break;
2440  case TCP_STATE_CLOSE_WAIT:
2441  /* Do the same processing as for the ESTABLISHED state. */
2442  if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
2443  goto drop;
2444  break;
2445  case TCP_STATE_CLOSING:
2446  /* In addition to the processing for the ESTABLISHED state, if
2447  * the ACK acknowledges our FIN then enter the TIME-WAIT state,
2448  * otherwise ignore the segment. */
2449  if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
2450  goto drop;
2451 
2452  tc0->state = TCP_STATE_TIME_WAIT;
2453  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2454  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2455  goto drop;
2456 
2457  break;
2458  case TCP_STATE_LAST_ACK:
2459  /* The only thing that [should] arrive in this state is an
2460  * acknowledgment of our FIN. If our FIN is now acknowledged,
2461  * delete the TCB, enter the CLOSED state, and return. */
2462 
2463  if (!tcp_rcv_ack_is_acceptable (tc0, b0))
2464  {
2465  error0 = TCP_ERROR_ACK_INVALID;
2466  goto drop;
2467  }
2468 
2469  tc0->snd_una = vnet_buffer (b0)->tcp.ack_number;
2470  /* Apparently our ACK for the peer's FIN was lost */
2471  if (is_fin0 && tc0->snd_una != tc0->snd_una_max)
2472  {
2473  tcp_send_fin (tc0);
2474  goto drop;
2475  }
2476 
2477  tc0->state = TCP_STATE_CLOSED;
2478  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2480 
2481  /* Don't delete the connection/session yet. Instead, wait a
2482  * reasonable amount of time until the pipes are cleared. In
2483  * particular, this makes sure that we won't have dead sessions
2484  * when processing events on the tx path */
2485  tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
2486 
2487  goto drop;
2488 
2489  break;
2490  case TCP_STATE_TIME_WAIT:
2491  /* The only thing that can arrive in this state is a
2492  * retransmission of the remote FIN. Acknowledge it, and restart
2493  * the 2 MSL timeout. */
2494 
2495  if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
2496  goto drop;
2497 
2498  tcp_make_ack (tc0, b0);
2499  next0 = tcp_next_output (is_ip4);
2500  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2501 
2502  goto drop;
2503 
2504  break;
2505  default:
2506  ASSERT (0);
2507  }
2508 
2509  /* 6: check the URG bit TODO */
2510 
2511  /* 7: process the segment text */
2512  switch (tc0->state)
2513  {
2514  case TCP_STATE_ESTABLISHED:
2515  case TCP_STATE_FIN_WAIT_1:
2516  case TCP_STATE_FIN_WAIT_2:
2517  if (vnet_buffer (b0)->tcp.data_len)
2518  error0 = tcp_segment_rcv (tm, tc0, b0, &next0);
2519  else if (is_fin0)
2520  tc0->rcv_nxt += 1;
2521  break;
2522  case TCP_STATE_CLOSE_WAIT:
2523  case TCP_STATE_CLOSING:
2524  case TCP_STATE_LAST_ACK:
2525  case TCP_STATE_TIME_WAIT:
2526  /* This should not occur, since a FIN has been received from the
2527  * remote side. Ignore the segment text. */
2528  break;
2529  }
2530 
2531  /* 8: check the FIN bit */
2532  if (!is_fin0)
2533  goto drop;
2534 
2535  switch (tc0->state)
2536  {
2537  case TCP_STATE_ESTABLISHED:
2538  case TCP_STATE_SYN_RCVD:
2539  /* Send FIN-ACK notify app and enter CLOSE-WAIT */
2541  tcp_make_fin (tc0, b0);
2542  tc0->snd_nxt += 1;
2543  next0 = tcp_next_output (tc0->c_is_ip4);
2544  stream_session_disconnect_notify (&tc0->connection);
2545  tc0->state = TCP_STATE_CLOSE_WAIT;
2546  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2547  break;
2548  case TCP_STATE_CLOSE_WAIT:
2549  case TCP_STATE_CLOSING:
2550  case TCP_STATE_LAST_ACK:
2551  /* move along .. */
2552  break;
2553  case TCP_STATE_FIN_WAIT_1:
2554  tc0->state = TCP_STATE_CLOSING;
2555  tcp_make_ack (tc0, b0);
2556  next0 = tcp_next_output (is_ip4);
2557  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2558  /* Wait for ACK but not forever */
2559  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
2560  break;
2561  case TCP_STATE_FIN_WAIT_2:
2562  /* Got FIN, send ACK! Be more aggressive with resource cleanup */
2563  tc0->state = TCP_STATE_TIME_WAIT;
2565  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2566  tcp_make_ack (tc0, b0);
2567  next0 = tcp_next_output (is_ip4);
2568  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
2569  break;
2570  case TCP_STATE_TIME_WAIT:
2571  /* Remain in the TIME-WAIT state. Restart the time-wait
2572  * timeout.
2573  */
2574  tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
2575  break;
2576  }
2577  TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc0);
2578 
2579  drop:
2580  b0->error = error0 ? node->errors[error0] : 0;
2581 
2583  {
2584  tcp_rx_trace_t *t0 =
2585  vlib_add_trace (vm, node, b0, sizeof (*t0));
2586  tcp_set_rx_trace_data (t0, tc0, tcp0, b0, is_ip4);
2587  }
2588 
2589  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2590  n_left_to_next, bi0, next0);
2591  }
2592 
2593  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2594  }
2595 
2597  my_thread_index);
2598  tcp_node_inc_counter (vm, is_ip4, tcp4_rcv_process_node.index,
2599  tcp6_rcv_process_node.index,
2600  TCP_ERROR_EVENT_FIFO_FULL, errors);
2601 
2602  return from_frame->n_vectors;
2603 }
2604 
2605 static uword
2607  vlib_frame_t * from_frame)
2608 {
2609  return tcp46_rcv_process_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2610 }
2611 
2612 static uword
2614  vlib_frame_t * from_frame)
2615 {
2616  return tcp46_rcv_process_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2617 }
2618 
2619 /* *INDENT-OFF* */
2621 {
2622  .function = tcp4_rcv_process,
2623  .name = "tcp4-rcv-process",
2624  /* Takes a vector of packets. */
2625  .vector_size = sizeof (u32),
2626  .n_errors = TCP_N_ERROR,
2627  .error_strings = tcp_error_strings,
2628  .n_next_nodes = TCP_RCV_PROCESS_N_NEXT,
2629  .next_nodes =
2630  {
2631 #define _(s,n) [TCP_RCV_PROCESS_NEXT_##s] = n,
2633 #undef _
2634  },
2635  .format_trace = format_tcp_rx_trace_short,
2636 };
2637 /* *INDENT-ON* */
2638 
2640 
2641 /* *INDENT-OFF* */
2643 {
2644  .function = tcp6_rcv_process,
2645  .name = "tcp6-rcv-process",
2646  /* Takes a vector of packets. */
2647  .vector_size = sizeof (u32),
2648  .n_errors = TCP_N_ERROR,
2649  .error_strings = tcp_error_strings,
2650  .n_next_nodes = TCP_RCV_PROCESS_N_NEXT,
2651  .next_nodes =
2652  {
2653 #define _(s,n) [TCP_RCV_PROCESS_NEXT_##s] = n,
2655 #undef _
2656  },
2657  .format_trace = format_tcp_rx_trace_short,
2658 };
2659 /* *INDENT-ON* */
2660 
2662 
2665 
2666 /**
2667  * LISTEN state processing as per RFC 793 p. 65
2668  */
2671  vlib_frame_t * from_frame, int is_ip4)
2672 {
2673  u32 n_left_from, next_index, *from, *to_next;
2674  u32 my_thread_index = vm->thread_index;
2675 
2676  from = vlib_frame_vector_args (from_frame);
2677  n_left_from = from_frame->n_vectors;
2678 
2679  next_index = node->cached_next_index;
2680 
2681  while (n_left_from > 0)
2682  {
2683  u32 n_left_to_next;
2684 
2685  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2686 
2687  while (n_left_from > 0 && n_left_to_next > 0)
2688  {
2689  u32 bi0;
2690  vlib_buffer_t *b0;
2691  tcp_rx_trace_t *t0;
2692  tcp_header_t *th0 = 0;
2693  tcp_connection_t *lc0;
2694  ip4_header_t *ip40;
2695  ip6_header_t *ip60;
2696  tcp_connection_t *child0;
2697  u32 error0 = TCP_ERROR_SYNS_RCVD, next0 = tcp_next_drop (is_ip4);
2698 
2699  bi0 = from[0];
2700  to_next[0] = bi0;
2701  from += 1;
2702  to_next += 1;
2703  n_left_from -= 1;
2704  n_left_to_next -= 1;
2705 
2706  b0 = vlib_get_buffer (vm, bi0);
2707  lc0 = tcp_listener_get (vnet_buffer (b0)->tcp.connection_index);
2708 
2709  if (is_ip4)
2710  {
2711  ip40 = vlib_buffer_get_current (b0);
2712  th0 = ip4_next_header (ip40);
2713  }
2714  else
2715  {
2716  ip60 = vlib_buffer_get_current (b0);
2717  th0 = ip6_next_header (ip60);
2718  }
2719 
2720  /* Create child session. For syn-flood protection use filter */
2721 
2722  /* 1. first check for an RST: handled in dispatch */
2723  /* if (tcp_rst (th0))
2724  goto drop; */
2725 
2726  /* 2. second check for an ACK: handled in dispatch */
2727  /* if (tcp_ack (th0))
2728  {
2729  tcp_send_reset (b0, is_ip4);
2730  goto drop;
2731  } */
2732 
2733  /* 3. check for a SYN (did that already) */
2734 
2735  /* Make sure connection wasn't just created */
2736  child0 =
2737  tcp_lookup_connection (lc0->c_fib_index, b0, my_thread_index,
2738  is_ip4);
2739  if (PREDICT_FALSE (child0->state != TCP_STATE_LISTEN))
2740  {
2741  error0 = TCP_ERROR_CREATE_EXISTS;
2742  goto drop;
2743  }
2744 
2745  /* Create child session and send SYN-ACK */
2746  child0 = tcp_connection_new (my_thread_index);
2747  child0->c_lcl_port = th0->dst_port;
2748  child0->c_rmt_port = th0->src_port;
2749  child0->c_is_ip4 = is_ip4;
2750  child0->state = TCP_STATE_SYN_RCVD;
2751 
2752  if (is_ip4)
2753  {
2754  child0->c_lcl_ip4.as_u32 = ip40->dst_address.as_u32;
2755  child0->c_rmt_ip4.as_u32 = ip40->src_address.as_u32;
2756  }
2757  else
2758  {
2759  clib_memcpy (&child0->c_lcl_ip6, &ip60->dst_address,
2760  sizeof (ip6_address_t));
2761  clib_memcpy (&child0->c_rmt_ip6, &ip60->src_address,
2762  sizeof (ip6_address_t));
2763  }
2764 
2765  if (tcp_options_parse (th0, &child0->rcv_opts))
2766  {
2767  clib_warning ("options parse fail");
2768  goto drop;
2769  }
2770 
2771  child0->irs = vnet_buffer (b0)->tcp.seq_number;
2772  child0->rcv_nxt = vnet_buffer (b0)->tcp.seq_number + 1;
2773  child0->rcv_las = child0->rcv_nxt;
2774 
2775  /* RFC1323: TSval timestamps sent on {SYN} and {SYN,ACK}
2776  * segments are used to initialize PAWS. */
2777  if (tcp_opts_tstamp (&child0->rcv_opts))
2778  {
2779  child0->tsval_recent = child0->rcv_opts.tsval;
2780  child0->tsval_recent_age = tcp_time_now ();
2781  }
2782 
2783  if (tcp_opts_wscale (&child0->rcv_opts))
2784  child0->snd_wscale = child0->rcv_opts.wscale;
2785 
2786  child0->snd_wnd = clib_net_to_host_u16 (th0->window)
2787  << child0->snd_wscale;
2788  child0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number;
2789  child0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number;
2790 
2791  tcp_connection_init_vars (child0);
2792  TCP_EVT_DBG (TCP_EVT_SYN_RCVD, child0, 1);
2793 
2794  if (stream_session_accept (&child0->connection, lc0->c_s_index,
2795  0 /* notify */ ))
2796  {
2797  clib_warning ("session accept fail");
2798  tcp_connection_cleanup (child0);
2799  error0 = TCP_ERROR_CREATE_SESSION_FAIL;
2800  goto drop;
2801  }
2802 
2803  /* Reuse buffer to make syn-ack and send */
2804  tcp_make_synack (child0, b0);
2805  next0 = tcp_next_output (is_ip4);
2806  tcp_timer_set (child0, TCP_TIMER_ESTABLISH, TCP_SYN_RCVD_TIME);
2807 
2808  drop:
2810  {
2811  t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
2812  clib_memcpy (&t0->tcp_header, th0, sizeof (t0->tcp_header));
2813  clib_memcpy (&t0->tcp_connection, lc0,
2814  sizeof (t0->tcp_connection));
2815  }
2816 
2817  b0->error = node->errors[error0];
2818 
2819  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2820  n_left_to_next, bi0, next0);
2821  }
2822 
2823  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2824  }
2825  return from_frame->n_vectors;
2826 }
2827 
2828 static uword
2830  vlib_frame_t * from_frame)
2831 {
2832  return tcp46_listen_inline (vm, node, from_frame, 1 /* is_ip4 */ );
2833 }
2834 
2835 static uword
2837  vlib_frame_t * from_frame)
2838 {
2839  return tcp46_listen_inline (vm, node, from_frame, 0 /* is_ip4 */ );
2840 }
2841 
2842 /* *INDENT-OFF* */
2844 {
2845  .function = tcp4_listen,
2846  .name = "tcp4-listen",
2847  /* Takes a vector of packets. */
2848  .vector_size = sizeof (u32),
2849  .n_errors = TCP_N_ERROR,
2850  .error_strings = tcp_error_strings,
2851  .n_next_nodes = TCP_LISTEN_N_NEXT,
2852  .next_nodes =
2853  {
2854 #define _(s,n) [TCP_LISTEN_NEXT_##s] = n,
2856 #undef _
2857  },
2858  .format_trace = format_tcp_rx_trace_short,
2859 };
2860 /* *INDENT-ON* */
2861 
2863 
2864 /* *INDENT-OFF* */
2866 {
2867  .function = tcp6_listen,
2868  .name = "tcp6-listen",
2869  /* Takes a vector of packets. */
2870  .vector_size = sizeof (u32),
2871  .n_errors = TCP_N_ERROR,
2872  .error_strings = tcp_error_strings,
2873  .n_next_nodes = TCP_LISTEN_N_NEXT,
2874  .next_nodes =
2875  {
2876 #define _(s,n) [TCP_LISTEN_NEXT_##s] = n,
2878 #undef _
2879  },
2880  .format_trace = format_tcp_rx_trace_short,
2881 };
2882 /* *INDENT-ON* */
2883 
2885 
2888 
2889 typedef enum _tcp_input_next
2890 {
2900 
2901 #define foreach_tcp4_input_next \
2902  _ (DROP, "ip4-drop") \
2903  _ (LISTEN, "tcp4-listen") \
2904  _ (RCV_PROCESS, "tcp4-rcv-process") \
2905  _ (SYN_SENT, "tcp4-syn-sent") \
2906  _ (ESTABLISHED, "tcp4-established") \
2907  _ (RESET, "tcp4-reset") \
2908  _ (PUNT, "ip4-punt")
2909 
2910 #define foreach_tcp6_input_next \
2911  _ (DROP, "ip6-drop") \
2912  _ (LISTEN, "tcp6-listen") \
2913  _ (RCV_PROCESS, "tcp6-rcv-process") \
2914  _ (SYN_SENT, "tcp6-syn-sent") \
2915  _ (ESTABLISHED, "tcp6-established") \
2916  _ (RESET, "tcp6-reset") \
2917  _ (PUNT, "ip6-punt")
2918 
2919 #define filter_flags (TCP_FLAG_SYN|TCP_FLAG_ACK|TCP_FLAG_RST|TCP_FLAG_FIN)
2920 
2923  vlib_frame_t * from_frame, int is_ip4)
2924 {
2925  u32 n_left_from, next_index, *from, *to_next;
2926  u32 my_thread_index = vm->thread_index;
2927  tcp_main_t *tm = vnet_get_tcp_main ();
2928 
2929  from = vlib_frame_vector_args (from_frame);
2930  n_left_from = from_frame->n_vectors;
2931  next_index = node->cached_next_index;
2932  tcp_set_time_now (my_thread_index);
2933 
2934  while (n_left_from > 0)
2935  {
2936  u32 n_left_to_next;
2937 
2938  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2939 
2940  while (n_left_from > 0 && n_left_to_next > 0)
2941  {
2942  int n_advance_bytes0, n_data_bytes0;
2943  u32 bi0, fib_index0;
2944  vlib_buffer_t *b0;
2945  tcp_header_t *tcp0 = 0;
2946  tcp_connection_t *tc0;
2947  transport_connection_t *tconn;
2948  ip4_header_t *ip40;
2949  ip6_header_t *ip60;
2950  u32 error0 = TCP_ERROR_NO_LISTENER, next0 = TCP_INPUT_NEXT_DROP;
2951  u8 flags0, is_filtered = 0;
2952 
2953  bi0 = from[0];
2954  to_next[0] = bi0;
2955  from += 1;
2956  to_next += 1;
2957  n_left_from -= 1;
2958  n_left_to_next -= 1;
2959 
2960  b0 = vlib_get_buffer (vm, bi0);
2961  vnet_buffer (b0)->tcp.flags = 0;
2962  fib_index0 = vnet_buffer (b0)->ip.fib_index;
2963 
2964  /* Checksum computed by ipx_local no need to compute again */
2965 
2966  if (is_ip4)
2967  {
2968  ip40 = vlib_buffer_get_current (b0);
2969  tcp0 = ip4_next_header (ip40);
2970  n_advance_bytes0 = (ip4_header_bytes (ip40)
2971  + tcp_header_bytes (tcp0));
2972  n_data_bytes0 = clib_net_to_host_u16 (ip40->length)
2973  - n_advance_bytes0;
2974  tconn = session_lookup_connection_wt4 (fib_index0,
2975  &ip40->dst_address,
2976  &ip40->src_address,
2977  tcp0->dst_port,
2978  tcp0->src_port,
2980  my_thread_index,
2981  &is_filtered);
2982  }
2983  else
2984  {
2985  ip60 = vlib_buffer_get_current (b0);
2986  tcp0 = ip6_next_header (ip60);
2987  n_advance_bytes0 = tcp_header_bytes (tcp0);
2988  n_data_bytes0 = clib_net_to_host_u16 (ip60->payload_length)
2989  - n_advance_bytes0;
2990  n_advance_bytes0 += sizeof (ip60[0]);
2991  tconn = session_lookup_connection_wt6 (fib_index0,
2992  &ip60->dst_address,
2993  &ip60->src_address,
2994  tcp0->dst_port,
2995  tcp0->src_port,
2997  my_thread_index,
2998  &is_filtered);
2999  }
3000 
3001  /* Length check */
3002  if (PREDICT_FALSE (n_advance_bytes0 < 0))
3003  {
3004  error0 = TCP_ERROR_LENGTH;
3005  goto done;
3006  }
3007 
3008  vnet_buffer (b0)->tcp.hdr_offset = (u8 *) tcp0
3009  - (u8 *) vlib_buffer_get_current (b0);
3010 
3011  /* Session exists */
3012  if (PREDICT_TRUE (0 != tconn))
3013  {
3014  tc0 = tcp_get_connection_from_transport (tconn);
3015  ASSERT (tcp_lookup_is_valid (tc0, tcp0));
3016 
3017  /* Save connection index */
3018  vnet_buffer (b0)->tcp.connection_index = tc0->c_c_index;
3019  vnet_buffer (b0)->tcp.seq_number =
3020  clib_net_to_host_u32 (tcp0->seq_number);
3021  vnet_buffer (b0)->tcp.ack_number =
3022  clib_net_to_host_u32 (tcp0->ack_number);
3023 
3024  vnet_buffer (b0)->tcp.data_offset = n_advance_bytes0;
3025  vnet_buffer (b0)->tcp.data_len = n_data_bytes0;
3026 
3027  flags0 = tcp0->flags & filter_flags;
3028  next0 = tm->dispatch_table[tc0->state][flags0].next;
3029  error0 = tm->dispatch_table[tc0->state][flags0].error;
3030 
3031  if (PREDICT_FALSE (error0 == TCP_ERROR_DISPATCH
3032  || next0 == TCP_INPUT_NEXT_RESET))
3033  {
3034  /* Overload tcp flags to store state */
3035  tcp_state_t state0 = tc0->state;
3036  vnet_buffer (b0)->tcp.flags = tc0->state;
3037 
3038  if (error0 == TCP_ERROR_DISPATCH)
3039  clib_warning ("disp error state %U flags %U",
3041  (int) flags0);
3042  }
3043  }
3044  else
3045  {
3046  if (is_filtered)
3047  {
3048  next0 = TCP_INPUT_NEXT_DROP;
3049  error0 = TCP_ERROR_FILTERED;
3050  }
3051  else if ((is_ip4 && tm->punt_unknown4) ||
3052  (!is_ip4 && tm->punt_unknown6))
3053  {
3054  next0 = TCP_INPUT_NEXT_PUNT;
3055  error0 = TCP_ERROR_PUNT;
3056  }
3057  else
3058  {
3059  /* Send reset */
3060  next0 = TCP_INPUT_NEXT_RESET;
3061  error0 = TCP_ERROR_NO_LISTENER;
3062  }
3063  tc0 = 0;
3064  }
3065 
3066  done:
3067  b0->error = error0 ? node->errors[error0] : 0;
3068 
3070  {
3071  tcp_rx_trace_t *t0;
3072  t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
3073  tcp_set_rx_trace_data (t0, tc0, tcp0, b0, is_ip4);
3074  }
3075  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
3076  n_left_to_next, bi0, next0);
3077  }
3078 
3079  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
3080  }
3081 
3082  return from_frame->n_vectors;
3083 }
3084 
3085 static uword
3087  vlib_frame_t * from_frame)
3088 {
3089  return tcp46_input_inline (vm, node, from_frame, 1 /* is_ip4 */ );
3090 }
3091 
3092 static uword
3094  vlib_frame_t * from_frame)
3095 {
3096  return tcp46_input_inline (vm, node, from_frame, 0 /* is_ip4 */ );
3097 }
3098 
3099 /* *INDENT-OFF* */
3101 {
3102  .function = tcp4_input,
3103  .name = "tcp4-input",
3104  /* Takes a vector of packets. */
3105  .vector_size = sizeof (u32),
3106  .n_errors = TCP_N_ERROR,
3107  .error_strings = tcp_error_strings,
3108  .n_next_nodes = TCP_INPUT_N_NEXT,
3109  .next_nodes =
3110  {
3111 #define _(s,n) [TCP_INPUT_NEXT_##s] = n,
3113 #undef _
3114  },
3115  .format_buffer = format_tcp_header,
3116  .format_trace = format_tcp_rx_trace,
3117 };
3118 /* *INDENT-ON* */
3119 
3121 
3122 /* *INDENT-OFF* */
3124 {
3125  .function = tcp6_input,
3126  .name = "tcp6-input",
3127  /* Takes a vector of packets. */
3128  .vector_size = sizeof (u32),
3129  .n_errors = TCP_N_ERROR,
3130  .error_strings = tcp_error_strings,
3131  .n_next_nodes = TCP_INPUT_N_NEXT,
3132  .next_nodes =
3133  {
3134 #define _(s,n) [TCP_INPUT_NEXT_##s] = n,
3136 #undef _
3137  },
3138  .format_buffer = format_tcp_header,
3139  .format_trace = format_tcp_rx_trace,
3140 };
3141 /* *INDENT-ON* */
3142 
3144 
3145 static void
3147 {
3148  int i, j;
3149  for (i = 0; i < ARRAY_LEN (tm->dispatch_table); i++)
3150  for (j = 0; j < ARRAY_LEN (tm->dispatch_table[i]); j++)
3151  {
3152  tm->dispatch_table[i][j].next = TCP_INPUT_NEXT_DROP;
3153  tm->dispatch_table[i][j].error = TCP_ERROR_DISPATCH;
3154  }
3155 
3156 #define _(t,f,n,e) \
3157 do { \
3158  tm->dispatch_table[TCP_STATE_##t][f].next = (n); \
3159  tm->dispatch_table[TCP_STATE_##t][f].error = (e); \
3160 } while (0)
3161 
3162  /* SYNs for new connections -> tcp-listen. */
3163  _(LISTEN, TCP_FLAG_SYN, TCP_INPUT_NEXT_LISTEN, TCP_ERROR_NONE);
3164  _(LISTEN, TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET, TCP_ERROR_NONE);
3165  _(LISTEN, TCP_FLAG_RST, TCP_INPUT_NEXT_DROP, TCP_ERROR_NONE);
3167  TCP_ERROR_NONE);
3168  /* ACK for for a SYN-ACK -> tcp-rcv-process. */
3169  _(SYN_RCVD, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3170  _(SYN_RCVD, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3171  _(SYN_RCVD, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3172  /* SYN-ACK for a SYN */
3174  TCP_ERROR_NONE);
3175  _(SYN_SENT, TCP_FLAG_ACK, TCP_INPUT_NEXT_SYN_SENT, TCP_ERROR_NONE);
3176  _(SYN_SENT, TCP_FLAG_RST, TCP_INPUT_NEXT_SYN_SENT, TCP_ERROR_NONE);
3178  TCP_ERROR_NONE);
3179  /* ACK for for established connection -> tcp-established. */
3180  _(ESTABLISHED, TCP_FLAG_ACK, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3181  /* FIN for for established connection -> tcp-established. */
3182  _(ESTABLISHED, TCP_FLAG_FIN, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3184  TCP_ERROR_NONE);
3185  _(ESTABLISHED, TCP_FLAG_RST, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3187  TCP_ERROR_NONE);
3188  _(ESTABLISHED, TCP_FLAG_SYN, TCP_INPUT_NEXT_ESTABLISHED, TCP_ERROR_NONE);
3190  TCP_ERROR_NONE);
3191  /* ACK or FIN-ACK to our FIN */
3192  _(FIN_WAIT_1, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3194  TCP_ERROR_NONE);
3195  /* FIN in reply to our FIN from the other side */
3196  _(FIN_WAIT_1, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3197  _(FIN_WAIT_1, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3198  /* FIN confirming that the peer (app) has closed */
3199  _(FIN_WAIT_2, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3200  _(FIN_WAIT_2, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3202  TCP_ERROR_NONE);
3203  _(CLOSE_WAIT, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3205  TCP_ERROR_NONE);
3206  _(LAST_ACK, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3207  _(LAST_ACK, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3209  TCP_ERROR_NONE);
3210  _(LAST_ACK, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3211  _(TIME_WAIT, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3213  TCP_ERROR_NONE);
3214  _(TIME_WAIT, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3215  _(TIME_WAIT, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
3216  _(CLOSED, TCP_FLAG_ACK, TCP_INPUT_NEXT_DROP, TCP_ERROR_CONNECTION_CLOSED);
3217  _(CLOSED, TCP_FLAG_RST, TCP_INPUT_NEXT_DROP, TCP_ERROR_CONNECTION_CLOSED);
3219  TCP_ERROR_CONNECTION_CLOSED);
3220 #undef _
3221 }
3222 
3223 clib_error_t *
3225 {
3226  clib_error_t *error = 0;
3227  tcp_main_t *tm = vnet_get_tcp_main ();
3228 
3229  if ((error = vlib_call_init_function (vm, tcp_init)))
3230  return error;
3231 
3232  /* Initialize dispatch table. */
3234 
3235  return error;
3236 }
3237 
3239 
3240 /*
3241  * fd.io coding-style-patch-verification: ON
3242  *
3243  * Local Variables:
3244  * eval: (c-set-style "gnu")
3245  * End:
3246  */
#define tcp_in_cong_recovery(tc)
Definition: tcp.h:330
static int tcp_session_enqueue_ooo(tcp_connection_t *tc, vlib_buffer_t *b, u16 data_len)
Enqueue out-of-order data.
Definition: tcp_input.c:1442
static void tcp_update_timestamp(tcp_connection_t *tc, u32 seq, u32 seq_end)
Update tsval recent.
Definition: tcp_input.c:246
static u8 tcp_should_fastrecover(tcp_connection_t *tc)
Definition: tcp_input.c:1034
#define TCP_2MSL_TIME
Definition: tcp.h:101
End of options.
Definition: tcp_packet.h:104
#define tcp_next_drop(is_ip4)
Definition: tcp_input.c:79
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define tcp_fastrecovery_1_smss_off(tc)
Definition: tcp.h:328
static int tcp_segment_rcv(tcp_main_t *tm, tcp_connection_t *tc, vlib_buffer_t *b, u32 *next0)
Definition: tcp_input.c:1544
#define clib_min(x, y)
Definition: clib.h:340
#define CLIB_UNUSED(x)
Definition: clib.h:79
static void tcp_cc_update(tcp_connection_t *tc, vlib_buffer_t *b)
Definition: tcp_input.c:1006
vlib_node_registration_t tcp6_rcv_process_node
(constructor) VLIB_REGISTER_NODE (tcp6_rcv_process_node)
Definition: tcp_input.c:2270
#define tcp_in_recovery(tc)
Definition: tcp.h:324
#define TCP_OPTION_LEN_SACK_PERMITTED
Definition: tcp_packet.h:167
static int tcp_rcv_ack_is_acceptable(tcp_connection_t *tc0, vlib_buffer_t *tb0)
Definition: tcp_input.c:379
#define seq_leq(_s1, _s2)
Definition: tcp.h:531
void tcp_make_fin(tcp_connection_t *tc, vlib_buffer_t *b)
Convert buffer to FIN-ACK.
Definition: tcp_output.c:559
struct _sack_block sack_block_t
void tcp_rcv_sacks(tcp_connection_t *tc, u32 ack)
Definition: tcp_input.c:724
#define timestamp_leq(_t1, _t2)
Definition: tcp.h:538
ip4_address_t src_address
Definition: ip4_packet.h:164
static u8 tcp_cc_is_spurious_retransmit(tcp_connection_t *tc)
Definition: tcp_input.c:976
static uword tcp46_input_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
Definition: tcp_input.c:2922
enum _tcp_state_next tcp_state_next_t
struct _transport_connection transport_connection_t
#define tcp_rst(_th)
Definition: tcp_packet.h:81
#define TCP_TIMEWAIT_TIME
Definition: tcp.h:103
static uword tcp6_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:3093
Selective Ack permitted.
Definition: tcp_packet.h:108
#define TCP_FLAG_SYN
Definition: fa_node.h:8
#define tcp_opts_tstamp(_to)
Definition: tcp_packet.h:157
#define PREDICT_TRUE(x)
Definition: clib.h:106
void tcp_fast_retransmit(tcp_connection_t *tc)
Do fast retransmit.
Definition: tcp_output.c:1730
static int tcp_segment_validate(vlib_main_t *vm, tcp_connection_t *tc0, vlib_buffer_t *b0, tcp_header_t *th0, u32 *next0)
Validate incoming segment as per RFC793 p.
Definition: tcp_input.c:274
tcp_connection_t * tcp_connection_new(u8 thread_index)
Definition: tcp.c:204
static void tcp_dispatch_table_init(tcp_main_t *tm)
Definition: tcp_input.c:3146
static int ip4_header_bytes(ip4_header_t *i)
Definition: ip4_packet.h:227
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_rto(tcp_connection_t *tc)
Definition: tcp_input.c:419
void scoreboard_update_bytes(tcp_connection_t *tc, sack_scoreboard_t *sb)
Definition: tcp_input.c:598
#define tcp_doff(_th)
Definition: tcp_packet.h:78
struct _tcp_main tcp_main_t
u32 thread_index
Definition: main.h:173
void tcp_connection_timers_reset(tcp_connection_t *tc)
Stop all connection timers.
Definition: tcp.c:354
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
#define tcp_recovery_off(tc)
Definition: tcp.h:322
#define clib_abs(x)
Definition: clib.h:347
struct _vlib_node_registration vlib_node_registration_t
static sack_scoreboard_hole_t * scoreboard_prev_hole(sack_scoreboard_t *sb, sack_scoreboard_hole_t *hole)
Definition: tcp.h:821
static int tcp_update_rtt(tcp_connection_t *tc, u32 ack)
Update RTT estimate and RTO timer.
Definition: tcp_input.c:437
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:557
static u32 format_get_indent(u8 *s)
Definition: format.h:72
vlib_node_registration_t tcp4_rcv_process_node
(constructor) VLIB_REGISTER_NODE (tcp4_rcv_process_node)
Definition: tcp_input.c:2269
struct _tcp_connection tcp_connection_t
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
#define tcp_opts_sack(_to)
Definition: tcp_packet.h:159
void tcp_fast_retransmit_sack(tcp_connection_t *tc)
Do fast retransmit with SACKs.
Definition: tcp_output.c:1616
tcp_connection_t tcp_connection
Definition: tcp_input.c:1627
static u8 tcp_sack_vector_is_sane(sack_block_t *sacks)
Definition: tcp_input.c:1304
static tcp_connection_t * tcp_get_connection_from_transport(transport_connection_t *tconn)
Definition: tcp.h:468
static void tcp_cc_congestion_undo(tcp_connection_t *tc)
Definition: tcp_input.c:962
int session_enqueue_stream_connection(transport_connection_t *tc, vlib_buffer_t *b, u32 offset, u8 queue_event, u8 is_in_order)
Definition: session.c:304
u64 session_lookup_half_open_handle(transport_connection_t *tc)
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
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:415
No operation.
Definition: tcp_packet.h:105
format_function_t format_tcp_flags
Definition: tcp.h:64
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:225
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
int tcp_half_open_connection_cleanup(tcp_connection_t *tc)
Try to cleanup half-open connection.
Definition: tcp.c:129
static uword tcp6_listen(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:2836
ip6_address_t src_address
Definition: ip6_packet.h:341
vlib_node_registration_t tcp6_syn_sent_node
(constructor) VLIB_REGISTER_NODE (tcp6_syn_sent_node)
Definition: tcp_input.c:1866
struct _sack_scoreboard_hole sack_scoreboard_hole_t
u8 wscale
Window scale advertised.
Definition: tcp_packet.h:148
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static tcp_connection_t * tcp_lookup_connection(u32 fib_index, vlib_buffer_t *b, u8 thread_index, u8 is_ip4)
Lookup transport connection.
Definition: tcp_input.c:1907
static void tcp_dequeue_acked(tcp_connection_t *tc, u32 ack)
Dequeue bytes that have been acked and while at it update RTT estimates.
Definition: tcp_input.c:481
#define tcp_fastrecovery_on(tc)
Definition: tcp.h:319
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
Limit MSS.
Definition: tcp_packet.h:106
static uword tcp4_listen(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:2829
#define VLIB_BUFFER_NEXT_PRESENT
Definition: buffer.h:95
static u32 scoreboard_hole_index(sack_scoreboard_t *sb, sack_scoreboard_hole_t *hole)
Definition: tcp.h:871
#define tcp_is_fin(_th)
Definition: tcp_packet.h:90
static uword tcp6_rcv_process(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:2613
static uword tcp4_syn_sent(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:2212
#define seq_gt(_s1, _s2)
Definition: tcp.h:532
void tcp_init_snd_vars(tcp_connection_t *tc)
Initialize connection send variables.
Definition: tcp.c:464
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
vlib_node_registration_t tcp4_established_node
(constructor) VLIB_REGISTER_NODE (tcp4_established_node)
Definition: tcp_input.c:82
#define TCP_CLOSEWAIT_TIME
Definition: tcp.h:102
void stream_session_accept_notify(transport_connection_t *tc)
Definition: session.c:677
#define always_inline
Definition: clib.h:92
#define TCP_OPTION_LEN_SACK_BLOCK
Definition: tcp_packet.h:169
static void tcp_node_inc_counter(vlib_main_t *vm, u32 tcp4_node, u32 tcp6_node, u8 is_ip4, u8 evt, u8 val)
Definition: tcp_input.c:1677
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 TCP_DELACK_TIME
Definition: tcp.h:98
static tcp_header_t * tcp_buffer_hdr(vlib_buffer_t *b)
Definition: tcp.h:428
static void tcp_cc_recovery_exit(tcp_connection_t *tc)
Definition: tcp_input.c:938
enum _tcp_state tcp_state_t
#define TCP_ALWAYS_ACK
On/off delayed acks.
Definition: tcp.h:38
unsigned long u64
Definition: types.h:89
vlib_node_registration_t tcp6_input_node
(constructor) VLIB_REGISTER_NODE (tcp6_input_node)
Definition: tcp_input.c:2887
static u8 tcp_ack_is_dupack(tcp_connection_t *tc, vlib_buffer_t *b, u32 prev_snd_wnd, u32 prev_snd_una)
Check if duplicate ack as per RFC5681 Sec.
Definition: tcp_input.c:501
#define TCP_RTO_MAX
Definition: tcp.h:107
static u32 ooo_segment_length(svm_fifo_t *f, ooo_segment_t *s)
Definition: svm_fifo.h:199
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
#define vec_end(v)
End (last data address) of vector.
static tcp_cc_algorithm_t * tcp_cc_algo_get(tcp_cc_algorithm_type_e type)
Definition: tcp.h:898
static u32 scoreboard_hole_bytes(sack_scoreboard_hole_t *hole)
Definition: tcp.h:865
struct _stream_session_t stream_session_t
#define vlib_call_init_function(vm, x)
Definition: init.h:162
#define TCP_MAX_SACK_BLOCKS
Max number of SACK blocks stored.
Definition: tcp.h:162
#define tcp_validate_txf_size(_tc, _a)
Definition: tcp.h:786
#define TCP_EVT_DBG(_evt, _args...)
Definition: tcp_debug.h:235
#define timestamp_lt(_t1, _t2)
Definition: tcp.h:537
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
static void svm_fifo_newest_ooo_segment_reset(svm_fifo_t *f)
Definition: svm_fifo.h:165
static heap_elt_t * first(heap_header_t *h)
Definition: heap.c:59
u32 stream_session_dequeue_drop(transport_connection_t *tc, u32 max_bytes)
Definition: session.c:427
#define TCP_INVALID_SACK_HOLE_INDEX
Definition: tcp.h:163
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:459
void tcp_cc_init(tcp_connection_t *tc)
Definition: tcp_input.c:1204
u8 * format_tcp_rx_trace(u8 *s, va_list *args)
Definition: tcp_input.c:1631
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:72
void tcp_cc_fastrecovery_exit(tcp_connection_t *tc)
Definition: tcp_input.c:950
static uword tcp46_listen_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
LISTEN state processing as per RFC 793 p.
Definition: tcp_input.c:2670
#define tcp_in_fastrecovery(tc)
Definition: tcp.h:323
void tcp_retransmit_first_unacked(tcp_connection_t *tc)
Retransmit first unacked segment.
Definition: tcp_output.c:1593
#define foreach_tcp4_input_next
Definition: tcp_input.c:2901
static sack_scoreboard_hole_t * scoreboard_next_hole(sack_scoreboard_t *sb, sack_scoreboard_hole_t *hole)
Definition: tcp.h:813
static u32 ooo_segment_offset(svm_fifo_t *f, ooo_segment_t *s)
Definition: svm_fifo.h:187
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:195
#define filter_flags
Definition: tcp_input.c:2919
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:271
static int tcp_buffer_discard_bytes(vlib_buffer_t *b, u32 n_bytes_to_drop)
Definition: tcp_input.c:1516
#define foreach_tcp6_input_next
Definition: tcp_input.c:2910
#define TCP_TIMER_HANDLE_INVALID
Definition: tcp.h:93
void tcp_fast_retransmit_no_sack(tcp_connection_t *tc)
Fast retransmit without SACK info.
Definition: tcp_output.c:1693
#define TCP_CLEANUP_TIME
Definition: tcp.h:104
#define PREDICT_FALSE(x)
Definition: clib.h:105
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:801
int tcp_options_parse(tcp_header_t *th, tcp_options_t *to)
Parse TCP header options.
Definition: tcp_input.c:127
#define TCP_FLAG_FIN
Definition: fa_node.h:7
#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
static sack_scoreboard_hole_t * scoreboard_last_hole(sack_scoreboard_t *sb)
Definition: tcp.h:837
int stream_session_accept(transport_connection_t *tc, u32 listener_index, u8 notify)
Accept a stream session.
Definition: session.c:761
#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
vlib_node_registration_t tcp4_listen_node
(constructor) VLIB_REGISTER_NODE (tcp4_listen_node)
Definition: tcp_input.c:2663
#define TCP_OPTION_LEN_TIMESTAMP
Definition: tcp_packet.h:168
static u8 tcp_lookup_is_valid(tcp_connection_t *tc, tcp_header_t *hdr)
Definition: tcp_input.c:1869
static ooo_segment_t * svm_fifo_newest_ooo_segment(svm_fifo_t *f)
Definition: svm_fifo.h:157
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:113
Selective Ack block.
Definition: tcp_packet.h:109
vlib_node_registration_t tcp6_established_node
(constructor) VLIB_REGISTER_NODE (tcp6_established_node)
Definition: tcp_input.c:83
static int tcp_can_delack(tcp_connection_t *tc)
Check if ACK could be delayed.
Definition: tcp_input.c:1500
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1158
#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_DBG(_fmt, _args...)
Definition: tcp_debug.h:86
#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
static uword tcp6_syn_sent_rcv(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:2219
vlib_node_registration_t tcp4_syn_sent_node
(constructor) VLIB_REGISTER_NODE (tcp4_syn_sent_node)
Definition: tcp_input.c:1865
u16 n_vectors
Definition: node.h:344
vlib_main_t * vm
Definition: buffer.c:283
u32 stream_session_tx_fifo_max_dequeue(transport_connection_t *tc)
Definition: session.c:410
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
#define TCP_DUPACK_THRESHOLD
Definition: tcp.h:34
format_function_t format_tcp_state
Definition: tcp.h:63
#define clib_warning(format, args...)
Definition: error.h:59
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:93
#define clib_memcpy(a, b, c)
Definition: string.h:75
static int tcp_rcv_ack(tcp_connection_t *tc, vlib_buffer_t *b, tcp_header_t *th, u32 *next, u32 *error)
Process incoming ACK.
Definition: tcp_input.c:1214
tcp_header_t tcp_header
Definition: tcp_input.c:1626
format_function_t format_tcp_header
Definition: format.h:102
void tcp_make_synack(tcp_connection_t *ts, vlib_buffer_t *b)
Convert buffer to SYN-ACK.
Definition: tcp_output.c:602
#define ARRAY_LEN(x)
Definition: clib.h:59
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
#define TCP_RTT_MAX
Definition: tcp.h:109
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
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
void tcp_make_ack(tcp_connection_t *ts, vlib_buffer_t *b)
Convert buffer to ACK.
Definition: tcp_output.c:544
void stream_session_disconnect_notify(transport_connection_t *tc)
Notification from transport that connection is being closed.
Definition: session.c:695
transport_connection_t * session_lookup_connection_wt4(u32 fib_index, ip4_address_t *lcl, ip4_address_t *rmt, u16 lcl_port, u16 rmt_port, u8 proto, u32 thread_index, u8 *is_filtered)
Lookup connection with ip4 and transport layer information.
u8 tcp_scoreboard_is_sane_post_recovery(tcp_connection_t *tc)
Test that scoreboard is sane after recovery.
Definition: tcp_input.c:716
static void tcp_timer_update(tcp_connection_t *tc, u8 timer_id, u32 interval)
Definition: tcp.h:711
#define TCP_PAWS_IDLE
24 days
Definition: tcp.h:30
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:456
clib_error_t * tcp_input_init(vlib_main_t *vm)
Definition: tcp_input.c:3224
#define ASSERT(truth)
#define tcp_syn(_th)
Definition: tcp_packet.h:80
unsigned int u32
Definition: types.h:88
static void tcp_estimate_rtt(tcp_connection_t *tc, u32 mrtt)
Compute smoothed RTT as per VJ&#39;s &#39;88 SIGCOMM and RFC6298.
Definition: tcp_input.c:396
enum _tcp_rcv_process_next tcp_rcv_process_next_t
static uword tcp4_established(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:1807
#define seq_geq(_s1, _s2)
Definition: tcp.h:533
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:109
static uword tcp46_established_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
Definition: tcp_input.c:1690
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:208
static int tcp_segment_check_paws(tcp_connection_t *tc)
RFC1323: Check against wrapped sequence numbers (PAWS).
Definition: tcp_input.c:236
static void tcp_cc_handle_event(tcp_connection_t *tc, u32 is_dack)
One function to rule them all ...
Definition: tcp_input.c:1044
enum _tcp_input_next tcp_input_next_t
transport_connection_t * session_lookup_connection_wt6(u32 fib_index, ip6_address_t *lcl, ip6_address_t *rmt, u16 lcl_port, u16 rmt_port, u8 proto, u32 thread_index, u8 *is_filtered)
Lookup connection with ip6 and transport layer information.
void tcp_update_sack_list(tcp_connection_t *tc, u32 start, u32 end)
Build SACK list as per RFC2018.
Definition: tcp_input.c:1327
Out-of-order segment.
Definition: svm_fifo.h:27
static u8 tcp_segment_in_rcv_wnd(tcp_connection_t *tc, u32 seq, u32 end_seq)
Validate segment sequence number.
Definition: tcp_input.c:113
#define clib_max(x, y)
Definition: clib.h:333
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
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
VLIB_NODE_FUNCTION_MULTIARCH(tcp4_established_node, tcp4_established)
void scoreboard_init_high_rxt(sack_scoreboard_t *sb, u32 seq)
Definition: tcp_input.c:697
static uword tcp6_established(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:1814
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
#define tcp_is_syn(_th)
Definition: tcp_packet.h:89
#define tcp_opts_wscale(_to)
Definition: tcp_packet.h:158
enum _tcp_syn_sent_next tcp_syn_sent_next_t
static sack_scoreboard_hole_t * scoreboard_get_hole(sack_scoreboard_t *sb, u32 index)
Definition: tcp.h:805
static void tcp_update_snd_wnd(tcp_connection_t *tc, u32 seq, u32 ack, u32 snd_wnd)
Try to update snd_wnd based on feedback received from peer.
Definition: tcp_input.c:897
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
enum _tcp_established_next tcp_established_next_t
u16 payload_length
Definition: ip6_packet.h:332
sack_scoreboard_hole_t * scoreboard_insert_hole(sack_scoreboard_t *sb, u32 prev_index, u32 start, u32 end)
Definition: tcp_input.c:561
u32 tsecr
Echoed/reflected time stamp.
Definition: tcp_packet.h:150
vlib_node_registration_t tcp4_input_node
(constructor) VLIB_REGISTER_NODE (tcp4_input_node)
Definition: tcp_input.c:2886
void tcp_send_fin(tcp_connection_t *tc)
Send FIN.
Definition: tcp_output.c:1048
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
enum _tcp_listen_next tcp_listen_next_t
#define foreach_tcp_state_next
Definition: tcp_input.c:29
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
static uword tcp4_rcv_process(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:2606
static void tcp_retransmit_timer_update(tcp_connection_t *tc)
Definition: tcp.h:767
static int tcp_session_enqueue_data(tcp_connection_t *tc, vlib_buffer_t *b, u16 data_len)
Enqueue data for delivery to application.
Definition: tcp_input.c:1382
static u8 tcp_should_fastrecover_sack(tcp_connection_t *tc)
Definition: tcp_input.c:1028
#define seq_max(_s1, _s2)
Definition: tcp.h:534
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:267
void tcp_connection_init_vars(tcp_connection_t *tc)
Initialize tcp connection variables.
Definition: tcp.c:488
#define TCP_OPTION_LEN_MSS
Definition: tcp_packet.h:165
#define tcp_next_output(is_ip4)
Definition: tcp_input.c:76
clib_error_t * tcp_init(vlib_main_t *vm)
Definition: tcp.c:1281
#define TCP_RTO_MIN
Definition: tcp.h:108
struct clib_bihash_value offset
template key/value backing page structure
#define tcp_scoreboard_trace_add(_tc, _ack)
Definition: tcp.h:226
u8 * format_tcp_connection(u8 *s, va_list *args)
Definition: tcp.c:741
void tcp_set_rx_trace_data(tcp_rx_trace_t *t0, tcp_connection_t *tc0, tcp_header_t *th0, vlib_buffer_t *b0, u8 is_ip4)
Definition: tcp_input.c:1662
#define vnet_buffer(b)
Definition: buffer.h:326
int session_manager_flush_enqueue_events(u8 transport_proto, u32 thread_index)
Flushes queue of sessions that are to be notified of new data enqueued events.
Definition: session.c:510
static tcp_connection_t * tcp_connection_get(u32 conn_index, u32 thread_index)
Definition: tcp.h:449
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
static int tcp_header_bytes(tcp_header_t *t)
Definition: tcp_packet.h:93
int session_stream_connect_notify(transport_connection_t *tc, u8 is_fail)
Definition: session.c:549
void tcp_connection_cleanup(tcp_connection_t *tc)
Cleans up connection state.
Definition: tcp.c:158
static uword tcp4_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: tcp_input.c:3086
Window scale.
Definition: tcp_packet.h:107
vlib_node_registration_t tcp6_listen_node
(constructor) VLIB_REGISTER_NODE (tcp6_listen_node)
Definition: tcp_input.c:2664
#define tcp_opts_sack_permitted(_to)
Definition: tcp_packet.h:160
int tcp_cc_recover(tcp_connection_t *tc)
Definition: tcp_input.c:985
Timestamps.
Definition: tcp_packet.h:110
void scoreboard_remove_hole(sack_scoreboard_t *sb, sack_scoreboard_hole_t *hole)
Definition: tcp_input.c:526
#define TCP_SYN_RCVD_TIME
Definition: tcp.h:100
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 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
static uword tcp46_syn_sent_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
Definition: tcp_input.c:1948
#define tcp_fastrecovery_off(tc)
Definition: tcp.h:320
static uword tcp46_rcv_process_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
Handles reception for all states except LISTEN, SYN-SENT and ESTABLISHED as per RFC793 p...
Definition: tcp_input.c:2277
static void tcp_retransmit_timer_reset(tcp_connection_t *tc)
Definition: tcp.h:731
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
u8 * format_tcp_rx_trace_short(u8 *s, va_list *args)
Definition: tcp_input.c:1647
#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
transport_connection_t * session_lookup_half_open_connection(u64 handle, u8 proto, u8 is_ip4)
static tcp_connection_t * tcp_listener_get(u32 tli)
Definition: tcp.h:493
ip6_address_t dst_address
Definition: ip6_packet.h:341
static u8 tcp_ack_is_cc_event(tcp_connection_t *tc, vlib_buffer_t *b, u32 prev_snd_wnd, u32 prev_snd_una, u8 *is_dack)
Checks if ack is a congestion control event.
Definition: tcp_input.c:514
void tcp_cc_init_congestion(tcp_connection_t *tc)
Definition: tcp_input.c:929
static void tcp_persist_timer_reset(tcp_connection_t *tc)
Definition: tcp.h:761
static char * tcp_error_strings[]
Definition: tcp_input.c:22