103 .name =
"ip4-lookup",
104 .vector_size =
sizeof (
u32),
122 n_left = frame->n_vectors;
131 u32 lbi0, hc0, lbi1, hc1;
262 return frame->n_vectors;
268 .name =
"ip4-load-balance",
269 .vector_size =
sizeof (
u32),
270 .sibling_of =
"ip4-lookup",
275 #ifndef CLIB_MARCH_VARIANT 287 (lm, ia, sw_if_index,
297 *result_ia = result ? ia : 0;
388 else if (pfx.
fp_len == 31)
390 u32 mask = clib_host_to_net_u32(1);
394 net_pfx.
fp_addr.ip4.as_u32 ^= mask;
415 if (classify_table_index != (
u32) ~ 0)
474 else if (pfx.
fp_len == 31)
476 u32 mask = clib_host_to_net_u32(1);
480 net_pfx.
fp_addr.ip4.as_u32 ^= mask;
489 #ifndef CLIB_MARCH_VARIANT 516 sw_if_index, !is_enable, 0, 0);
529 u32 address_length,
u32 is_del)
535 u32 if_address_index, elts_before;
539 if (sw_if_index == 0)
565 if (im->fib_index_by_sw_if_index[sw_if_index] ==
566 im->fib_index_by_sw_if_index[sif->sw_if_index])
568 foreach_ip_interface_address
569 (&im->lookup_main, ia, sif->sw_if_index,
573 ip_interface_address_get_address
574 (&im->lookup_main, ia);
575 if (ip4_destination_matches_route
576 (im, address, x, ia->address_length) ||
577 ip4_destination_matches_route (im,
582 vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
586 (
"failed to add %U which conflicts with %U for interface %U",
587 format_ip4_address_and_length, address,
589 format_ip4_address_and_length, x,
591 format_vnet_sw_if_index_name, vnm,
600 elts_before =
pool_elts (lm->if_address_pool);
603 (lm,
sw_if_index, addr_fib, address_length, is_del, &if_address_index);
617 im, ip4_af.fib_index,
619 (lm->if_address_pool, if_address_index));
623 if (elts_before !=
pool_elts (lm->if_address_pool))
626 vec_foreach (cb, im->add_del_interface_address_callbacks)
628 address, address_length, if_address_index, is_del);
640 u32 address_length,
u32 is_del)
643 (vm, sw_if_index, address, address_length, is_del);
662 if (ia->address_length <= 30)
666 ipa = ip_interface_address_get_address (&im->lookup_main, ia);
670 .fp_proto = FIB_PROTOCOL_IP4,
672 .ip4.as_u32 = (ipa->as_u32 | ~im->fib_masks[ia->address_length]),
676 ip4_add_subnet_bcast_route
677 (fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP4,
692 u32 is_admin_up, fib_index;
698 lookup_main.if_address_pool_index_by_sw_if_index,
709 a = ip_interface_address_get_address (&im->lookup_main, ia);
711 ip4_add_interface_routes (sw_if_index,
715 ip4_del_interface_routes (im, fib_index,
716 a, ia->address_length);
729 .arc_name =
"ip4-unicast",
730 .start_nodes =
VNET_FEATURES (
"ip4-input",
"ip4-input-no-checksum"),
731 .last_in_arc =
"ip4-lookup",
737 .arc_name =
"ip4-unicast",
738 .node_name =
"ip4-flow-classify",
744 .arc_name =
"ip4-unicast",
745 .node_name =
"ip4-inacl",
751 .arc_name =
"ip4-unicast",
752 .node_name =
"ip4-source-check-via-rx",
758 .arc_name =
"ip4-unicast",
759 .node_name =
"ip4-source-check-via-any",
765 .arc_name =
"ip4-unicast",
766 .node_name =
"ip4-source-and-port-range-check-rx",
772 .arc_name =
"ip4-unicast",
773 .node_name =
"ip4-policer-classify",
779 .arc_name =
"ip4-unicast",
780 .node_name =
"ipsec4-input-feature",
786 .arc_name =
"ip4-unicast",
787 .node_name =
"vpath-input-ip4",
793 .arc_name =
"ip4-unicast",
794 .node_name =
"ip4-vxlan-bypass",
800 .arc_name =
"ip4-unicast",
801 .node_name =
"ip4-not-enabled",
807 .arc_name =
"ip4-unicast",
808 .node_name =
"ip4-lookup",
815 .arc_name =
"ip4-multicast",
816 .start_nodes =
VNET_FEATURES (
"ip4-input",
"ip4-input-no-checksum"),
817 .last_in_arc =
"ip4-mfib-forward-lookup",
823 .arc_name =
"ip4-multicast",
824 .node_name =
"vpath-input-ip4",
830 .arc_name =
"ip4-multicast",
831 .node_name =
"ip4-not-enabled",
837 .arc_name =
"ip4-multicast",
838 .node_name =
"ip4-mfib-forward-lookup",
845 .arc_name =
"ip4-output",
846 .start_nodes =
VNET_FEATURES (
"ip4-rewrite",
"ip4-midchain",
"ip4-dvr-dpo"),
847 .last_in_arc =
"interface-output",
853 .arc_name =
"ip4-output",
854 .node_name =
"ip4-source-and-port-range-check-tx",
860 .arc_name =
"ip4-output",
861 .node_name =
"ip4-outacl",
867 .arc_name =
"ip4-output",
868 .node_name =
"ipsec4-output-feature",
875 .arc_name =
"ip4-output",
876 .node_name =
"interface-output",
912 sw_if_index, is_add, 0, 0);
920 #ifndef CLIB_MARCH_VARIANT 970 #define _16(f,v) h.f = clib_host_to_net_u16 (v); 971 #define _8(f,v) h.f = v; 972 _16 (l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
973 _16 (l3_type, ETHERNET_TYPE_IP4);
974 _8 (n_l2_address_bytes, 6);
975 _8 (n_l3_address_bytes, 4);
976 _16 (opcode, ETHERNET_ARP_OPCODE_request);
1004 #ifndef CLIB_MARCH_VARIANT 1027 s =
format (s,
"fib %d dpo-idx %d flow hash: 0x%08x",
1043 s =
format (s,
"tx_sw_if_index %d dpo-idx %d : %U flow hash: 0x%08x",
1053 #ifndef CLIB_MARCH_VARIANT 1082 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1097 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
1124 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1148 u32 ip_header_length, payload_length_host_byte_order;
1149 u32 n_this_buffer, n_bytes_left, n_ip_bytes_this_buffer;
1151 u8 *data_this_buffer;
1156 payload_length_host_byte_order =
1157 clib_net_to_host_u16 (ip0->
length) - ip_header_length;
1159 clib_host_to_net_u32 (payload_length_host_byte_order +
1175 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1176 data_this_buffer = (
u8 *) ip0 + ip_header_length;
1177 n_ip_bytes_this_buffer =
1179 if (n_this_buffer + ip_header_length > n_ip_bytes_this_buffer)
1181 n_this_buffer = n_ip_bytes_this_buffer > ip_header_length ?
1182 n_ip_bytes_this_buffer - ip_header_length : 0;
1188 n_bytes_left -= n_this_buffer;
1189 if (n_bytes_left == 0)
1193 if (!(p0->
flags & VLIB_BUFFER_NEXT_PRESENT))
1196 length_odd = (n_this_buffer & 1);
1208 data_this_buffer[0] = 0;
1224 || ip0->
protocol == IP_PROTOCOL_UDP);
1226 udp0 = (
void *) (ip0 + 1);
1229 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1230 | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1236 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1237 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1246 .arc_name =
"ip4-local",
1248 .last_in_arc =
"ip4-local-end-of-arc",
1259 *good_tcp_udp = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1263 u32 ip_len, udp_len;
1267 ip_len = clib_net_to_host_u16 (ip->
length);
1268 udp_len = clib_net_to_host_u16 (udp->
length);
1270 len_diff = ip_len - udp_len;
1271 *good_tcp_udp &= len_diff >= 0;
1272 *error = len_diff < 0 ? IP4_ERROR_UDP_LENGTH : *error;
1276 #define ip4_local_csum_is_offloaded(_b) \ 1277 _b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM \ 1278 || _b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM 1280 #define ip4_local_need_csum_check(is_tcp_udp, _b) \ 1281 (is_tcp_udp && !(_b->flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED \ 1282 || ip4_local_csum_is_offloaded (_b))) 1284 #define ip4_local_csum_is_valid(_b) \ 1285 (_b->flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT \ 1286 || (ip4_local_csum_is_offloaded (_b))) != 0 1292 u8 is_udp, is_tcp_udp, good_tcp_udp;
1294 is_udp = ih->
protocol == IP_PROTOCOL_UDP;
1295 is_tcp_udp = is_udp || ih->
protocol == IP_PROTOCOL_TCP;
1302 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1303 *error = (is_tcp_udp && !good_tcp_udp
1304 ? IP4_ERROR_TCP_CHECKSUM + is_udp : *error);
1311 u8 is_udp[2], is_tcp_udp[2], good_tcp_udp[2];
1313 is_udp[0] = ih[0]->
protocol == IP_PROTOCOL_UDP;
1314 is_udp[1] = ih[1]->
protocol == IP_PROTOCOL_UDP;
1316 is_tcp_udp[0] = is_udp[0] || ih[0]->
protocol == IP_PROTOCOL_TCP;
1317 is_tcp_udp[1] = is_udp[1] || ih[1]->
protocol == IP_PROTOCOL_TCP;
1333 error[0] = (is_tcp_udp[0] && !good_tcp_udp[0] ?
1334 IP4_ERROR_TCP_CHECKSUM + is_udp[0] : error[0]);
1335 error[1] = (is_tcp_udp[1] && !good_tcp_udp[1] ?
1336 IP4_ERROR_TCP_CHECKSUM + is_udp[1] : error[1]);
1342 u8 head_of_feature_arc)
1349 if (head_of_feature_arc)
1417 *error0 = ((*error0 == IP4_ERROR_UNKNOWN_PROTOCOL
1419 IP4_ERROR_SPOOFED_LOCAL_PACKETS : *error0);
1420 *error0 = ((*error0 == IP4_ERROR_UNKNOWN_PROTOCOL
1423 IP4_ERROR_SRC_LOOKUP_MISS : *error0);
1426 last_check->
lbi = lbi0;
1427 last_check->
error = *error0;
1434 *error0 = last_check->
error;
1435 last_check->
first = 0;
1450 not_last_hit = last_check->
first;
1505 error[0] = ((error[0] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1507 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error[0]);
1508 error[0] = ((error[0] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1511 ? IP4_ERROR_SRC_LOOKUP_MISS : error[0]);
1513 error[1] = ((error[1] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1515 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error[1]);
1516 error[1] = ((error[1] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1519 ? IP4_ERROR_SRC_LOOKUP_MISS : error[1]);
1522 last_check->
lbi = lbi[1];
1523 last_check->
error = error[1];
1535 error[0] = last_check->
error;
1536 error[1] = last_check->
error;
1537 last_check->
first = 0;
1579 u32 *from, n_left_from;
1596 .error = IP4_ERROR_UNKNOWN_PROTOCOL,
1610 while (n_left_from >= 6)
1623 error[0] = error[1] = IP4_ERROR_UNKNOWN_PROTOCOL;
1634 not_batch = pt[0] ^ pt[1];
1636 if (head_of_feature_arc == 0 || (pt[0] && not_batch == 0))
1661 head_of_feature_arc);
1663 head_of_feature_arc);
1670 while (n_left_from > 0)
1672 error[0] = IP4_ERROR_UNKNOWN_PROTOCOL;
1678 if (head_of_feature_arc == 0 || pt[0])
1687 head_of_feature_arc);
1707 .name =
"ip4-local",
1708 .vector_size =
sizeof (
u32),
1732 .name =
"ip4-local-end-of-arc",
1733 .vector_size =
sizeof (
u32),
1736 .sibling_of =
"ip4-local",
1740 .arc_name =
"ip4-local",
1741 .node_name =
"ip4-local-end-of-arc",
1746 #ifndef CLIB_MARCH_VARIANT 1810 .path =
"show ip local",
1812 .short_help =
"show ip local",
1824 u32 *from, *to_next_drop;
1825 uword n_left_from, n_left_to_next_drop, next_index;
1840 while (n_left_from > 0)
1843 to_next_drop, n_left_to_next_drop);
1845 while (n_left_from > 0 && n_left_to_next_drop > 0)
1847 u32 pi0, bi0, adj_index0, sw_if_index0;
1860 to_next_drop[0] = pi0;
1862 n_left_to_next_drop -= 1;
1880 sw_if_index0 = adj0->rewrite_header.sw_if_index;
1964 adj0->rewrite_header.next_index, bi0);
1998 .vector_size =
sizeof (
u32),
2011 .name =
"ip4-glean",
2012 .vector_size =
sizeof (
u32),
2023 #define foreach_notrace_ip4_arp_error \ 2029 _(NO_SOURCE_ADDRESS) 2038 vnet_pcap_drop_trace_filter_add_del \ 2039 (rt->errors[IP4_ARP_ERROR_##a], \ 2049 #ifndef CLIB_MARCH_VARIANT 2066 u8 unicast_rewrite = 0;
2082 vnm->
api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE;
2085 "no matching interface address for destination %U (interface %U)",
2115 ip46_address_t
nh = {
2127 unicast_rewrite = 1;
2139 if (unicast_rewrite)
2142 etype[0] = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
2171 #if CLIB_ARCH_IS_BIG_ENDIAN 2172 #define IP4_MCAST_ADDR_MASK 0x007fffff 2174 #define IP4_MCAST_ADDR_MASK 0xffff7f00 2179 u16 adj_packet_bytes,
bool df,
u16 * next,
u32 * error)
2181 if (packet_len > adj_packet_bytes)
2183 *error = IP4_ERROR_MTU_EXCEEDED;
2187 (b, ICMP4_destination_unreachable,
2188 ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
2212 b->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2221 checksum = ip->
checksum + clib_host_to_net_u16 (0x0100);
2222 checksum += checksum >= 0xffff;
2234 *error = IP4_ERROR_TIME_EXPIRED;
2237 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2244 (b->
flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2252 int do_counters,
int is_midchain,
int is_mcast,
2269 if (n_left_from >= 6)
2272 for (i = 2; i < 6; i++)
2278 while (n_left_from >= 8)
2282 u32 rw_len0, error0, adj_index0;
2283 u32 rw_len1, error1, adj_index1;
2284 u32 tx_sw_if_index0, tx_sw_if_index1;
2299 thread_index, adj_index0);
2301 thread_index, adj_index1);
2307 error0 = error1 = IP4_ERROR_NONE;
2317 rw_len0 = adj0[0].rewrite_header.data_bytes;
2318 rw_len1 = adj1[0].rewrite_header.data_bytes;
2319 vnet_buffer (b[0])->ip.save_rewrite_length = rw_len0;
2320 vnet_buffer (b[1])->ip.save_rewrite_length = rw_len1;
2331 u16 ip0_len = clib_net_to_host_u16 (ip0->
length);
2332 u16 ip1_len = clib_net_to_host_u16 (ip1->
length);
2334 if (do_gso && (b[0]->
flags & VNET_BUFFER_F_GSO))
2336 if (do_gso && (b[1]->
flags & VNET_BUFFER_F_GSO))
2340 adj0[0].rewrite_header.max_l3_packet_bytes,
2345 adj1[0].rewrite_header.max_l3_packet_bytes,
2352 error0 = ((adj0[0].rewrite_header.sw_if_index ==
2354 IP4_ERROR_SAME_INTERFACE : error0);
2355 error1 = ((adj1[0].rewrite_header.sw_if_index ==
2357 IP4_ERROR_SAME_INTERFACE : error1);
2364 u32 next_index = adj0[0].rewrite_header.next_index;
2367 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2373 tx_sw_if_index0, &next_index, b[0]);
2374 next[0] = next_index;
2382 u32 next_index = adj1[0].rewrite_header.next_index;
2386 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
2392 tx_sw_if_index1, &next_index, b[1]);
2393 next[1] = next_index;
2440 adj0->rewrite_header.dst_mcast_offset,
2443 adj1->rewrite_header.dst_mcast_offset,
2452 while (n_left_from > 0)
2456 u32 rw_len0, adj_index0, error0;
2457 u32 tx_sw_if_index0;
2465 thread_index, adj_index0);
2469 error0 = IP4_ERROR_NONE;
2475 rw_len0 = adj0[0].rewrite_header.data_bytes;
2476 vnet_buffer (b[0])->ip.save_rewrite_length = rw_len0;
2479 u16 ip0_len = clib_net_to_host_u16 (ip0->
length);
2480 if (do_gso && (b[0]->
flags & VNET_BUFFER_F_GSO))
2484 adj0[0].rewrite_header.max_l3_packet_bytes,
2491 error0 = ((adj0[0].rewrite_header.sw_if_index ==
2493 IP4_ERROR_SAME_INTERFACE : error0);
2500 u32 next_index = adj0[0].rewrite_header.next_index;
2503 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2509 tx_sw_if_index0, &next_index, b[0]);
2510 next[0] = next_index;
2526 thread_index, adj_index0, 1,
2542 adj0->rewrite_header.dst_mcast_offset,
2564 int do_counters,
int is_midchain,
int is_mcast)
2569 is_midchain, is_mcast,
2573 is_midchain, is_mcast,
2661 .name =
"ip4-rewrite",
2662 .vector_size =
sizeof (
u32),
2675 .name =
"ip4-rewrite-bcast",
2676 .vector_size =
sizeof (
u32),
2679 .sibling_of =
"ip4-rewrite",
2683 .name =
"ip4-rewrite-mcast",
2684 .vector_size =
sizeof (
u32),
2687 .sibling_of =
"ip4-rewrite",
2691 .name =
"ip4-mcast-midchain",
2692 .vector_size =
sizeof (
u32),
2695 .sibling_of =
"ip4-rewrite",
2699 .name =
"ip4-midchain",
2700 .vector_size =
sizeof (
u32),
2702 .sibling_of =
"ip4-rewrite",
2738 if (
unformat (input,
"table %d", &table_id))
2742 if ((fib) && (fib->
index != table_id))
2746 else if (
unformat (input,
"count %f", &count))
2759 for (i = 0; i < n; i++)
2764 ip4_base_address.
as_u32 =
2765 clib_host_to_net_u32 (1 +
2766 clib_net_to_host_u32 (ip4_base_address.
as_u32));
2797 .path =
"test lookup",
2798 .short_help =
"test lookup <ipv4-addr> [table <fib-id>] [count <nn>]",
2803 #ifndef CLIB_MARCH_VARIANT 2811 if (~0 == fib_index)
2812 return VNET_API_ERROR_NO_SUCH_FIB;
2828 u32 flow_hash_config = 0;
2833 if (
unformat (input,
"table %d", &table_id))
2836 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;} 2853 case VNET_API_ERROR_NO_SUCH_FIB:
2857 clib_warning (
"BUG: illegal flow hash config 0x%x", flow_hash_config);
2950 .path =
"set ip flow-hash",
2952 "set ip flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
2957 #ifndef CLIB_MARCH_VARIANT 2970 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
2973 return VNET_API_ERROR_NO_SUCH_ENTRY;
2980 if (
NULL != if_addr)
2985 .fp_addr.ip4 = *if_addr,
2993 if (table_index != (
u32) ~ 0)
3024 u32 table_index = ~0;
3025 int table_index_set = 0;
3031 if (
unformat (input,
"table-index %d", &table_index))
3032 table_index_set = 1;
3040 if (table_index_set == 0)
3043 if (sw_if_index == ~0)
3053 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3056 case VNET_API_ERROR_NO_SUCH_ENTRY:
3075 .path =
"set ip classify",
3077 "set ip classify intfc <interface> table-index <classify-idx>",
3094 "invalid heap-size parameter `%U'",
vlib_node_registration_t ip4_mcast_midchain_node
(constructor) VLIB_REGISTER_NODE (ip4_mcast_midchain_node)
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
#define foreach_ip_interface_address(lm, a, sw_if_index, loop, body)
#define vnet_rewrite_one_header(rw0, p0, most_likely_size)
u16 lb_n_buckets
number of buckets in the load-balance.
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
u32 mfib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, mfib_source_t src)
Get the index of the FIB for a Table-ID.
#define ip4_local_need_csum_check(is_tcp_udp, _b)
clib_error_t * ip4_add_del_interface_address(vlib_main_t *vm, u32 sw_if_index, ip4_address_t *address, u32 address_length, u32 is_del)
ip4_address_t * ip4_interface_first_address(ip4_main_t *im, u32 sw_if_index, ip_interface_address_t **result_ia)
static clib_error_t * ip4_config(vlib_main_t *vm, unformat_input_t *input)
static uword ip4_local_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int head_of_feature_arc)
int vnet_set_ip4_flow_hash(u32 table_id, u32 flow_hash_config)
static int fib_urpf_check_size(index_t ui)
Data-Plane function to check the size of an uRPF list, (i.e.
void ip_frag_set_vnet_buffer(vlib_buffer_t *b, u16 mtu, u8 next_index, u8 flags)
format_function_t format_vlib_node_name
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
static void vlib_set_next_frame_buffer(vlib_main_t *vm, vlib_node_runtime_t *node, u32 next_index, u32 buffer_index)
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 clib_error_t * ip4_lookup_init(vlib_main_t *vm)
static clib_error_t * ip4_add_del_interface_address_internal(vlib_main_t *vm, u32 sw_if_index, ip4_address_t *address, u32 address_length, u32 is_del)
static ip4_fib_mtrie_leaf_t ip4_fib_mtrie_lookup_step(const ip4_fib_mtrie_t *m, ip4_fib_mtrie_leaf_t current_leaf, const ip4_address_t *dst_address, u32 dst_address_byte_index)
Lookup step.
vnet_interface_main_t interface_main
vlib_node_registration_t ip4_lookup_node
(constructor) VLIB_REGISTER_NODE (ip4_lookup_node)
static int ip4_lookup_validate(ip4_address_t *a, u32 fib_index0)
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
static void ip4_mtu_check(vlib_buffer_t *b, u16 packet_len, u16 adj_packet_bytes, bool df, u16 *next, u32 *error)
#define clib_memcpy_fast(a, b, c)
static u32 ip4_compute_flow_hash(const ip4_header_t *ip, flow_hash_config_t flow_hash_config)
static f64 vlib_time_now(vlib_main_t *vm)
struct ip_adjacency_t_::@48::@51 glean
IP_LOOKUP_NEXT_GLEAN.
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.
flow_hash_config_t lb_hash_config
the hash config to use when selecting a bucket.
static const dpo_id_t * load_balance_get_fwd_bucket(const load_balance_t *lb, u16 bucket)
This packet is to be rewritten and forwarded to the next processing node.
u16 current_length
Nbytes between current data and the end of this buffer.
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
static clib_error_t * test_lookup_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static uword ip4_lookup_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
ip_lookup_main_t lookup_main
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
static void ip4_local_set_next_and_error(vlib_node_runtime_t *error_node, vlib_buffer_t *b, u16 *next, u8 error, u8 head_of_feature_arc)
unformat_function_t unformat_vnet_sw_interface
#define VLIB_NODE_FN(node)
vlib_error_t * errors
Vector of errors for this node.
static uword ip4_rewrite_inline_with_gso(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int do_counters, int is_midchain, int is_mcast, int do_gso)
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
VNET_FEATURE_ARC_INIT(ip4_unicast, static)
static u32 ip4_lookup(gid_ip4_table_t *db, u32 vni, ip_prefix_t *key)
u8 mcast_feature_arc_index
Feature arc indices.
format_function_t format_vnet_sw_if_index_name
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
enum vnet_sw_interface_flags_t_ vnet_sw_interface_flags_t
static void ip4_local_check_l4_csum_x2(vlib_main_t *vm, vlib_buffer_t **b, ip4_header_t **ih, u8 *error)
static int ip4_is_fragment(const ip4_header_t *i)
static pg_node_t * pg_get_node(uword node_index)
static void ip4_local_check_l4_csum(vlib_main_t *vm, vlib_buffer_t *b, ip4_header_t *ih, u8 *error)
union ip_adjacency_t_::@48 sub_type
fib_node_index_t fib_table_entry_update_one_path(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, fib_mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags)
Update the entry to have just one path.
u8 output_feature_arc_index
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
static clib_error_t * show_ip_local_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
#define static_always_inline
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.
ip4_enable_disable_interface_callback_t * enable_disable_interface_callbacks
Functions to call when interface becomes IPv4 enabled/disable.
#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...
vl_api_interface_index_t sw_if_index
#define VLIB_INIT_FUNCTION(x)
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a 'special' entry from the FIB.
static uword pow2_mask(uword x)
static void ip4_add_interface_routes(u32 sw_if_index, ip4_main_t *im, u32 fib_index, ip_interface_address_t *a)
u16 lb_n_buckets_minus_1
number of buckets in the load-balance - 1.
static_always_inline void calc_checksums(vlib_main_t *vm, vlib_buffer_t *b)
#define ip4_local_csum_is_valid(_b)
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
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...)
vlib_node_registration_t ip4_arp_node
(constructor) VLIB_REGISTER_NODE (ip4_arp_node)
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
void ip4_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
static void ip4_local_check_src_x2(vlib_buffer_t **b, ip4_header_t **ip, ip4_local_last_check_t *last_check, u8 *error)
static void * ip4_next_header(ip4_header_t *i)
#define clib_error_create(args...)
struct ip_adjacency_t_::@48::@50 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
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)
#define foreach_notrace_ip4_arp_error
static clib_error_t * vnet_feature_init(vlib_main_t *vm)
static u32 ip4_fib_mtrie_leaf_get_adj_index(ip4_fib_mtrie_leaf_t n)
From the stored slot value extract the LB index value.
vlib_node_registration_t ip4_rewrite_node
(constructor) VLIB_REGISTER_NODE (ip4_rewrite_node)
void ip4_directed_broadcast(u32 sw_if_index, u8 enable)
vlib_error_t error
Error code for buffers to be enqueued to error handler.
vnet_api_error_t api_errno
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static_always_inline void mac_address_from_bytes(mac_address_t *mac, const u8 *bytes)
vlib_node_registration_t ip4_input_node
Global ip4 input node.
void vlib_packet_template_init(vlib_main_t *vm, vlib_packet_template_t *t, void *packet_data, uword n_packet_data_bytes, uword min_n_buffers_each_alloc, char *fmt,...)
u32 * classify_table_index_by_sw_if_index
First table index to use for this interface, ~0 => none.
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
vlib_node_registration_t ip4_local_node
(constructor) VLIB_REGISTER_NODE (ip4_local_node)
index_t classify_dpo_create(dpo_proto_t proto, u32 classify_table_index)
dpo_type_t dpoi_type
the type
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
void ip4_register_protocol(u32 protocol, u32 node_index)
vl_api_ip_proto_t protocol
uword mtrie_heap_size
Heapsize for the Mtries.
static uword ip4_arp_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int is_glean)
void ip4_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
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
static uword ip4_rewrite_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int do_counters, int is_midchain, int is_mcast)
void ip4_unregister_protocol(u32 protocol)
ip4_main_t ip4_main
Global ip4 main structure.
static u64 throttle_seed(throttle_t *t, u32 thread_index, f64 time_now)
u8 local_next_by_ip_protocol[256]
Table mapping ip protocol to ip[46]-local node next index.
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
vnet_sw_interface_flags_t flags
static void vlib_prefetch_combined_counter(const vlib_combined_counter_main_t *cm, u32 thread_index, u32 index)
Pre-fetch a per-thread combined counter for the given object index.
vl_api_address_union_t src_address
void vnet_sw_interface_update_unnumbered(u32 unnumbered_sw_if_index, u32 ip_sw_if_index, u8 enable)
load_balance_main_t load_balance_main
The one instance of load-balance main.
#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).
vlib_combined_counter_main_t adjacency_counters
Adjacency packet counters.
ip4_fib_mtrie_t mtrie
Mtrie for fast lookups.
static u8 * format_ip4_lookup_trace(u8 *s, va_list *args)
struct ip_adjacency_t_::@48::@49 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
fib_node_index_t fib_table_entry_special_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags)
Add a 'special' entry to the FIB.
#define IP4_LOOKUP_NEXT_NODES
static u8 * format_ip4_rewrite_trace(u8 *s, va_list *args)
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
#define VLIB_REGISTER_NODE(x,...)
static void vlib_buffer_copy_trace_flag(vlib_main_t *vm, vlib_buffer_t *b, u32 bi_target)
#define CLIB_PREFETCH(addr, size, type)
static_always_inline void vlib_buffer_enqueue_to_next(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u16 *nexts, uword count)
static void ip4_local_l4_csum_validate(vlib_main_t *vm, vlib_buffer_t *p, ip4_header_t *ip, u8 is_udp, u8 *error, u8 *good_tcp_udp)
ip4_enable_disable_interface_function_t * function
#define vec_free(V)
Free vector's memory (no header).
vnet_feature_arc_registration_t vnet_feat_arc_ip4_local
void fib_table_entry_delete(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Delete a FIB entry.
void icmp4_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
ip4_add_del_interface_address_function_t * function
static ip4_fib_t * ip4_fib_get(u32 index)
Get the FIB at the given index.
void fib_table_set_flow_hash_config(u32 fib_index, fib_protocol_t proto, flow_hash_config_t hash_config)
Set the flow hash configured used by the table.
static ip_csum_t ip_incremental_checksum(ip_csum_t sum, void *_data, uword n_bytes)
#define clib_warning(format, args...)
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
static void ip4_local_check_src(vlib_buffer_t *b, ip4_header_t *ip0, ip4_local_last_check_t *last_check, u8 *error0)
#define IP4_MCAST_ADDR_MASK
This bits of an IPv4 address to mask to construct a multicast MAC address.
static clib_error_t * set_ip_flow_hash_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
unformat_function_t * unformat_edit
u8 packet_data[64-1 *sizeof(u32)]
void ip_lookup_init(ip_lookup_main_t *lm, u32 is_ip6)
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
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.
clib_error_t * ip4_probe_neighbor(vlib_main_t *vm, ip4_address_t *dst, u32 sw_if_index, u8 refresh)
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
vlib_combined_counter_main_t lbm_via_counters
static clib_error_t * set_ip_classify_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define VLIB_CLI_COMMAND(x,...)
static clib_error_t * ip4_sw_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
struct _vnet_classify_main vnet_classify_main_t
#define foreach_flow_hash_bit
fib_node_index_t fib_table_entry_special_dpo_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Add a 'special' entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
vlib_packet_template_t ip4_arp_request_packet_template
Template used to generate IP4 ARP packets.
static clib_error_t * ip4_mtrie_module_init(vlib_main_t *vm)
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
vlib_node_registration_t ip4_load_balance_node
(constructor) VLIB_REGISTER_NODE (ip4_load_balance_node)
index_t lb_urpf
This is the index of the uRPF list for this LB.
static ip4_fib_mtrie_leaf_t ip4_fib_mtrie_lookup_step_one(const ip4_fib_mtrie_t *m, const ip4_address_t *dst_address)
Lookup step number 1.
u32 ip4_tcp_udp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
static load_balance_t * load_balance_get(index_t lbi)
The default route source.
static clib_error_t * fib_module_init(vlib_main_t *vm)
throttle_t arp_throttle
ARP throttling.
vlib_node_registration_t ip4_glean_node
(constructor) VLIB_REGISTER_NODE (ip4_glean_node)
static void ip4_addr_fib_init(ip4_address_fib_t *addr_fib, const ip4_address_t *address, u32 fib_index)
u32 fib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, fib_source_t src)
Get the index of the FIB for a Table-ID.
vlib_node_registration_t ip4_midchain_node
(constructor) VLIB_REGISTER_NODE (ip4_midchain_node)
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
vnet_classify_main_t vnet_classify_main
vlib_node_registration_t ip4_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip4_rewrite_mcast_node)
#define clib_mem_unaligned(pointer, type)
Route added as a result of interface configuration.
vlib_node_registration_t ip4_rewrite_bcast_node
(constructor) VLIB_REGISTER_NODE (ip4_rewrite_bcast_node)
#define VNET_FEATURES(...)
static vlib_main_t * vlib_get_main(void)
static uword vnet_sw_interface_is_admin_up(vnet_main_t *vnm, u32 sw_if_index)
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
static_always_inline void clib_memset_u16(void *p, u16 val, uword count)
#define vec_elt(v, i)
Get vector value at index i.
static_always_inline void ip4_ttl_and_checksum_check(vlib_buffer_t *b, ip4_header_t *ip, u16 *next, u32 *error)
u8 ucast_feature_arc_index
u16 ip4_tcp_udp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip4_header_t *ip0)
static void vnet_ip_mcast_fixup_header(u32 dst_mcast_mask, u32 dst_mcast_offset, u32 *addr, u8 *packet0)
index_t dpoi_index
the index of objects of that type
VNET_FEATURE_INIT(ip4_flow_classify, static)
#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.
u32 next_buffer
Next buffer for this linked-list of buffers.
#define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
VLIB buffer representation.
static u8 ip4_local_classify(vlib_buffer_t *b, ip4_header_t *ip, u16 *next)
Determine packet type and next node.
vnet_sw_interface_t * sw_interfaces
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
u8 * format_ip4_forward_next_trace(u8 *s, va_list *args)
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
adj_index_t adj_glean_add_or_lock(fib_protocol_t proto, vnet_link_t linkt, u32 sw_if_index, const ip46_address_t *nh_addr)
Glean Adjacency.
clib_error_t * ip_interface_address_add_del(ip_lookup_main_t *lm, u32 sw_if_index, void *addr_fib, u32 address_length, u32 is_del, u32 *result_if_address_index)
A collection of combined counters.
static void ip4_add_subnet_bcast_route(u32 fib_index, fib_prefix_t *pfx, u32 sw_if_index)
static clib_error_t * ip4_sw_interface_admin_up_down(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
static clib_error_t * mfib_module_init(vlib_main_t *vm)
static void ip4_del_interface_routes(ip4_main_t *im, u32 fib_index, ip4_address_t *address, u32 address_length)
static uword ip4_source_and_port_range_check_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static vnet_sw_interface_flags_t vnet_sw_interface_get_flags(vnet_main_t *vnm, u32 sw_if_index)
int vnet_set_ip4_classify_intfc(vlib_main_t *vm, u32 sw_if_index, u32 table_index)
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
adj_index_t adj_nbr_add_or_lock(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Neighbour Adjacency sub-type.
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
#define vec_foreach(var, vec)
Vector iterator.
index_t ip4_fib_table_lookup_lb(ip4_fib_t *fib, const ip4_address_t *addr)
#define IP4_HEADER_FLAG_DONT_FRAGMENT
u16 flags
Copy of main node flags.
u16 dpoi_next_node
The next VLIB node to follow.
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(ip4_sw_interface_add_del)
static int ip4_header_bytes(const ip4_header_t *i)
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.
#define VLIB_NODE_FLAG_TRACE
#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)
#define vnet_rewrite_two_headers(rw0, rw1, p0, p1, most_likely_size)
#define CLIB_CACHE_LINE_BYTES
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(ip4_sw_interface_admin_up_down)
This adjacency/interface has output features configured.
static int ip4_src_address_for_packet(ip_lookup_main_t *lm, u32 sw_if_index, ip4_address_t *src)
static clib_error_t * arp_notrace_init(vlib_main_t *vm)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
static uword ip4_source_and_port_range_check_rx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static u16 ip4_header_checksum(ip4_header_t *i)
const ip46_address_t ADJ_BCAST_ADDR
The special broadcast address (to construct a broadcast adjacency.
static u16 ip_csum_fold(ip_csum_t c)
static int adj_are_counters_enabled(void)
Get the global configuration option for enabling per-adj counters.
static char * ip4_arp_error_strings[]
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
vlib_node_registration_t ip4_local_end_of_arc_node
(constructor) VLIB_REGISTER_NODE (ip4_local_end_of_arc_node)
static int throttle_check(throttle_t *t, u32 thread_index, u64 hash, u64 seed)
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_always_inline void vnet_feature_arc_start(u8 arc, u32 sw_if_index, u32 *next0, vlib_buffer_t *b0)
static uword pool_elts(void *v)
Number of active elements in a pool.