55 u8 code = va_arg (*args,
int);
58 #define _(n,f) case n: t = #f; break; 71 return format (s,
"unknown 0x%x", type);
76 switch ((type << 8) | code)
78 #define _(a,n,f) case (ICMP4_##a << 8) | (n): t = #f; break; 94 icmp46_header_t *icmp = va_arg (*args, icmp46_header_t *);
95 u32 max_header_bytes = va_arg (*args,
u32);
98 if (max_header_bytes <
sizeof (icmp[0]))
99 return format (s,
"ICMP header truncated");
101 s =
format (s,
"ICMP %U checksum 0x%x",
103 clib_net_to_host_u16 (icmp->checksum));
134 u8 ip4_input_next_index_by_type[256];
146 u32 n_left_from, n_left_to_next, next;
149 n_left_from = n_packets;
157 while (n_left_from > 0)
161 while (n_left_from > 0 && n_left_to_next > 0)
165 icmp46_header_t *icmp0;
177 bi0 = to_next[0] = from[0];
190 p0->
error = node->
errors[ICMP4_ERROR_UNKNOWN_TYPE];
211 .name =
"ip4-icmp-input",
213 .vector_size =
sizeof (
u32),
233 u32 n_left_from, n_left_to_next, next;
235 u16 *fragment_ids, *fid;
239 n_left_from = n_packets;
250 sizeof (fragment_ids[0]));
252 while (n_left_from > 0)
256 while (n_left_from > 2 && n_left_to_next > 2)
260 icmp46_header_t *icmp0, *icmp1;
265 bi0 = to_next[0] = from[0];
266 bi1 = to_next[1] = from[1];
286 sum0 = icmp0->checksum;
287 sum1 = icmp1->checksum;
289 ASSERT (icmp0->type == ICMP4_echo_request);
290 ASSERT (icmp1->type == ICMP4_echo_request);
291 sum0 =
ip_csum_update (sum0, ICMP4_echo_request, ICMP4_echo_reply,
292 icmp46_header_t, type);
293 sum1 =
ip_csum_update (sum1, ICMP4_echo_request, ICMP4_echo_reply,
294 icmp46_header_t, type);
295 icmp0->type = ICMP4_echo_reply;
296 icmp1->type = ICMP4_echo_reply;
321 ip0->
ttl = host_config_ttl;
322 ip1->
ttl = host_config_ttl;
339 p0->
flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
340 p1->
flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
343 while (n_left_from > 0 && n_left_to_next > 0)
347 icmp46_header_t *icmp0;
351 bi0 = to_next[0] = from[0];
366 sum0 = icmp0->checksum;
368 ASSERT (icmp0->type == ICMP4_echo_request);
369 sum0 =
ip_csum_update (sum0, ICMP4_echo_request, ICMP4_echo_reply,
370 icmp46_header_t, type);
371 icmp0->type = ICMP4_echo_reply;
384 ip0->
ttl = host_config_ttl;
395 p0->
flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
402 ICMP4_ERROR_ECHO_REPLIES_SENT, frame->
n_vectors);
410 .name =
"ip4-icmp-echo-request",
412 .vector_size =
sizeof (
u32),
418 [0] =
"ip4-load-balance",
443 case ICMP4_destination_unreachable:
444 return ICMP4_ERROR_DEST_UNREACH_SENT;
445 case ICMP4_time_exceeded:
446 return ICMP4_ERROR_TTL_EXPIRE_SENT;
447 case ICMP4_parameter_problem:
448 return ICMP4_ERROR_PARAM_PROBLEM_SENT;
450 return ICMP4_ERROR_DROP;
459 uword n_left_from, n_left_to_next;
473 while (n_left_from > 0)
477 while (n_left_from > 0 && n_left_to_next > 0)
487 u32 org_pi0 = from[0];
489 u8 error0 = ICMP4_ERROR_NONE;
492 icmp46_header_t *icmp0;
493 u32 sw_if_index0, if_add_index0;
498 if (!p0 || pi0 == ~0)
514 sizeof (icmp46_header_t) - 4);
519 icmp0 = (icmp46_header_t *) & out_ip0[1];
528 out_ip0->
protocol = IP_PROTOCOL_ICMP;
547 error0 = ICMP4_ERROR_DROP;
554 *((
u32 *) (icmp0 + 1)) =
555 clib_host_to_net_u32 (
vnet_buffer (p0)->ip.icmp.data);
564 if (error0 == ICMP4_ERROR_NONE)
571 to_next, n_left_to_next,
592 .name =
"ip4-icmp-error",
593 .vector_size =
sizeof (
u32),
612 icmp46_header_t *
h = va_arg (*args, icmp46_header_t *);
619 h->type = (i >> 8) & 0xff;
620 h->code = (i >> 0) & 0xff;
640 u32 ip_offset, icmp_offset;
643 ip_offset = (g - 1)->start_byte_offset;
645 while (n_packets >= 1)
649 icmp46_header_t *icmp0;
657 ip0 = (
void *) (p0->
data + ip_offset);
658 icmp0 = (
void *) (p0->
data + icmp_offset);
664 len0 = clib_net_to_host_u16 (ip0->
length) - icmp_offset;
681 #define _(f) pg_edit_init (&p->f, icmp46_header_t, f); 769 #define _(n,t) hash_set_mem (cm->type_by_name, #t, (n)); 774 #define _(a,n,t) hash_set_mem (cm->type_by_name, #t, (n) | (ICMP4_##a << 8)); 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 uword ip4_icmp_error(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
ip_interface_address_t * if_address_pool
Pool of addresses that are assigned to interfaces.
static u8 * format_icmp_input_trace(u8 *s, va_list *va)
static void pg_edit_set_fixed(pg_edit_t *e, u64 value)
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
static void vlib_error_count(vlib_main_t *vm, uword node_index, uword counter, uword increment)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static void * clib_random_buffer_get_data(clib_random_buffer_t *b, uword n_bytes)
void(* edit_function)(struct pg_main_t *pg, struct pg_stream_t *s, struct pg_edit_group_t *g, u32 *buffers, u32 n_buffers)
static char * icmp_error_strings[]
u16 current_length
Nbytes between current data and the end of this buffer.
uword unformat_pg_edit(unformat_input_t *input, va_list *args)
ip_lookup_main_t lookup_main
vlib_error_t * errors
Vector of errors for this node.
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
static pg_edit_group_t * pg_stream_get_group(pg_stream_t *s, u32 group_index)
unformat_function_t * unformat_pg_edit
#define vlib_prefetch_buffer_with_index(vm, bi, type)
Prefetch buffer metadata by buffer index The first 64 bytes of buffer contains most header informatio...
#define VLIB_INIT_FUNCTION(x)
u32 local_interface_sw_if_index
static uword unformat_icmp_type_and_code(unformat_input_t *input, va_list *args)
uword unformat_pg_payload(unformat_input_t *input, va_list *args)
static_always_inline void vlib_buffer_enqueue_to_single_next(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u16 next_index, u32 count)
static void * ip4_next_header(ip4_header_t *i)
static void * pg_create_edit_group(pg_stream_t *s, int n_edit_bytes, int n_packet_bytes, u32 *group_index)
#define vlib_call_init_function(vm, x)
struct ip4_main_t::@212 host_config
Template information for VPP generated packets.
#define hash_create_string(elts, value_bytes)
vlib_error_t error
Error code for buffers to be enqueued to error handler.
void ip4_icmp_register_type(vlib_main_t *vm, icmp4_type_t type, u32 node_index)
static clib_error_t * icmp4_init(vlib_main_t *vm)
static vlib_buffer_t * vlib_buffer_copy_no_chain(vlib_main_t *vm, vlib_buffer_t *b, u32 *di)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static ip_protocol_info_t * ip_get_protocol_info(ip_main_t *im, u32 protocol)
format_function_t * format_header
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
static uword unformat_pg_icmp_header(unformat_input_t *input, va_list *args)
static u8 * format_ip4_icmp_type_and_code(u8 *s, va_list *args)
u32 node_index
Node 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).
static void icmp4_pg_edit_function(pg_main_t *pg, pg_stream_t *s, pg_edit_group_t *g, u32 *packets, u32 n_packets)
#define VLIB_REGISTER_NODE(x,...)
clib_error_t * ip_main_init(vlib_main_t *vm)
#define CLIB_PREFETCH(addr, size, type)
static u8 * format_ip4_icmp_header(u8 *s, va_list *args)
void icmp4_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
static ip_csum_t ip_incremental_checksum(ip_csum_t sum, void *_data, uword n_bytes)
uword * type_and_code_by_name
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 uword ip4_icmp_echo_request(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u32 * if_address_pool_index_by_sw_if_index
Head of doubly linked list of interface addresses for each software interface.
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
static vlib_node_registration_t ip4_icmp_echo_request_node
(constructor) VLIB_REGISTER_NODE (ip4_icmp_echo_request_node)
static void pg_free_edit_group(pg_stream_t *s)
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
uword edit_function_opaque
static vlib_main_t * vlib_get_main(void)
void vlib_trace_frame_buffers_only(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, uword n_buffers, uword next_buffer_stride, uword n_buffer_data_bytes_in_trace)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
VLIB buffer representation.
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
#define ip_csum_update(sum, old, new, type, field)
vlib_node_registration_t ip4_icmp_error_node
(constructor) VLIB_REGISTER_NODE (ip4_icmp_error_node)
uword unformat_pg_number(unformat_input_t *input, va_list *args)
static vlib_node_registration_t ip4_icmp_input_node
(constructor) VLIB_REGISTER_NODE (ip4_icmp_input_node)
ip4_main_t ip4_main
Global ip4 main structure.
u8 ip4_input_next_index_by_type[256]
u16 flags
Copy of main node flags.
static void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
static uword ip4_icmp_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define VLIB_NODE_FLAG_TRACE
static u8 icmp4_icmp_type_to_error(u8 type)
#define CLIB_CACHE_LINE_BYTES
static void pg_icmp_header_init(pg_icmp46_header_t *p)
u8 ttl
TTL to use for host generated packets.
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
static u16 ip4_header_checksum(ip4_header_t *i)
clib_random_buffer_t random_buffer
static u16 ip_csum_fold(ip_csum_t c)