X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Fnat%2Fnat44_cli.c;h=65f40753a3f668dc7935a1c9393cf5c8286de337;hb=9f57c72e27e21ce8dc8ebfee059711e3102d0c6b;hp=4f02896f4b95b7d8396acb88415fbf67f4c6716e;hpb=bb4e022502dd7f76d4f1cd705a7bac628d8c098c;p=vpp.git diff --git a/src/plugins/nat/nat44_cli.c b/src/plugins/nat/nat44_cli.c index 4f02896f4b9..65f40753a3f 100644 --- a/src/plugins/nat/nat44_cli.c +++ b/src/plugins/nat/nat44_cli.c @@ -19,30 +19,27 @@ #include #include -#include #include #include +#include #include #include +#include -#define UNSUPPORTED_IN_DET_MODE_STR \ - "This command is unsupported in deterministic mode" -#define SUPPORTED_ONLY_IN_DET_MODE_STR \ - "This command is supported only in deterministic mode" +#define UNSUPPORTED_IN_ED_MODE_STR \ + "This command is unsupported in endpoint dependent mode" +#define SUPPORTED_ONLY_IN_ED_MODE_STR \ + "This command is supported only in endpoint dependent mode" static clib_error_t * set_workers_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; - snat_main_t *sm = &snat_main; uword *bitmap = 0; int rv = 0; clib_error_t *error = 0; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) return 0; @@ -95,9 +92,6 @@ nat_show_workers_commnad_fn (vlib_main_t * vm, unformat_input_t * input, snat_main_t *sm = &snat_main; u32 *worker; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - if (sm->num_workers > 1) { vlib_cli_output (vm, "%d workers", vec_len (sm->workers)); @@ -114,6 +108,39 @@ nat_show_workers_commnad_fn (vlib_main_t * vm, unformat_input_t * input, return 0; } +static clib_error_t * +snat_set_log_level_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, *line_input = &_line_input; + snat_main_t *sm = &snat_main; + u8 log_level = SNAT_LOG_NONE; + clib_error_t *error = 0; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + if (!unformat (line_input, "%d", &log_level)) + { + error = clib_error_return (0, "unknown input '%U'", + format_unformat_error, line_input); + goto done; + } + if (log_level > SNAT_LOG_DEBUG) + { + error = clib_error_return (0, "unknown logging level '%d'", log_level); + goto done; + } + sm->log_level = log_level; + +done: + unformat_free (line_input); + + return error; +} + static clib_error_t * snat_ipfix_logging_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input, @@ -128,7 +155,13 @@ snat_ipfix_logging_enable_disable_command_fn (vlib_main_t * vm, /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) - return 0; + { + rv = snat_ipfix_logging_enable_disable (enable, domain_id, + (u16) src_port); + if (rv) + return clib_error_return (0, "ipfix logging enable failed"); + return 0; + } while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { @@ -161,7 +194,7 @@ done: } static clib_error_t * -nat44_show_hash_commnad_fn (vlib_main_t * vm, unformat_input_t * input, +nat44_show_hash_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { snat_main_t *sm = &snat_main; @@ -180,6 +213,7 @@ nat44_show_hash_commnad_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_output (vm, "%U", format_bihash_8_8, &sm->static_mapping_by_external, verbose); + vlib_cli_output (vm, "%U", format_bihash_16_8, &sm->out2in_ed, verbose); vec_foreach_index (i, sm->per_thread_data) { tsm = vec_elt_at_index (sm->per_thread_data, i); @@ -189,8 +223,6 @@ nat44_show_hash_commnad_fn (vlib_main_t * vm, unformat_input_t * input, { vlib_cli_output (vm, "%U", format_bihash_16_8, &tsm->in2out_ed, verbose); - vlib_cli_output (vm, "%U", format_bihash_16_8, &tsm->out2in_ed, - verbose); } else { @@ -201,8 +233,21 @@ nat44_show_hash_commnad_fn (vlib_main_t * vm, unformat_input_t * input, } if (sm->endpoint_dependent) - vlib_cli_output (vm, "%U", format_bihash_16_8, &nam->affinity_hash, - verbose); + { + vlib_cli_output (vm, "%U", format_bihash_16_8, &nam->affinity_hash, + verbose); + } + + vlib_cli_output (vm, "-------- hash table parameters --------\n"); + vlib_cli_output (vm, "translation buckets: %u", sm->translation_buckets); + vlib_cli_output (vm, "translation memory size: %U", + format_memory_size, sm->translation_memory_size); + if (!sm->endpoint_dependent) + { + vlib_cli_output (vm, "user buckets: %u", sm->user_buckets); + vlib_cli_output (vm, "user memory size: %U", + format_memory_size, sm->user_memory_size); + } return 0; } @@ -212,13 +257,9 @@ nat44_set_alloc_addr_and_port_alg_command_fn (vlib_main_t * vm, vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; - snat_main_t *sm = &snat_main; clib_error_t *error = 0; u32 psid, psid_offset, psid_length, port_start, port_end; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) return 0; @@ -268,9 +309,6 @@ nat44_show_alloc_addr_and_port_alg_command_fn (vlib_main_t * vm, { snat_main_t *sm = &snat_main; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - vlib_cli_output (vm, "NAT address and port: %U", format_nat_addr_and_port_alloc_alg, sm->addr_and_port_alloc_alg); @@ -309,10 +347,7 @@ nat_set_mss_clamping_command_fn (vlib_main_t * vm, unformat_input_t * input, if (unformat (line_input, "disable")) sm->mss_clamping = 0; else if (unformat (line_input, "%d", &mss)) - { - sm->mss_clamping = (u16) mss; - sm->mss_value_net = clib_host_to_net_u16 (sm->mss_clamping); - } + sm->mss_clamping = (u16) mss; else { error = clib_error_return (0, "unknown input '%U'", @@ -341,6 +376,143 @@ nat_show_mss_clamping_command_fn (vlib_main_t * vm, unformat_input_t * input, return 0; } +static clib_error_t * +nat_ha_failover_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, *line_input = &_line_input; + ip4_address_t addr; + u32 port, session_refresh_interval = 10; + int rv; + clib_error_t *error = 0; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "%U:%u", unformat_ip4_address, &addr, &port)) + ; + else + if (unformat + (line_input, "refresh-interval %u", &session_refresh_interval)) + ; + else + { + error = clib_error_return (0, "unknown input '%U'", + format_unformat_error, line_input); + goto done; + } + } + + rv = nat_ha_set_failover (&addr, (u16) port, session_refresh_interval); + if (rv) + error = clib_error_return (0, "set HA failover failed"); + +done: + unformat_free (line_input); + + return error; +} + +static clib_error_t * +nat_ha_listener_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, *line_input = &_line_input; + ip4_address_t addr; + u32 port, path_mtu = 512; + int rv; + clib_error_t *error = 0; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "%U:%u", unformat_ip4_address, &addr, &port)) + ; + else if (unformat (line_input, "path-mtu %u", &path_mtu)) + ; + else + { + error = clib_error_return (0, "unknown input '%U'", + format_unformat_error, line_input); + goto done; + } + } + + rv = nat_ha_set_listener (&addr, (u16) port, path_mtu); + if (rv) + error = clib_error_return (0, "set HA listener failed"); + +done: + unformat_free (line_input); + + return error; +} + +static clib_error_t * +nat_show_ha_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + ip4_address_t addr; + u16 port; + u32 path_mtu, session_refresh_interval, resync_ack_missed; + u8 in_resync; + + nat_ha_get_listener (&addr, &port, &path_mtu); + if (!port) + { + vlib_cli_output (vm, "NAT HA disabled\n"); + return 0; + } + + vlib_cli_output (vm, "LISTENER:\n"); + vlib_cli_output (vm, " %U:%u path-mtu %u\n", + format_ip4_address, &addr, port, path_mtu); + + nat_ha_get_failover (&addr, &port, &session_refresh_interval); + vlib_cli_output (vm, "FAILOVER:\n"); + if (port) + vlib_cli_output (vm, " %U:%u refresh-interval %usec\n", + format_ip4_address, &addr, port, + session_refresh_interval); + else + vlib_cli_output (vm, " NA\n"); + + nat_ha_get_resync_status (&in_resync, &resync_ack_missed); + vlib_cli_output (vm, "RESYNC:\n"); + if (in_resync) + vlib_cli_output (vm, " in progress\n"); + else + vlib_cli_output (vm, " completed (%d ACK missed)\n", resync_ack_missed); + + return 0; +} + +static clib_error_t * +nat_ha_flush_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + nat_ha_flush (0); + return 0; +} + +static clib_error_t * +nat_ha_resync_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + clib_error_t *error = 0; + + if (nat_ha_resync (0, 0, 0)) + error = clib_error_return (0, "NAT HA resync already running"); + + return error; +} + static clib_error_t * add_address_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) @@ -356,9 +528,6 @@ add_address_command_fn (vlib_main_t * vm, clib_error_t *error = 0; u8 twice_nat = 0; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) return 0; @@ -449,6 +618,178 @@ done: return error; } +static void +nat44_show_lru_summary (vlib_main_t * vm, snat_main_per_thread_data_t * tsm, + u64 now, u64 sess_timeout_time) +{ + snat_main_t *sm = &snat_main; + dlist_elt_t *oldest_elt; + snat_session_t *s; + u32 oldest_index; + +#define _(n, d) \ + oldest_index = \ + clib_dlist_remove_head (tsm->lru_pool, tsm->n##_lru_head_index); \ + if (~0 != oldest_index) \ + { \ + oldest_elt = pool_elt_at_index (tsm->lru_pool, oldest_index); \ + s = pool_elt_at_index (tsm->sessions, oldest_elt->value); \ + sess_timeout_time = \ + s->last_heard + (f64)nat44_session_get_timeout (sm, s); \ + vlib_cli_output (vm, d " LRU min session timeout %llu (now %llu)", \ + sess_timeout_time, now); \ + clib_dlist_addhead (tsm->lru_pool, tsm->n##_lru_head_index, \ + oldest_index); \ + } + _(tcp_estab, "established tcp"); + _(tcp_trans, "transitory tcp"); + _(udp, "udp"); + _(unk_proto, "unknown protocol"); + _(icmp, "icmp"); +#undef _ +} + +static clib_error_t * +nat44_show_summary_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + snat_main_per_thread_data_t *tsm; + snat_main_t *sm = &snat_main; + snat_session_t *s; + + if (!sm->endpoint_dependent) + return clib_error_return (0, SUPPORTED_ONLY_IN_ED_MODE_STR); + + u32 count = 0; + + u64 now = vlib_time_now (vm); + u64 sess_timeout_time; + + u32 udp_sessions = 0; + u32 tcp_sessions = 0; + u32 icmp_sessions = 0; + + u32 timed_out = 0; + u32 transitory = 0; + u32 transitory_wait_closed = 0; + u32 transitory_closed = 0; + u32 established = 0; + + u32 fib; + + for (fib = 0; fib < vec_len (sm->max_translations_per_fib); fib++) + vlib_cli_output (vm, "max translations per thread: %u fib %u", + sm->max_translations_per_fib[fib], fib); + + if (sm->num_workers > 1) + { + /* *INDENT-OFF* */ + vec_foreach (tsm, sm->per_thread_data) + { + pool_foreach (s, tsm->sessions, + ({ + sess_timeout_time = s->last_heard + + (f64) nat44_session_get_timeout (sm, s); + if (now >= sess_timeout_time) + timed_out++; + + switch (s->nat_proto) + { + case NAT_PROTOCOL_ICMP: + icmp_sessions++; + break; + case NAT_PROTOCOL_TCP: + tcp_sessions++; + if (s->state) + { + if (s->tcp_closed_timestamp) + { + if (now >= s->tcp_closed_timestamp) + { + ++transitory_closed; + } + else + { + ++transitory_wait_closed; + } + } + transitory++; + } + else + established++; + break; + case NAT_PROTOCOL_UDP: + default: + udp_sessions++; + break; + } + })); + nat44_show_lru_summary (vm, tsm, now, sess_timeout_time); + count += pool_elts (tsm->sessions); + } + /* *INDENT-ON* */ + } + else + { + tsm = vec_elt_at_index (sm->per_thread_data, sm->num_workers); + /* *INDENT-OFF* */ + pool_foreach (s, tsm->sessions, + ({ + sess_timeout_time = s->last_heard + + (f64) nat44_session_get_timeout (sm, s); + if (now >= sess_timeout_time) + timed_out++; + + switch (s->nat_proto) + { + case NAT_PROTOCOL_ICMP: + icmp_sessions++; + break; + case NAT_PROTOCOL_TCP: + tcp_sessions++; + if (s->state) + { + if (s->tcp_closed_timestamp) + { + if (now >= s->tcp_closed_timestamp) + { + ++transitory_closed; + } + else + { + ++transitory_wait_closed; + } + } + transitory++; + } + else + established++; + break; + case NAT_PROTOCOL_UDP: + default: + udp_sessions++; + break; + } + })); + /* *INDENT-ON* */ + nat44_show_lru_summary (vm, tsm, now, sess_timeout_time); + count = pool_elts (tsm->sessions); + } + + vlib_cli_output (vm, "total timed out sessions: %u", timed_out); + vlib_cli_output (vm, "total sessions: %u", count); + vlib_cli_output (vm, "total tcp sessions: %u", tcp_sessions); + vlib_cli_output (vm, "total tcp established sessions: %u", established); + vlib_cli_output (vm, "total tcp transitory sessions: %u", transitory); + vlib_cli_output (vm, "total tcp transitory (WAIT-CLOSED) sessions: %u", + transitory_wait_closed); + vlib_cli_output (vm, "total tcp transitory (CLOSED) sessions: %u", + transitory_closed); + vlib_cli_output (vm, "total udp sessions: %u", udp_sessions); + vlib_cli_output (vm, "total icmp sessions: %u", icmp_sessions); + return 0; +} + static clib_error_t * nat44_show_addresses_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) @@ -456,9 +797,6 @@ nat44_show_addresses_command_fn (vlib_main_t * vm, unformat_input_t * input, snat_main_t *sm = &snat_main; snat_address_t *ap; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - vlib_cli_output (vm, "NAT44 pool addresses:"); /* *INDENT-OFF* */ vec_foreach (ap, sm->addresses) @@ -471,7 +809,7 @@ nat44_show_addresses_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_output (vm, " tenant VRF independent"); #define _(N, i, n, s) \ vlib_cli_output (vm, " %d busy %s ports", ap->busy_##n##_ports, s); - foreach_snat_protocol + foreach_nat_protocol #undef _ } vlib_cli_output (vm, "NAT44 twice-nat pool addresses:"); @@ -485,7 +823,7 @@ nat44_show_addresses_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_output (vm, " tenant VRF independent"); #define _(N, i, n, s) \ vlib_cli_output (vm, " %d busy %s ports", ap->busy_##n##_ports, s); - foreach_snat_protocol + foreach_nat_protocol #undef _ } /* *INDENT-ON* */ @@ -641,7 +979,6 @@ add_static_mapping_command_fn (vlib_main_t * vm, vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; - snat_main_t *sm = &snat_main; clib_error_t *error = 0; ip4_address_t l_addr, e_addr; u32 l_port = 0, e_port = 0, vrf_id = ~0; @@ -650,14 +987,11 @@ add_static_mapping_command_fn (vlib_main_t * vm, u32 sw_if_index = ~0; vnet_main_t *vnm = vnet_get_main (); int rv; - snat_protocol_t proto = ~0; + nat_protocol_t proto = NAT_PROTOCOL_OTHER; u8 proto_set = 0; twice_nat_type_t twice_nat = TWICE_NAT_DISABLED; u8 out2in_only = 0; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) return 0; @@ -686,7 +1020,7 @@ add_static_mapping_command_fn (vlib_main_t * vm, ; else if (unformat (line_input, "vrf %u", &vrf_id)) ; - else if (unformat (line_input, "%U", unformat_snat_protocol, &proto)) + else if (unformat (line_input, "%U", unformat_nat_protocol, &proto)) proto_set = 1; else if (unformat (line_input, "twice-nat")) twice_nat = TWICE_NAT; @@ -710,15 +1044,26 @@ add_static_mapping_command_fn (vlib_main_t * vm, goto done; } - if (!addr_only && !proto_set) + if (addr_only) { - error = clib_error_return (0, "missing protocol"); + if (proto_set) + { + error = + clib_error_return (0, + "address only mapping doesn't support protocol"); + goto done; + } + } + else if (!proto_set) + { + error = clib_error_return (0, "protocol is required"); goto done; } - rv = snat_add_static_mapping (l_addr, e_addr, (u16) l_port, (u16) e_port, + rv = snat_add_static_mapping (l_addr, e_addr, clib_host_to_net_u16 (l_port), + clib_host_to_net_u16 (e_port), vrf_id, addr_only, sw_if_index, proto, is_add, - twice_nat, out2in_only, 0); + twice_nat, out2in_only, 0, 0); switch (rv) { @@ -727,7 +1072,7 @@ add_static_mapping_command_fn (vlib_main_t * vm, goto done; case VNET_API_ERROR_NO_SUCH_ENTRY: if (is_add) - error = clib_error_return (0, "External addres must be allocated."); + error = clib_error_return (0, "External address must be allocated."); else error = clib_error_return (0, "Mapping not exist."); goto done; @@ -758,7 +1103,6 @@ add_identity_mapping_command_fn (vlib_main_t * vm, vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; - snat_main_t *sm = &snat_main; clib_error_t *error = 0; ip4_address_t addr; u32 port = 0, vrf_id = ~0; @@ -767,10 +1111,7 @@ add_identity_mapping_command_fn (vlib_main_t * vm, u32 sw_if_index = ~0; vnet_main_t *vnm = vnet_get_main (); int rv; - snat_protocol_t proto; - - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); + nat_protocol_t proto; addr.as_u32 = 0; @@ -787,7 +1128,7 @@ add_identity_mapping_command_fn (vlib_main_t * vm, ; else if (unformat (line_input, "vrf %u", &vrf_id)) ; - else if (unformat (line_input, "%U %u", unformat_snat_protocol, &proto, + else if (unformat (line_input, "%U %u", unformat_nat_protocol, &proto, &port)) addr_only = 0; else if (unformat (line_input, "del")) @@ -800,9 +1141,10 @@ add_identity_mapping_command_fn (vlib_main_t * vm, } } - rv = snat_add_static_mapping (addr, addr, (u16) port, (u16) port, - vrf_id, addr_only, sw_if_index, proto, is_add, - 0, 0, 0); + rv = + snat_add_static_mapping (addr, addr, clib_host_to_net_u16 (port), + clib_host_to_net_u16 (port), vrf_id, addr_only, + sw_if_index, proto, is_add, 0, 0, 0, 1); switch (rv) { @@ -811,7 +1153,7 @@ add_identity_mapping_command_fn (vlib_main_t * vm, goto done; case VNET_API_ERROR_NO_SUCH_ENTRY: if (is_add) - error = clib_error_return (0, "External addres must be allocated."); + error = clib_error_return (0, "External address must be allocated."); else error = clib_error_return (0, "Mapping not exist."); goto done; @@ -837,21 +1179,17 @@ add_lb_static_mapping_command_fn (vlib_main_t * vm, vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; - snat_main_t *sm = &snat_main; clib_error_t *error = 0; ip4_address_t l_addr, e_addr; u32 l_port = 0, e_port = 0, vrf_id = 0, probability = 0, affinity = 0; int is_add = 1; int rv; - snat_protocol_t proto; + nat_protocol_t proto; u8 proto_set = 0; nat44_lb_addr_port_t *locals = 0, local; twice_nat_type_t twice_nat = TWICE_NAT_DISABLED; u8 out2in_only = 0; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) return 0; @@ -861,7 +1199,7 @@ add_lb_static_mapping_command_fn (vlib_main_t * vm, if (unformat (line_input, "local %U:%u probability %u", unformat_ip4_address, &l_addr, &l_port, &probability)) { - memset (&local, 0, sizeof (local)); + clib_memset (&local, 0, sizeof (local)); local.addr = l_addr; local.port = (u16) l_port; local.probability = (u8) probability; @@ -871,7 +1209,7 @@ add_lb_static_mapping_command_fn (vlib_main_t * vm, unformat_ip4_address, &l_addr, &l_port, &vrf_id, &probability)) { - memset (&local, 0, sizeof (local)); + clib_memset (&local, 0, sizeof (local)); local.addr = l_addr; local.port = (u16) l_port; local.probability = (u8) probability; @@ -881,7 +1219,7 @@ add_lb_static_mapping_command_fn (vlib_main_t * vm, else if (unformat (line_input, "external %U:%u", unformat_ip4_address, &e_addr, &e_port)) ; - else if (unformat (line_input, "protocol %U", unformat_snat_protocol, + else if (unformat (line_input, "protocol %U", unformat_nat_protocol, &proto)) proto_set = 1; else if (unformat (line_input, "twice-nat")) @@ -925,7 +1263,7 @@ add_lb_static_mapping_command_fn (vlib_main_t * vm, goto done; case VNET_API_ERROR_NO_SUCH_ENTRY: if (is_add) - error = clib_error_return (0, "External addres must be allocated."); + error = clib_error_return (0, "External address must be allocated."); else error = clib_error_return (0, "Mapping not exist."); goto done; @@ -948,45 +1286,17 @@ done: } static clib_error_t * -nat44_show_static_mappings_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - snat_main_t *sm = &snat_main; - snat_static_mapping_t *m; - snat_static_map_resolve_t *rp; - - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - - vlib_cli_output (vm, "NAT44 static mappings:"); - /* *INDENT-OFF* */ - pool_foreach (m, sm->static_mappings, - ({ - vlib_cli_output (vm, " %U", format_snat_static_mapping, m); - })); - vec_foreach (rp, sm->to_resolve) - vlib_cli_output (vm, " %U", format_snat_static_map_to_resolve, rp); - /* *INDENT-ON* */ - - return 0; -} - -static clib_error_t * -snat_add_interface_address_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +add_lb_backend_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - u32 sw_if_index; - int rv; - int is_del = 0; clib_error_t *error = 0; - u8 twice_nat = 0; - - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); + ip4_address_t l_addr, e_addr; + u32 l_port = 0, e_port = 0, vrf_id = 0, probability = 0; + int is_add = 1; + int rv; + nat_protocol_t proto; + u8 proto_set = 0; /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) @@ -994,37 +1304,147 @@ snat_add_interface_address_command_fn (vlib_main_t * vm, while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "%U", unformat_vnet_sw_interface, - sm->vnet_main, &sw_if_index)) + if (unformat (line_input, "local %U:%u probability %u", + unformat_ip4_address, &l_addr, &l_port, &probability)) ; - else if (unformat (line_input, "twice-nat")) - twice_nat = 1; + else if (unformat (line_input, "local %U:%u vrf %u probability %u", + unformat_ip4_address, &l_addr, &l_port, &vrf_id, + &probability)) + ; + else if (unformat (line_input, "external %U:%u", unformat_ip4_address, + &e_addr, &e_port)) + ; + else if (unformat (line_input, "protocol %U", unformat_nat_protocol, + &proto)) + proto_set = 1; else if (unformat (line_input, "del")) - is_del = 1; + is_add = 0; else { - error = clib_error_return (0, "unknown input '%U'", + error = clib_error_return (0, "unknown input: '%U'", format_unformat_error, line_input); goto done; } } - rv = snat_add_interface_address (sm, sw_if_index, is_del, twice_nat); - - switch (rv) + if (!l_port || !e_port) { - case 0: - break; - - default: - error = clib_error_return (0, "snat_add_interface_address returned %d", - rv); + error = clib_error_return (0, "local or external must be set"); goto done; } -done: - unformat_free (line_input); - + if (!proto_set) + { + error = clib_error_return (0, "missing protocol"); + goto done; + } + + rv = + nat44_lb_static_mapping_add_del_local (e_addr, (u16) e_port, l_addr, + l_port, proto, vrf_id, probability, + is_add); + + switch (rv) + { + case VNET_API_ERROR_INVALID_VALUE: + error = clib_error_return (0, "External is not load-balancing static " + "mapping."); + goto done; + case VNET_API_ERROR_NO_SUCH_ENTRY: + error = clib_error_return (0, "Mapping or back-end not exist."); + goto done; + case VNET_API_ERROR_VALUE_EXIST: + error = clib_error_return (0, "Back-end already exist."); + goto done; + case VNET_API_ERROR_FEATURE_DISABLED: + error = + clib_error_return (0, "Available only for endpoint-dependent mode."); + goto done; + case VNET_API_ERROR_UNSPECIFIED: + error = clib_error_return (0, "At least two back-ends must remain"); + goto done; + default: + break; + } + +done: + unformat_free (line_input); + + return error; +} + +static clib_error_t * +nat44_show_static_mappings_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + snat_main_t *sm = &snat_main; + snat_static_mapping_t *m; + snat_static_map_resolve_t *rp; + + vlib_cli_output (vm, "NAT44 static mappings:"); + /* *INDENT-OFF* */ + pool_foreach (m, sm->static_mappings, + ({ + vlib_cli_output (vm, " %U", format_snat_static_mapping, m); + })); + vec_foreach (rp, sm->to_resolve) + vlib_cli_output (vm, " %U", format_snat_static_map_to_resolve, rp); + /* *INDENT-ON* */ + + return 0; +} + +static clib_error_t * +snat_add_interface_address_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + snat_main_t *sm = &snat_main; + unformat_input_t _line_input, *line_input = &_line_input; + u32 sw_if_index; + int rv; + int is_del = 0; + clib_error_t *error = 0; + u8 twice_nat = 0; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "%U", unformat_vnet_sw_interface, + sm->vnet_main, &sw_if_index)) + ; + else if (unformat (line_input, "twice-nat")) + twice_nat = 1; + else if (unformat (line_input, "del")) + is_del = 1; + else + { + error = clib_error_return (0, "unknown input '%U'", + format_unformat_error, line_input); + goto done; + } + } + + rv = snat_add_interface_address (sm, sw_if_index, is_del, twice_nat); + + switch (rv) + { + case 0: + break; + + default: + error = clib_error_return (0, "snat_add_interface_address returned %d", + rv); + goto done; + } + +done: + unformat_free (line_input); + return error; } @@ -1037,9 +1457,6 @@ nat44_show_interface_address_command_fn (vlib_main_t * vm, vnet_main_t *vnm = vnet_get_main (); u32 *sw_if_index; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - /* *INDENT-OFF* */ vlib_cli_output (vm, "NAT44 pool address interfaces:"); vec_foreach (sw_if_index, sm->auto_add_sw_if_indices) @@ -1062,143 +1479,87 @@ static clib_error_t * nat44_show_sessions_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { - int verbose = 0; - snat_main_t *sm = &snat_main; - snat_main_per_thread_data_t *tsm; - snat_user_t *u; - int i = 0; - - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); - - if (unformat (input, "detail")) - verbose = 1; - - vlib_cli_output (vm, "NAT44 sessions:"); - - /* *INDENT-OFF* */ - vec_foreach_index (i, sm->per_thread_data) - { - tsm = vec_elt_at_index (sm->per_thread_data, i); - - vlib_cli_output (vm, "-------- thread %d %s: %d sessions --------\n", - i, vlib_worker_threads[i].name, - pool_elts (tsm->sessions)); - pool_foreach (u, tsm->users, - ({ - vlib_cli_output (vm, " %U", format_snat_user, tsm, u, verbose); - })); - } - /* *INDENT-ON* */ - - return 0; -} - -static clib_error_t * -nat44_del_session_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - int is_in = 0, is_ed = 0; clib_error_t *error = 0; - ip4_address_t addr, eh_addr; - u32 port = 0, eh_port = 0, vrf_id = sm->outside_vrf_id; - snat_protocol_t proto; - int rv; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); + snat_main_per_thread_data_t *tsm; + snat_main_t *sm = &snat_main; + + int detail = 0; + int i = 0; - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) - return 0; + goto print; while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat - (line_input, "%U:%u %U", unformat_ip4_address, &addr, &port, - unformat_snat_protocol, &proto)) - ; - else if (unformat (line_input, "in")) - { - is_in = 1; - vrf_id = sm->inside_vrf_id; - } - else if (unformat (line_input, "out")) - { - is_in = 0; - vrf_id = sm->outside_vrf_id; - } - else if (unformat (line_input, "vrf %u", &vrf_id)) - ; - else - if (unformat - (line_input, "external-host %U:%u", unformat_ip4_address, - &eh_addr, &eh_port)) - is_ed = 1; + if (unformat (line_input, "detail")) + detail = 1; else { error = clib_error_return (0, "unknown input '%U'", format_unformat_error, line_input); - goto done; + break; } } + unformat_free (line_input); - if (is_ed) - rv = - nat44_del_ed_session (sm, &addr, port, &eh_addr, eh_port, - snat_proto_to_ip_proto (proto), vrf_id, is_in); +print: + if (!sm->endpoint_dependent) + vlib_cli_output (vm, "NAT44 sessions:"); else - rv = nat44_del_session (sm, &addr, port, proto, vrf_id, is_in); + vlib_cli_output (vm, "NAT44 ED sessions:"); - switch (rv) + /* *INDENT-OFF* */ + vec_foreach_index (i, sm->per_thread_data) { - case 0: - break; - - default: - error = clib_error_return (0, "nat44_del_session returned %d", rv); - goto done; - } + tsm = vec_elt_at_index (sm->per_thread_data, i); -done: - unformat_free (line_input); + vlib_cli_output (vm, "-------- thread %d %s: %d sessions --------\n", + i, vlib_worker_threads[i].name, + pool_elts (tsm->sessions)); + if (!sm->endpoint_dependent) + { + snat_user_t *u; + pool_foreach (u, tsm->users, + ({ + vlib_cli_output (vm, " %U", format_snat_user, tsm, u, detail); + })); + } + else + { + snat_session_t *s; + pool_foreach (s, tsm->sessions, + ({ + vlib_cli_output (vm, " %U\n", format_snat_session, tsm, s); + })); + } + } + /* *INDENT-ON* */ return error; } static clib_error_t * -snat_forwarding_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +nat44_set_session_limit_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { - snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - u8 forwarding_enable; - u8 forwarding_enable_set = 0; clib_error_t *error = 0; - if (sm->deterministic) - return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR); + u32 session_limit = 0, vrf_id = 0; /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) - return clib_error_return (0, "'enable' or 'disable' expected"); + return 0; while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (!forwarding_enable_set && unformat (line_input, "enable")) - { - forwarding_enable = 1; - forwarding_enable_set = 1; - } - else if (!forwarding_enable_set && unformat (line_input, "disable")) - { - forwarding_enable = 0; - forwarding_enable_set = 1; - } + if (unformat (line_input, "%u", &session_limit)) + ; + else if (unformat (line_input, "vrf %u", &vrf_id)) + ; else { error = clib_error_return (0, "unknown input '%U'", @@ -1207,13 +1568,10 @@ snat_forwarding_set_command_fn (vlib_main_t * vm, } } - if (!forwarding_enable_set) - { - error = clib_error_return (0, "'enable' or 'disable' expected"); - goto done; - } - - sm->forwarding_enabled = forwarding_enable; + if (!session_limit) + error = clib_error_return (0, "missing value of session limit"); + else if (nat44_update_session_limit (session_limit, vrf_id)) + error = clib_error_return (0, "nat44_set_session_limit failed"); done: unformat_free (line_input); @@ -1222,18 +1580,18 @@ done: } static clib_error_t * -snat_det_map_command_fn (vlib_main_t * vm, - unformat_input_t * input, vlib_cli_command_t * cmd) +nat44_del_user_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - ip4_address_t in_addr, out_addr; - u32 in_plen, out_plen; - int is_add = 1, rv; clib_error_t *error = 0; + ip4_address_t addr; + u32 fib_index = 0; + int rv; - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); + if (sm->endpoint_dependent) + return clib_error_return (0, UNSUPPORTED_IN_ED_MODE_STR); /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) @@ -1241,16 +1599,10 @@ snat_det_map_command_fn (vlib_main_t * vm, while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat - (line_input, "in %U/%u", unformat_ip4_address, &in_addr, &in_plen)) + if (unformat (line_input, "%U", unformat_ip4_address, &addr)) ; - else - if (unformat - (line_input, "out %U/%u", unformat_ip4_address, &out_addr, - &out_plen)) + else if (unformat (line_input, "fib %u", &fib_index)) ; - else if (unformat (line_input, "del")) - is_add = 0; else { error = clib_error_return (0, "unknown input '%U'", @@ -1259,13 +1611,11 @@ snat_det_map_command_fn (vlib_main_t * vm, } } - rv = snat_det_add_map (sm, &in_addr, (u8) in_plen, &out_addr, (u8) out_plen, - is_add); + rv = nat44_user_del (&addr, fib_index); - if (rv) + if (!rv) { - error = clib_error_return (0, "snat_det_add_map return %d", rv); - goto done; + error = clib_error_return (0, "nat44_user_del returned %d", rv); } done: @@ -1275,48 +1625,28 @@ done: } static clib_error_t * -nat44_det_show_mappings_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +nat44_clear_sessions_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { - snat_main_t *sm = &snat_main; - snat_det_map_t *dm; - - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); - - vlib_cli_output (vm, "NAT44 deterministic mappings:"); - /* *INDENT-OFF* */ - pool_foreach (dm, sm->det_maps, - ({ - vlib_cli_output (vm, " in %U/%d out %U/%d\n", - format_ip4_address, &dm->in_addr, dm->in_plen, - format_ip4_address, &dm->out_addr, dm->out_plen); - vlib_cli_output (vm, " outside address sharing ratio: %d\n", - dm->sharing_ratio); - vlib_cli_output (vm, " number of ports per inside host: %d\n", - dm->ports_per_host); - vlib_cli_output (vm, " sessions number: %d\n", dm->ses_num); - })); - /* *INDENT-ON* */ - - return 0; + clib_error_t *error = 0; + nat44_sessions_clear (); + return error; } static clib_error_t * -snat_det_forward_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +nat44_del_session_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - ip4_address_t in_addr, out_addr; - u16 lo_port; - snat_det_map_t *dm; + int is_in = 0, is_ed = 0; clib_error_t *error = 0; - - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); + ip4_address_t addr, eh_addr; + u32 port = 0, eh_port = 0, vrf_id = sm->outside_vrf_id; + nat_protocol_t proto; + int rv; /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) @@ -1324,8 +1654,27 @@ snat_det_forward_command_fn (vlib_main_t * vm, while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "%U", unformat_ip4_address, &in_addr)) + if (unformat + (line_input, "%U:%u %U", unformat_ip4_address, &addr, &port, + unformat_nat_protocol, &proto)) + ; + else if (unformat (line_input, "in")) + { + is_in = 1; + vrf_id = sm->inside_vrf_id; + } + else if (unformat (line_input, "out")) + { + is_in = 0; + vrf_id = sm->outside_vrf_id; + } + else if (unformat (line_input, "vrf %u", &vrf_id)) ; + else + if (unformat + (line_input, "external-host %U:%u", unformat_ip4_address, + &eh_addr, &eh_port)) + is_ed = 1; else { error = clib_error_return (0, "unknown input '%U'", @@ -1334,14 +1683,24 @@ snat_det_forward_command_fn (vlib_main_t * vm, } } - dm = snat_det_map_by_user (sm, &in_addr); - if (!dm) - vlib_cli_output (vm, "no match"); + if (is_ed) + rv = + nat44_del_ed_session (sm, &addr, clib_host_to_net_u16 (port), &eh_addr, + clib_host_to_net_u16 (eh_port), + nat_proto_to_ip_proto (proto), vrf_id, is_in); else + rv = + nat44_del_session (sm, &addr, clib_host_to_net_u16 (port), proto, + vrf_id, is_in); + + switch (rv) { - snat_det_forward (dm, &in_addr, &out_addr, &lo_port); - vlib_cli_output (vm, "%U:<%d-%d>", format_ip4_address, &out_addr, - lo_port, lo_port + dm->ports_per_host - 1); + case 0: + break; + + default: + error = clib_error_return (0, "nat44_del_session returned %d", rv); + goto done; } done: @@ -1351,29 +1710,32 @@ done: } static clib_error_t * -snat_det_reverse_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +snat_forwarding_set_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - ip4_address_t in_addr, out_addr; - u32 out_port; - snat_det_map_t *dm; + u8 forwarding_enable; + u8 forwarding_enable_set = 0; clib_error_t *error = 0; - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); - /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) - return 0; + return clib_error_return (0, "'enable' or 'disable' expected"); while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat - (line_input, "%U:%d", unformat_ip4_address, &out_addr, &out_port)) - ; + if (!forwarding_enable_set && unformat (line_input, "enable")) + { + forwarding_enable = 1; + forwarding_enable_set = 1; + } + else if (!forwarding_enable_set && unformat (line_input, "disable")) + { + forwarding_enable = 0; + forwarding_enable_set = 1; + } else { error = clib_error_return (0, "unknown input '%U'", @@ -1382,20 +1744,13 @@ snat_det_reverse_command_fn (vlib_main_t * vm, } } - if (out_port < 1024 || out_port > 65535) + if (!forwarding_enable_set) { - error = clib_error_return (0, "wrong port, must be <1024-65535>"); + error = clib_error_return (0, "'enable' or 'disable' expected"); goto done; } - dm = snat_det_map_by_out (sm, &out_addr); - if (!dm) - vlib_cli_output (vm, "no match"); - else - { - snat_det_reverse (dm, &out_addr, (u16) out_port, &in_addr); - vlib_cli_output (vm, "%U", format_ip4_address, &in_addr); - } + sm->forwarding_enabled = forwarding_enable; done: unformat_free (line_input); @@ -1474,10 +1829,8 @@ set_timeout_command_fn (vlib_main_t * vm, goto done; } } - done: unformat_free (line_input); - return error; } @@ -1499,49 +1852,13 @@ nat_show_timeouts_command_fn (vlib_main_t * vm, } static clib_error_t * -nat44_det_show_sessions_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - snat_main_t *sm = &snat_main; - snat_det_map_t *dm; - snat_det_session_t *ses; - int i; - - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); - - vlib_cli_output (vm, "NAT44 deterministic sessions:"); - /* *INDENT-OFF* */ - pool_foreach (dm, sm->det_maps, - ({ - vec_foreach_index (i, dm->sessions) - { - ses = vec_elt_at_index (dm->sessions, i); - if (ses->in_port) - vlib_cli_output (vm, " %U", format_det_map_ses, dm, ses, &i); - } - })); - /* *INDENT-ON* */ - return 0; -} - -static clib_error_t * -snat_det_close_session_out_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +nat44_debug_fib_expire_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { - snat_main_t *sm = &snat_main; unformat_input_t _line_input, *line_input = &_line_input; - ip4_address_t out_addr, ext_addr, in_addr; - u32 out_port, ext_port; - snat_det_map_t *dm; - snat_det_session_t *ses; - snat_det_out_key_t key; clib_error_t *error = 0; - - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); + u32 fib = ~0; /* Get a line of input. */ if (!unformat_user (input, unformat_line_input, line_input)) @@ -1549,9 +1866,7 @@ snat_det_close_session_out_fn (vlib_main_t * vm, while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "%U:%d %U:%d", - unformat_ip4_address, &out_addr, &out_port, - unformat_ip4_address, &ext_addr, &ext_port)) + if (unformat (line_input, "%u", &fib)) ; else { @@ -1560,89 +1875,54 @@ snat_det_close_session_out_fn (vlib_main_t * vm, goto done; } } - - unformat_free (line_input); - - dm = snat_det_map_by_out (sm, &out_addr); - if (!dm) - vlib_cli_output (vm, "no match"); - else - { - snat_det_reverse (dm, &ext_addr, (u16) out_port, &in_addr); - key.ext_host_addr = out_addr; - key.ext_host_port = ntohs ((u16) ext_port); - key.out_port = ntohs ((u16) out_port); - ses = snat_det_get_ses_by_out (dm, &out_addr, key.as_u64); - if (!ses) - vlib_cli_output (vm, "no match"); - else - snat_det_ses_close (dm, ses); - } - + expire_per_vrf_sessions (fib); done: unformat_free (line_input); - return error; } static clib_error_t * -snat_det_close_session_in_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +nat44_debug_fib_registration_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { snat_main_t *sm = &snat_main; - unformat_input_t _line_input, *line_input = &_line_input; - ip4_address_t in_addr, ext_addr; - u32 in_port, ext_port; - snat_det_map_t *dm; - snat_det_session_t *ses; - snat_det_out_key_t key; - clib_error_t *error = 0; - - if (!sm->deterministic) - return clib_error_return (0, SUPPORTED_ONLY_IN_DET_MODE_STR); - - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, line_input)) - return 0; + snat_main_per_thread_data_t *tsm; + per_vrf_sessions_t *per_vrf_sessions; - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + vlib_cli_output (vm, "VRF registration debug:"); + vec_foreach (tsm, sm->per_thread_data) + { + vlib_cli_output (vm, "thread %u:", tsm->thread_index); + vec_foreach (per_vrf_sessions, tsm->per_vrf_sessions_vec) { - if (unformat (line_input, "%U:%d %U:%d", - unformat_ip4_address, &in_addr, &in_port, - unformat_ip4_address, &ext_addr, &ext_port)) - ; - else - { - error = clib_error_return (0, "unknown input '%U'", - format_unformat_error, line_input); - goto done; - } + vlib_cli_output (vm, "rx fib %u tx fib %u ses count %u %s", + per_vrf_sessions->rx_fib_index, + per_vrf_sessions->tx_fib_index, + per_vrf_sessions->ses_count, + per_vrf_sessions->expired ? "expired" : ""); } + } + return 0; +} - unformat_free (line_input); - - dm = snat_det_map_by_user (sm, &in_addr); - if (!dm) - vlib_cli_output (vm, "no match"); - else - { - key.ext_host_addr = ext_addr; - key.ext_host_port = ntohs ((u16) ext_port); - ses = - snat_det_find_ses_by_in (dm, &in_addr, ntohs ((u16) in_port), key); - if (!ses) - vlib_cli_output (vm, "no match"); - else - snat_det_ses_close (dm, ses); - } +/* *INDENT-OFF* */ -done: - unformat_free (line_input); +/*? +?*/ +VLIB_CLI_COMMAND (nat44_debug_fib_expire_command, static) = { + .path = "debug nat44 fib expire", + .short_help = "debug nat44 fib expire ", + .function = nat44_debug_fib_expire_command_fn, +}; - return error; -} -/* *INDENT-OFF* */ +/*? +?*/ +VLIB_CLI_COMMAND (nat44_debug_fib_registration_command, static) = { + .path = "debug nat44 fib registration", + .short_help = "debug nat44 fib registration", + .function = nat44_debug_fib_registration_command_fn, +}; /*? * @cliexpar @@ -1679,7 +1959,7 @@ VLIB_CLI_COMMAND (nat_show_workers_command, static) = { * Set values of timeouts for NAT sessions (in seconds), use: * vpp# set nat timeout udp 120 tcp-established 7500 tcp-transitory 250 icmp 90 * To reset default values use: - * vpp# set nat44 deterministic timeout reset + * vpp# set nat timeout reset * @cliexend ?*/ VLIB_CLI_COMMAND (set_timeout_command, static) = { @@ -1707,6 +1987,19 @@ VLIB_CLI_COMMAND (nat_show_timeouts_command, static) = { .function = nat_show_timeouts_command_fn, }; +/*? + * @cliexpar + * @cliexstart{nat set logging level} + * To set NAT logging level use: + * Set nat logging level + * @cliexend +?*/ +VLIB_CLI_COMMAND (snat_set_log_level_command, static) = { + .path = "nat set logging level", + .function = snat_set_log_level_command_fn, + .short_help = "nat set logging level ", +}; + /*? * @cliexpar * @cliexstart{snat ipfix logging} @@ -1760,6 +2053,7 @@ VLIB_CLI_COMMAND (nat44_show_alloc_addr_and_port_alg_command, static) = { * vpp# nat mss-clamping 1452 * To disbale TCP MSS rewriting use: * vpp# nat mss-clamping disable + * @cliexend ?*/ VLIB_CLI_COMMAND (nat_set_mss_clamping_command, static) = { .path = "nat mss-clamping", @@ -1769,8 +2063,9 @@ VLIB_CLI_COMMAND (nat_set_mss_clamping_command, static) = { /*? * @cliexpar - * @cliexstart{nat mss-clamping} + * @cliexstart{show nat mss-clamping} * Show TCP MSS rewriting configuration + * @cliexend ?*/ VLIB_CLI_COMMAND (nat_show_mss_clamping_command, static) = { .path = "show nat mss-clamping", @@ -1778,6 +2073,66 @@ VLIB_CLI_COMMAND (nat_show_mss_clamping_command, static) = { .function = nat_show_mss_clamping_command_fn, }; +/*? + * @cliexpar + * @cliexstart{nat ha failover} + * Set HA failover (remote settings) + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat_ha_failover_command, static) = { + .path = "nat ha failover", + .short_help = "nat ha failover : [refresh-interval ]", + .function = nat_ha_failover_command_fn, +}; + +/*? + * @cliexpar + * @cliexstart{nat ha listener} + * Set HA listener (local settings) + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat_ha_listener_command, static) = { + .path = "nat ha listener", + .short_help = "nat ha listener : [path-mtu ]", + .function = nat_ha_listener_command_fn, +}; + +/*? + * @cliexpar + * @cliexstart{show nat ha} + * Show HA configuration/status + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat_show_ha_command, static) = { + .path = "show nat ha", + .short_help = "show nat ha", + .function = nat_show_ha_command_fn, +}; + +/*? + * @cliexpar + * @cliexstart{nat ha flush} + * Flush the current HA data (for testing) + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat_ha_flush_command, static) = { + .path = "nat ha flush", + .short_help = "nat ha flush", + .function = nat_ha_flush_command_fn, +}; + +/*? + * @cliexpar + * @cliexstart{nat ha resync} + * Resync HA (resend existing sessions to new failover) + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat_ha_resync_command, static) = { + .path = "nat ha resync", + .short_help = "nat ha resync", + .function = nat_ha_resync_command_fn, +}; + /*? * @cliexpar * @cliexstart{show nat44 hash tables} @@ -1787,7 +2142,7 @@ VLIB_CLI_COMMAND (nat_show_mss_clamping_command, static) = { VLIB_CLI_COMMAND (nat44_show_hash, static) = { .path = "show nat44 hash tables", .short_help = "show nat44 hash tables [detail|verbose]", - .function = nat44_show_hash_commnad_fn, + .function = nat44_show_hash_command_fn, }; /*? @@ -1808,6 +2163,19 @@ VLIB_CLI_COMMAND (add_address_command, static) = { .function = add_address_command_fn, }; +/*? + * @cliexpar + * @cliexstart{show nat44 summary} + * Show NAT44 summary + * vpp# show nat44 summary + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat44_show_summary_command, static) = { + .path = "show nat44 summary", + .short_help = "show nat44 summary", + .function = nat44_show_summary_command_fn, +}; + /*? * @cliexpar * @cliexstart{show nat44 addresses} @@ -1881,16 +2249,19 @@ VLIB_CLI_COMMAND (nat44_show_interfaces_command, static) = { * vpp# nat44 add static mapping tcp local 10.0.0.3 6303 external 4.4.4.4 3606 * If not runnig "static mapping only" NAT plugin mode use before: * vpp# nat44 add address 4.4.4.4 - * To create static mapping between local and external address use: + * To create address only static mapping between local and external address use: * vpp# nat44 add static mapping local 10.0.0.3 external 4.4.4.4 + * To create ICMP static mapping between local and external with ICMP echo + * identifier 10 use: + * vpp# nat44 add static mapping icmp local 10.0.0.3 10 external 4.4.4.4 10 * @cliexend ?*/ VLIB_CLI_COMMAND (add_static_mapping_command, static) = { .path = "nat44 add static mapping", .function = add_static_mapping_command_fn, .short_help = - "nat44 add static mapping tcp|udp|icmp local [] " - "external [] [vrf ] [twice-nat|self-twice-nat] " + "nat44 add static mapping tcp|udp|icmp local [] " + "external [] [vrf ] [twice-nat|self-twice-nat] " "[out2in-only] [del]", }; @@ -1904,13 +2275,13 @@ VLIB_CLI_COMMAND (add_static_mapping_command, static) = { * To create identity mapping for address 10.0.0.3 use: * vpp# nat44 add identity mapping 10.0.0.3 * To create identity mapping for DHCP addressed interface use: - * vpp# nat44 add identity mapping GigabitEthernet0/a/0 tcp 3606 + * vpp# nat44 add identity mapping external GigabitEthernet0/a/0 tcp 3606 * @cliexend ?*/ VLIB_CLI_COMMAND (add_identity_mapping_command, static) = { .path = "nat44 add identity mapping", .function = add_identity_mapping_command_fn, - .short_help = "nat44 add identity mapping | " + .short_help = "nat44 add identity mapping |external " "[ ] [vrf ] [del]", }; @@ -1934,6 +2305,24 @@ VLIB_CLI_COMMAND (add_lb_static_mapping_command, static) = { "[affinity ] [del]", }; +/*? + * @cliexpar + * @cliexstart{nat44 add load-balancing static mapping} + * Modify service load balancing using NAT44 + * To add new back-end server 10.100.10.30:8080 for service load balancing + * static mapping with external IP address 1.2.3.4 and TCP port 80 use: + * vpp# nat44 add load-balancing back-end protocol tcp external 1.2.3.4:80 local 10.100.10.30:8080 probability 25 + * @cliexend +?*/ +VLIB_CLI_COMMAND (add_lb_backend_command, static) = { + .path = "nat44 add load-balancing back-end", + .function = add_lb_backend_command_fn, + .short_help = + "nat44 add load-balancing back-end protocol tcp|udp " + "external : local : [vrf ] " + "probability [del]", +}; + /*? * @cliexpar * @cliexstart{show nat44 static mappings} @@ -1994,10 +2383,48 @@ VLIB_CLI_COMMAND (nat44_show_interface_address_command, static) = { ?*/ VLIB_CLI_COMMAND (nat44_show_sessions_command, static) = { .path = "show nat44 sessions", - .short_help = "show nat44 sessions [detail]", + .short_help = "show nat44 sessions [detail|metrics]", .function = nat44_show_sessions_command_fn, }; +/*? + * @cliexpar + * @cliexstart{set nat44 session limit} + * Set NAT44 session limit. + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat44_set_session_limit_command, static) = { + .path = "set nat44 session limit", + .short_help = "set nat44 session limit [vrf ]", + .function = nat44_set_session_limit_command_fn, +}; + +/*? + * @cliexpar + * @cliexstart{nat44 del user} + * To delete all NAT44 user sessions: + * vpp# nat44 del user 10.0.0.3 + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat44_del_user_command, static) = { + .path = "nat44 del user", + .short_help = "nat44 del user [fib ]", + .function = nat44_del_user_command_fn, +}; + +/*? + * @cliexpar + * @cliexstart{clear nat44 sessions} + * To clear all NAT44 sessions + * vpp# clear nat44 sessions + * @cliexend +?*/ +VLIB_CLI_COMMAND (nat44_clear_sessions_command, static) = { + .path = "clear nat44 sessions", + .short_help = "clear nat44 sessions", + .function = nat44_clear_sessions_command_fn, +}; + /*? * @cliexpar * @cliexstart{nat44 del session} @@ -2031,119 +2458,6 @@ VLIB_CLI_COMMAND (snat_forwarding_set_command, static) = { .function = snat_forwarding_set_command_fn, }; -/*? - * @cliexpar - * @cliexstart{nat44 deterministic add} - * Create bijective mapping of inside address to outside address and port range - * pairs, with the purpose of enabling deterministic NAT to reduce logging in - * CGN deployments. - * To create deterministic mapping between inside network 10.0.0.0/18 and - * outside network 1.1.1.0/30 use: - * # vpp# nat44 deterministic add in 10.0.0.0/18 out 1.1.1.0/30 - * @cliexend -?*/ -VLIB_CLI_COMMAND (snat_det_map_command, static) = { - .path = "nat44 deterministic add", - .short_help = "nat44 deterministic add in / out / [del]", - .function = snat_det_map_command_fn, -}; - -/*? - * @cliexpar - * @cliexpstart{show nat44 deterministic mappings} - * Show NAT44 deterministic mappings - * vpp# show nat44 deterministic mappings - * NAT44 deterministic mappings: - * in 10.0.0.0/24 out 1.1.1.1/32 - * outside address sharing ratio: 256 - * number of ports per inside host: 252 - * sessions number: 0 - * @cliexend -?*/ -VLIB_CLI_COMMAND (nat44_det_show_mappings_command, static) = { - .path = "show nat44 deterministic mappings", - .short_help = "show nat44 deterministic mappings", - .function = nat44_det_show_mappings_command_fn, -}; - -/*? - * @cliexpar - * @cliexstart{nat44 deterministic forward} - * Return outside address and port range from inside address for deterministic - * NAT. - * To obtain outside address and port of inside host use: - * vpp# nat44 deterministic forward 10.0.0.2 - * 1.1.1.0:<1054-1068> - * @cliexend -?*/ -VLIB_CLI_COMMAND (snat_det_forward_command, static) = { - .path = "nat44 deterministic forward", - .short_help = "nat44 deterministic forward ", - .function = snat_det_forward_command_fn, -}; - -/*? - * @cliexpar - * @cliexstart{nat44 deterministic reverse} - * Return inside address from outside address and port for deterministic NAT. - * To obtain inside host address from outside address and port use: - * #vpp nat44 deterministic reverse 1.1.1.1:1276 - * 10.0.16.16 - * @cliexend -?*/ -VLIB_CLI_COMMAND (snat_det_reverse_command, static) = { - .path = "nat44 deterministic reverse", - .short_help = "nat44 deterministic reverse :", - .function = snat_det_reverse_command_fn, -}; - -/*? - * @cliexpar - * @cliexstart{show nat44 deterministic sessions} - * Show NAT44 deterministic sessions. - * vpp# show nat44 deterministic sessions - * NAT44 deterministic sessions: - * in 10.0.0.3:3005 out 1.1.1.2:1146 external host 172.16.1.2:3006 state: udp-active expire: 306 - * in 10.0.0.3:3000 out 1.1.1.2:1141 external host 172.16.1.2:3001 state: udp-active expire: 306 - * in 10.0.0.4:3005 out 1.1.1.2:1177 external host 172.16.1.2:3006 state: udp-active expire: 306 - * @cliexend -?*/ -VLIB_CLI_COMMAND (nat44_det_show_sessions_command, static) = { - .path = "show nat44 deterministic sessions", - .short_help = "show nat44 deterministic sessions", - .function = nat44_det_show_sessions_command_fn, -}; - -/*? - * @cliexpar - * @cliexstart{nat44 deterministic close session out} - * Close session using outside ip address and port - * and external ip address and port, use: - * vpp# nat44 deterministic close session out 1.1.1.1:1276 2.2.2.2:2387 - * @cliexend -?*/ -VLIB_CLI_COMMAND (snat_det_close_sesion_out_command, static) = { - .path = "nat44 deterministic close session out", - .short_help = "nat44 deterministic close session out " - ": :", - .function = snat_det_close_session_out_fn, -}; - -/*? - * @cliexpar - * @cliexstart{nat44 deterministic close session in} - * Close session using inside ip address and port - * and external ip address and port, use: - * vpp# nat44 deterministic close session in 3.3.3.3:3487 2.2.2.2:2387 - * @cliexend -?*/ -VLIB_CLI_COMMAND (snat_det_close_session_in_command, static) = { - .path = "nat44 deterministic close session in", - .short_help = "nat44 deterministic close session in " - ": :", - .function = snat_det_close_session_in_fn, -}; - /* *INDENT-ON* */ /*