105 ethernet_arp_ip4_over_ethernet_address_t
a;
109 #define ETHERNET_ARP_ARGS_REMOVE (1<<0) 110 #define ETHERNET_ARP_ARGS_FLUSH (1<<1) 111 #define ETHERNET_ARP_ARGS_POPULATE (1<<2) 112 #define ETHERNET_ARP_ARGS_WC_PUB (1<<3) 131 #define _(n,f) case n: t = #f; break; 136 return format (s,
"unknown 0x%x", h);
139 return format (s,
"%s", t);
149 #define _(f) case ETHERNET_ARP_OPCODE_##f: t = #f; break; 154 return format (s,
"unknown 0x%x", o);
157 return format (s,
"%s", t);
164 int *result = va_arg (*args,
int *);
192 int *result = va_arg (*args,
int *);
197 *result = clib_host_to_net_u16 ((
u16) * result);
205 u32 max_header_bytes = va_arg (*va,
u32);
207 u16 l2_type, l3_type;
209 if (max_header_bytes != 0 &&
sizeof (a[0]) > max_header_bytes)
210 return format (s,
"ARP header truncated");
212 l2_type = clib_net_to_host_u16 (a->
l2_type);
213 l3_type = clib_net_to_host_u16 (a->
l3_type);
217 s =
format (s,
"%U, type %U/%U, address size %d/%d",
223 if (l2_type == ETHERNET_ARP_HARDWARE_TYPE_ethernet
224 && l3_type == ETHERNET_TYPE_IP4)
226 s =
format (s,
"\n%U%U/%U -> %U/%U",
237 s =
format (s,
"\n%U%U/%U -> %U/%U",
257 return format (s,
"%=12s%=16s%=6s%=20s%=24s",
"Time",
"IP4",
258 "Flags",
"Ethernet",
"Interface");
263 flags =
format (flags,
"S");
266 flags =
format (flags,
"D");
269 flags =
format (flags,
"N");
271 s =
format (s,
"%=12U%=16U%=6s%=20U%U",
274 flags ? (
char *) flags :
"",
400 adj->rewrite_header.sw_if_index,
503 offset =
vec_len (rewrite) - 2;
554 ethernet_arp_ip4_over_ethernet_address_t *
a = &args->
a;
556 int make_new_arp_cache_entry = 1;
578 make_new_arp_cache_entry = 0;
582 if (make_new_arp_cache_entry)
599 if (!is_no_fib_entry)
618 goto check_customers;
641 while (next_index != (
u32) ~ 0)
660 while (next_index != (
u32) ~ 0)
669 rv = (*fp) (mc->
data, a->ethernet, sw_if_index, 0);
731 while (p && *p != ~0)
740 int found = p && *p != ~0;
744 return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
749 .
next_index = ~0,.node_index = node_index,.type_opaque =
750 type_opaque,.data = data,.data_callback = data_callback,.pid =
763 return VNET_API_ERROR_NO_SUCH_ENTRY;
766 void (*fp) (
u32,
u8 *) = data_callback;
768 (*fp) (mc->
data, 0 );
775 if (*p == ~0 && p == first)
789 #define foreach_ethernet_arp_error \ 790 _ (replies_sent, "ARP replies sent") \ 791 _ (l2_type_not_ethernet, "L2 type not ethernet") \ 792 _ (l3_type_not_ip4, "L3 type not IP4") \ 793 _ (l3_src_address_not_local, "IP4 source address not local to subnet") \ 794 _ (l3_dst_address_not_local, "IP4 destination address not local to subnet") \ 795 _ (l3_src_address_is_local, "IP4 source address matches local interface") \ 796 _ (l3_src_address_learned, "ARP request IP4 source address learned") \ 797 _ (replies_received, "ARP replies received") \ 798 _ (opcode_not_request, "ARP opcode not request") \ 799 _ (proxy_arp_replies_sent, "Proxy ARP replies sent") \ 800 _ (l2_address_mismatch, "ARP hw addr does not match L2 frame src addr") \ 801 _ (gratuitous_arp, "ARP probe or announcement dropped") \ 802 _ (interface_no_table, "Interface is not mapped to an IP table") \ 803 _ (interface_not_ip_enabled, "Interface is not IP enabled") \ 807 #define _(sym,string) ETHERNET_ARP_ERROR_##sym, 820 ethernet_arp_ip4_over_ethernet_address_t delme;
847 u32 input_sw_if_index,
u32 conn_sw_if_index)
879 return (ETHERNET_ARP_ERROR_l3_src_address_learned);
888 u32 n_left_from, next_index, *from, *to_next;
889 u32 n_replies_sent = 0, n_proxy_arp_replies_sent = 0;
900 while (n_left_from > 0)
906 while (n_left_from > 0 && n_left_to_next > 0)
913 u32 pi0, error0, next0, sw_if_index0, conn_sw_if_index0, fib_index0;
914 u8 is_request0, dst_is_local0, is_unnum0, is_vrrp_reply0;
919 u8 *rewrite0, rewrite0_len;
934 is_request0 = arp0->
opcode 935 == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request);
937 error0 = ETHERNET_ARP_ERROR_replies_sent;
941 clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet) ?
942 ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
945 clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
946 ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
953 ETHERNET_ARP_ERROR_interface_not_ip_enabled : error0);
960 if (~0 == fib_index0)
962 error0 = ETHERNET_ARP_ERROR_interface_no_table;
974 is_unnum0 = sw_if_index0 != conn_sw_if_index0;
999 ip4_over_ethernet[0].ip4,
1017 error0 = ETHERNET_ARP_ERROR_l3_src_address_is_local;
1072 error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
1079 error0 = ETHERNET_ARP_ERROR_l3_dst_address_not_local;
1099 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
1112 error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
1119 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply) &&
1122 error0 =
arp_learn (vnm, am, sw_if_index0,
1127 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request) &&
1128 (dst_is_local0 == 0))
1141 rewrite0_len =
vec_len (rewrite0);
1154 arp0->
opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
1184 error0 =
arp_learn (vnm, am, sw_if_index0,
1188 n_left_to_next, pi0, next0);
1190 n_replies_sent += 1;
1198 error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
1205 u32 this_addr = clib_net_to_host_u32
1219 u32 lo_addr = clib_net_to_host_u32 (pa->
lo_addr);
1220 u32 hi_addr = clib_net_to_host_u32 (pa->
hi_addr);
1223 if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
1232 if_addr0 = &proxy_src;
1234 n_proxy_arp_replies_sent++;
1246 n_left_to_next, pi0, next0);
1253 ETHERNET_ARP_ERROR_replies_sent,
1254 n_replies_sent - n_proxy_arp_replies_sent);
1257 ETHERNET_ARP_ERROR_proxy_arp_replies_sent,
1258 n_proxy_arp_replies_sent);
1263 #define _(sym,string) string, 1272 .name =
"arp-input",
1273 .vector_size =
sizeof (
u32),
1309 if (sw_if_index != ~0 && n->sw_if_index != sw_if_index)
1311 vec_add1 (ns, n[0]);
1377 .path =
"show ip arp",
1379 .short_help =
"show ip arp",
1392 } ip4_over_ethernet[2];
1399 #define _(f) pg_edit_init (&p->f, ethernet_arp_header_t, f); 1402 _(n_l2_address_bytes);
1403 _(n_l3_address_bytes);
1405 _(ip4_over_ethernet[0].ethernet);
1406 _(ip4_over_ethernet[0].ip4);
1407 _(ip4_over_ethernet[1].ethernet);
1408 _(ip4_over_ethernet[1].ip4);
1429 if (!
unformat (input,
"%U: %U/%U -> %U/%U",
1462 u32 sw_if_index,
void *a_arg)
1464 ethernet_arp_ip4_over_ethernet_address_t *
a = a_arg;
1472 (
u8 *) & args,
sizeof (args));
1484 u32 sw_if_index,
void *a_arg)
1486 ethernet_arp_ip4_over_ethernet_address_t *
a = a_arg;
1494 (
u8 *) & args,
sizeof (args));
1507 u32 sw_if_index,
void *a_arg)
1509 ethernet_arp_ip4_over_ethernet_address_t *
a = a_arg;
1517 (
u8 *) & args,
sizeof (args));
1528 ethernet_arp_ip4_over_ethernet_address_t *
a = a_arg;
1531 .sw_if_index = sw_if_index,
1536 (
u8 *) & args,
sizeof (args));
1550 if (ni == (
uword) ~ 0)
1554 r->
ip4 = args->
a.ip4.as_u32;
1556 memcpy (r->
mac, args->
a.ethernet,
sizeof r->
mac);
1578 u32 if_address_index,
u32 is_del)
1593 u32 i, *to_delete = 0;
1601 e = pool_elt_at_index(am->ip4_entry_pool,
1603 if (ip4_destination_matches_route (im, &e->ip4_address,
1604 address, address_length))
1606 vec_add1 (to_delete, e - am->ip4_entry_pool);
1613 ethernet_arp_ip4_over_ethernet_address_t delme;
1654 u32 sw_if_index,
u32 new_fib_index,
u32 old_fib_index)
1674 e = pool_elt_at_index(am->ip4_entry_pool,
1679 arp_adj_fib_remove(e, old_fib_index);
1680 arp_adj_fib_add(e, new_fib_index);
1703 #define _(o) hash_set_mem (am->opcode_by_name, #o, ETHERNET_ARP_OPCODE_##o); 1720 vnet_pcap_drop_trace_filter_add_del \ 1721 (rt->errors[ETHERNET_ARP_ERROR_##a], \ 1729 cb.function_opaque = 0;
1871 u32 i, *to_delete = 0;
1876 if (e->sw_if_index == sw_if_index)
1877 vec_add1 (to_delete,
1878 e - am->ip4_entry_pool);
1882 for (i = 0; i <
vec_len (to_delete); i++)
1884 ethernet_arp_ip4_over_ethernet_address_t delme;
1913 for (i = 3; i >= 0; i--)
1915 old = a->ip4.as_u8[
i];
1916 a->ip4.as_u8[
i] += 1;
1917 if (old < a->ip4.as_u8[i])
1921 for (i = 5; i >= 0; i--)
1923 old = a->ethernet[
i];
1924 a->ethernet[
i] += 1;
1925 if (old < a->ethernet[i])
1932 u32 sw_if_index,
void *a_arg,
1933 int is_static,
int is_no_fib_entry)
1935 ethernet_arp_ip4_over_ethernet_address_t *
a = a_arg;
1945 (
u8 *) & args,
sizeof (args));
1955 u32 found_at_index = ~0;
1967 if (found_at_index != ~0)
1976 return VNET_API_ERROR_NO_SUCH_ENTRY;
1995 u32 *entries_to_delete = 0;
2000 if (~0 == fib_index)
2001 return VNET_API_ERROR_NO_SUCH_ENTRY;
2011 for (i = 0; i <
vec_len (entries_to_delete); i++)
2027 ethernet_arp_ip4_over_ethernet_address_t lo_addr, hi_addr,
addr;
2034 int is_no_fib_entry = 0;
2049 else if (
unformat (input,
"static"))
2052 else if (
unformat (input,
"no-fib-entry"))
2053 is_no_fib_entry = 1;
2055 else if (
unformat (input,
"count %d", &count))
2058 else if (
unformat (input,
"fib-id %d", &fib_id))
2062 if (~0 == fib_index)
2066 else if (
unformat (input,
"proxy %U - %U",
2085 for (i = 0; i <
count; i++)
2089 uword event_type, *event_data = 0;
2097 (vnm, sw_if_index, &addr, is_static, is_no_fib_entry);
2102 if (event_type != 1)
2150 .path =
"set ip arp",
2152 "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [no-fib-entry] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
2216 .path =
"set interface proxy-arp",
2218 "set interface proxy-arp <intfc> [enable|disable]",
2242 u32 n_left_from, next_index, *from, *to_next;
2243 u32 n_replies_sent = 0;
2244 u16 last_bd_index = ~0;
2252 while (n_left_from > 0)
2258 while (n_left_from > 0 && n_left_to_next > 0)
2265 u32 pi0, error0, next0, sw_if_index0;
2277 n_left_to_next -= 1;
2282 goto next_l2_feature;
2286 ethertype0 = clib_net_to_host_u16 (*(
u16 *) (l3h0 - 2));
2291 clib_host_to_net_u16
2292 (ETHERNET_ARP_OPCODE_request))))
2304 error0 = ETHERNET_ARP_ERROR_replies_sent;
2307 clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
2308 ? ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
2311 clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
2312 ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
2321 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
2334 error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
2349 || (last_bd_index == (
u16) ~ 0)))
2351 last_bd_index = bd_index0;
2357 goto next_l2_feature;
2361 arp0->
opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
2367 n_replies_sent += 1;
2375 vnet_buffer (p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
2377 goto next_l2_feature;
2384 to_next, n_left_to_next, pi0,
2393 iph0->
protocol == IP_PROTOCOL_ICMP6 &&
2399 (vm, node, p0, eth0, iph0, sw_if_index0,
2401 goto output_response;
2407 L2INPUT_FEAT_ARP_TERM);
2409 to_next, n_left_to_next,
2419 error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
2425 to_next, n_left_to_next, pi0,
2433 ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
2440 .name =
"arp-term-l2bd",
2441 .vector_size =
sizeof (
u32),
2487 change_arp_mac (sw_if_index, e);
2501 clib_warning (
"Sending GARP for IP4 address %U on sw_if_idex %d",
2521 e->
type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
#define vnet_rewrite_one_header(rw0, p0, most_likely_size)
static void set_ip4_over_ethernet_rpc_callback(vnet_arp_set_ip4_over_ethernet_rpc_args_t *a)
#define VNET_SW_INTERFACE_FLAG_UNNUMBERED
#define pool_next_index(P, I)
Return next occupied pool index after i, useful for safe iteration.
#define VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST
static uword arp_term_l2bd(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define hash_set(h, key, value)
l2_input_config_t * configs
sll srl srl sll sra u16x4 i
ip4_table_bind_function_t * function
u8 * format_ethernet_arp_ip4_entry(u8 *s, va_list *va)
ip4_add_del_interface_address_callback_t * add_del_interface_address_callbacks
Functions to call when interface address changes.
#define hash_unset(h, key)
An indication that the rewrite is incomplete, i.e.
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
uword unformat_pg_arp_header(unformat_input_t *input, va_list *args)
static void pg_ethernet_arp_header_init(pg_ethernet_arp_header_t *p)
static int vnet_arp_unset_ip4_over_ethernet_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
static void increment_ip4_and_mac_address(ethernet_arp_ip4_over_ethernet_address_t *a)
An indication that the rewrite is complete, i.e.
vnet_main_t * vnet_get_main(void)
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
static uword vlib_current_process(vlib_main_t *vm)
static void arp_add_del_interface_address(ip4_main_t *im, uword opaque, u32 sw_if_index, ip4_address_t *address, u32 address_length, u32 if_address_index, u32 is_del)
static void pg_edit_set_fixed(pg_edit_t *e, u64 value)
static clib_error_t * show_ip4_arp(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
vnet_interface_main_t interface_main
pending_resolution_t * pending_resolutions
void fib_entry_get_prefix(fib_node_index_t fib_entry_index, fib_prefix_t *pfx)
static void vlib_error_count(vlib_main_t *vm, uword node_index, uword counter, uword increment)
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
ip4_address_t * ip4_interface_first_address(ip4_main_t *im, u32 sw_if_index, ip_interface_address_t **result_ia)
Information related to the source of a FIB entry.
struct ethernet_arp_interface_t_ ethernet_arp_interface_t
Per-interface ARP configuration and state.
void change_arp_mac(u32 sw_if_index, ethernet_arp_ip4_entry_t *e)
static u8 * format_ethernet_arp_header(u8 *s, va_list *va)
static clib_error_t * set_int_proxy_arp_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
clib_error_t * ip4_set_arp_limit(u32 arp_limit)
static uword arp_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
This packet is to be rewritten and forwarded to the next processing node.
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
static u64 clib_cpu_time_now(void)
void arp_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
static void arp_table_bind(ip4_main_t *im, uword opaque, u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
static uword unformat_ethernet_arp_opcode_host_byte_order(unformat_input_t *input, va_list *args)
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
uword unformat_pg_edit(unformat_input_t *input, va_list *args)
void adj_nbr_walk_nh4(u32 sw_if_index, const ip4_address_t *addr, adj_walk_cb_t cb, void *ctx)
Walk adjacencies on a link with a given v4 next-hop.
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static int vnet_arp_wc_publish(u32 sw_if_index, void *a_arg)
publish wildcard arp event
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
format_function_t format_vlib_cpu_time
unformat_function_t unformat_vnet_sw_interface
u64 cpu_time_last_updated
void vl_api_rpc_call_main_thread(void *fp, u8 *data, u32 data_length)
vlib_error_t * errors
Vector of errors for this node.
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
static u32 vnet_l2_feature_next(vlib_buffer_t *b, u32 *next_nodes, u32 feat_bit)
Return the graph node index for the feature corresponding to the next set bit after clearing the curr...
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static pg_node_t * pg_get_node(uword node_index)
vnet_link_t ia_link
link/ether-type 1 bytes
static int vnet_arp_populate_ip4_over_ethernet_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
u32 send_garp_na_process_node_index
Adjacency to punt this packet.
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(ethernet_arp_sw_interface_up_down)
static const u8 vrrp_prefix[]
void arp_adj_fib_remove(ethernet_arp_ip4_entry_t *e, u32 fib_index)
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
u8 * format_ethernet_address(u8 *s, va_list *args)
#define VNET_SW_INTERFACE_FLAG_PROXY_ARP
void * vlib_packet_template_get_packet(vlib_main_t *vm, vlib_packet_template_t *t, u32 *bi_result)
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
#define VLIB_INIT_FUNCTION(x)
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
pending_resolution_t * mac_changes
static int vnet_arp_set_ip4_over_ethernet_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
static int ip4_arp_entry_sort(void *a1, void *a2)
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
Aggregrate type for a prefix.
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
#define clib_error_return(e, args...)
ethernet_arp_hardware_type_t
static u8 * format_ethernet_arp_input_trace(u8 *s, va_list *va)
static int vnet_arp_flush_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, void *a_arg)
Internally generated event to flush the ARP cache on an interface state change event.
#define foreach_ethernet_arp_opcode
uword * pending_resolutions_by_address
static void * pg_create_edit_group(pg_stream_t *s, int n_edit_bytes, int n_packet_bytes, u32 *group_index)
u32 fib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
u16 fp_len
The mask length.
#define vlib_call_init_function(vm, x)
static ethernet_arp_ip4_entry_t * arp_entry_find(ethernet_arp_interface_t *eai, const ip4_address_t *addr)
int vnet_arp_unset_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, void *a_arg)
Control Plane hook to remove an ARP entry.
#define hash_create_string(elts, value_bytes)
static adj_walk_rc_t arp_mk_complete_walk(adj_index_t ai, void *ctx)
Per-interface ARP configuration and state.
static heap_elt_t * first(heap_header_t *h)
#define FOR_EACH_SRC_ADDED(_entry, _src, _source, action)
format_function_t format_vnet_sw_interface_name
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static ethernet_header_t * ethernet_buffer_get_header(vlib_buffer_t *b)
#define foreach_ethernet_arp_error
static void arp_mk_complete(adj_index_t ai, ethernet_arp_ip4_entry_t *e)
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
enum fib_source_t_ fib_source_t
The different sources that can create a route.
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
#define ETHERNET_ARP_ARGS_FLUSH
struct ip_adjacency_t_::@38::@39 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
ip4_address_t ip4_address
static u32 arp_learn(vnet_main_t *vnm, ethernet_arp_main_t *am, u32 sw_if_index, void *addr)
void send_ip4_garp(vlib_main_t *vm, vnet_hw_interface_t *hi)
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.
u8 * ip_enabled_by_sw_if_index
#define pool_put(P, E)
Free an object E in pool P.
static void * vlib_process_signal_event_data(vlib_main_t *vm, uword node_index, uword type_opaque, uword n_data_elts, uword n_data_elt_bytes)
static void unset_random_arp_entry(void)
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
ethernet_arp_interface_t * ethernet_arp_by_sw_if_index
Per interface state.
u32 node_index
Node index.
static clib_error_t * ethernet_arp_init(vlib_main_t *vm)
#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 fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
vlib_error_t error
Error code for buffers to be enqueued to error handler.
u32 fib_entry_get_resolving_interface(fib_node_index_t entry_index)
static clib_error_t * ip_arp_add_del_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
union ip_adjacency_t_::@38 sub_type
u8 * format_ethernet_type(u8 *s, va_list *args)
fib_node_index_t ip4_fib_table_lookup(const ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
static void arp_adj_fib_add(ethernet_arp_ip4_entry_t *e, u32 fib_index)
ethernet_proxy_arp_t * proxy_arps
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
int fib_entry_is_sourced(fib_node_index_t fib_entry_index, fib_source_t source)
Adjacency to drop this packet.
static_always_inline uword vlib_get_thread_index(void)
static void arp_mk_incomplete(adj_index_t ai)
int ip4_address_compare(ip4_address_t *a1, ip4_address_t *a2)
#define vec_free(V)
Free vector's memory (no header).
ip4_add_del_interface_address_function_t * function
static ethernet_arp_main_t ethernet_arp_main
static ip4_fib_t * ip4_fib_get(u32 index)
Get the FIB at the given index.
static void feat_bitmap_init_next_nodes(vlib_main_t *vm, u32 node_index, u32 num_features, char **feat_names, u32 *next_nodes)
Initialize the feature next-node indexes of a graph node.
Multicast Midchain Adjacency.
static char * ethernet_arp_error_strings[]
#define ETHERNET_ARP_ARGS_POPULATE
#define clib_warning(format, args...)
#define VLIB_BUFFER_IS_TRACED
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
#define clib_memcpy(a, b, c)
unformat_function_t * unformat_edit
uword * mac_changes_by_address
uword wc_ip4_arp_publisher_et
void wc_arp_set_publisher_node(uword node_index, uword event_type)
u32 fib_node_index_t
A typedef of a node index.
u32 adj_index_t
An index for adjacencies.
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.
void vnet_register_ip4_arp_resolution_event(vnet_main_t *vnm, void *address_arg, uword node_index, uword type_opaque, uword data)
static clib_error_t * ethernet_arp_sw_interface_up_down(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Invoked when the interface's admin state changes.
fib_entry_t * fib_entry_get(fib_node_index_t index)
int vnet_proxy_arp_add_del(ip4_address_t *lo_addr, ip4_address_t *hi_addr, u32 fib_index, int is_del)
enum fib_entry_flag_t_ fib_entry_flag_t
static u8 * format_ethernet_arp_opcode(u8 *s, va_list *va)
void fib_table_lock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Release a reference counting lock on the table.
u32 unnumbered_sw_if_index
#define VLIB_CLI_COMMAND(x,...)
This packets follow a mid-chain adjacency.
clib_error_t * arp_term_init(vlib_main_t *vm)
vlib_packet_template_t ip4_arp_request_packet_template
Template used to generate IP4 ARP packets.
#define hash_create(elts, value_bytes)
#define ETHERNET_ARP_ARGS_REMOVE
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
uword unformat_ethernet_address(unformat_input_t *input, va_list *args)
u32 arp_term_next_node_index[32]
#define vec_delete(V, N, M)
Delete N elements starting at element M.
The default route source.
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.
void adj_mcast_update_rewrite(adj_index_t adj_index, u8 *rewrite, u8 offset, u32 mask)
adj_mcast_update_rewrite
#define VLIB_NODE_FLAG_TRACE
ethernet_arp_entry_flags_t flags
void fib_table_entry_path_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, dpo_proto_t next_hop_proto, const ip46_address_t *next_hop, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, fib_route_path_flags_t path_flags)
remove one path to an entry (aka route) in the FIB.
static void arp_nbr_probe(ip_adjacency_t *adj)
ethernet_arp_ip4_over_ethernet_address_t a
void ethernet_register_input_type(vlib_main_t *vm, ethernet_type_t type, u32 node_index)
static vlib_main_t * vlib_get_main(void)
static vlib_node_registration_t arp_term_l2bd_node
(constructor) VLIB_REGISTER_NODE (arp_term_l2bd_node)
uword * arp_entries
Hash table of ARP entries.
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
#define vec_elt(v, i)
Get vector value at index i.
ip4_table_bind_callback_t * table_bind_callbacks
Functions to call when interface to table biding changes.
fib_entry_flag_t fib_entry_get_flags_for_source(fib_node_index_t fib_entry_index, fib_source_t source)
This packets needs to go to ICMP error.
This packet is for one of our own IP addresses.
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)
static vlib_node_registration_t arp_input_node
(constructor) VLIB_REGISTER_NODE (arp_input_node)
#define FIB_NODE_INDEX_INVALID
int vnet_proxy_arp_fib_reset(u32 fib_id)
fib_node_index_t fib_entry_index
The index of the adj-fib entry created.
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
#define ETHERNET_ARP_ARGS_WC_PUB
static u8 * format_arp_term_input_trace(u8 *s, va_list *va)
static int vnet_arp_flush_ip4_over_ethernet_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
vnet_sw_interface_t * sw_interfaces
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
static clib_error_t * ethernet_init(vlib_main_t *vm)
static u8 * format_ethernet_arp_hardware_type(u8 *s, va_list *va)
u8 * ethernet_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
build a rewrite string to use for sending packets of type 'link_type' to 'dst_address' ...
l2_bridge_domain_t * bd_configs
static void arp_entry_free(ethernet_arp_interface_t *eai, ethernet_arp_ip4_entry_t *e)
#define clib_mem_unaligned(pointer, type)
ethernet_arp_input_error_t
static void vnet_arp_wc_publish_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
struct clib_bihash_value offset
template key/value backing page structure
#define VLIB_REGISTER_NODE(x,...)
ip4_main_t ip4_main
Global ip4 main structure.
#define vec_foreach(var, vec)
Vector iterator.
static uword ip6_address_is_unspecified(ip6_address_t *a)
u16 flags
Copy of main node flags.
static int arp_unnumbered(vlib_buffer_t *p0, u32 input_sw_if_index, u32 conn_sw_if_index)
ethernet_arp_ip4_entry_t * ip4_neighbor_entries(u32 sw_if_index)
uword wc_ip4_arp_publisher_node
int vnet_arp_set_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, void *a_arg, int is_static, int is_no_fib_entry)
static int vnet_arp_populate_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, void *a_arg)
Internally generated event to populate the ARP cache on an interface state change event...
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 unformat_ethernet_arp_opcode_net_byte_order(unformat_input_t *input, va_list *args)
void adj_nbr_update_rewrite(adj_index_t adj_index, adj_nbr_rewrite_flag_t flags, u8 *rewrite)
adj_nbr_update_rewrite
void ethernet_arp_change_mac(u32 sw_if_index)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
ethernet_arp_ip4_entry_t * ip4_entry_pool
int vnet_add_del_ip4_arp_change_event(vnet_main_t *vnm, void *data_callback, u32 pid, void *address_arg, uword node_index, uword type_opaque, uword data, int is_add)
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
const u8 * ethernet_ip4_mcast_dst_addr(void)
int vnet_ip6_nd_term(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_buffer_t *p0, ethernet_header_t *eth, ip6_header_t *ip, u32 sw_if_index, u16 bd_index)
fib_node_index_t fib_table_entry_path_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, dpo_proto_t next_hop_proto, const ip46_address_t *next_hop, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags)
Add one path to an entry (aka route) in the FIB.
fib_entry_flag_t fib_entry_get_flags(fib_node_index_t fib_entry_index)
static adj_walk_rc_t arp_mk_incomplete_walk(adj_index_t ai, void *ctx)
static ip4_address_t * ip4_interface_address_matching_destination(ip4_main_t *im, ip4_address_t *dst, u32 sw_if_index, ip_interface_address_t **result_ia)
static uword pool_elts(void *v)
Number of active elements in a pool.