Use a lookup table instead.
Type: improvement
Signed-off-by: Klement Sekera <ksekera@cisco.com>
Change-Id: Ia8461099828bb8824bf016201f135e6b69c444d1
ip40 = vlib_buffer_get_current (b0) + sizeof (ip6_header_t);
proto0 = ip_proto_to_nat_proto (ip40->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
error0 = DSLITE_ERROR_UNSUPPORTED_PROTOCOL;
next0 = DSLITE_CE_DECAP_NEXT_DROP;
ip40 = vlib_buffer_get_current (b0);
proto0 = ip_proto_to_nat_proto (ip40->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
error0 = DSLITE_ERROR_UNSUPPORTED_PROTOCOL;
next0 = DSLITE_CE_ENCAP_NEXT_DROP;
ip40 = vlib_buffer_get_current (b0) + sizeof (ip6_header_t);
proto0 = ip_proto_to_nat_proto (ip40->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
error0 = DSLITE_ERROR_UNSUPPORTED_PROTOCOL;
next0 = DSLITE_IN2OUT_NEXT_DROP;
ip40 = vlib_buffer_get_current (b0);
proto0 = ip_proto_to_nat_proto (ip40->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
error0 = DSLITE_ERROR_UNSUPPORTED_PROTOCOL;
next0 = DSLITE_OUT2IN_NEXT_DROP;
if (!icmp_type_is_error_message
(vnet_buffer (b)->ip.reass.icmp_type_or_tcp_flags))
{
- key0.protocol = SNAT_PROTOCOL_ICMP;
+ key0.protocol = NAT_PROTOCOL_ICMP;
key0.addr = ip0->src_address;
key0.port = vnet_buffer (b)->ip.reass.l4_src_port; // TODO fixme should this be dst port?
}
{
inner_ip0 = (ip4_header_t *) (echo0 + 1);
l4_header = ip4_next_header (inner_ip0);
- key0.protocol = ip_proto_to_snat_proto (inner_ip0->protocol);
+ key0.protocol = ip_proto_to_nat_proto (inner_ip0->protocol);
key0.addr = inner_ip0->dst_address;
switch (key0.protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
key0.port = inner_echo0->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
key0.port = ((tcp_udp_header_t *) l4_header)->dst_port;
break;
default:
else
{
if (PREDICT_FALSE (snat_not_translate (sm, node, sw_if_index0,
- ip0, SNAT_PROTOCOL_ICMP,
+ ip0, NAT_PROTOCOL_ICMP,
rx_fib_index0,
thread_index)))
{
switch (protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
identifier);
icmp0->checksum = ip_csum_fold (sum0);
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
old_id0 = ((tcp_udp_header_t *) l4_header)->dst_port;
new_id0 = sm0.port;
((tcp_udp_header_t *) l4_header)->dst_port = new_id0;
goto trace00;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
/* Next configured feature, probably ip4-lookup */
if (is_slow_path)
{
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
if (nat_in2out_sm_unknown_proto
(sm, b0, ip0, rx_fib_index0))
goto trace00;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_in2out_slow_path
(sm, b0, ip0, icmp0, sw_if_index0, rx_fib_index0,
}
else
{
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
next0 = SNAT_IN2OUT_NEXT_SLOW_PATH;
goto trace00;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = SNAT_IN2OUT_NEXT_SLOW_PATH;
goto trace00;
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto0 == SNAT_PROTOCOL_UDP
+ (proto0 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b0)->ip.reass.l4_dst_port ==
clib_host_to_net_u16
(UDP_DST_PORT_dhcp_to_server))
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
goto trace01;
}
- proto1 = ip_proto_to_snat_proto (ip1->protocol);
+ proto1 = ip_proto_to_nat_proto (ip1->protocol);
/* Next configured feature, probably ip4-lookup */
if (is_slow_path)
{
- if (PREDICT_FALSE (proto1 == ~0))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_OTHER))
{
if (nat_in2out_sm_unknown_proto
(sm, b1, ip1, rx_fib_index1))
goto trace01;
}
- if (PREDICT_FALSE (proto1 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_ICMP))
{
next1 = icmp_in2out_slow_path
(sm, b1, ip1, icmp1, sw_if_index1, rx_fib_index1, node,
}
else
{
- if (PREDICT_FALSE (proto1 == ~0))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_OTHER))
{
next1 = SNAT_IN2OUT_NEXT_SLOW_PATH;
goto trace01;
}
- if (PREDICT_FALSE (proto1 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_ICMP))
{
next1 = SNAT_IN2OUT_NEXT_SLOW_PATH;
goto trace01;
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto1 == SNAT_PROTOCOL_UDP
+ (proto1 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b1)->ip.reass.l4_dst_port ==
clib_host_to_net_u16
(UDP_DST_PORT_dhcp_to_server))
src_address /* changed member */ );
ip1->checksum = ip_csum_fold (sum1);
- if (PREDICT_TRUE (proto1 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto1 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
goto trace0;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
/* Next configured feature, probably ip4-lookup */
if (is_slow_path)
{
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
if (nat_in2out_sm_unknown_proto
(sm, b0, ip0, rx_fib_index0))
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_in2out_slow_path
(sm, b0, ip0, icmp0, sw_if_index0, rx_fib_index0, node,
}
else
{
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
next0 = SNAT_IN2OUT_NEXT_SLOW_PATH;
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = SNAT_IN2OUT_NEXT_SLOW_PATH;
goto trace0;
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto0 == SNAT_PROTOCOL_UDP
+ (proto0 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b0)->ip.reass.l4_dst_port ==
clib_host_to_net_u16
(UDP_DST_PORT_dhcp_to_server))
src_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
goto trace0;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
goto trace0;
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_in2out (sm, b0, ip0, icmp0, sw_if_index0,
rx_fib_index0, node, next0, ~0, 0, 0);
old_port0 = udp0->src_port;
udp0->src_port = new_port0;
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
sum0 = tcp0->checksum;
sum0 = ip_csum_update (sum0, old_addr0, new_addr0,
}
else
{
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
sum0 = tcp0->checksum;
sum0 = ip_csum_update (sum0, old_addr0, new_addr0,
}
else
{
- proto = snat_proto_to_ip_proto (s->in2out.protocol);
+ proto = nat_proto_to_ip_proto (s->in2out.protocol);
l_port = s->out2in.port;
r_port = s->ext_host_port;
}
static int
nat_ed_alloc_addr_and_port (snat_main_t * sm, u32 rx_fib_index,
- u32 snat_proto, u32 thread_index,
+ u32 nat_proto, u32 thread_index,
ip4_address_t r_addr, u16 r_port, u8 proto,
u16 port_per_thread, u32 snat_thread_index,
snat_session_t * s,
for (i = 0; i < vec_len (sm->addresses); i++)
{
a = sm->addresses + i;
- switch (snat_proto)
+ switch (nat_proto)
{
#define _(N, j, n, unused) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->fib_index == rx_fib_index) \
{ \
u16 port = snat_random_port (1, port_per_thread); \
} \
break;
- foreach_snat_protocol;
+ foreach_nat_protocol;
default:
nat_elog_info ("unknown protocol");
return 1;
/* fake fib_index to reuse macro */
rx_fib_index = ~0;
a = ga;
- switch (snat_proto)
+ switch (nat_proto)
{
- foreach_snat_protocol;
+ foreach_nat_protocol;
default:
nat_elog_info ("unknown protocol");
return 1;
snat_session_key_t key0, key1;
lb_nat_type_t lb = 0;
snat_main_per_thread_data_t *tsm = &sm->per_thread_data[thread_index];
- u32 snat_proto = ip_proto_to_snat_proto (proto);
+ u32 nat_proto = ip_proto_to_nat_proto (proto);
nat_outside_fib_t *outside_fib;
fib_node_index_t fei = FIB_NODE_INDEX_INVALID;
clib_bihash_kv_16_8_t out2in_ed_kv;
};
nat44_is_idle_session_ctx_t ctx;
- if (PREDICT_TRUE (snat_proto == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (nat_proto == NAT_PROTOCOL_TCP))
{
if (PREDICT_FALSE
(!tcp_flags_is_init
key0.addr = l_addr;
key0.port = l_port;
- key1.protocol = key0.protocol = snat_proto;
+ key1.protocol = key0.protocol = nat_proto;
key0.fib_index = rx_fib_index;
key1.fib_index = sm->outside_fib_index;
}
/* Try to create dynamic translation */
- if (nat_ed_alloc_addr_and_port (sm, rx_fib_index, snat_proto,
+ if (nat_ed_alloc_addr_and_port (sm, rx_fib_index, nat_proto,
thread_index, r_addr, r_port, proto,
sm->port_per_thread,
tsm->snat_thread_index, s,
else
{
if (PREDICT_FALSE (nat44_ed_not_translate (sm, node, sw_if_index,
- ip, SNAT_PROTOCOL_ICMP,
+ ip, NAT_PROTOCOL_ICMP,
rx_fib_index,
thread_index)))
{
udp0 = ip4_next_header (ip0);
tcp0 = (tcp_header_t *) udp0;
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
next0 = def_slow;
goto trace0;
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = def_slow;
goto trace0;
old_port0 = vnet_buffer (b0)->ip.reass.l4_src_port;
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
udp0 = ip4_next_header (ip0);
tcp0 = (tcp_header_t *) udp0;
icmp0 = (icmp46_header_t *) udp0;
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
s0 = nat44_ed_in2out_unknown_proto (sm, b0, ip0,
rx_fib_index0,
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_in2out_ed_slow_path
(sm, b0, ip0, icmp0, sw_if_index0, rx_fib_index0,
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto0 == SNAT_PROTOCOL_UDP
+ (proto0 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b0)->ip.reass.l4_dst_port ==
clib_host_to_net_u16 (UDP_DST_PORT_dhcp_to_server))
&& ip0->dst_address.as_u32 == 0xffffffff))
old_port0 = vnet_buffer (b0)->ip.reass.l4_src_port;
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
* limitations under the License.
*/
/**
- * @brief The NAT44 inline functions
+ * @brief Common NAT inline functions
*/
#ifndef included_nat_inlines_h__
#define included_nat_inlines_h__
-static_always_inline u32
+always_inline nat_protocol_t
ip_proto_to_nat_proto (u8 ip_proto)
{
- u32 nat_proto = ~0;
+ static const nat_protocol_t lookup_table[256] = {
+ [IP_PROTOCOL_TCP] = NAT_PROTOCOL_TCP,
+ [IP_PROTOCOL_UDP] = NAT_PROTOCOL_UDP,
+ [IP_PROTOCOL_ICMP] = NAT_PROTOCOL_ICMP,
+ [IP_PROTOCOL_ICMP6] = NAT_PROTOCOL_ICMP,
+ };
- nat_proto = (ip_proto == IP_PROTOCOL_UDP) ? NAT_PROTOCOL_UDP : nat_proto;
- nat_proto = (ip_proto == IP_PROTOCOL_TCP) ? NAT_PROTOCOL_TCP : nat_proto;
- nat_proto = (ip_proto == IP_PROTOCOL_ICMP) ? NAT_PROTOCOL_ICMP : nat_proto;
- nat_proto = (ip_proto == IP_PROTOCOL_ICMP6) ? NAT_PROTOCOL_ICMP : nat_proto;
-
- return nat_proto;
+ return lookup_table[ip_proto];
}
static_always_inline u8
nat_proto_to_ip_proto (nat_protocol_t nat_proto)
{
- u8 ip_proto = ~0;
+ ASSERT (nat_proto <= NAT_PROTOCOL_ICMP);
+
+ static const u8 lookup_table[256] = {
+ [NAT_PROTOCOL_OTHER] = ~0,
+ [NAT_PROTOCOL_TCP] = IP_PROTOCOL_TCP,
+ [NAT_PROTOCOL_UDP] = IP_PROTOCOL_UDP,
+ [NAT_PROTOCOL_ICMP] = IP_PROTOCOL_ICMP,
+ };
- ip_proto = (nat_proto == NAT_PROTOCOL_UDP) ? IP_PROTOCOL_UDP : ip_proto;
- ip_proto = (nat_proto == NAT_PROTOCOL_TCP) ? IP_PROTOCOL_TCP : ip_proto;
- ip_proto = (nat_proto == NAT_PROTOCOL_ICMP) ? IP_PROTOCOL_ICMP : ip_proto;
+ ASSERT (NAT_PROTOCOL_OTHER == nat_proto || NAT_PROTOCOL_TCP == nat_proto
+ || NAT_PROTOCOL_UDP == nat_proto || NAT_PROTOCOL_ICMP == nat_proto);
- return ip_proto;
+ return lookup_table[nat_proto];
}
static_always_inline u8
#ifndef included_nat_lib_h__
#define included_nat_lib_h__
-#define foreach_nat_error \
- _(VALUE_EXIST, -1, "Value already exists") \
- _(NO_SUCH_ENTRY, -2, "No such entry") \
- _(UNKNOWN_PROTOCOL, -3, "Unknown protocol") \
- _(OUT_OF_TRANSLATIONS, -4, "Out of translations")
-
-#define foreach_nat_protocol \
- _(UDP, 0, udp, "udp") \
- _(TCP, 1, tcp, "tcp") \
- _(ICMP, 2, icmp, "icmp")
+#define foreach_nat_error \
+ _ (VALUE_EXIST, -1, "Value already exists") \
+ _ (NO_SUCH_ENTRY, -2, "No such entry") \
+ _ (UNKNOWN_PROTOCOL, -3, "Unknown protocol") \
+ _ (OUT_OF_TRANSLATIONS, -4, "Out of translations")
typedef enum
{
#undef _
} nat_error_t;
+#define foreach_nat_protocol \
+ _ (OTHER, 0, other, "other") \
+ _ (UDP, 1, udp, "udp") \
+ _ (TCP, 2, tcp, "tcp") \
+ _ (ICMP, 3, icmp, "icmp")
+
typedef enum
{
#define _(N, i, n, s) NAT_PROTOCOL_##N = i,
r_port = s->ext_host_port;
l_addr = &s->in2out.addr;
r_addr = &s->ext_host_addr;
- proto = snat_proto_to_ip_proto (s->in2out.protocol);
+ proto = nat_proto_to_ip_proto (s->in2out.protocol);
make_ed_kv (l_addr, r_addr, proto, fib_index, l_port, r_port, ~0ULL,
&ed_kv);
}
}
else
{
- proto = snat_proto_to_ip_proto (s->in2out.protocol);
+ proto = nat_proto_to_ip_proto (s->in2out.protocol);
l_port = s->out2in.port;
r_port = s->ext_host_port;
}
}
else
{
- proto = snat_proto_to_ip_proto (s->in2out.protocol);
+ proto = nat_proto_to_ip_proto (s->in2out.protocol);
l_port = s->in2out.port;
r_port = s->ext_host_port;
}
}
else
{
- proto = snat_proto_to_ip_proto (s->in2out.protocol);
+ proto = nat_proto_to_ip_proto (s->in2out.protocol);
l_port = s->out2in.port;
r_port = s->ext_host_port;
}
ap->busy_##n##_ports = 0; \
ap->busy_##n##_ports_per_thread = 0;\
vec_validate_init_empty (ap->busy_##n##_ports_per_thread, tm->n_vlib_mains - 1, 0);
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
if (twice_nat)
return 0;
u32 sw_if_index,
u16 e_port,
u32 vrf_id,
- snat_protocol_t proto,
+ nat_protocol_t proto,
int addr_only, int is_add, u8 * tag,
int twice_nat, int out2in_only,
int identity_nat)
int
snat_add_static_mapping (ip4_address_t l_addr, ip4_address_t e_addr,
u16 l_port, u16 e_port, u32 vrf_id, int addr_only,
- u32 sw_if_index, snat_protocol_t proto, int is_add,
+ u32 sw_if_index, nat_protocol_t proto, int is_add,
twice_nat_type_t twice_nat, u8 out2in_only, u8 * tag,
u8 identity_nat)
{
switch (proto)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_port_refcounts[e_port]) \
return VNET_API_ERROR_INVALID_VALUE; \
++a->busy_##n##_port_refcounts[e_port]; \
a->busy_##n##_ports_per_thread[get_thread_idx_by_port(e_port)]++; \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (proto)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
--a->busy_##n##_port_refcounts[e_port]; \
if (e_port > 1024) \
{ \
a->busy_##n##_ports_per_thread[get_thread_idx_by_port(e_port)]--; \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
int
nat44_add_del_lb_static_mapping (ip4_address_t e_addr, u16 e_port,
- snat_protocol_t proto,
+ nat_protocol_t proto,
nat44_lb_addr_port_t * locals, u8 is_add,
twice_nat_type_t twice_nat, u8 out2in_only,
u8 * tag, u32 affinity)
switch (proto)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_port_refcounts[e_port]) \
return VNET_API_ERROR_INVALID_VALUE; \
++a->busy_##n##_port_refcounts[e_port]; \
a->busy_##n##_ports_per_thread[get_thread_idx_by_port(e_port)]++; \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (proto)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
--a->busy_##n##_port_refcounts[e_port]; \
if (e_port > 1024) \
{ \
a->busy_##n##_ports_per_thread[get_thread_idx_by_port(e_port)]--; \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
int
nat44_lb_static_mapping_add_del_local (ip4_address_t e_addr, u16 e_port,
ip4_address_t l_addr, u16 l_port,
- snat_protocol_t proto, u32 vrf_id,
+ nat_protocol_t proto, u32 vrf_id,
u8 probability, u8 is_add)
{
snat_main_t *sm = &snat_main;
#define _(N, i, n, s) \
vec_free (a->busy_##n##_ports_per_thread);
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
if (twice_nat)
{
switch (k->protocol)
{
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
ASSERT (a->busy_##n##_port_refcounts[port_host_byte_order] >= 1); \
--a->busy_##n##_port_refcounts[port_host_byte_order]; \
a->busy_##n##_ports--; \
a->busy_##n##_ports_per_thread[thread_index]--; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (k->protocol)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_port_refcounts[port_host_byte_order]) \
return VNET_API_ERROR_INSTANCE_IN_USE; \
++a->busy_##n##_port_refcounts[port_host_byte_order]; \
a->busy_##n##_ports_per_thread[thread_index]++; \
a->busy_##n##_ports++; \
return 0;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (k->protocol)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_ports_per_thread[thread_index] < port_per_thread) \
{ \
if (a->fib_index == fib_index) \
} \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (k->protocol)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
while (1) \
{ \
portnum = (port_per_thread * \
return 0; \
}
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (k->protocol)
{
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_ports < ports) \
{ \
while (1) \
} \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
switch (k->protocol)
{
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_ports < ports) \
{ \
while (1) \
} \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_info ("unknown protocol");
}
}
- proto = ip_proto_to_snat_proto (ip0->protocol);
+ proto = ip_proto_to_nat_proto (ip0->protocol);
udp = ip4_next_header (ip0);
port = udp->dst_port;
/* unknown protocol */
- if (PREDICT_FALSE (proto == ~0))
+ if (PREDICT_FALSE (proto == NAT_PROTOCOL_OTHER))
{
/* use current thread */
return vlib_get_thread_index ();
{
/* if error message, then it's not fragmented and we can access it */
ip4_header_t *inner_ip = (ip4_header_t *) (echo + 1);
- proto = ip_proto_to_snat_proto (inner_ip->protocol);
+ proto = ip_proto_to_nat_proto (inner_ip->protocol);
void *l4_header = ip4_next_header (inner_ip);
switch (proto)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
icmp = (icmp46_header_t *) l4_header;
echo = (icmp_echo_header_t *) (icmp + 1);
port = echo->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
port = ((tcp_udp_header_t *) l4_header)->src_port;
break;
default:
snat_static_mapping_t *m;
u32 hash;
- proto = ip_proto_to_snat_proto (ip->protocol);
+ proto = ip_proto_to_nat_proto (ip->protocol);
- if (PREDICT_TRUE (proto == SNAT_PROTOCOL_UDP || proto == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto == NAT_PROTOCOL_UDP || proto == NAT_PROTOCOL_TCP))
{
udp = ip4_next_header (ip);
}
/* *INDENT-ON* */
}
- else if (proto == SNAT_PROTOCOL_ICMP)
+ else if (proto == NAT_PROTOCOL_ICMP)
{
if (!get_icmp_o2i_ed_key (b, ip, rx_fib_index, ~0ULL, 0, 0, 0, &kv16))
{
}
/* unknown protocol */
- if (PREDICT_FALSE (proto == ~0))
+ if (PREDICT_FALSE (proto == NAT_PROTOCOL_OTHER))
{
/* use current thread */
next_worker_index = vlib_get_thread_index ();
{
/* if error message, then it's not fragmented and we can access it */
ip4_header_t *inner_ip = (ip4_header_t *) (echo + 1);
- proto = ip_proto_to_snat_proto (inner_ip->protocol);
+ proto = ip_proto_to_nat_proto (inner_ip->protocol);
void *l4_header = ip4_next_header (inner_ip);
switch (proto)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
icmp = (icmp46_header_t *) l4_header;
echo = (icmp_echo_header_t *) (icmp + 1);
port = echo->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
port = ((tcp_udp_header_t *) l4_header)->src_port;
break;
default:
s->in2out = key;
make_ed_kv (in_addr, &s->ext_host_nat_addr,
- snat_proto_to_ip_proto (proto), fib_index, in_port,
+ nat_proto_to_ip_proto (proto), fib_index, in_port,
s->ext_host_nat_port, s - tsm->sessions, &kv);
if (clib_bihash_add_del_16_8 (&tsm->in2out_ed, &kv, 1))
nat_elog_warn ("in2out key add failed");
- make_ed_kv (out_addr, eh_addr, snat_proto_to_ip_proto (proto),
+ make_ed_kv (out_addr, eh_addr, nat_proto_to_ip_proto (proto),
s->out2in.fib_index, out_port, eh_port, s - tsm->sessions, &kv);
if (clib_bihash_add_del_16_8 (&tsm->out2in_ed, &kv, 1))
nat_elog_warn ("out2in key add failed");
int
nat44_del_session (snat_main_t * sm, ip4_address_t * addr, u16 port,
- snat_protocol_t proto, u32 vrf_id, int is_in)
+ nat_protocol_t proto, u32 vrf_id, int is_in)
{
snat_main_per_thread_data_t *tsm;
clib_bihash_kv_8_8_t kv, value;
#include <vlibapi/api.h>
#include <vlib/log.h>
#include <vppinfra/bihash_16_8.h>
+#include <nat/lib/lib.h>
+#include <nat/lib/inlines.h>
/* default session timeouts */
#define SNAT_UDP_TIMEOUT 300
#undef _
} nat_addr_and_port_alloc_alg_t;
-
-/* Supported L4 protocols */
-#define foreach_snat_protocol \
- _(UDP, 0, udp, "udp") \
- _(TCP, 1, tcp, "tcp") \
- _(ICMP, 2, icmp, "icmp")
-
-typedef enum
-{
-#define _(N, i, n, s) SNAT_PROTOCOL_##N = i,
- foreach_snat_protocol
-#undef _
-} snat_protocol_t;
-
-
/* Session state */
#define foreach_snat_session_state \
_(0, UNKNOWN, "unknown") \
u16 busy_##n##_ports; \
u16 * busy_##n##_ports_per_thread; \
u32 busy_##n##_port_refcounts[65535];
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
} snat_address_t;
u32 vrf_id;
u32 fib_index;
/* protocol */
- snat_protocol_t proto;
+ nat_protocol_t proto;
/* 0 = disabled, otherwise client IP affinity sticky time in seconds */
u32 affinity;
/* worker threads used by backends/local host */
u16 e_port;
u32 sw_if_index;
u32 vrf_id;
- snat_protocol_t proto;
+ nat_protocol_t proto;
u32 flags;
int addr_only;
int twice_nat;
format_function_t format_det_map_ses;
format_function_t format_snat_key;
format_function_t format_static_mapping_key;
-format_function_t format_snat_protocol;
+format_function_t format_nat_protocol;
format_function_t format_nat_addr_and_port_alloc_alg;
/* unformat functions */
-unformat_function_t unformat_snat_protocol;
+unformat_function_t unformat_nat_protocol;
/** \brief Check if SNAT session is created from static mapping.
@param s SNAT session
int snat_add_static_mapping (ip4_address_t l_addr, ip4_address_t e_addr,
u16 l_port, u16 e_port, u32 vrf_id,
int addr_only, u32 sw_if_index,
- snat_protocol_t proto, int is_add,
+ nat_protocol_t proto, int is_add,
twice_nat_type_t twice_nat, u8 out2in_only,
u8 * tag, u8 identity_nat);
* @return 0 on success, non-zero value otherwise
*/
int nat44_add_del_lb_static_mapping (ip4_address_t e_addr, u16 e_port,
- snat_protocol_t proto,
+ nat_protocol_t proto,
nat44_lb_addr_port_t * locals, u8 is_add,
twice_nat_type_t twice_nat,
u8 out2in_only, u8 * tag, u32 affinity);
int nat44_lb_static_mapping_add_del_local (ip4_address_t e_addr, u16 e_port,
ip4_address_t l_addr, u16 l_port,
- snat_protocol_t proto, u32 vrf_id,
+ nat_protocol_t proto, u32 vrf_id,
u8 probability, u8 is_add);
clib_error_t *snat_api_init (vlib_main_t * vm, snat_main_t * sm);
* @return 0 on success, non-zero value otherwise
*/
int nat44_del_session (snat_main_t * sm, ip4_address_t * addr, u16 port,
- snat_protocol_t proto, u32 vrf_id, int is_in);
+ nat_protocol_t proto, u32 vrf_id, int is_in);
/**
* @brief Delete NAT44 endpoint-dependent session
}
m_key0.port =
clib_net_to_host_u16 (vnet_buffer (b0)->ip.reass.l4_dst_port);
- m_key0.protocol = ip_proto_to_snat_proto (ip0->protocol);
+ m_key0.protocol = ip_proto_to_nat_proto (ip0->protocol);
kv0.key = m_key0.as_u64;
if (!clib_bihash_search_8_8
(&sm->static_mapping_by_external, &kv0, &value0))
}
m_key0.port =
clib_net_to_host_u16 (vnet_buffer (b0)->ip.reass.l4_dst_port);
- m_key0.protocol = ip_proto_to_snat_proto (ip0->protocol);
+ m_key0.protocol = ip_proto_to_nat_proto (ip0->protocol);
kv0.key = m_key0.as_u64;
if (!clib_bihash_search_8_8
(&sm->static_mapping_by_external, &kv0, &value0))
switch (s->in2out.protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
icmp_sessions++;
break;
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_TCP:
tcp_sessions++;
if (s->state)
{
else
established++;
break;
- case SNAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_UDP:
default:
udp_sessions++;
break;
switch (s->in2out.protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
icmp_sessions++;
break;
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_TCP:
tcp_sessions++;
if (s->state)
{
else
established++;
break;
- case SNAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_UDP:
default:
udp_sessions++;
break;
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:");
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* */
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;
;
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;
u32 sw_if_index = ~0;
vnet_main_t *vnm = vnet_get_main ();
int rv;
- snat_protocol_t proto;
+ nat_protocol_t proto;
if (sm->deterministic)
return clib_error_return (0, UNSUPPORTED_IN_DET_MODE_STR);
;
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"))
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;
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"))
u32 l_port = 0, e_port = 0, vrf_id = 0, probability = 0;
int is_add = 1;
int rv;
- snat_protocol_t proto;
+ nat_protocol_t proto;
u8 proto_set = 0;
if (sm->deterministic)
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, "del"))
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;
+ nat_protocol_t proto;
int rv;
if (sm->deterministic)
{
if (unformat
(line_input, "%U:%u %U", unformat_ip4_address, &addr, &port,
- unformat_snat_protocol, &proto))
+ unformat_nat_protocol, &proto))
;
else if (unformat (line_input, "in"))
{
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);
+ nat_proto_to_ip_proto (proto), vrf_id, is_in);
else
rv = nat44_del_session (sm, &addr, port, proto, vrf_id, is_in);
old_dst_port0 = tcp0->dst;
if (PREDICT_TRUE (new_dst_port0 != old_dst_port0))
{
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
tcp0->dst = new_dst_port0;
sum0 = tcp0->checksum;
}
else
{
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
sum0 = tcp0->checksum;
sum0 = ip_csum_update (sum0, old_dst_addr0, new_dst_addr0,
inner_ip0 = (ip4_header_t *) ((icmp_echo_header_t *) (icmp0 + 1) + 1);
l4_header = ip4_next_header (inner_ip0);
- u32 protocol = ip_proto_to_snat_proto (inner_ip0->protocol);
+ u32 protocol = ip_proto_to_nat_proto (inner_ip0->protocol);
- if (protocol != SNAT_PROTOCOL_TCP && protocol != SNAT_PROTOCOL_UDP)
+ if (protocol != NAT_PROTOCOL_TCP && protocol != NAT_PROTOCOL_UDP)
return 1;
if (is_ed)
u16 icmp_id0 = echo0->identifier;
key0.addr = ip0->dst_address;
key0.port = icmp_id0;
- key0.protocol = SNAT_PROTOCOL_ICMP;
+ key0.protocol = NAT_PROTOCOL_ICMP;
key0.fib_index = sm->outside_fib_index;
kv0.key = key0.as_u64;
if (sm->num_workers > 1)
udp0 = ip4_next_header (ip0);
tcp0 = (tcp_header_t *) udp0;
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
vnet_get_config_data (&cm->config_main, &b0->current_config_index,
&next0, 0);
next0 = NAT_HAIRPIN_NEXT_LOOKUP;
ip0 = vlib_buffer_get_current (b0);
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
vnet_buffer (b0)->snat.flags = 0;
if (PREDICT_FALSE (is_hairpinning (sm, &ip0->dst_address)))
{
- if (proto0 == SNAT_PROTOCOL_TCP || proto0 == SNAT_PROTOCOL_UDP)
+ if (proto0 == NAT_PROTOCOL_TCP || proto0 == NAT_PROTOCOL_UDP)
{
udp_header_t *udp0 = ip4_next_header (ip0);
tcp_header_t *tcp0 = (tcp_header_t *) udp0;
snat_hairpinning (sm, b0, ip0, udp0, tcp0, proto0, is_ed);
}
- else if (proto0 == SNAT_PROTOCOL_ICMP)
+ else if (proto0 == NAT_PROTOCOL_ICMP)
{
icmp46_header_t *icmp0 = ip4_next_header (ip0);
u16 port;
u32 proto;
- proto = ip_proto_to_snat_proto (ip->protocol);
+ proto = ip_proto_to_nat_proto (ip->protocol);
udp = ip4_next_header (ip);
port = udp->dst_port;
/* unknown protocol */
- if (PREDICT_FALSE (proto == ~0))
+ if (PREDICT_FALSE (proto == NAT_PROTOCOL_OTHER))
{
nat64_db_t *db;
ip46_address_t daddr;
{
/* if error message, then it's not fragmented and we can access it */
ip4_header_t *inner_ip = (ip4_header_t *) (echo + 1);
- proto = ip_proto_to_snat_proto (inner_ip->protocol);
+ proto = ip_proto_to_nat_proto (inner_ip->protocol);
void *l4_header = ip4_next_header (inner_ip);
switch (proto)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
icmp = (icmp46_header_t *) l4_header;
echo = (icmp_echo_header_t *) (icmp + 1);
port = echo->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
port = ((tcp_udp_header_t *) l4_header)->src_port;
break;
default:
clib_memset (a->busy_##n##_port_refcounts, 0, sizeof(a->busy_##n##_port_refcounts)); \
a->busy_##n##_ports = 0; \
vec_validate_init_empty (a->busy_##n##_ports_per_thread, tm->n_vlib_mains - 1, 0);
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
}
else
}
int
-nat64_alloc_out_addr_and_port (u32 fib_index, snat_protocol_t proto,
+nat64_alloc_out_addr_and_port (u32 fib_index, nat_protocol_t proto,
ip4_address_t * addr, u16 * port,
u32 thread_index)
{
int i;
snat_address_t *a;
u32 thread_index = db - nm->db;
- snat_protocol_t proto = ip_proto_to_snat_proto (protocol);
+ nat_protocol_t proto = ip_proto_to_nat_proto (protocol);
u16 port_host_byte_order = clib_net_to_host_u16 (port);
for (i = 0; i < vec_len (nm->addr_pool); i++)
switch (proto)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
ASSERT (a->busy_##n##_port_refcounts[port_host_byte_order] >= 1); \
--a->busy_##n##_port_refcounts[port_host_byte_order]; \
a->busy_##n##_ports--; \
a->busy_##n##_ports_per_thread[thread_index]--; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
nat_elog_notice ("unknown protocol");
nat64_db_bib_entry_t *bibe;
u32 fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, vrf_id,
nat_fib_src_hi);
- snat_protocol_t p = ip_proto_to_snat_proto (proto);
+ nat_protocol_t p = ip_proto_to_nat_proto (proto);
ip46_address_t addr;
int i;
snat_address_t *a;
switch (p)
{
#define _(N, j, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
if (a->busy_##n##_port_refcounts[out_port]) \
return VNET_API_ERROR_INVALID_VALUE; \
++a->busy_##n##_port_refcounts[out_port]; \
a->busy_##n##_ports_per_thread[thread_index]++; \
} \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
default:
clib_memset (&addr, 0, sizeof (addr));
nat64_main_t *nm = &nat64_main;
u32 now = (u32) vlib_time_now (vm);
- switch (ip_proto_to_snat_proto (ste->proto))
+ switch (ip_proto_to_nat_proto (ste->proto))
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
ste->expire = now + nm->icmp_timeout;
return;
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_TCP:
{
switch (ste->tcp_state)
{
return;
}
}
- case SNAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_UDP:
ste->expire = now + nm->udp_timeout;
return;
default:
*
* @returns 0 on success, non-zero value otherwise.
*/
-int nat64_alloc_out_addr_and_port (u32 fib_index, snat_protocol_t proto,
+int nat64_alloc_out_addr_and_port (u32 fib_index, nat_protocol_t proto,
ip4_address_t * addr, u16 * port,
u32 thread_index);
#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 _
return 0;
}
u32 in_port = 0;
u32 out_port = 0;
u32 vrf_id = 0, protocol;
- snat_protocol_t proto = 0;
+ nat_protocol_t proto = 0;
u8 p = 0;
int rv;
;
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))
;
else
if (unformat
goto done;
}
- p = snat_proto_to_ip_proto (proto);
+ p = nat_proto_to_ip_proto (proto);
}
rv =
clib_net_to_host_u16 (bibe->in_port),
format_ip4_address, &bibe->out_addr,
clib_net_to_host_u16 (bibe->out_port),
- format_snat_protocol,
- ip_proto_to_snat_proto (bibe->proto), fib->ft_table_id,
+ format_nat_protocol,
+ ip_proto_to_nat_proto (bibe->proto), fib->ft_table_id,
bibe->is_static ? "static" : "dynamic", bibe->ses_num);
break;
default:
nat64_main_t *nm = &nat64_main;
unformat_input_t _line_input, *line_input = &_line_input;
clib_error_t *error = 0;
- u32 proto = ~0;
+ u32 proto = NAT_PROTOCOL_OTHER;
u8 p = 255;
nat64_db_t *db;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- if (unformat (line_input, "%U", unformat_snat_protocol, &proto))
- p = snat_proto_to_ip_proto (proto);
+ if (unformat (line_input, "%U", unformat_nat_protocol, &proto))
+ p = nat_proto_to_ip_proto (proto);
else if (unformat (line_input, "unknown"))
p = 0;
else if (unformat (line_input, "all"))
if (p == 255)
vlib_cli_output (vm, "NAT64 BIB entries:");
else
- vlib_cli_output (vm, "NAT64 %U BIB entries:", format_snat_protocol,
- proto);
+ vlib_cli_output (vm, "NAT64 %U BIB entries:", format_nat_protocol, proto);
/* *INDENT-OFF* */
vec_foreach (db, nm->db)
format_ip4_address, &bibe->out_addr,
format_ip4_address, &ste->out_r_addr,
clib_net_to_host_u16 (bibe->out_port),
- format_snat_protocol,
- ip_proto_to_snat_proto (bibe->proto), vrf_id);
+ format_nat_protocol,
+ ip_proto_to_nat_proto (bibe->proto), vrf_id);
else if (ste->proto == IP_PROTOCOL_TCP || ste->proto == IP_PROTOCOL_UDP)
vlib_cli_output (vm, " %U %u %U %u %U %u %U %u protcol %U vrf %u",
format_ip6_address, &bibe->in_addr,
clib_net_to_host_u16 (bibe->out_port),
format_ip4_address, &ste->out_r_addr,
clib_net_to_host_u16 (ste->r_port),
- format_snat_protocol,
- ip_proto_to_snat_proto (bibe->proto), vrf_id);
+ format_nat_protocol,
+ ip_proto_to_nat_proto (bibe->proto), vrf_id);
else
vlib_cli_output (vm, " %U %U %U %U protocol %u vrf %u",
format_ip6_address, &bibe->in_addr,
nat64_main_t *nm = &nat64_main;
unformat_input_t _line_input, *line_input = &_line_input;
clib_error_t *error = 0;
- u32 proto = ~0;
+ u32 proto = NAT_PROTOCOL_OTHER;
u8 p = 255;
nat64_db_t *db;
nat64_cli_st_walk_ctx_t ctx = {
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- if (unformat (line_input, "%U", unformat_snat_protocol, &proto))
- p = snat_proto_to_ip_proto (proto);
+ if (unformat (line_input, "%U", unformat_nat_protocol, &proto))
+ p = nat_proto_to_ip_proto (proto);
else if (unformat (line_input, "unknown"))
p = 0;
else if (unformat (line_input, "all"))
if (p == 255)
vlib_cli_output (vm, "NAT64 sessions:");
else
- vlib_cli_output (vm, "NAT64 %U sessions:", format_snat_protocol, proto);
+ vlib_cli_output (vm, "NAT64 %U sessions:", format_nat_protocol, proto);
/* *INDENT-OFF* */
vec_foreach (db, nm->db)
{
}
/* create pool entry */
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
pool_get (db->bib._##n##_bib, bibe); \
kv.value = bibe - db->bib._##n##_bib; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
nat64_db_st_entry_t *st, *ste;
fib_table_t *fib;
- switch (ip_proto_to_snat_proto (bibe->proto))
+ switch (ip_proto_to_nat_proto (bibe->proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
bib = db->bib._##n##_bib; \
st = db->st._##n##_st; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
clib_bihash_kv_24_8_t kv, value;
nat64_db_bib_entry_t *bib;
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
bib = db->bib._##n##_bib; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
if (fn (bibe, ctx)) \
return; \
}));
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
bib = db->bib._unk_proto_bib;
pool_foreach (bibe, bib, ({
}
else
{
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
bib = db->bib._##n##_bib; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
{
nat64_db_bib_entry_t *bib;
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
bib = db->bib._##n##_bib; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
if (fn (ste, ctx)) \
return; \
}));
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
st = db->st._unk_proto_st;
pool_foreach (ste, st, ({
}
else
{
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
st = db->st._##n##_st; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
}
/* create pool entry */
- switch (ip_proto_to_snat_proto (bibe->proto))
+ switch (ip_proto_to_nat_proto (bibe->proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
pool_get (db->st._##n##_st, ste); \
kv.value = ste - db->st._##n##_st; \
bib = db->bib._##n##_bib; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
clib_bihash_kv_48_8_t kv;
fib_table_t *fib;
- switch (ip_proto_to_snat_proto (ste->proto))
+ switch (ip_proto_to_nat_proto (ste->proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
st = db->st._##n##_st; \
bib = db->bib._##n##_bib; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
nat64_db_st_entry_key_t ste_key;
clib_bihash_kv_48_8_t kv, value;
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
st = db->st._##n##_st; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
{
nat64_db_st_entry_t *st;
- switch (ip_proto_to_snat_proto (ste->proto))
+ switch (ip_proto_to_nat_proto (ste->proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
st = db->st._##n##_st; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
{
nat64_db_st_entry_t *st;
- switch (ip_proto_to_snat_proto (proto))
+ switch (ip_proto_to_nat_proto (proto))
{
/* *INDENT-OFF* */
#define _(N, i, n, s) \
- case SNAT_PROTOCOL_##N: \
+ case NAT_PROTOCOL_##N: \
st = db->st._##n##_st; \
break;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
default:
#define _(N, i, n, s) \
st = db->st._##n##_st; \
pool_foreach (ste, st, ({\
- if (i == SNAT_PROTOCOL_TCP && !ste->tcp_state) \
+ if (i == NAT_PROTOCOL_TCP && !ste->tcp_state) \
continue; \
if (ste->expire < now) \
vec_add1 (ste_to_be_free, ste - st); \
pool_elt_at_index(st, ste_index[0])); \
vec_free (ste_to_be_free); \
ste_to_be_free = 0;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
st = db->st._unk_proto_st;
pool_foreach (ste, st, ({
pool_elt_at_index(st, ste_index[0])); \
vec_free (ste_to_be_free); \
ste_to_be_free = 0;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
st = db->st._unk_proto_st;
pool_foreach (ste, st, ({
/* *INDENT-OFF* */
#define _(N, i, n, s) \
nat64_db_bib_entry_t *_##n##_bib;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
nat64_db_bib_entry_t *_unk_proto_bib;
/* *INDENT-OFF* */
#define _(N, i, n, s) \
nat64_db_st_entry_t *_##n##_st;
- foreach_snat_protocol
+ foreach_nat_protocol
#undef _
/* *INDENT-ON* */
nat64_db_st_entry_t *_unk_proto_st;
u16 out_port;
ip4_address_t out_addr;
if (nat64_alloc_out_addr_and_port
- (fib_index, ip_proto_to_snat_proto (proto), &out_addr,
+ (fib_index, ip_proto_to_nat_proto (proto), &out_addr,
&out_port, ctx->thread_index))
return -1;
u16 out_id;
ip4_address_t out_addr;
if (nat64_alloc_out_addr_and_port
- (fib_index, SNAT_PROTOCOL_ICMP, &out_addr, &out_id,
+ (fib_index, NAT_PROTOCOL_ICMP, &out_addr, &out_id,
ctx->thread_index))
return -1;
u16 out_port;
ip4_address_t out_addr;
if (nat64_alloc_out_addr_and_port
- (fib_index, ip_proto_to_snat_proto (proto), &out_addr,
+ (fib_index, ip_proto_to_nat_proto (proto), &out_addr,
&out_port, thread_index))
return -1;
goto trace0;
}
- proto0 = ip_proto_to_snat_proto (l4_protocol0);
+ proto0 = ip_proto_to_nat_proto (l4_protocol0);
if (is_slow_path)
{
- if (PREDICT_TRUE (proto0 == ~0))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_OTHER))
{
other_packets++;
if (is_hairpinning (&ip60->dst_address))
}
else
{
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
next0 = NAT64_IN2OUT_NEXT_SLOWPATH;
goto trace0;
}
}
- if (proto0 == SNAT_PROTOCOL_ICMP)
+ if (proto0 == NAT_PROTOCOL_ICMP)
{
icmp_packets++;
if (is_hairpinning (&ip60->dst_address))
goto trace0;
}
}
- else if (proto0 == SNAT_PROTOCOL_TCP || proto0 == SNAT_PROTOCOL_UDP)
+ else if (proto0 == NAT_PROTOCOL_TCP || proto0 == NAT_PROTOCOL_UDP)
{
- if (proto0 == SNAT_PROTOCOL_TCP)
+ if (proto0 == NAT_PROTOCOL_TCP)
tcp_packets++;
else
udp_packets++;
next0 = NAT64_OUT2IN_NEXT_IP6_LOOKUP;
- proto0 = ip_proto_to_snat_proto (ip40->protocol);
+ proto0 = ip_proto_to_nat_proto (ip40->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
if (nat64_out2in_unk_proto (vm, b0, &ctx0))
{
goto trace0;
}
- if (proto0 == SNAT_PROTOCOL_ICMP)
+ if (proto0 == NAT_PROTOCOL_ICMP)
{
icmp_packets++;
if (icmp_to_icmp6
}
else
{
- if (proto0 == SNAT_PROTOCOL_TCP)
+ if (proto0 == NAT_PROTOCOL_TCP)
tcp_packets++;
else
udp_packets++;
* Send DHCP packets to the ipv4 stack, or we won't
* be able to use dhcp client on the outside interface
*/
- if ((proto0 == SNAT_PROTOCOL_UDP)
+ if ((proto0 == NAT_PROTOCOL_UDP)
&& (udp0->dst_port ==
clib_host_to_net_u16 (UDP_DST_PORT_dhcp_to_client)))
{
format_ip4_address, &k.client_addr,
format_ip4_address, &k.service_addr,
clib_net_to_host_u16 (k.service_port),
- format_snat_protocol, k.proto);
+ format_nat_protocol, k.proto);
return s;
}
u32 vrf_id, external_sw_if_index;
twice_nat_type_t twice_nat = TWICE_NAT_DISABLED;
int rv = 0;
- snat_protocol_t proto;
+ nat_protocol_t proto;
u8 *tag = 0;
if (sm->deterministic)
vrf_id = clib_net_to_host_u32 (mp->vrf_id);
external_sw_if_index = clib_net_to_host_u32 (mp->external_sw_if_index);
- proto = ip_proto_to_snat_proto (mp->protocol);
+ proto = ip_proto_to_nat_proto (mp->protocol);
if (mp->flags & NAT_API_IS_TWICE_NAT)
twice_nat = TWICE_NAT;
}
else
{
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->protocol = nat_proto_to_ip_proto (m->proto);
rmp->external_port = htons (m->external_port);
rmp->local_port = htons (m->local_port);
}
}
else
{
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->protocol = nat_proto_to_ip_proto (m->proto);
rmp->external_port = htons (m->e_port);
rmp->local_port = htons (m->l_port);
}
u16 port = 0;
u32 vrf_id, sw_if_index;
int rv = 0;
- snat_protocol_t proto = ~0;
+ nat_protocol_t proto = NAT_PROTOCOL_OTHER;
u8 *tag = 0;
if (sm->deterministic)
if (!(mp->flags & NAT_API_IS_ADDR_ONLY))
{
port = clib_net_to_host_u16 (mp->port);
- proto = ip_proto_to_snat_proto (mp->protocol);
+ proto = ip_proto_to_nat_proto (mp->protocol);
}
vrf_id = clib_net_to_host_u32 (mp->vrf_id);
sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
rmp->port = htons (m->local_port);
rmp->sw_if_index = ~0;
rmp->vrf_id = htonl (local->vrf_id);
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->protocol = nat_proto_to_ip_proto (m->proto);
rmp->context = context;
if (m->tag)
strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
rmp->port = htons (m->l_port);
rmp->sw_if_index = htonl (m->sw_if_index);
rmp->vrf_id = htonl (m->vrf_id);
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->protocol = nat_proto_to_ip_proto (m->proto);
rmp->context = context;
if (m->tag)
strncpy ((char *) rmp->tag, (char *) m->tag, vec_len (m->tag));
{
rmp->outside_port = s->out2in.port;
rmp->inside_port = s->in2out.port;
- rmp->protocol = ntohs (snat_proto_to_ip_proto (s->in2out.protocol));
+ rmp->protocol = ntohs (nat_proto_to_ip_proto (s->in2out.protocol));
}
if (is_ed_session (s) || is_fwd_bypass_session (s))
{
int rv = 0;
nat44_lb_addr_port_t *locals = 0;
ip4_address_t e_addr;
- snat_protocol_t proto;
+ nat_protocol_t proto;
u8 *tag = 0;
if (!sm->endpoint_dependent)
unformat_nat44_lb_addr_port (mp->locals,
clib_net_to_host_u32 (mp->local_num));
clib_memcpy (&e_addr, mp->external_addr, 4);
- proto = ip_proto_to_snat_proto (mp->protocol);
+ proto = ip_proto_to_nat_proto (mp->protocol);
if (mp->flags & NAT_API_IS_TWICE_NAT)
twice_nat = TWICE_NAT;
vl_api_nat44_lb_static_mapping_add_del_local_reply_t *rmp;
int rv = 0;
ip4_address_t e_addr, l_addr;
- snat_protocol_t proto;
+ nat_protocol_t proto;
if (!sm->endpoint_dependent)
{
clib_memcpy (&e_addr, mp->external_addr, 4);
clib_memcpy (&l_addr, mp->local.addr, 4);
- proto = ip_proto_to_snat_proto (mp->protocol);
+ proto = ip_proto_to_nat_proto (mp->protocol);
rv =
nat44_lb_static_mapping_add_del_local (e_addr,
clib_memcpy (rmp->external_addr, &(m->external_addr), 4);
rmp->external_port = ntohs (m->external_port);
- rmp->protocol = snat_proto_to_ip_proto (m->proto);
+ rmp->protocol = nat_proto_to_ip_proto (m->proto);
rmp->context = context;
if (m->twice_nat == TWICE_NAT)
u32 vrf_id;
int rv = 0;
u8 is_in;
- snat_protocol_t proto;
+ nat_protocol_t proto;
if (sm->deterministic)
{
memcpy (&addr.as_u8, mp->address, 4);
port = clib_net_to_host_u16 (mp->port);
vrf_id = clib_net_to_host_u32 (mp->vrf_id);
- proto = ip_proto_to_snat_proto (mp->protocol);
+ proto = ip_proto_to_nat_proto (mp->protocol);
memcpy (&eh_addr.as_u8, mp->ext_host_address, 4);
eh_port = clib_net_to_host_u16 (mp->ext_host_port);
if (!icmp_type_is_error_message
(vnet_buffer (b0)->ip.reass.icmp_type_or_tcp_flags))
{
- protocol = SNAT_PROTOCOL_ICMP;
+ protocol = NAT_PROTOCOL_ICMP;
in_addr = ip0->src_address;
in_port = vnet_buffer (b0)->ip.reass.l4_src_port;
}
/* if error message, then it's not fragmented and we can access it */
inner_ip0 = (ip4_header_t *) (echo0 + 1);
l4_header = ip4_next_header (inner_ip0);
- protocol = ip_proto_to_snat_proto (inner_ip0->protocol);
+ protocol = ip_proto_to_nat_proto (inner_ip0->protocol);
in_addr = inner_ip0->dst_address;
switch (protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
in_port = inner_echo0->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
in_port = ((tcp_udp_header_t *) l4_header)->dst_port;
break;
default:
goto trace0;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
rx_fib_index0 =
ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
src_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (tcp0->flags & TCP_FLAG_SYN)
ses0->state = SNAT_SESSION_TCP_SYN_SENT;
goto trace1;
}
- proto1 = ip_proto_to_snat_proto (ip1->protocol);
+ proto1 = ip_proto_to_nat_proto (ip1->protocol);
- if (PREDICT_FALSE (proto1 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_ICMP))
{
rx_fib_index1 =
ip4_fib_table_get_index_for_sw_if_index (sw_if_index1);
src_address /* changed member */ );
ip1->checksum = ip_csum_fold (sum1);
- if (PREDICT_TRUE (proto1 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto1 == NAT_PROTOCOL_TCP))
{
if (tcp1->flags & TCP_FLAG_SYN)
ses1->state = SNAT_SESSION_TCP_SYN_SENT;
goto trace00;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
rx_fib_index0 =
ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
src_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (tcp0->flags & TCP_FLAG_SYN)
ses0->state = SNAT_SESSION_TCP_SYN_SENT;
if (!icmp_type_is_error_message
(vnet_buffer (b0)->ip.reass.icmp_type_or_tcp_flags))
{
- protocol = SNAT_PROTOCOL_ICMP;
+ protocol = NAT_PROTOCOL_ICMP;
key0.ext_host_addr = ip0->src_address;
key0.ext_host_port = 0;
key0.out_port = vnet_buffer (b0)->ip.reass.l4_src_port;
/* if error message, then it's not fragmented and we can access it */
inner_ip0 = (ip4_header_t *) (echo0 + 1);
l4_header = ip4_next_header (inner_ip0);
- protocol = ip_proto_to_snat_proto (inner_ip0->protocol);
+ protocol = ip_proto_to_nat_proto (inner_ip0->protocol);
key0.ext_host_addr = inner_ip0->dst_address;
out_addr = inner_ip0->src_address;
switch (protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
key0.ext_host_port = 0;
key0.out_port = inner_echo0->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
key0.ext_host_port = ((tcp_udp_header_t *) l4_header)->dst_port;
key0.out_port = ((tcp_udp_header_t *) l4_header)->src_port;
break;
goto trace0;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
rx_fib_index0 =
ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
dst_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (tcp0->flags & TCP_FLAG_FIN
&& ses0->state == SNAT_SESSION_TCP_ESTABLISHED)
goto trace1;
}
- proto1 = ip_proto_to_snat_proto (ip1->protocol);
+ proto1 = ip_proto_to_nat_proto (ip1->protocol);
- if (PREDICT_FALSE (proto1 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_ICMP))
{
rx_fib_index1 =
ip4_fib_table_get_index_for_sw_if_index (sw_if_index1);
dst_address /* changed member */ );
ip1->checksum = ip_csum_fold (sum1);
- if (PREDICT_TRUE (proto1 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto1 == NAT_PROTOCOL_TCP))
{
if (tcp1->flags & TCP_FLAG_FIN
&& ses1->state == SNAT_SESSION_TCP_ESTABLISHED)
goto trace00;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
rx_fib_index0 =
ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
dst_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (tcp0->flags & TCP_FLAG_FIN
&& ses0->state == SNAT_SESSION_TCP_ESTABLISHED)
#include <nat/nat_det.h>
uword
-unformat_snat_protocol (unformat_input_t * input, va_list * args)
+unformat_nat_protocol (unformat_input_t * input, va_list * args)
{
u32 *r = va_arg (*args, u32 *);
if (0);
-#define _(N, i, n, s) else if (unformat (input, s)) *r = SNAT_PROTOCOL_##N;
- foreach_snat_protocol
+#define _(N, i, n, s) else if (unformat (input, s)) *r = NAT_PROTOCOL_##N;
+ foreach_nat_protocol
#undef _
else
return 0;
}
u8 *
-format_snat_protocol (u8 * s, va_list * args)
+format_nat_protocol (u8 * s, va_list * args)
{
u32 i = va_arg (*args, u32);
u8 *t = 0;
switch (i)
{
-#define _(N, j, n, str) case SNAT_PROTOCOL_##N: t = (u8 *) str; break;
- foreach_snat_protocol
+#define _(N, j, n, str) case NAT_PROTOCOL_##N: t = (u8 *) str; break;
+ foreach_nat_protocol
#undef _
default:
s = format (s, "unknown");
s = format (s, "%U proto %U port %d fib %d",
format_ip4_address, &key->addr,
- format_snat_protocol, key->protocol,
+ format_nat_protocol, key->protocol,
clib_net_to_host_u16 (key->port), key->fib_index);
return s;
}
s = format (s, "%U proto %U port %d fib %d",
format_ip4_address, &key->addr,
- format_snat_protocol, key->protocol, key->port, key->fib_index);
+ format_nat_protocol, key->protocol, key->port, key->fib_index);
return s;
}
format_ip4_address, &m->local_addr);
else
s = format (s, "identity mapping %U %U:%d",
- format_snat_protocol, m->proto,
+ format_nat_protocol, m->proto,
format_ip4_address, &m->local_addr, m->local_port);
/* *INDENT-OFF* */
if (is_lb_static_mapping (m))
{
s = format (s, "%U external %U:%d %s %s",
- format_snat_protocol, m->proto,
+ format_nat_protocol, m->proto,
format_ip4_address, &m->external_addr, m->external_port,
m->twice_nat == TWICE_NAT ? "twice-nat" :
m->twice_nat == TWICE_NAT_SELF ? "self-twice-nat" : "",
}
else
s = format (s, "%U local %U:%d external %U:%d vrf %d %s %s",
- format_snat_protocol, m->proto,
+ format_nat_protocol, m->proto,
format_ip4_address, &m->local_addr, m->local_port,
format_ip4_address, &m->external_addr, m->external_port,
m->vrf_id,
format_vnet_sw_if_index_name, vnm, m->sw_if_index, m->vrf_id);
else
s = format (s, "%U local %U:%d external %U:%d vrf %d",
- format_snat_protocol, m->proto,
+ format_nat_protocol, m->proto,
format_ip4_address, &m->l_addr, m->l_port,
format_vnet_sw_if_index_name, vnm, m->sw_if_index,
m->e_port, m->vrf_id);
return frame->n_vectors;
}
-always_inline u32
-ip_proto_to_snat_proto (u8 ip_proto)
-{
- u32 snat_proto = ~0;
-
- snat_proto = (ip_proto == IP_PROTOCOL_UDP) ? SNAT_PROTOCOL_UDP : snat_proto;
- snat_proto = (ip_proto == IP_PROTOCOL_TCP) ? SNAT_PROTOCOL_TCP : snat_proto;
- snat_proto =
- (ip_proto == IP_PROTOCOL_ICMP) ? SNAT_PROTOCOL_ICMP : snat_proto;
- snat_proto =
- (ip_proto == IP_PROTOCOL_ICMP6) ? SNAT_PROTOCOL_ICMP : snat_proto;
-
- return snat_proto;
-}
-
-always_inline u8
-snat_proto_to_ip_proto (snat_protocol_t snat_proto)
-{
- u8 ip_proto = ~0;
-
- ip_proto = (snat_proto == SNAT_PROTOCOL_UDP) ? IP_PROTOCOL_UDP : ip_proto;
- ip_proto = (snat_proto == SNAT_PROTOCOL_TCP) ? IP_PROTOCOL_TCP : ip_proto;
- ip_proto = (snat_proto == SNAT_PROTOCOL_ICMP) ? IP_PROTOCOL_ICMP : ip_proto;
-
- return ip_proto;
-}
-
-static_always_inline u8
-icmp_type_is_error_message (u8 icmp_type)
-{
- switch (icmp_type)
- {
- case ICMP4_destination_unreachable:
- case ICMP4_time_exceeded:
- case ICMP4_parameter_problem:
- case ICMP4_source_quench:
- case ICMP4_redirect:
- case ICMP4_alternate_host_address:
- return 1;
- }
- return 0;
-}
-
always_inline u8
is_interface_addr (snat_main_t * sm, vlib_node_runtime_t * node,
u32 sw_if_index0, u32 ip4_addr)
{
switch (s->in2out.protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
return sm->icmp_timeout;
- case SNAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_UDP:
return sm->udp_timeout;
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_TCP:
{
if (s->state)
return sm->tcp_transitory_timeout;
static_always_inline int
get_icmp_i2o_ed_key (vlib_buffer_t * b, ip4_header_t * ip0, u32 rx_fib_index,
- u64 value, u8 * snat_proto, u16 * l_port, u16 * r_port,
+ u64 value, u8 * nat_proto, u16 * l_port, u16 * r_port,
clib_bihash_kv_16_8_t * kv)
{
u8 proto;
proto = inner_ip0->protocol;
r_addr = &inner_ip0->src_address;
l_addr = &inner_ip0->dst_address;
- switch (ip_proto_to_snat_proto (inner_ip0->protocol))
+ switch (ip_proto_to_nat_proto (inner_ip0->protocol))
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
_r_port = 0;
_l_port = inner_echo0->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
_l_port = ((tcp_udp_header_t *) l4_header)->dst_port;
_r_port = ((tcp_udp_header_t *) l4_header)->src_port;
break;
}
make_ed_kv (l_addr, r_addr, proto, rx_fib_index, _l_port, _r_port, value,
kv);
- if (snat_proto)
+ if (nat_proto)
{
- *snat_proto = ip_proto_to_snat_proto (proto);
+ *nat_proto = ip_proto_to_nat_proto (proto);
}
if (l_port)
{
static_always_inline int
get_icmp_o2i_ed_key (vlib_buffer_t * b, ip4_header_t * ip0, u32 rx_fib_index,
- u64 value, u8 * snat_proto, u16 * l_port, u16 * r_port,
+ u64 value, u8 * nat_proto, u16 * l_port, u16 * r_port,
clib_bihash_kv_16_8_t * kv)
{
icmp46_header_t *icmp0;
proto = inner_ip0->protocol;
l_addr = &inner_ip0->src_address;
r_addr = &inner_ip0->dst_address;
- switch (ip_proto_to_snat_proto (inner_ip0->protocol))
+ switch (ip_proto_to_nat_proto (inner_ip0->protocol))
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
_l_port = inner_echo0->identifier;
_r_port = 0;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
_l_port = ((tcp_udp_header_t *) l4_header)->src_port;
_r_port = ((tcp_udp_header_t *) l4_header)->dst_port;
break;
}
make_ed_kv (l_addr, r_addr, proto, rx_fib_index, _l_port, _r_port, value,
kv);
- if (snat_proto)
+ if (nat_proto)
{
- *snat_proto = ip_proto_to_snat_proto (proto);
+ *nat_proto = ip_proto_to_nat_proto (proto);
}
if (l_port)
{
u8 nat_event;
u32 src_ip;
u32 nat_src_ip;
- snat_protocol_t snat_proto;
+ nat_protocol_t nat_proto;
u16 src_port;
u16 nat_src_port;
u32 vrf_id;
static void
snat_ipfix_logging_nat44_ses (u32 thread_index, u8 nat_event, u32 src_ip,
- u32 nat_src_ip, snat_protocol_t snat_proto,
+ u32 nat_src_ip, nat_protocol_t nat_proto,
u16 src_port, u16 nat_src_port, u32 vrf_id,
int do_flush)
{
u32 offset;
vlib_main_t *vm = vlib_mains[thread_index];
u64 now;
- u8 proto = ~0;
+ u8 proto;
u16 template_id;
- proto = snat_proto_to_ip_proto (snat_proto);
+ proto = nat_proto_to_ip_proto (nat_proto);
now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
now += silm->milisecond_time_0;
* @param thread_index thread index
* @param src_ip source IPv4 address
* @param nat_src_ip transaltes source IPv4 address
- * @param snat_proto NAT transport protocol
+ * @param nat_proto NAT transport protocol
* @param src_port source port
* @param nat_src_port translated source port
* @param vrf_id VRF ID
snat_ipfix_logging_nat44_ses_create (u32 thread_index,
u32 src_ip,
u32 nat_src_ip,
- snat_protocol_t snat_proto,
+ nat_protocol_t nat_proto,
u16 src_port,
u16 nat_src_port, u32 vrf_id)
{
skip_if_disabled ();
snat_ipfix_logging_nat44_ses (thread_index, NAT44_SESSION_CREATE, src_ip,
- nat_src_ip, snat_proto, src_port, nat_src_port,
+ nat_src_ip, nat_proto, src_port, nat_src_port,
vrf_id, 0);
}
* @param thread_index thread index
* @param src_ip source IPv4 address
* @param nat_src_ip transaltes source IPv4 address
- * @param snat_proto NAT transport protocol
+ * @param nat_proto NAT transport protocol
* @param src_port source port
* @param nat_src_port translated source port
* @param vrf_id VRF ID
snat_ipfix_logging_nat44_ses_delete (u32 thread_index,
u32 src_ip,
u32 nat_src_ip,
- snat_protocol_t snat_proto,
+ nat_protocol_t nat_proto,
u16 src_port,
u16 nat_src_port, u32 vrf_id)
{
skip_if_disabled ();
snat_ipfix_logging_nat44_ses (thread_index, NAT44_SESSION_DELETE, src_ip,
- nat_src_ip, snat_proto, src_port, nat_src_port,
+ nat_src_ip, nat_proto, src_port, nat_src_port,
vrf_id, 0);
}
int snat_ipfix_logging_enable_disable (int enable, u32 domain_id, u16 src_port);
void snat_ipfix_logging_nat44_ses_create (u32 thread_index, u32 src_ip,
u32 nat_src_ip,
- snat_protocol_t snat_proto,
+ nat_protocol_t nat_proto,
u16 src_port, u16 nat_src_port,
u32 vrf_id);
void snat_ipfix_logging_nat44_ses_delete (u32 thread_index, u32 src_ip,
u32 nat_src_ip,
- snat_protocol_t snat_proto,
+ nat_protocol_t nat_proto,
u16 src_port, u16 nat_src_port,
u32 vrf_id);
void snat_ipfix_logging_addresses_exhausted(u32 thread_index, u32 pool_id);
u32 local_port = 0, external_port = 0, vrf_id = ~0;
u32 sw_if_index = ~0;
u8 sw_if_index_set = 0;
- u32 proto = ~0;
+ u32 proto = NAT_PROTOCOL_OTHER;
u8 proto_set = 0;
int ret;
if (!icmp_type_is_error_message
(vnet_buffer (b)->ip.reass.icmp_type_or_tcp_flags))
{
- key0.protocol = SNAT_PROTOCOL_ICMP;
+ key0.protocol = NAT_PROTOCOL_ICMP;
key0.addr = ip0->dst_address;
key0.port = vnet_buffer (b)->ip.reass.l4_src_port; // TODO should this be dst port?
}
{
inner_ip0 = (ip4_header_t *) (echo0 + 1);
l4_header = ip4_next_header (inner_ip0);
- key0.protocol = ip_proto_to_snat_proto (inner_ip0->protocol);
+ key0.protocol = ip_proto_to_nat_proto (inner_ip0->protocol);
key0.addr = inner_ip0->src_address;
switch (key0.protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
key0.port = inner_echo0->identifier;
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
key0.port = ((tcp_udp_header_t *) l4_header)->src_port;
break;
default:
switch (protocol)
{
- case SNAT_PROTOCOL_ICMP:
+ case NAT_PROTOCOL_ICMP:
inner_icmp0 = (icmp46_header_t *) l4_header;
inner_echo0 = (icmp_echo_header_t *) (inner_icmp0 + 1);
identifier);
icmp0->checksum = ip_csum_fold (sum0);
break;
- case SNAT_PROTOCOL_UDP:
- case SNAT_PROTOCOL_TCP:
+ case NAT_PROTOCOL_UDP:
+ case NAT_PROTOCOL_TCP:
old_id0 = ((tcp_udp_header_t *) l4_header)->src_port;
new_id0 = sm0.port;
((tcp_udp_header_t *) l4_header)->src_port = new_id0;
goto trace0;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
if (nat_out2in_sm_unknown_proto (sm, b0, ip0, rx_fib_index0))
{
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_out2in_slow_path
(sm, b0, ip0, icmp0, sw_if_index0, rx_fib_index0, node,
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto0 == SNAT_PROTOCOL_UDP
+ (proto0 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b0)->ip.reass.l4_dst_port ==
clib_host_to_net_u16
(UDP_DST_PORT_dhcp_to_client))))
dst_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
goto trace1;
}
- proto1 = ip_proto_to_snat_proto (ip1->protocol);
+ proto1 = ip_proto_to_nat_proto (ip1->protocol);
- if (PREDICT_FALSE (proto1 == ~0))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_OTHER))
{
if (nat_out2in_sm_unknown_proto (sm, b1, ip1, rx_fib_index1))
{
goto trace1;
}
- if (PREDICT_FALSE (proto1 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto1 == NAT_PROTOCOL_ICMP))
{
next1 = icmp_out2in_slow_path
(sm, b1, ip1, icmp1, sw_if_index1, rx_fib_index1, node,
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto1 == SNAT_PROTOCOL_UDP
+ (proto1 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b1)->ip.reass.l4_dst_port ==
clib_host_to_net_u16
(UDP_DST_PORT_dhcp_to_client))))
dst_address /* changed member */ );
ip1->checksum = ip_csum_fold (sum1);
- if (PREDICT_TRUE (proto1 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto1 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b1)->ip.reass.is_non_first_fragment)
{
rx_fib_index0 = vec_elt (sm->ip4_main->fib_index_by_sw_if_index,
sw_if_index0);
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
if (nat_out2in_sm_unknown_proto (sm, b0, ip0, rx_fib_index0))
{
goto trace00;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_out2in_slow_path
(sm, b0, ip0, icmp0, sw_if_index0, rx_fib_index0, node,
* be able to use dhcp client on the outside interface
*/
if (PREDICT_FALSE
- (proto0 == SNAT_PROTOCOL_UDP
+ (proto0 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b0)->ip.reass.l4_dst_port ==
clib_host_to_net_u16
(UDP_DST_PORT_dhcp_to_client))))
dst_address /* changed member */ );
ip0->checksum = ip_csum_fold (sum0);
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
goto trace00;
}
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
goto trace00;
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_out2in (sm, b0, ip0, icmp0, sw_if_index0,
rx_fib_index0, node, next0, ~0, 0, 0);
old_port0 = udp0->dst_port;
udp0->dst_port = new_port0;
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
sum0 = tcp0->checksum;
sum0 = ip_csum_update (sum0, old_addr0, new_addr0,
}
else
{
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
sum0 = tcp0->checksum;
sum0 = ip_csum_update (sum0, old_addr0, new_addr0,
}
else
{
- proto = snat_proto_to_ip_proto (s->in2out.protocol);
+ proto = nat_proto_to_ip_proto (s->in2out.protocol);
l_port = s->in2out.port;
r_port = s->ext_host_port;
}
udp = ip4_next_header (ip);
s->ext_host_addr.as_u32 = ip->src_address.as_u32;
- s->ext_host_port = e_key.protocol == SNAT_PROTOCOL_ICMP ? 0 : udp->src_port;
+ s->ext_host_port = e_key.protocol == NAT_PROTOCOL_ICMP ? 0 : udp->src_port;
s->flags |= SNAT_SESSION_FLAG_STATIC_MAPPING;
if (lb_nat)
s->flags |= SNAT_SESSION_FLAG_LOAD_BALANCING;
return;
}
- proto = ip_proto_to_snat_proto (ip->protocol);
+ proto = ip_proto_to_nat_proto (ip->protocol);
s->ext_host_addr = ip->src_address;
s->ext_host_port = r_port;
s->out2in.addr = ip->dst_address;
s->out2in.port = l_port;
s->out2in.protocol = proto;
- if (proto == ~0)
+ if (proto == NAT_PROTOCOL_OTHER)
{
s->flags |= SNAT_SESSION_FLAG_UNKNOWN_PROTO;
s->out2in.port = ip->protocol;
/* Try to match static mapping */
e_key.addr = ip->dst_address;
e_key.port = l_port;
- e_key.protocol = ip_proto_to_snat_proto (ip->protocol);
+ e_key.protocol = ip_proto_to_nat_proto (ip->protocol);
e_key.fib_index = rx_fib_index;
if (snat_static_mapping_match
(sm, e_key, &l_key, 1, &is_addr_only, 0, 0, 0, &identity_nat))
udp0 = ip4_next_header (ip0);
tcp0 = (tcp_header_t *) udp0;
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
next0 = NAT_NEXT_OUT2IN_ED_SLOW_PATH;
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = NAT_NEXT_OUT2IN_ED_SLOW_PATH;
goto trace0;
old_port0 = vnet_buffer (b0)->ip.reass.l4_dst_port;
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
udp0 = ip4_next_header (ip0);
tcp0 = (tcp_header_t *) udp0;
icmp0 = (icmp46_header_t *) udp0;
- proto0 = ip_proto_to_snat_proto (ip0->protocol);
+ proto0 = ip_proto_to_nat_proto (ip0->protocol);
- if (PREDICT_FALSE (proto0 == ~0))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_OTHER))
{
s0 =
nat44_ed_out2in_unknown_proto (sm, b0, ip0, rx_fib_index0,
goto trace0;
}
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_ICMP))
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_ICMP))
{
next0 = icmp_out2in_ed_slow_path
(sm, b0, ip0, icmp0, sw_if_index0, rx_fib_index0, node,
* Send DHCP packets to the ipv4 stack, or we won't
* be able to use dhcp client on the outside interface
*/
- if (PREDICT_FALSE (proto0 == SNAT_PROTOCOL_UDP
+ if (PREDICT_FALSE (proto0 == NAT_PROTOCOL_UDP
&& (vnet_buffer (b0)->ip.
reass.l4_dst_port ==
clib_host_to_net_u16
if (PREDICT_FALSE (identity_nat0))
goto trace0;
- if ((proto0 == SNAT_PROTOCOL_TCP)
+ if ((proto0 == NAT_PROTOCOL_TCP)
&& !tcp_flags_is_init (vnet_buffer (b0)->ip.
reass.icmp_type_or_tcp_flags))
{
old_port0 = vnet_buffer (b0)->ip.reass.l4_dst_port;
- if (PREDICT_TRUE (proto0 == SNAT_PROTOCOL_TCP))
+ if (PREDICT_TRUE (proto0 == NAT_PROTOCOL_TCP))
{
if (!vnet_buffer (b0)->ip.reass.is_non_first_fragment)
{
fields_desc = [ByteEnumField("event_type", None,
{1: "add", 2: "del", 3: "refresh"}),
ByteEnumField("protocol", None,
- {0: "udp", 1: "tcp", 2: "icmp"}),
+ {0: "other", 1: "udp", 2: "tcp", 3: "icmp"}),
ShortField("flags", 0),
IPField("in_addr", None),
IPField("out_addr", None),
Code Review / vpp.git / commitdiff