62 format (s,
"NAT64-out2in-reass: sw_if_index %d, next index %d, status %s",
64 t->
cached ?
"cached" :
"translated");
73 #define foreach_nat64_out2in_error \ 74 _(UNSUPPORTED_PROTOCOL, "Unsupported protocol") \ 75 _(OUT2IN_PACKETS, "Good out2in packets processed") \ 76 _(NO_TRANSLATION, "No translation") \ 77 _(UNKNOWN, "unknown") \ 78 _(DROP_FRAGMENT, "Drop fragment") \ 79 _(MAX_REASS, "Maximum reassemblies exceeded") \ 80 _(MAX_FRAG, "Maximum fragments per reassembly exceeded") 85 #define _(sym,str) NAT64_OUT2IN_ERROR_##sym, 92 #define _(sym,string) string, 119 nat64_db_bib_entry_t *bibe;
120 nat64_db_st_entry_t *ste;
121 ip46_address_t saddr, daddr;
128 u32 sw_if_index, fib_index;
136 memset (&saddr, 0,
sizeof (saddr));
138 memset (&daddr, 0,
sizeof (daddr));
171 if (proto == IP_PROTOCOL_UDP)
174 checksum = &tcp->checksum;
189 nat64_db_bib_entry_t *bibe;
190 nat64_db_st_entry_t *ste;
191 ip46_address_t saddr, daddr;
193 u32 sw_if_index, fib_index;
200 memset (&saddr, 0,
sizeof (saddr));
202 memset (&daddr, 0,
sizeof (daddr));
205 if (icmp->type == ICMP6_echo_request || icmp->type == ICMP6_echo_reply)
207 u16 out_id = ((
u16 *) (icmp))[2];
210 IP_PROTOCOL_ICMP, fib_index, 0);
224 IP_PROTOCOL_ICMP, fib_index, 0);
240 ((
u16 *) (icmp))[2] = bibe->in_port;
263 nat64_db_bib_entry_t *bibe;
264 nat64_db_st_entry_t *ste;
265 ip46_address_t saddr, daddr;
266 u32 sw_if_index, fib_index;
274 memset (&saddr, 0,
sizeof (saddr));
276 memset (&daddr, 0,
sizeof (daddr));
279 if (proto == IP_PROTOCOL_ICMP6)
282 u16 out_id = ((
u16 *) (icmp))[2];
283 proto = IP_PROTOCOL_ICMP;
286 (icmp->type == ICMP6_echo_request
287 || icmp->type == ICMP6_echo_reply))
304 ((
u16 *) (icmp))[2] = bibe->in_port;
332 if (proto == IP_PROTOCOL_UDP)
335 checksum = &tcp->checksum;
355 nat64_db_bib_entry_t *bibe;
356 nat64_db_st_entry_t *ste;
357 ip46_address_t saddr, daddr;
359 u32 sw_if_index, fib_index;
366 memset (&saddr, 0,
sizeof (saddr));
368 memset (&daddr, 0,
sizeof (daddr));
407 u32 n_left_from, *from, *to_next;
409 u32 pkts_processed = 0;
415 while (n_left_from > 0)
421 while (n_left_from > 0 && n_left_to_next > 0)
455 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_NO_TRANSLATION];
466 if (proto0 == SNAT_PROTOCOL_ICMP)
473 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_NO_TRANSLATION];
486 if ((proto0 == SNAT_PROTOCOL_UDP)
488 clib_host_to_net_u16 (UDP_DST_PORT_dhcp_to_client)))
494 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_NO_TRANSLATION];
513 n_left_to_next, bi0, next0);
518 NAT64_OUT2IN_ERROR_OUT2IN_PACKETS,
526 .name =
"nat64-out2in",
527 .vector_size =
sizeof (
u32),
560 nat64_db_st_entry_t *ste;
561 nat64_db_bib_entry_t *bibe;
581 if (ip4->
protocol == IP_PROTOCOL_UDP)
588 clib_host_to_net_u16 (ip4->
length) -
sizeof (*ip4);
594 clib_host_to_net_u16 (IP_PROTOCOL_UDP));
617 checksum = &tcp->checksum;
646 u32 n_left_from, *from, *to_next;
648 u32 pkts_processed = 0;
649 u32 *fragments_to_drop = 0;
650 u32 *fragments_to_loopback = 0;
658 while (n_left_from > 0)
664 while (n_left_from > 0 && n_left_to_next > 0)
671 u32 sw_if_index0, fib_index0;
673 nat_reass_ip4_t *reass0;
674 ip46_address_t saddr0, daddr0;
675 nat64_db_st_entry_t *ste0;
676 nat64_db_bib_entry_t *bibe0;
702 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_DROP_FRAGMENT];
709 || ip40->
protocol == IP_PROTOCOL_UDP)))
712 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_DROP_FRAGMENT];
722 1, &fragments_to_drop);
727 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_MAX_REASS];
735 memset (&saddr0, 0,
sizeof (saddr0));
737 memset (&daddr0, 0,
sizeof (daddr0));
753 node->
errors[NAT64_OUT2IN_ERROR_NO_TRANSLATION];
767 node->
errors[NAT64_OUT2IN_ERROR_NO_TRANSLATION];
784 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_MAX_FRAG];
801 b0->
error = node->
errors[NAT64_OUT2IN_ERROR_UNKNOWN];
828 to_next, n_left_to_next,
832 if (n_left_from == 0 &&
vec_len (fragments_to_loopback))
846 fragments_to_loopback + (len -
859 NAT64_OUT2IN_ERROR_OUT2IN_PACKETS,
863 &node->
errors[NAT64_OUT2IN_ERROR_DROP_FRAGMENT],
874 .name =
"nat64-out2in-reass",
875 .vector_size =
sizeof (
u32),
909 m = t->
do_handoff ?
"next worker" :
"same worker";
921 u32 n_left_from, *from, *to_next = 0, *to_next_drop = 0;
929 u32 n_left_to_next_worker = 0, *to_next_worker = 0;
930 u32 next_worker_index = 0;
931 u32 current_worker_index = ~0;
951 while (n_left_from > 0)
972 if (next_worker_index != current_worker_index)
977 congested_handoff_queue_by_worker_index);
988 to_next_drop[0] = bi0;
1000 handoff_queue_elt_by_worker_index);
1003 current_worker_index = next_worker_index;
1006 ASSERT (to_next_worker != 0);
1009 to_next_worker[0] = bi0;
1011 n_left_to_next_worker--;
1013 if (n_left_to_next_worker == 0)
1017 current_worker_index = ~0;
1018 handoff_queue_elt_by_worker_index[next_worker_index] = 0;
1059 for (i = 0; i <
vec_len (handoff_queue_elt_by_worker_index); i++)
1061 if (handoff_queue_elt_by_worker_index[i])
1063 hf = handoff_queue_elt_by_worker_index[
i];
1071 handoff_queue_elt_by_worker_index[
i] = 0;
1076 congested_handoff_queue_by_worker_index[
i] =
1080 current_worker_index = ~0;
1087 .name =
"nat64-out2in-handoff",
1088 .vector_size =
sizeof (
u32),
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
nat64_db_t * db
BIB and session DB per thread.
sll srl srl sll sra u16x4 i
static char * nat64_out2in_error_strings[]
struct nat64_out2in_frag_set_ctx_t_ nat64_out2in_frag_set_ctx_t
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.
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.
int nat_ip4_reass_add_fragment(nat_reass_ip4_t *reass, u32 bi)
Cache fragment.
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.
struct _vlib_node_registration vlib_node_registration_t
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
static int nat64_out2in_tcp_udp_set_cb(ip4_header_t *ip4, ip6_header_t *ip6, void *arg)
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.
u32 buffer_index[VLIB_FRAME_SIZE]
vlib_error_t * errors
Vector of errors for this node.
static u8 * format_nat64_out2in_reass_trace(u8 *s, va_list *args)
vlib_node_registration_t nat64_out2in_reass_node
(constructor) VLIB_REGISTER_NODE (nat64_out2in_reass_node)
struct _tcp_header tcp_header_t
static vlib_frame_queue_t * is_vlib_frame_queue_congested(u32 frame_queue_index, u32 index, u32 queue_hi_thresh, vlib_frame_queue_t **handoff_queue_by_worker_index)
struct nat64_out2in_set_ctx_t_ nat64_out2in_set_ctx_t
IPv4 to IPv6 translation.
vlib_node_registration_t nat64_out2in_handoff_node
(constructor) VLIB_REGISTER_NODE (nat64_out2in_handoff_node)
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
ip_csum_t ip_incremental_checksum(ip_csum_t sum, void *_data, uword n_bytes)
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
static void * ip4_next_header(ip4_header_t *i)
static int ip4_is_fragment(ip4_header_t *i)
u32 nat64_get_worker_out2in(ip4_header_t *ip)
Get worker thread index for NAT64 out2in.
void nat64_session_reset_timeout(nat64_db_st_entry_t *ste, vlib_main_t *vm)
Reset NAT64 session timeout.
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
static int nat64_out2in_icmp_set_cb(ip4_header_t *ip4, ip6_header_t *ip6, void *arg)
static u8 * format_nat64_out2in_trace(u8 *s, va_list *args)
static vlib_frame_queue_elt_t * vlib_get_worker_handoff_queue_elt(u32 frame_queue_index, u32 vlib_worker_index, vlib_frame_queue_elt_t **handoff_queue_elt_by_worker_index)
#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)
static uword nat64_out2in_handoff_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static_always_inline uword vlib_get_thread_index(void)
static u8 * format_nat64_out2in_handoff_trace(u8 *s, va_list *args)
u8 nat_reass_is_drop_frag(u8 is_ip6)
Get status of virtual fragmentation reassembly.
static int ip4_to_ip6_tcp_udp(vlib_buffer_t *p, ip4_to_ip6_set_fn_t fn, void *ctx)
Translate IPv4 UDP/TCP packet to IPv6.
#define vec_free(V)
Free vector's memory (no header).
#define VLIB_BUFFER_IS_TRACED
#define clib_memcpy(a, b, c)
static int ip4_is_first_fragment(ip4_header_t *i)
static int nat64_out2in_frag_set_cb(ip4_header_t *ip4, ip6_header_t *ip6, void *arg)
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 int nat64_out2in_inner_icmp_set_cb(ip4_header_t *ip4, ip6_header_t *ip6, void *arg)
static uword nat64_out2in_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
#define u8_ptr_add(ptr, index)
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.
VLIB_NODE_FUNCTION_MULTIARCH(nat64_out2in_node, nat64_out2in_node_fn)
static uword nat64_out2in_reass_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u32 nat64_db_st_entry_get_index(nat64_db_t *db, nat64_db_st_entry_t *ste)
static u32 ip_proto_to_snat_proto(u8 ip_proto)
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.
static int icmp_to_icmp6(vlib_buffer_t *p, ip4_to_ip6_set_fn_t fn, void *ctx, ip4_to_ip6_set_fn_t inner_fn, void *inner_ctx)
Translate ICMP4 packet to ICMP6.
vlib_node_registration_t nat64_out2in_node
(constructor) VLIB_REGISTER_NODE (nat64_out2in_node)
#define VLIB_NODE_FLAG_TRACE
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
static int nat64_out2in_unk_proto_set_cb(ip4_header_t *ip4, ip6_header_t *ip6, void *arg)
NAT64 global declarations.
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static int ip4_to_ip6_fragmented(vlib_buffer_t *p, ip4_to_ip6_set_fn_t fn, void *ctx)
Translate IPv4 fragmented packet to IPv6.
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
nat_reass_ip4_t * nat_ip4_reass_find_or_create(ip4_address_t src, ip4_address_t dst, u16 frag_id, u8 proto, u8 reset_timeout, u32 **bi_to_drop)
Find or create reassembly.
static void vlib_put_frame_queue_elt(vlib_frame_queue_elt_t *hf)
static int ip4_to_ip6(vlib_buffer_t *p, ip4_to_ip6_set_fn_t fn, void *ctx)
Translate IPv4 packet to IPv6 (IP header only).
#define VLIB_REGISTER_NODE(x,...)
static vlib_thread_main_t * vlib_get_thread_main()
static_always_inline void nat_send_all_to_node(vlib_main_t *vm, u32 *bi_vector, vlib_node_runtime_t *node, vlib_error_t *error, u32 next)
u16 flags
Copy of main node flags.
void nat_ip4_reass_get_frags(nat_reass_ip4_t *reass, u32 **bi)
Get cached fragments.
NAT plugin virtual fragmentation reassembly.
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
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 u16 ip_csum_fold(ip_csum_t c)
#define foreach_nat64_out2in_error
static ip_csum_t ip_csum_add_even(ip_csum_t c, ip_csum_t x)