41 tag = t->
is_slow_path ?
"NAT64-in2out-slowpath" :
"NAT64-in2out";
66 format (s,
"NAT64-in2out-reass: sw_if_index %d, next index %d, status %s",
68 t->
cached ?
"cached" :
"translated");
78 #define foreach_nat64_in2out_error \ 79 _(UNSUPPORTED_PROTOCOL, "unsupported protocol") \ 80 _(IN2OUT_PACKETS, "good in2out packets processed") \ 81 _(NO_TRANSLATION, "no translation") \ 82 _(UNKNOWN, "unknown") \ 83 _(DROP_FRAGMENT, "drop fragment") \ 84 _(MAX_REASS, "maximum reassemblies exceeded") \ 85 _(MAX_FRAG, "maximum fragments per reassembly exceeded") \ 86 _(TCP_PACKETS, "TCP packets") \ 87 _(UDP_PACKETS, "UDP packets") \ 88 _(ICMP_PACKETS, "ICMP packets") \ 89 _(OTHER_PACKETS, "other protocol packets") \ 90 _(FRAGMENTS, "fragments") \ 91 _(CACHED_FRAGMENTS, "cached fragments") \ 92 _(PROCESSED_FRAGMENTS, "processed fragments") 97 #define _(sym,str) NAT64_IN2OUT_ERROR_##sym, 104 #define _(sym,string) string, 177 nat64_db_bib_entry_t *bibe;
178 nat64_db_st_entry_t *ste;
179 ip46_address_t saddr, daddr;
221 sport, out_port, fib_index, proto, 0);
245 if (proto == IP_PROTOCOL_TCP)
252 checksum = &tcp->checksum;
269 nat64_db_bib_entry_t *bibe;
270 nat64_db_st_entry_t *ste;
271 ip46_address_t saddr, daddr;
285 if (icmp->type == ICMP4_echo_request || icmp->type == ICMP4_echo_reply)
287 u16 in_id = ((
u16 *) (icmp))[2];
290 IP_PROTOCOL_ICMP, fib_index, 1);
304 IP_PROTOCOL_ICMP, fib_index, 1);
311 (fib_index, SNAT_PROTOCOL_ICMP, &out_addr, &out_id,
317 &out_addr, in_id, out_id,
318 fib_index, IP_PROTOCOL_ICMP, 0);
340 ((
u16 *) (icmp))[2] = bibe->out_port;
362 nat64_db_st_entry_t *ste;
363 nat64_db_bib_entry_t *bibe;
364 ip46_address_t saddr, daddr;
378 if (proto == IP_PROTOCOL_ICMP6)
381 u16 in_id = ((
u16 *) (icmp))[2];
382 proto = IP_PROTOCOL_ICMP;
385 (icmp->type == ICMP4_echo_request
386 || icmp->type == ICMP4_echo_reply))
400 ((
u16 *) (icmp))[2] = bibe->out_port;
427 if (proto == IP_PROTOCOL_TCP)
428 checksum = &tcp->checksum;
454 nat64_db_bib_entry_t *bibe;
455 ip46_address_t saddr, daddr;
468 saddr.ip4.as_u32 = bibe->out_addr.as_u32;
490 nat64_db_bib_entry_t *bibe;
491 nat64_db_st_entry_t *ste;
492 ip46_address_t saddr, daddr,
addr;
528 .out_addr.as_u32 = 0,
529 .fib_index = fib_index,
560 &ctx.
out_addr, 0, 0, fib_index, proto,
594 nat64_db_bib_entry_t *bibe;
595 nat64_db_st_entry_t *ste;
596 ip46_address_t saddr, daddr;
616 if (proto == IP_PROTOCOL_UDP)
619 checksum = &tcp->checksum;
648 &out_port, thread_index))
653 sport, out_port, fib_index, proto, 0);
672 if (proto == IP_PROTOCOL_TCP)
677 sport = udp->
src_port = bibe->out_port;
681 daddr.ip4.as_u32 = ste->out_r_addr.as_u32;
717 nat64_db_bib_entry_t *bibe;
718 nat64_db_st_entry_t *ste;
721 ip46_address_t saddr, daddr;
726 u16 *checksum, sport, dport;
730 if (icmp->type == ICMP6_echo_request || icmp->type == ICMP6_echo_reply)
737 if (proto == IP_PROTOCOL_ICMP6)
755 if (proto == IP_PROTOCOL_UDP)
758 checksum = &tcp->checksum;
777 dport = udp->
dst_port = bibe->out_port;
782 saddr.ip4.as_u32 = ste->out_r_addr.as_u32;
783 daddr.ip4.as_u32 = bibe->out_addr.as_u32;
843 nat64_db_bib_entry_t *bibe;
844 nat64_db_st_entry_t *ste;
845 ip46_address_t saddr, daddr,
addr;
881 .out_addr.as_u32 = 0,
882 .fib_index = fib_index,
913 &ctx.
out_addr, 0, 0, fib_index, proto,
937 daddr.ip4.as_u32 = ste->out_r_addr.as_u32;
963 u32 n_left_from, *from, *to_next;
965 u32 pkts_processed = 0;
966 u32 stats_node_index;
968 u32 tcp_packets = 0, udp_packets = 0, icmp_packets = 0, other_packets =
978 while (n_left_from > 0)
984 while (n_left_from > 0 && n_left_to_next > 0)
990 u16 l4_offset0, frag_offset0;
1002 n_left_to_next -= 1;
1019 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_UNKNOWN];
1042 (vm, b0, ip60, thread_index))
1046 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1055 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1071 (ip60->
protocol == IP_PROTOCOL_IPV6_FRAGMENTATION))
1078 if (proto0 == SNAT_PROTOCOL_ICMP)
1085 (vm, b0, ip60, thread_index))
1089 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1099 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1103 else if (proto0 == SNAT_PROTOCOL_TCP || proto0 == SNAT_PROTOCOL_UDP)
1105 if (proto0 == SNAT_PROTOCOL_TCP)
1114 (vm, b0, ip60, thread_index))
1118 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1127 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1134 && (b0->
flags & VLIB_BUFFER_IS_TRACED)))
1147 n_left_to_next, bi0, next0);
1152 NAT64_IN2OUT_ERROR_IN2OUT_PACKETS,
1155 NAT64_IN2OUT_ERROR_TCP_PACKETS, tcp_packets);
1157 NAT64_IN2OUT_ERROR_UDP_PACKETS, tcp_packets);
1159 NAT64_IN2OUT_ERROR_ICMP_PACKETS, icmp_packets);
1161 NAT64_IN2OUT_ERROR_OTHER_PACKETS,
1164 NAT64_IN2OUT_ERROR_FRAGMENTS, fragments);
1179 .name =
"nat64-in2out",
1180 .vector_size =
sizeof (
u32),
1209 .name =
"nat64-in2out-slowpath",
1210 .vector_size =
sizeof (
u32),
1245 nat64_db_st_entry_t *ste;
1246 nat64_db_bib_entry_t *bibe;
1264 if (ctx->
proto == IP_PROTOCOL_TCP)
1271 checksum = &tcp->checksum;
1297 nat64_db_st_entry_t *ste;
1298 nat64_db_bib_entry_t *bibe;
1305 ip46_address_t daddr;
1310 if (ctx->
proto == IP_PROTOCOL_UDP)
1313 checksum = &tcp->checksum;
1331 if (ctx->
proto == IP_PROTOCOL_TCP)
1336 sport = bibe->out_port;
1337 dport = ste->r_port;
1342 daddr.ip4.as_u32 = ste->out_r_addr.as_u32;
1381 u32 n_left_from, *from, *to_next;
1383 u32 pkts_processed = 0, cached_fragments = 0;
1384 u32 *fragments_to_drop = 0;
1385 u32 *fragments_to_loopback = 0;
1393 while (n_left_from > 0)
1399 while (n_left_from > 0 && n_left_to_next > 0)
1406 u16 l4_offset0, frag_offset0;
1408 nat_reass_ip6_t *reass0;
1409 ip6_frag_hdr_t *frag0;
1410 nat64_db_bib_entry_t *bibe0;
1411 nat64_db_st_entry_t *ste0;
1414 u32 sw_if_index0, fib_index0;
1415 ip46_address_t saddr0, daddr0;
1425 n_left_to_next -= 1;
1440 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_DROP_FRAGMENT];
1452 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_UNKNOWN];
1457 (!(l4_protocol0 == IP_PROTOCOL_TCP
1458 || l4_protocol0 == IP_PROTOCOL_UDP)))
1461 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_DROP_FRAGMENT];
1466 frag0 = (ip6_frag_hdr_t *)
u8_ptr_add (ip60, frag_offset0);
1471 frag0->identification,
1473 1, &fragments_to_drop);
1478 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_MAX_REASS];
1488 (reass0, bi0, &fragments_to_drop))
1490 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_MAX_FRAG];
1510 l4_protocol0, fib_index0, 1);
1515 l4_protocol0, fib_index0, 1);
1521 (fib_index0, proto0, &out_addr0, &out_port0,
1526 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1534 out_port0, fib_index0,
1540 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1556 node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1569 ctx0.
proto = l4_protocol0;
1579 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_NO_TRANSLATION];
1588 b0->
error = node->
errors[NAT64_IN2OUT_ERROR_UNKNOWN];
1596 && (b0->
flags & VLIB_BUFFER_IS_TRACED)))
1617 to_next, n_left_to_next,
1621 if (n_left_from == 0 &&
vec_len (fragments_to_loopback))
1628 sizeof (
u32) * len);
1647 NAT64_IN2OUT_ERROR_PROCESSED_FRAGMENTS,
1650 NAT64_IN2OUT_ERROR_CACHED_FRAGMENTS,
1654 &node->
errors[NAT64_IN2OUT_ERROR_DROP_FRAGMENT],
1665 .name =
"nat64-in2out-reass",
1666 .vector_size =
sizeof (
u32),
1686 #define foreach_nat64_in2out_handoff_error \ 1687 _(CONGESTION_DROP, "congestion drop") \ 1688 _(SAME_WORKER, "same worker") \ 1689 _(DO_HANDOFF, "do handoff") 1693 #define _(sym,str) NAT64_IN2OUT_HANDOFF_ERROR_##sym, 1700 #define _(sym,string) string, 1730 u32 n_enq, n_left_from, *from;
1734 u32 do_handoff = 0, same_worker = 0;
1741 ti = thread_indices;
1745 while (n_left_from > 0)
1752 if (ti[0] != thread_index)
1759 && (b[0]->
flags & VLIB_BUFFER_IS_TRACED)))
1775 if (n_enq < frame->n_vectors)
1777 NAT64_IN2OUT_HANDOFF_ERROR_CONGESTION_DROP,
1780 NAT64_IN2OUT_HANDOFF_ERROR_SAME_WORKER,
1783 NAT64_IN2OUT_HANDOFF_ERROR_DO_HANDOFF,
1792 .name =
"nat64-in2out-handoff",
1793 .vector_size =
sizeof (
u32),
#define foreach_ip_interface_address(lm, a, sw_if_index, loop, body)
nat64_db_t * db
BIB and session DB per thread.
static int unk_proto_st_walk(nat64_db_st_entry_t *ste, void *arg)
static int nat64_in2out_frag_set_cb(ip6_header_t *ip6, ip4_header_t *ip4, void *arg)
static int nat64_in2out_frag_hairpinning(vlib_buffer_t *b, ip6_header_t *ip6, nat64_in2out_frag_set_ctx_t *ctx)
snat_address_t * addr_pool
Address pool vector.
static int icmp6_to_icmp(vlib_buffer_t *p, ip6_to_ip4_set_fn_t fn, void *ctx, ip6_to_ip4_set_fn_t inner_fn, void *inner_ctx)
Translate ICMP6 packet to ICMP4.
void nat64_extract_ip4(ip6_address_t *ip6, ip4_address_t *ip4, u32 fib_index)
Extract IPv4 address from the IPv4-embedded IPv6 addresses.
vlib_node_registration_t nat64_in2out_node
(constructor) VLIB_REGISTER_NODE (nat64_in2out_node)
#define clib_memcpy_fast(a, b, c)
nat64_db_st_entry_t * nat64_db_st_entry_create(nat64_db_t *db, nat64_db_bib_entry_t *bibe, ip6_address_t *in_r_addr, ip4_address_t *out_r_addr, u16 r_port)
Create new NAT64 session table entry.
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
u32 fib_table_get_index_for_sw_if_index(fib_protocol_t proto, u32 sw_if_index)
Get the index of the FIB bound to the interface.
nat64_db_bib_entry_t * nat64_db_bib_entry_create(nat64_db_t *db, ip6_address_t *in_addr, ip4_address_t *out_addr, u16 in_port, u16 out_port, u32 fib_index, u8 proto, u8 is_static)
Create new NAT64 BIB entry.
void nat_ip6_reass_get_frags(nat_reass_ip6_t *reass, u32 **bi)
Get cached fragments.
nat64_db_bib_entry_t * nat64_db_bib_entry_find(nat64_db_t *db, ip46_address_t *addr, u16 port, u8 proto, u32 fib_index, u8 is_ip6)
Find NAT64 BIB entry.
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
static u8 * format_nat64_in2out_trace(u8 *s, va_list *args)
nat64_db_st_entry_t * nat64_db_st_entry_by_index(nat64_db_t *db, u8 proto, u32 ste_index)
Get ST entry by index and protocol.
vlib_error_t * errors
Vector of errors for this node.
vlib_node_registration_t nat64_in2out_handoff_node
(constructor) VLIB_REGISTER_NODE (nat64_in2out_handoff_node)
struct _tcp_header tcp_header_t
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static int nat64_in2out_tcp_udp_hairpinning(vlib_main_t *vm, vlib_buffer_t *b, ip6_header_t *ip6, u32 thread_index)
u32 nat64_get_worker_in2out(ip6_address_t *addr)
Get worker thread index for NAT64 in2out.
#define static_always_inline
vlib_node_registration_t nat64_in2out_reass_node
(constructor) VLIB_REGISTER_NODE (nat64_in2out_reass_node)
static_always_inline int ip6_parse(const ip6_header_t *ip6, u32 buff_len, u8 *l4_protocol, u16 *l4_offset, u16 *frag_hdr_offset)
Parse some useful information from IPv6 header.
struct unk_proto_st_walk_ctx_t_ unk_proto_st_walk_ctx_t
void nat64_tcp_session_set_state(nat64_db_st_entry_t *ste, tcp_header_t *tcp, u8 is_ip6)
Set NAT64 TCP session state.
static int ip6_to_ip4_tcp_udp(vlib_buffer_t *p, ip6_to_ip4_set_fn_t fn, void *ctx, u8 udp_checksum)
Translate IPv6 UDP/TCP packet to IPv4.
static void mss_clamping(snat_main_t *sm, tcp_header_t *tcp, ip_csum_t *sum)
u16 current_length
Nbytes between current data and the end of this buffer.
void nat64_session_reset_timeout(nat64_db_st_entry_t *ste, vlib_main_t *vm)
Reset NAT64 session timeout.
static uword nat64_in2out_slowpath_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
int nat64_alloc_out_addr_and_port(u32 fib_index, snat_protocol_t proto, ip4_address_t *addr, u16 *port, u32 thread_index)
Alloce IPv4 address and port pair from NAT64 pool.
static u8 * format_nat64_in2out_reass_trace(u8 *s, va_list *args)
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
int ip6_address_compare(ip6_address_t *a1, ip6_address_t *a2)
static int nat64_in2out_inner_icmp_set_cb(ip6_header_t *ip6, ip4_header_t *ip4, void *arg)
u32 node_index
Node index.
static void vlib_set_simple_counter(vlib_simple_counter_main_t *cm, u32 thread_index, u32 index, u64 value)
Set a simple counter.
static char * nat64_in2out_error_strings[]
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
void nat64_compose_ip6(ip6_address_t *ip6, ip4_address_t *ip4, u32 fib_index)
Compose IPv4-embedded IPv6 addresses.
vlib_error_t error
Error code for buffers to be enqueued to error handler.
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
vlib_simple_counter_main_t total_sessions
static u8 * format_nat64_in2out_handoff_trace(u8 *s, va_list *args)
#define VLIB_REGISTER_NODE(x,...)
static int nat64_in2out_unk_proto_hairpinning(vlib_main_t *vm, vlib_buffer_t *b, ip6_header_t *ip6, u32 thread_index)
static int nat64_in2out_icmp_set_cb(ip6_header_t *ip6, ip4_header_t *ip4, void *arg)
u8 nat_reass_is_drop_frag(u8 is_ip6)
Get status of virtual fragmentation reassembly.
static int nat64_in2out_tcp_udp_set_cb(ip6_header_t *ip6, ip4_header_t *ip4, void *arg)
int nat_ip6_reass_add_fragment(nat_reass_ip6_t *reass, u32 bi, u32 **bi_to_drop)
Cache fragment.
#define vec_free(V)
Free vector's memory (no header).
static ip_csum_t ip_incremental_checksum(ip_csum_t sum, void *_data, uword n_bytes)
vlib_node_registration_t nat64_in2out_slowpath_node
(constructor) VLIB_REGISTER_NODE (nat64_in2out_slowpath_node)
#define foreach_nat64_in2out_handoff_error
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
static void * ip6_next_header(ip6_header_t *i)
#define ip6_frag_hdr_offset(hdr)
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
nat64_db_st_entry_t * nat64_db_st_entry_find(nat64_db_t *db, ip46_address_t *l_addr, ip46_address_t *r_addr, u16 l_port, u16 r_port, u8 proto, u32 fib_index, u8 is_ip6)
Find NAT64 session table entry.
nat64_in2out_handoff_error_t
void nat64_db_st_walk(nat64_db_t *db, u8 proto, nat64_db_st_walk_fn_t fn, void *ctx)
Walk NAT64 session table.
static int nat64_in2out_icmp_hairpinning(vlib_main_t *vm, vlib_buffer_t *b, ip6_header_t *ip6, u32 thread_index)
ip_lookup_main_t lookup_main
u32 fq_in2out_index
Worker handoff.
u32 nat64_db_st_entry_get_index(nat64_db_t *db, nat64_db_st_entry_t *ste)
static u8 nat64_not_translate(u32 sw_if_index, ip6_address_t ip6_addr)
static ip_csum_t ip_csum_sub_even(ip_csum_t c, ip_csum_t x)
nat64_db_bib_entry_t * nat64_db_bib_entry_by_index(nat64_db_t *db, u8 proto, u32 bibe_index)
Get BIB entry by index and protocol.
IPv6 to IPv4 translation.
static uword nat64_in2out_reass_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define u8_ptr_add(ptr, index)
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
struct _vlib_node_registration vlib_node_registration_t
NAT64 global declarations.
static u32 ip_proto_to_snat_proto(u8 ip_proto)
The NAT inline functions.
static char * nat64_in2out_handoff_error_strings[]
VLIB_NODE_FUNCTION_MULTIARCH(nat64_in2out_node, nat64_in2out_node_fn)
#define ip46_address_is_equal(a1, a2)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
nat_reass_ip6_t * nat_ip6_reass_find_or_create(ip6_address_t src, ip6_address_t dst, u32 frag_id, u8 proto, u8 reset_timeout, u32 **bi_to_drop)
Find or create reassembly.
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
static uword nat64_in2out_handoff_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static_always_inline u32 vlib_buffer_enqueue_to_thread(vlib_main_t *vm, u32 frame_queue_index, u32 *buffer_indices, u16 *thread_indices, u32 n_packets, int drop_on_congestion)
static uword nat64_in2out_node_fn_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 is_slow_path)
static int nat64_in2out_unk_proto_set_cb(ip6_header_t *ip6, ip4_header_t *ip4, void *arg)
static_always_inline int is_hairpinning(ip6_address_t *dst_addr)
Check whether is a hairpinning.
#define vec_foreach(var, vec)
Vector iterator.
static uword nat64_in2out_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u16 flags
Copy of main node flags.
static void nat_send_all_to_node(vlib_main_t *vm, u32 *bi_vector, vlib_node_runtime_t *node, vlib_error_t *error, u32 next)
static void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
static_always_inline void vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b, int count)
Translate array of buffer indices into buffer pointers.
NAT plugin virtual fragmentation reassembly.
#define VLIB_NODE_FLAG_TRACE
#define foreach_nat64_in2out_error
struct nat64_in2out_set_ctx_t_ nat64_in2out_set_ctx_t
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
static int ip6_to_ip4(vlib_buffer_t *p, ip6_to_ip4_set_fn_t fn, void *ctx)
Translate IPv6 packet to IPv4 (IP header only).
static u16 ip_csum_fold(ip_csum_t c)
struct nat64_in2out_frag_set_ctx_t_ nat64_in2out_frag_set_ctx_t
static ip_csum_t ip_csum_add_even(ip_csum_t c, ip_csum_t x)
vlib_simple_counter_main_t total_bibs
static int ip6_to_ip4_fragmented(vlib_buffer_t *p, ip6_to_ip4_set_fn_t fn, void *ctx)
Translate IPv6 fragmented packet to IPv4.