diff options
Diffstat (limited to 'src/vnet/tcp/tcp_input.c')
| -rw-r--r-- | src/vnet/tcp/tcp_input.c | 652 |
1 files changed, 290 insertions, 362 deletions
diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c index 3d3272c8765..70b5d28e0cc 100644 --- a/src/vnet/tcp/tcp_input.c +++ b/src/vnet/tcp/tcp_input.c @@ -21,65 +21,23 @@ #include <vnet/session/session.h> #include <math.h> -static char *tcp_error_strings[] = { -#define tcp_error(n,s) s, +static vlib_error_desc_t tcp_input_error_counters[] = { +#define tcp_error(f, n, s, d) { #n, d, VL_COUNTER_SEVERITY_##s }, #include <vnet/tcp/tcp_error.def> #undef tcp_error }; -/* All TCP nodes have the same outgoing arcs */ -#define foreach_tcp_state_next \ - _ (DROP4, "ip4-drop") \ - _ (DROP6, "ip6-drop") \ - _ (TCP4_OUTPUT, "tcp4-output") \ - _ (TCP6_OUTPUT, "tcp6-output") - -typedef enum _tcp_established_next -{ -#define _(s,n) TCP_ESTABLISHED_NEXT_##s, - foreach_tcp_state_next -#undef _ - TCP_ESTABLISHED_N_NEXT, -} tcp_established_next_t; - -typedef enum _tcp_rcv_process_next -{ -#define _(s,n) TCP_RCV_PROCESS_NEXT_##s, - foreach_tcp_state_next -#undef _ - TCP_RCV_PROCESS_N_NEXT, -} tcp_rcv_process_next_t; - -typedef enum _tcp_syn_sent_next -{ -#define _(s,n) TCP_SYN_SENT_NEXT_##s, - foreach_tcp_state_next -#undef _ - TCP_SYN_SENT_N_NEXT, -} tcp_syn_sent_next_t; - -typedef enum _tcp_listen_next -{ -#define _(s,n) TCP_LISTEN_NEXT_##s, - foreach_tcp_state_next -#undef _ - TCP_LISTEN_N_NEXT, -} tcp_listen_next_t; - -/* Generic, state independent indices */ -typedef enum _tcp_state_next +typedef enum _tcp_input_next { -#define _(s,n) TCP_NEXT_##s, - foreach_tcp_state_next -#undef _ - TCP_STATE_N_NEXT, -} tcp_state_next_t; - -#define tcp_next_output(is_ip4) (is_ip4 ? TCP_NEXT_TCP4_OUTPUT \ - : TCP_NEXT_TCP6_OUTPUT) - -#define tcp_next_drop(is_ip4) (is_ip4 ? TCP_NEXT_DROP4 \ - : TCP_NEXT_DROP6) + TCP_INPUT_NEXT_DROP, + TCP_INPUT_NEXT_LISTEN, + TCP_INPUT_NEXT_RCV_PROCESS, + TCP_INPUT_NEXT_SYN_SENT, + TCP_INPUT_NEXT_ESTABLISHED, + TCP_INPUT_NEXT_RESET, + TCP_INPUT_NEXT_PUNT, + TCP_INPUT_N_NEXT +} tcp_input_next_t; /** * Validate segment sequence number. As per RFC793: @@ -404,17 +362,10 @@ tcp_rcv_ack_no_cc (tcp_connection_t * tc, vlib_buffer_t * b, u32 * error) if (!(seq_leq (tc->snd_una, vnet_buffer (b)->tcp.ack_number) && seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt))) { - if (seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt) - && seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_una)) - { - tc->snd_nxt = vnet_buffer (b)->tcp.ack_number; - goto acceptable; - } *error = TCP_ERROR_ACK_INVALID; return -1; } -acceptable: tc->bytes_acked = vnet_buffer (b)->tcp.ack_number - tc->snd_una; tc->snd_una = vnet_buffer (b)->tcp.ack_number; *error = TCP_ERROR_ACK_OK; @@ -594,7 +545,7 @@ tcp_handle_postponed_dequeues (tcp_worker_ctx_t * wrk) tc->burst_acked = 0; } - _vec_len (wrk->pending_deq_acked) = 0; + vec_set_len (wrk->pending_deq_acked, 0); } static void @@ -629,11 +580,15 @@ tcp_update_snd_wnd (tcp_connection_t * tc, u32 seq, u32 ack, u32 snd_wnd) if (PREDICT_FALSE (tc->snd_wnd < tc->snd_mss)) { - /* Set persist timer if not set and we just got 0 wnd */ - if (!tcp_timer_is_active (tc, TCP_TIMER_PERSIST) - && !tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)) + if (!tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)) { tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); + + /* Set persist timer if we just got 0 wnd. If already set, + * update it because some data sent with snd_wnd < snd_mss was + * acked. */ + if (tcp_timer_is_active (tc, TCP_TIMER_PERSIST)) + tcp_persist_timer_reset (&wrk->timer_wheel, tc); tcp_persist_timer_set (&wrk->timer_wheel, tc); } } @@ -742,7 +697,7 @@ tcp_should_fastrecover (tcp_connection_t * tc, u8 has_sack) } static int -tcp_cc_recover (tcp_connection_t * tc) +tcp_cc_try_recover (tcp_connection_t *tc) { sack_scoreboard_hole_t *hole; u8 is_spurious = 0; @@ -757,14 +712,14 @@ tcp_cc_recover (tcp_connection_t * tc) tcp_connection_tx_pacer_reset (tc, tc->cwnd, 0 /* start bucket */ ); tc->rcv_dupacks = 0; + tcp_recovery_off (tc); /* Previous recovery left us congested. Continue sending as part * of the current recovery event with an updated snd_congestion */ - if (tc->sack_sb.sacked_bytes) + if (tc->sack_sb.sacked_bytes && tcp_in_fastrecovery (tc)) { tc->snd_congestion = tc->snd_nxt; - tcp_program_retransmit (tc); - return is_spurious; + return -1; } tc->rxt_delivered = 0; @@ -778,19 +733,18 @@ tcp_cc_recover (tcp_connection_t * tc) if (hole && hole->start == tc->snd_una && hole->end == tc->snd_nxt) scoreboard_clear (&tc->sack_sb); - if (!tcp_in_recovery (tc) && !is_spurious) + if (tcp_in_fastrecovery (tc) && !is_spurious) tcp_cc_recovered (tc); tcp_fastrecovery_off (tc); tcp_fastrecovery_first_off (tc); - tcp_recovery_off (tc); TCP_EVT (TCP_EVT_CC_EVT, tc, 3); ASSERT (tc->rto_boff == 0); ASSERT (!tcp_in_cong_recovery (tc)); ASSERT (tcp_scoreboard_is_sane_post_recovery (tc)); - return is_spurious; + return 0; } static void @@ -803,15 +757,6 @@ tcp_cc_update (tcp_connection_t * tc, tcp_rate_sample_t * rs) /* If a cumulative ack, make sure dupacks is 0 */ tc->rcv_dupacks = 0; - - /* When dupacks hits the threshold we only enter fast retransmit if - * cumulative ack covers more than snd_congestion. Should snd_una - * wrap this test may fail under otherwise valid circumstances. - * Therefore, proactively update snd_congestion when wrap detected. */ - if (PREDICT_FALSE - (seq_leq (tc->snd_congestion, tc->snd_una - tc->bytes_acked) - && seq_gt (tc->snd_congestion, tc->snd_una))) - tc->snd_congestion = tc->snd_una - 1; } /** @@ -857,6 +802,20 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, */ /* + * See if we can exit and stop retransmitting + */ + if (seq_geq (tc->snd_una, tc->snd_congestion)) + { + /* If successfully recovered, treat ack as congestion avoidance ack + * and return. Otherwise, we're still congested so process feedback */ + if (!tcp_cc_try_recover (tc)) + { + tcp_cc_rcv_ack (tc, rs); + return; + } + } + + /* * Process (re)transmit feedback. Output path uses this to decide how much * more data to release into the network */ @@ -866,8 +825,7 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, tcp_fastrecovery_first_on (tc); tc->rxt_delivered += tc->sack_sb.rxt_sacked; - tc->prr_delivered += tc->bytes_acked + tc->sack_sb.last_sacked_bytes - - tc->sack_sb.last_bytes_delivered; + tc->prr_delivered += rs->delivered; } else { @@ -891,23 +849,6 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, tcp_fastrecovery_first_on (tc); } - /* - * See if we can exit and stop retransmitting - */ - if (seq_geq (tc->snd_una, tc->snd_congestion)) - { - /* If spurious return, we've already updated everything */ - if (tcp_cc_recover (tc)) - { - tc->tsecr_last_ack = tc->rcv_opts.tsecr; - return; - } - - /* Treat as congestion avoidance ack */ - tcp_cc_rcv_ack (tc, rs); - return; - } - tcp_program_retransmit (tc); /* @@ -991,15 +932,6 @@ tcp_rcv_ack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, /* If the ACK acks something not yet sent (SEG.ACK > SND.NXT) */ if (PREDICT_FALSE (seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt))) { - /* We've probably entered recovery and the peer still has some - * of the data we've sent. Update snd_nxt and accept the ack */ - if (seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt) - && seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_una)) - { - tc->snd_nxt = vnet_buffer (b)->tcp.ack_number; - goto process_ack; - } - tc->errors.above_ack_wnd += 1; *error = TCP_ERROR_ACK_FUTURE; TCP_EVT (TCP_EVT_ACK_RCV_ERR, tc, 0, vnet_buffer (b)->tcp.ack_number); @@ -1022,8 +954,6 @@ tcp_rcv_ack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, return 0; } -process_ack: - /* * Looks okay, process feedback */ @@ -1042,6 +972,9 @@ process_ack: if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) tcp_bt_sample_delivery_rate (tc, &rs); + else + rs.delivered = tc->bytes_acked + tc->sack_sb.last_sacked_bytes - + tc->sack_sb.last_bytes_delivered; if (tc->bytes_acked + tc->sack_sb.last_sacked_bytes) { @@ -1106,7 +1039,7 @@ tcp_handle_disconnects (tcp_worker_ctx_t * wrk) tcp_disconnect_pending_off (tc); session_transport_closing_notify (&tc->connection); } - _vec_len (wrk->pending_disconnects) = 0; + vec_set_len (wrk->pending_disconnects, 0); } if (vec_len (wrk->pending_resets)) @@ -1119,7 +1052,7 @@ tcp_handle_disconnects (tcp_worker_ctx_t * wrk) tcp_disconnect_pending_off (tc); tcp_handle_rst (tc); } - _vec_len (wrk->pending_resets) = 0; + vec_set_len (wrk->pending_resets, 0); } } @@ -1156,7 +1089,6 @@ tcp_session_enqueue_data (tcp_connection_t * tc, vlib_buffer_t * b, ASSERT (data_len); written = session_enqueue_stream_connection (&tc->connection, b, 0, 1 /* queue event */ , 1); - tc->bytes_in += written; TCP_EVT (TCP_EVT_INPUT, tc, 0, data_len, written); @@ -1164,17 +1096,20 @@ tcp_session_enqueue_data (tcp_connection_t * tc, vlib_buffer_t * b, if (PREDICT_TRUE (written == data_len)) { tc->rcv_nxt += written; + tc->bytes_in += written; } /* If more data written than expected, account for out-of-order bytes. */ else if (written > data_len) { tc->rcv_nxt += written; + tc->bytes_in += data_len; TCP_EVT (TCP_EVT_CC_INPUT, tc, data_len, written); } else if (written > 0) { /* We've written something but FIFO is probably full now */ tc->rcv_nxt += written; + tc->bytes_in += written; error = TCP_ERROR_PARTIALLY_ENQUEUED; } else @@ -1361,9 +1296,13 @@ format_tcp_rx_trace (u8 * s, va_list * args) tcp_connection_t *tc = &t->tcp_connection; u32 indent = format_get_indent (s); - s = format (s, "%U state %U\n%U%U", format_tcp_connection_id, tc, - format_tcp_state, tc->state, format_white_space, indent, - format_tcp_header, &t->tcp_header, 128); + if (!tc->c_lcl_port) + s = format (s, "no tcp connection\n%U%U", format_white_space, indent, + format_tcp_header, &t->tcp_header, 128); + else + s = format (s, "%U state %U\n%U%U", format_tcp_connection_id, tc, + format_tcp_state, tc->state, format_white_space, indent, + format_tcp_header, &t->tcp_header, 128); return s; } @@ -1433,53 +1372,14 @@ tcp_established_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node, } } -always_inline void -tcp_node_inc_counter_i (vlib_main_t * vm, u32 tcp4_node, u32 tcp6_node, - u8 is_ip4, u32 evt, u32 val) -{ - if (is_ip4) - vlib_node_increment_counter (vm, tcp4_node, evt, val); - else - vlib_node_increment_counter (vm, tcp6_node, evt, val); -} - -#define tcp_maybe_inc_counter(node_id, err, count) \ -{ \ - if (next0 != tcp_next_drop (is_ip4)) \ - tcp_node_inc_counter_i (vm, tcp4_##node_id##_node.index, \ - tcp6_##node_id##_node.index, is_ip4, err, \ - 1); \ -} -#define tcp_inc_counter(node_id, err, count) \ - tcp_node_inc_counter_i (vm, tcp4_##node_id##_node.index, \ - tcp6_##node_id##_node.index, is_ip4, \ - err, count) -#define tcp_maybe_inc_err_counter(cnts, err) \ -{ \ - cnts[err] += (next0 != tcp_next_drop (is_ip4)); \ -} -#define tcp_inc_err_counter(cnts, err, val) \ -{ \ - cnts[err] += val; \ -} -#define tcp_store_err_counters(node_id, cnts) \ -{ \ - int i; \ - for (i = 0; i < TCP_N_ERROR; i++) \ - if (cnts[i]) \ - tcp_inc_counter(node_id, i, cnts[i]); \ -} - - always_inline uword tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame, int is_ip4) { - u32 thread_index = vm->thread_index, errors = 0; + u32 thread_index = vm->thread_index, n_left_from, *from; tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; u16 err_counters[TCP_N_ERROR] = { 0 }; - u32 n_left_from, *from; if (node->flags & VLIB_NODE_FLAG_TRACE) tcp_established_trace_frame (vm, node, frame, is_ip4); @@ -1543,9 +1443,7 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node, b += 1; } - errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, - thread_index); - err_counters[TCP_ERROR_MSG_QUEUE_FULL] = errors; + session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, thread_index); tcp_store_err_counters (established, err_counters); tcp_handle_postponed_dequeues (wrk); tcp_handle_disconnects (wrk); @@ -1568,43 +1466,23 @@ VLIB_NODE_FN (tcp6_established_node) (vlib_main_t * vm, return tcp46_established_inline (vm, node, from_frame, 0 /* is_ip4 */ ); } -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (tcp4_established_node) = -{ +VLIB_REGISTER_NODE (tcp4_established_node) = { .name = "tcp4-established", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_ESTABLISHED_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_ESTABLISHED_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (tcp6_established_node) = -{ +VLIB_REGISTER_NODE (tcp6_established_node) = { .name = "tcp6-established", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_ESTABLISHED_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_ESTABLISHED_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ static u8 @@ -1796,15 +1674,54 @@ tcp_check_tx_offload (tcp_connection_t * tc, int is_ipv4) return; hw_if = vnet_get_sup_hw_interface (vnm, sw_if_idx); - if (hw_if->caps & VNET_HW_INTERFACE_CAP_SUPPORTS_TCP_GSO) + if (hw_if->caps & VNET_HW_IF_CAP_TCP_GSO) tc->cfg_flags |= TCP_CFG_F_TSO; } +static void +tcp_input_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, + vlib_buffer_t **bs, u16 *nexts, u32 n_bufs, u8 is_ip4) +{ + tcp_connection_t *tc; + tcp_header_t *tcp; + tcp_rx_trace_t *t; + u8 flags; + int i; + + for (i = 0; i < n_bufs; i++) + { + if (!(bs[i]->flags & VLIB_BUFFER_IS_TRACED)) + continue; + + t = vlib_add_trace (vm, node, bs[i], sizeof (*t)); + if (nexts[i] == TCP_INPUT_NEXT_DROP || nexts[i] == TCP_INPUT_NEXT_PUNT || + nexts[i] == TCP_INPUT_NEXT_RESET) + { + tc = 0; + } + else + { + flags = vnet_buffer (bs[i])->tcp.flags; + + if (flags == TCP_STATE_LISTEN) + tc = tcp_listener_get (vnet_buffer (bs[i])->tcp.connection_index); + else if (flags == TCP_STATE_SYN_SENT) + tc = tcp_half_open_connection_get ( + vnet_buffer (bs[i])->tcp.connection_index); + else + tc = tcp_connection_get (vnet_buffer (bs[i])->tcp.connection_index, + vm->thread_index); + } + tcp = tcp_buffer_hdr (bs[i]); + tcp_set_rx_trace_data (t, tc, tcp, bs[i], is_ip4); + } +} + always_inline uword tcp46_syn_sent_inline (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int is_ip4) { - u32 n_left_from, *from, thread_index = vm->thread_index, errors = 0; + u32 n_left_from, *from, thread_index = vm->thread_index; tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; @@ -1970,7 +1887,9 @@ tcp46_syn_sent_inline (vlib_main_t *vm, vlib_node_runtime_t *node, SESSION_E_NONE)) { tcp_send_reset_w_pkt (new_tc, b[0], thread_index, is_ip4); - tcp_connection_cleanup (new_tc); + tcp_program_cleanup (wrk, new_tc); + new_tc->state = TCP_STATE_CLOSED; + new_tc->c_s_index = ~0; error = TCP_ERROR_CREATE_SESSION_FAIL; goto cleanup_ho; } @@ -1991,8 +1910,10 @@ tcp46_syn_sent_inline (vlib_main_t *vm, vlib_node_runtime_t *node, if (session_stream_connect_notify (&new_tc->connection, SESSION_E_NONE)) { - tcp_connection_cleanup (new_tc); tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4); + tcp_program_cleanup (wrk, new_tc); + new_tc->state = TCP_STATE_CLOSED; + new_tc->c_s_index = ~0; TCP_EVT (TCP_EVT_RST_SENT, tc); error = TCP_ERROR_CREATE_SESSION_FAIL; goto cleanup_ho; @@ -2039,9 +1960,7 @@ tcp46_syn_sent_inline (vlib_main_t *vm, vlib_node_runtime_t *node, tcp_inc_counter (syn_sent, error, 1); } - errors = - session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, thread_index); - tcp_inc_counter (syn_sent, TCP_ERROR_MSG_QUEUE_FULL, errors); + session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, thread_index); vlib_buffer_free (vm, from, frame->n_vectors); tcp_handle_disconnects (wrk); @@ -2062,43 +1981,25 @@ VLIB_NODE_FN (tcp6_syn_sent_node) (vlib_main_t * vm, return tcp46_syn_sent_inline (vm, node, from_frame, 0 /* is_ip4 */ ); } -/* *INDENT-OFF* */ VLIB_REGISTER_NODE (tcp4_syn_sent_node) = { .name = "tcp4-syn-sent", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_SYN_SENT_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_SYN_SENT_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ -/* *INDENT-OFF* */ VLIB_REGISTER_NODE (tcp6_syn_sent_node) = { .name = "tcp6-syn-sent", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_SYN_SENT_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_SYN_SENT_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ static void tcp46_rcv_process_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, @@ -2130,7 +2031,7 @@ always_inline uword tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int is_ip4) { - u32 thread_index = vm->thread_index, errors, n_left_from, *from, max_deq; + u32 thread_index = vm->thread_index, n_left_from, *from, max_deq; tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; @@ -2198,15 +2099,6 @@ tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, switch (tc->state) { case TCP_STATE_SYN_RCVD: - - /* Make sure the segment is exactly right */ - if (tc->rcv_nxt != vnet_buffer (b[0])->tcp.seq_number || is_fin) - { - tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4); - error = TCP_ERROR_SEGMENT_INVALID; - goto drop; - } - /* * If the segment acknowledgment is not acceptable, form a * reset segment, @@ -2220,6 +2112,10 @@ tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, goto drop; } + /* Avoid notifying app if connection is about to be closed */ + if (PREDICT_FALSE (is_fin)) + break; + /* Update rtt and rto */ tcp_estimate_initial_rtt (tc); tcp_connection_tx_pacer_update (tc); @@ -2248,7 +2144,7 @@ tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, tcp_connection_cleanup (tc); goto drop; } - error = TCP_ERROR_ACK_OK; + error = TCP_ERROR_CONN_ACCEPTED; break; case TCP_STATE_ESTABLISHED: /* We can get packets in established state here because they @@ -2327,8 +2223,8 @@ tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, if (max_deq > tc->burst_acked) break; - tcp_send_fin (tc); tcp_connection_timers_reset (tc); + tcp_send_fin (tc); tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time); @@ -2440,15 +2336,15 @@ tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, tcp_cfg.closewait_time); break; case TCP_STATE_SYN_RCVD: - /* Send FIN-ACK, enter LAST-ACK and because the app was not - * notified yet, set a cleanup timer instead of relying on - * disconnect notify and the implicit close call. */ + /* Send FIN-ACK and enter TIME-WAIT, as opposed to LAST-ACK, + * because the app was not notified yet and we want to avoid + * session state transitions to ensure cleanup does not + * propagate to app. */ tcp_connection_timers_reset (tc); tc->rcv_nxt += 1; tcp_send_fin (tc); - tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); - tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, - tcp_cfg.lastack_time); + tcp_connection_set_state (tc, TCP_STATE_TIME_WAIT); + tcp_program_cleanup (wrk, tc); break; case TCP_STATE_CLOSE_WAIT: case TCP_STATE_CLOSING: @@ -2503,9 +2399,7 @@ tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, tcp_inc_counter (rcv_process, error, 1); } - errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, - thread_index); - tcp_inc_counter (rcv_process, TCP_ERROR_MSG_QUEUE_FULL, errors); + session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, thread_index); tcp_handle_postponed_dequeues (wrk); tcp_handle_disconnects (wrk); vlib_buffer_free (vm, from, frame->n_vectors); @@ -2527,43 +2421,23 @@ VLIB_NODE_FN (tcp6_rcv_process_node) (vlib_main_t * vm, return tcp46_rcv_process_inline (vm, node, from_frame, 0 /* is_ip4 */ ); } -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (tcp4_rcv_process_node) = -{ +VLIB_REGISTER_NODE (tcp4_rcv_process_node) = { .name = "tcp4-rcv-process", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_RCV_PROCESS_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_RCV_PROCESS_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (tcp6_rcv_process_node) = -{ +VLIB_REGISTER_NODE (tcp6_rcv_process_node) = { .name = "tcp6-rcv-process", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_RCV_PROCESS_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_RCV_PROCESS_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ static void tcp46_listen_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, @@ -2587,6 +2461,61 @@ tcp46_listen_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, } /** + * SYN received in TIME-WAIT state. + * + * RFC 1122: + * "When a connection is [...] on TIME-WAIT state [...] + * [a TCP] MAY accept a new SYN from the remote TCP to + * reopen the connection directly, if it: + * + * (1) assigns its initial sequence number for the new + * connection to be larger than the largest sequence + * number it used on the previous connection incarnation, + * and + * + * (2) returns to TIME-WAIT state if the SYN turns out + * to be an old duplicate". + * + * The function returns true if the syn can be accepted during + * connection time-wait (port reuse). In this case the function + * also calculates what the iss should be for the new connection. + */ +always_inline int +syn_during_timewait (tcp_connection_t *tc, vlib_buffer_t *b, u32 *iss) +{ + int paws_reject = tcp_segment_check_paws (tc); + u32 tw_iss; + + *iss = 0; + /* Check that the SYN arrived out of window. We accept it */ + if (!paws_reject && + (seq_geq (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt) || + (tcp_opts_tstamp (&tc->rcv_opts) && + timestamp_lt (tc->tsval_recent, tc->rcv_opts.tsval)))) + { + /* Set the iss of the new connection to be the largest sequence number + * the old peer would have accepted and add some random number + */ + tw_iss = tc->snd_nxt + tcp_available_snd_wnd (tc) + + (uword) (tcp_time_now_us (tc->c_thread_index) * 1e6) % 65535; + if (tw_iss == 0) + tw_iss++; + *iss = tw_iss; + + return 1; + } + else + { + TCP_DBG ( + "ERROR not accepting SYN in timewait,paws_reject=%d, seq_num =%ld, " + "rcv_nxt=%ld, tstamp_present=%d, tsval_recent = %d, tsval = %d\n", + paws_reject, vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt, + tcp_opts_tstamp (&tc->rcv_opts), tc->tsval_recent, tc->rcv_opts.tsval); + return 0; + } +} + +/** * LISTEN state processing as per RFC 793 p. 65 */ always_inline uword @@ -2596,6 +2525,7 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, u32 n_left_from, *from, n_syns = 0; vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; u32 thread_index = vm->thread_index; + u32 tw_iss = 0; from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; @@ -2608,7 +2538,6 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, while (n_left_from > 0) { - u32 error = TCP_ERROR_NONE; tcp_connection_t *lc, *child; /* Flags initialized with connection state after lookup */ @@ -2616,6 +2545,7 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, { lc = tcp_listener_get (vnet_buffer (b[0])->tcp.connection_index); } + /* Probably we are in time-wait or closed state */ else { tcp_connection_t *tc; @@ -2623,16 +2553,24 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, thread_index); if (tc->state != TCP_STATE_TIME_WAIT) { - error = TCP_ERROR_CREATE_EXISTS; + tcp_inc_counter (listen, TCP_ERROR_CREATE_EXISTS, 1); + goto done; + } + + if (PREDICT_FALSE (!syn_during_timewait (tc, b[0], &tw_iss))) + { + /* This SYN can't be accepted */ + tcp_inc_counter (listen, TCP_ERROR_CREATE_EXISTS, 1); goto done; } + lc = tcp_lookup_listener (b[0], tc->c_fib_index, is_ip4); /* clean up the old session */ tcp_connection_del (tc); /* listener was cleaned up */ if (!lc) { - error = TCP_ERROR_NO_LISTENER; + tcp_inc_counter (listen, TCP_ERROR_NO_LISTENER, 1); goto done; } } @@ -2642,7 +2580,7 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, tcp_lookup_connection (lc->c_fib_index, b[0], thread_index, is_ip4); if (PREDICT_FALSE (child->state != TCP_STATE_LISTEN)) { - error = TCP_ERROR_CREATE_EXISTS; + tcp_inc_counter (listen, TCP_ERROR_CREATE_EXISTS, 1); goto done; } @@ -2659,7 +2597,7 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, if (tcp_options_parse (tcp_buffer_hdr (b[0]), &child->rcv_opts, 1)) { - error = TCP_ERROR_OPTIONS; + tcp_inc_counter (listen, TCP_ERROR_OPTIONS, 1); tcp_connection_free (child); goto done; } @@ -2669,6 +2607,12 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, child->state = TCP_STATE_SYN_RCVD; child->c_fib_index = lc->c_fib_index; child->cc_algo = lc->cc_algo; + + /* In the regular case, the tw_iss will be zero, but + * in the special case of syn arriving in time_wait state, the value + * will be set according to rfc 1122 + */ + child->iss = tw_iss; tcp_connection_init_vars (child); child->rto = TCP_RTO_MIN; @@ -2683,7 +2627,7 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, lc->c_thread_index, 0 /* notify */ )) { tcp_connection_cleanup (child); - error = TCP_ERROR_CREATE_SESSION_FAIL; + tcp_inc_counter (listen, TCP_ERROR_CREATE_SESSION_FAIL, 1); goto done; } @@ -2691,12 +2635,11 @@ tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, child->tx_fifo_size = transport_tx_fifo_size (&child->connection); tcp_send_synack (child); + n_syns += 1; done: - b += 1; n_left_from -= 1; - n_syns += (error == TCP_ERROR_NONE); } tcp_inc_counter (listen, TCP_ERROR_SYNS_RCVD, n_syns); @@ -2717,98 +2660,82 @@ VLIB_NODE_FN (tcp6_listen_node) (vlib_main_t * vm, vlib_node_runtime_t * node, return tcp46_listen_inline (vm, node, from_frame, 0 /* is_ip4 */ ); } -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (tcp4_listen_node) = -{ +VLIB_REGISTER_NODE (tcp4_listen_node) = { .name = "tcp4-listen", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_LISTEN_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_LISTEN_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (tcp6_listen_node) = -{ +VLIB_REGISTER_NODE (tcp6_listen_node) = { .name = "tcp6-listen", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, - .n_next_nodes = TCP_LISTEN_N_NEXT, - .next_nodes = - { -#define _(s,n) [TCP_LISTEN_NEXT_##s] = n, - foreach_tcp_state_next -#undef _ - }, + .error_counters = tcp_input_error_counters, .format_trace = format_tcp_rx_trace_short, }; -/* *INDENT-ON* */ -typedef enum _tcp_input_next +always_inline uword +tcp46_drop_inline (vlib_main_t *vm, vlib_node_runtime_t *node, + vlib_frame_t *frame, int is_ip4) { - TCP_INPUT_NEXT_DROP, - TCP_INPUT_NEXT_LISTEN, - TCP_INPUT_NEXT_RCV_PROCESS, - TCP_INPUT_NEXT_SYN_SENT, - TCP_INPUT_NEXT_ESTABLISHED, - TCP_INPUT_NEXT_RESET, - TCP_INPUT_NEXT_PUNT, - TCP_INPUT_N_NEXT -} tcp_input_next_t; - -#define foreach_tcp4_input_next \ - _ (DROP, "ip4-drop") \ - _ (LISTEN, "tcp4-listen") \ - _ (RCV_PROCESS, "tcp4-rcv-process") \ - _ (SYN_SENT, "tcp4-syn-sent") \ - _ (ESTABLISHED, "tcp4-established") \ - _ (RESET, "tcp4-reset") \ - _ (PUNT, "ip4-punt") + u32 *from = vlib_frame_vector_args (frame); -#define foreach_tcp6_input_next \ - _ (DROP, "ip6-drop") \ - _ (LISTEN, "tcp6-listen") \ - _ (RCV_PROCESS, "tcp6-rcv-process") \ - _ (SYN_SENT, "tcp6-syn-sent") \ - _ (ESTABLISHED, "tcp6-established") \ - _ (RESET, "tcp6-reset") \ - _ (PUNT, "ip6-punt") + /* Error counters must be incremented by previous nodes */ + vlib_buffer_free (vm, from, frame->n_vectors); -#define filter_flags (TCP_FLAG_SYN|TCP_FLAG_ACK|TCP_FLAG_RST|TCP_FLAG_FIN) + return frame->n_vectors; +} -static void -tcp_input_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node, - vlib_buffer_t ** bs, u32 n_bufs, u8 is_ip4) +VLIB_NODE_FN (tcp4_drop_node) +(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame) { - tcp_connection_t *tc; - tcp_header_t *tcp; - tcp_rx_trace_t *t; - int i; + return tcp46_drop_inline (vm, node, from_frame, 1 /* is_ip4 */); +} - for (i = 0; i < n_bufs; i++) - { - if (bs[i]->flags & VLIB_BUFFER_IS_TRACED) - { - t = vlib_add_trace (vm, node, bs[i], sizeof (*t)); - tc = tcp_connection_get (vnet_buffer (bs[i])->tcp.connection_index, - vm->thread_index); - tcp = vlib_buffer_get_current (bs[i]); - tcp_set_rx_trace_data (t, tc, tcp, bs[i], is_ip4); - } - } +VLIB_NODE_FN (tcp6_drop_node) +(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame) +{ + return tcp46_drop_inline (vm, node, from_frame, 0 /* is_ip4 */); } +VLIB_REGISTER_NODE (tcp4_drop_node) = { + .name = "tcp4-drop", + .vector_size = sizeof (u32), + .n_errors = TCP_N_ERROR, + .error_counters = tcp_input_error_counters, +}; + +VLIB_REGISTER_NODE (tcp6_drop_node) = { + .name = "tcp6-drop", + .vector_size = sizeof (u32), + .n_errors = TCP_N_ERROR, + .error_counters = tcp_input_error_counters, +}; + +#define foreach_tcp4_input_next \ + _ (DROP, "tcp4-drop") \ + _ (LISTEN, "tcp4-listen") \ + _ (RCV_PROCESS, "tcp4-rcv-process") \ + _ (SYN_SENT, "tcp4-syn-sent") \ + _ (ESTABLISHED, "tcp4-established") \ + _ (RESET, "tcp4-reset") \ + _ (PUNT, "ip4-punt") + +#define foreach_tcp6_input_next \ + _ (DROP, "tcp6-drop") \ + _ (LISTEN, "tcp6-listen") \ + _ (RCV_PROCESS, "tcp6-rcv-process") \ + _ (SYN_SENT, "tcp6-syn-sent") \ + _ (ESTABLISHED, "tcp6-established") \ + _ (RESET, "tcp6-reset") \ + _ (PUNT, "ip6-punt") + +#define filter_flags (TCP_FLAG_SYN|TCP_FLAG_ACK|TCP_FLAG_RST|TCP_FLAG_FIN) + static void tcp_input_set_error_next (tcp_main_t * tm, u16 * next, u32 * error, u8 is_ip4) { @@ -2829,9 +2756,8 @@ tcp_input_set_error_next (tcp_main_t * tm, u16 * next, u32 * error, u8 is_ip4) } static inline void -tcp_input_dispatch_buffer (tcp_main_t * tm, tcp_connection_t * tc, - vlib_buffer_t * b, u16 * next, - vlib_node_runtime_t * error_node) +tcp_input_dispatch_buffer (tcp_main_t *tm, tcp_connection_t *tc, + vlib_buffer_t *b, u16 *next, u16 *err_counters) { tcp_header_t *tcp; u32 error; @@ -2843,13 +2769,17 @@ tcp_input_dispatch_buffer (tcp_main_t * tm, tcp_connection_t * tc, error = tm->dispatch_table[tc->state][flags].error; tc->segs_in += 1; - /* Track connection state when packet was received. It helps - * @ref tcp46_listen_inline detect port reuse */ + /* Track connection state when packet was received. It is required + * for @ref tcp46_listen_inline to detect whether we reached + * the node as a result of a SYN packet received while in time-wait + * state. In this case the connection_index in vnet buffer will point + * to the existing tcp connection and not the listener + */ vnet_buffer (b)->tcp.flags = tc->state; if (PREDICT_FALSE (error != TCP_ERROR_NONE)) { - b->error = error_node->errors[error]; + tcp_inc_err_counter (err_counters, error, 1); if (error == TCP_ERROR_DISPATCH) clib_warning ("tcp conn %u disp error state %U flags %U", tc->c_c_index, format_tcp_state, tc->state, @@ -2865,6 +2795,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_main_t *tm = vnet_get_tcp_main (); vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; u16 nexts[VLIB_FRAME_SIZE], *next; + u16 err_counters[TCP_N_ERROR] = { 0 }; tcp_update_time_now (tcp_get_worker (thread_index)); @@ -2903,8 +2834,8 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index; - tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], node); - tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], node); + tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], err_counters); + tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], err_counters); } else { @@ -2912,24 +2843,26 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { ASSERT (tcp_lookup_is_valid (tc0, b[0], tcp_buffer_hdr (b[0]))); vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; - tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], node); + tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], + err_counters); } else { tcp_input_set_error_next (tm, &next[0], &error0, is_ip4); - b[0]->error = node->errors[error0]; + tcp_inc_err_counter (err_counters, error0, 1); } if (PREDICT_TRUE (tc1 != 0)) { ASSERT (tcp_lookup_is_valid (tc1, b[1], tcp_buffer_hdr (b[1]))); vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index; - tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], node); + tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], + err_counters); } else { tcp_input_set_error_next (tm, &next[1], &error1, is_ip4); - b[1]->error = node->errors[error1]; + tcp_inc_err_counter (err_counters, error1, 1); } } @@ -2955,12 +2888,12 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { ASSERT (tcp_lookup_is_valid (tc0, b[0], tcp_buffer_hdr (b[0]))); vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; - tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], node); + tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], err_counters); } else { tcp_input_set_error_next (tm, &next[0], &error0, is_ip4); - b[0]->error = node->errors[error0]; + tcp_inc_err_counter (err_counters, error0, 1); } b += 1; @@ -2969,8 +2902,9 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, } if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE)) - tcp_input_trace_frame (vm, node, bufs, frame->n_vectors, is_ip4); + tcp_input_trace_frame (vm, node, bufs, nexts, frame->n_vectors, is_ip4); + tcp_store_err_counters (input, err_counters); vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); return frame->n_vectors; } @@ -2991,14 +2925,13 @@ VLIB_NODE_FN (tcp6_input_nolookup_node) (vlib_main_t * vm, 1 /* is_nolookup */ ); } -/* *INDENT-OFF* */ VLIB_REGISTER_NODE (tcp4_input_nolookup_node) = { .name = "tcp4-input-nolookup", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, + .error_counters = tcp_input_error_counters, .n_next_nodes = TCP_INPUT_N_NEXT, .next_nodes = { @@ -3009,16 +2942,14 @@ VLIB_REGISTER_NODE (tcp4_input_nolookup_node) = .format_buffer = format_tcp_header, .format_trace = format_tcp_rx_trace, }; -/* *INDENT-ON* */ -/* *INDENT-OFF* */ VLIB_REGISTER_NODE (tcp6_input_nolookup_node) = { .name = "tcp6-input-nolookup", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, + .error_counters = tcp_input_error_counters, .n_next_nodes = TCP_INPUT_N_NEXT, .next_nodes = { @@ -3029,7 +2960,6 @@ VLIB_REGISTER_NODE (tcp6_input_nolookup_node) = .format_buffer = format_tcp_header, .format_trace = format_tcp_rx_trace, }; -/* *INDENT-ON* */ VLIB_NODE_FN (tcp4_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * from_frame) @@ -3045,14 +2975,13 @@ VLIB_NODE_FN (tcp6_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node, 0 /* is_nolookup */ ); } -/* *INDENT-OFF* */ VLIB_REGISTER_NODE (tcp4_input_node) = { .name = "tcp4-input", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, + .error_counters = tcp_input_error_counters, .n_next_nodes = TCP_INPUT_N_NEXT, .next_nodes = { @@ -3063,16 +2992,14 @@ VLIB_REGISTER_NODE (tcp4_input_node) = .format_buffer = format_tcp_header, .format_trace = format_tcp_rx_trace, }; -/* *INDENT-ON* */ -/* *INDENT-OFF* */ VLIB_REGISTER_NODE (tcp6_input_node) = { .name = "tcp6-input", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = TCP_N_ERROR, - .error_strings = tcp_error_strings, + .error_counters = tcp_input_error_counters, .n_next_nodes = TCP_INPUT_N_NEXT, .next_nodes = { @@ -3083,7 +3010,6 @@ VLIB_REGISTER_NODE (tcp6_input_node) = .format_buffer = format_tcp_header, .format_trace = format_tcp_rx_trace, }; -/* *INDENT-ON* */ #ifndef CLIB_MARCH_VARIANT void @@ -3269,6 +3195,8 @@ do { \ _(FIN_WAIT_2, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(FIN_WAIT_2, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); + _ (FIN_WAIT_2, TCP_FLAG_SYN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, + TCP_ERROR_NONE); _(CLOSE_WAIT, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(CLOSE_WAIT, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); @@ -3318,7 +3246,7 @@ do { \ _(CLOSED, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_DROP, TCP_ERROR_CONNECTION_CLOSED); _(CLOSED, TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET, TCP_ERROR_CONNECTION_CLOSED); - _(CLOSED, TCP_FLAG_SYN, TCP_INPUT_NEXT_RESET, TCP_ERROR_CONNECTION_CLOSED); + _ (CLOSED, TCP_FLAG_SYN, TCP_INPUT_NEXT_LISTEN, TCP_ERROR_NONE); _(CLOSED, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET, TCP_ERROR_CONNECTION_CLOSED); #undef _ |