67 int lookup_for_responses_to_locally_received_packets)
71 u32 n_left_from, n_left_to_next, *from, *to_next;
79 while (n_left_from > 0)
83 while (n_left_from >= 8 && n_left_to_next >= 4)
92 u32 pi0, fib_index0, lb_index0;
93 u32 pi1, fib_index1, lb_index1;
94 u32 pi2, fib_index2, lb_index2;
95 u32 pi3, fib_index3, lb_index3;
98 u32 hash_c0, hash_c1, hash_c2, hash_c3;
99 const dpo_id_t *dpo0, *dpo1, *dpo2, *dpo3;
121 pi0 = to_next[0] = from[0];
122 pi1 = to_next[1] = from[1];
123 pi2 = to_next[2] = from[2];
124 pi3 = to_next[3] = from[3];
172 if (!lookup_for_responses_to_locally_received_packets)
185 if (!lookup_for_responses_to_locally_received_packets)
193 if (!lookup_for_responses_to_locally_received_packets)
201 if (lookup_for_responses_to_locally_received_packets)
216 ASSERT (lb_index0 && lb_index1 && lb_index2 && lb_index3);
303 (cm, thread_index, lb_index0, 1,
306 (cm, thread_index, lb_index1, 1,
309 (cm, thread_index, lb_index2, 1,
312 (cm, thread_index, lb_index3, 1,
316 to_next, n_left_to_next,
318 next0, next1, next2, next3);
321 while (n_left_from > 0 && n_left_to_next > 0)
330 u32 pi0, fib_index0, lbi0;
351 if (!lookup_for_responses_to_locally_received_packets)
358 if (!lookup_for_responses_to_locally_received_packets)
361 if (!lookup_for_responses_to_locally_received_packets)
364 if (lookup_for_responses_to_locally_received_packets)
477 .name =
"ip4-lookup",
478 .vector_size =
sizeof (
u32),
492 u32 n_left_from, n_left_to_next, *from, *to_next;
503 while (n_left_from > 0)
508 while (n_left_from >= 4 && n_left_to_next >= 2)
513 u32 pi0, lbi0, hc0, pi1, lbi1, hc1;
531 pi0 = to_next[0] = from[0];
532 pi1 = to_next[1] = from[1];
609 to_next, n_left_to_next,
610 pi0, pi1, next0, next1);
613 while (n_left_from > 0 && n_left_to_next > 0)
664 to_next, n_left_to_next,
678 .name =
"ip4-load-balance",
679 .vector_size =
sizeof (
u32),
680 .sibling_of =
"ip4-lookup",
699 (lm, ia, sw_if_index,
709 *result_ia = result ? ia : 0;
723 .fp_addr.ip4 = *address,
764 else if (pfx.
fp_len == 31)
766 u32 mask = clib_host_to_net_u32(1);
770 net_pfx.
fp_addr.ip4.as_u32 ^= mask;
789 u32 classify_table_index =
791 if (classify_table_index != (
u32) ~ 0)
829 .fp_addr.ip4 = *address,
850 else if (pfx.
fp_len == 31)
852 u32 mask = clib_host_to_net_u32(1);
856 net_pfx.
fp_addr.ip4.as_u32 ^= mask;
891 sw_if_index, !is_enable, 0, 0);
898 u32 address_length,
u32 is_del)
904 u32 if_address_index, elts_before;
908 if (sw_if_index == 0)
935 ip_interface_address_get_address
936 (&im->lookup_main, ia);
937 if (ip4_destination_matches_route
938 (im, address, x, ia->address_length) ||
939 ip4_destination_matches_route (im,
945 (
"failed to add %U which conflicts with %U for interface %U",
946 format_ip4_address_and_length, address,
948 format_ip4_address_and_length, x,
950 format_vnet_sw_if_index_name, vnm,
959 (lm, sw_if_index, addr_fib, address_length, is_del, &if_address_index);
979 address, address_length, if_address_index, is_del);
991 u32 address_length,
u32 is_del)
994 (vm, sw_if_index, address, address_length, is_del);
1001 .arc_name =
"ip4-unicast",
1002 .start_nodes =
VNET_FEATURES (
"ip4-input",
"ip4-input-no-checksum"),
1008 .arc_name =
"ip4-unicast",
1009 .node_name =
"ip4-flow-classify",
1015 .arc_name =
"ip4-unicast",
1016 .node_name =
"ip4-inacl",
1022 .arc_name =
"ip4-unicast",
1023 .node_name =
"ip4-source-check-via-rx",
1029 .arc_name =
"ip4-unicast",
1030 .node_name =
"ip4-source-check-via-any",
1036 .arc_name =
"ip4-unicast",
1037 .node_name =
"ip4-source-and-port-range-check-rx",
1043 .arc_name =
"ip4-unicast",
1044 .node_name =
"ip4-policer-classify",
1050 .arc_name =
"ip4-unicast",
1051 .node_name =
"ipsec-input-ip4",
1057 .arc_name =
"ip4-unicast",
1058 .node_name =
"vpath-input-ip4",
1064 .arc_name =
"ip4-unicast",
1065 .node_name =
"ip4-vxlan-bypass",
1071 .arc_name =
"ip4-unicast",
1072 .node_name =
"ip4-drop",
1078 .arc_name =
"ip4-unicast",
1079 .node_name =
"ip4-lookup",
1086 .arc_name =
"ip4-multicast",
1087 .start_nodes =
VNET_FEATURES (
"ip4-input",
"ip4-input-no-checksum"),
1093 .arc_name =
"ip4-multicast",
1094 .node_name =
"vpath-input-ip4",
1100 .arc_name =
"ip4-multicast",
1101 .node_name =
"ip4-drop",
1107 .arc_name =
"ip4-multicast",
1108 .node_name =
"ip4-mfib-forward-lookup",
1115 .arc_name =
"ip4-output",
1116 .start_nodes =
VNET_FEATURES (
"ip4-rewrite",
"ip4-midchain"),
1122 .arc_name =
"ip4-output",
1123 .node_name =
"ip4-source-and-port-range-check-tx",
1129 .arc_name =
"ip4-output",
1130 .node_name =
"ipsec-output-ip4",
1137 .arc_name =
"ip4-output",
1138 .node_name =
"interface-output",
1227 memset (&h, 0,
sizeof (h));
1233 #define _16(f,v) h.f = clib_host_to_net_u16 (v); 1234 #define _8(f,v) h.f = v; 1235 _16 (l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1236 _16 (l3_type, ETHERNET_TYPE_IP4);
1237 _8 (n_l2_address_bytes, 6);
1238 _8 (n_l3_address_bytes, 4);
1239 _16 (opcode, ETHERNET_ARP_OPCODE_request);
1288 s =
format (s,
"fib %d dpo-idx %d flow hash: 0x%08x",
1304 s =
format (s,
"tx_sw_if_index %d dpo-idx %d : %U flow hash: 0x%08x",
1408 u32 ip_header_length, payload_length_host_byte_order;
1409 u32 n_this_buffer, n_bytes_left, n_ip_bytes_this_buffer;
1411 void *data_this_buffer;
1415 payload_length_host_byte_order =
1416 clib_net_to_host_u16 (ip0->
length) - ip_header_length;
1418 clib_host_to_net_u32 (payload_length_host_byte_order +
1434 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1435 data_this_buffer = (
void *) ip0 + ip_header_length;
1436 n_ip_bytes_this_buffer =
1438 if (n_this_buffer + ip_header_length > n_ip_bytes_this_buffer)
1440 n_this_buffer = n_ip_bytes_this_buffer > ip_header_length ?
1441 n_ip_bytes_this_buffer - ip_header_length : 0;
1446 n_bytes_left -= n_this_buffer;
1447 if (n_bytes_left == 0)
1469 || ip0->
protocol == IP_PROTOCOL_UDP);
1471 udp0 = (
void *) (ip0 + 1);
1474 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1475 | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1481 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1482 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1490 .arc_name =
"ip4-local",
1497 u8 is_udp,
u8 * error,
u8 * good_tcp_udp)
1501 *good_tcp_udp = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1505 u32 ip_len, udp_len;
1509 ip_len = clib_net_to_host_u16 (ip->
length);
1510 udp_len = clib_net_to_host_u16 (udp->
length);
1512 len_diff = ip_len - udp_len;
1513 *good_tcp_udp &= len_diff >= 0;
1514 *error = len_diff < 0 ? IP4_ERROR_UDP_LENGTH : *error;
1518 #define ip4_local_do_l4_check(is_tcp_udp, flags) \ 1519 (is_tcp_udp && !(flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED \ 1520 || flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM \ 1521 || flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)) 1531 u32 *from, *to_next, n_left_from, n_left_to_next;
1543 while (n_left_from > 0)
1547 while (n_left_from >= 4 && n_left_to_next >= 2)
1555 u32 pi0, next0, fib_index0, lbi0;
1556 u32 pi1, next1, fib_index1, lbi1;
1557 u8 error0, is_udp0, is_tcp_udp0, good_tcp_udp0, proto0;
1558 u8 error1, is_udp1, is_tcp_udp1, good_tcp_udp1, proto1;
1559 u32 sw_if_index0, sw_if_index1;
1561 pi0 = to_next[0] = from[0];
1562 pi1 = to_next[1] = from[1];
1566 n_left_to_next -= 2;
1569 error0 = error1 = IP4_ERROR_UNKNOWN_PROTOCOL;
1588 if (head_of_feature_arc == 0)
1591 is_udp0 = proto0 == IP_PROTOCOL_UDP;
1592 is_udp1 = proto1 == IP_PROTOCOL_UDP;
1593 is_tcp_udp0 = is_udp0 || proto0 == IP_PROTOCOL_TCP;
1594 is_tcp_udp1 = is_udp1 || proto1 == IP_PROTOCOL_TCP;
1597 (p0->
flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT
1598 || (p0->
flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM
1599 || p0->
flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)) != 0;
1600 good_tcp_udp1 = (p1->
flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT
1601 || (p1->
flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM
1603 VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)) != 0;
1617 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1618 error0 = (is_tcp_udp0 && !good_tcp_udp0
1619 ? IP4_ERROR_TCP_CHECKSUM + is_udp0 : error0);
1620 error1 = (is_tcp_udp1 && !good_tcp_udp1
1621 ? IP4_ERROR_TCP_CHECKSUM + is_udp1 : error1);
1674 if (p0->
flags & VNET_BUFFER_F_IS_NATED)
1677 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1679 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error0);
1680 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1683 ? IP4_ERROR_SRC_LOOKUP_MISS : error0);
1686 if (p1->
flags & VNET_BUFFER_F_IS_NATED)
1689 error1 = ((error1 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1691 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error1);
1692 error1 = ((error1 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1695 ? IP4_ERROR_SRC_LOOKUP_MISS : error1);
1707 p0->
error = error0 ? error_node->
errors[error0] : 0;
1708 p1->
error = error1 ? error_node->
errors[error1] : 0;
1710 if (head_of_feature_arc)
1719 n_left_to_next, pi0, pi1,
1723 while (n_left_from > 0 && n_left_to_next > 0)
1729 u32 pi0, next0, fib_index0, lbi0;
1730 u8 error0, is_udp0, is_tcp_udp0, good_tcp_udp0, proto0;
1735 pi0 = to_next[0] = from[0];
1739 n_left_to_next -= 1;
1742 error0 = IP4_ERROR_UNKNOWN_PROTOCOL;
1753 if (head_of_feature_arc == 0 || p0->
flags & VNET_BUFFER_F_IS_NATED)
1756 is_udp0 = proto0 == IP_PROTOCOL_UDP;
1757 is_tcp_udp0 = is_udp0 || proto0 == IP_PROTOCOL_TCP;
1760 (p0->
flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT
1761 || (p0->
flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM
1762 || p0->
flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)) != 0;
1770 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1771 error0 = (is_tcp_udp0 && !good_tcp_udp0
1772 ? IP4_ERROR_TCP_CHECKSUM + is_udp0 : error0);
1792 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1794 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error0);
1795 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1798 ? IP4_ERROR_SRC_LOOKUP_MISS : error0);
1805 p0->
error = error0 ? error_node->
errors[error0] : 0;
1807 if (head_of_feature_arc)
1814 n_left_to_next, pi0, next0);
1832 .name =
"ip4-local",
1833 .vector_size =
sizeof (
u32),
1858 .name =
"ip4-local-end-of-arc",
1859 .vector_size =
sizeof (
u32),
1862 .sibling_of =
"ip4-local",
1868 .arc_name =
"ip4-local",
1869 .node_name =
"ip4-local-end-of-arc",
1926 .path =
"show ip local",
1928 .short_help =
"show ip local",
1940 u32 *from, *to_next_drop;
1941 uword n_left_from, n_left_to_next_drop, next_index;
1942 static f64 time_last_seed_change = -1e100;
1943 static u32 hash_seeds[3];
1951 if (time_now - time_last_seed_change > 1e-3)
1955 sizeof (hash_seeds));
1956 for (i = 0; i <
ARRAY_LEN (hash_seeds); i++)
1957 hash_seeds[i] = r[i];
1960 for (i = 0; i <
ARRAY_LEN (hash_bitmap); i++)
1963 time_last_seed_change = time_now;
1972 while (n_left_from > 0)
1975 to_next_drop, n_left_to_next_drop);
1977 while (n_left_from > 0 && n_left_to_next_drop > 0)
1979 u32 pi0, adj_index0, a0, b0, c0, m0, sw_if_index0, drop0;
1997 sw_if_index0 = adj0->rewrite_header.sw_if_index;
2017 c0 &=
BITS (hash_bitmap) - 1;
2021 bm0 = hash_bitmap[c0];
2022 drop0 = (bm0 & m0) != 0;
2025 hash_bitmap[c0] = bm0 | m0;
2029 to_next_drop[0] = pi0;
2031 n_left_to_next_drop -= 1;
2100 ip4_over_ethernet[0].ip4))
2123 adj0->rewrite_header.next_index,
2160 .vector_size =
sizeof (
u32),
2174 .name =
"ip4-glean",
2175 .vector_size =
sizeof (
u32),
2186 #define foreach_notrace_ip4_arp_error \ 2199 vnet_pcap_drop_trace_filter_add_del \ 2200 (rt->errors[IP4_ARP_ERROR_##a], \ 2240 vnm->
api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE;
2243 "no matching interface address for destination %U (interface %U)",
2271 ip46_address_t nh = {
2313 int do_counters,
int is_midchain,
int is_mcast)
2317 u32 n_left_from, n_left_to_next, *to_next, next_index;
2325 while (n_left_from > 0)
2329 while (n_left_from >= 4 && n_left_to_next >= 2)
2334 u32 pi0, rw_len0, next0, error0, checksum0, adj_index0;
2335 u32 pi1, rw_len1, next1, error1, checksum1, adj_index1;
2336 u32 tx_sw_if_index0, tx_sw_if_index1;
2352 pi0 = to_next[0] = from[0];
2353 pi1 = to_next[1] = from[1];
2358 n_left_to_next -= 2;
2372 thread_index, adj_index0);
2374 thread_index, adj_index1);
2380 error0 = error1 = IP4_ERROR_NONE;
2392 checksum0 = ip0->
checksum + clib_host_to_net_u16 (0x0100);
2393 checksum0 += checksum0 >= 0xffff;
2405 error0 = IP4_ERROR_TIME_EXPIRED;
2408 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2415 (p0->
flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2419 p0->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2428 checksum1 = ip1->
checksum + clib_host_to_net_u16 (0x0100);
2429 checksum1 += checksum1 >= 0xffff;
2441 error1 = IP4_ERROR_TIME_EXPIRED;
2444 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2451 (p1->
flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2455 p1->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2463 rw_len0 = adj0[0].rewrite_header.data_bytes;
2464 rw_len1 = adj1[0].rewrite_header.data_bytes;
2465 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2466 vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
2472 rewrite_header.max_l3_packet_bytes ? IP4_ERROR_MTU_EXCEEDED :
2477 rewrite_header.max_l3_packet_bytes ? IP4_ERROR_MTU_EXCEEDED :
2482 error0 = ((adj0[0].rewrite_header.sw_if_index ==
2484 IP4_ERROR_SAME_INTERFACE : error0);
2485 error1 = ((adj1[0].rewrite_header.sw_if_index ==
2487 IP4_ERROR_SAME_INTERFACE : error1);
2496 next0 = adj0[0].rewrite_header.next_index;
2499 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2505 tx_sw_if_index0, &next0, p0);
2509 next1 = adj1[0].rewrite_header.next_index;
2513 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
2519 tx_sw_if_index1, &next1, p1);
2559 to_next, n_left_to_next,
2560 pi0, pi1, next0, next1);
2563 while (n_left_from > 0 && n_left_to_next > 0)
2568 u32 pi0, rw_len0, adj_index0, next0, error0, checksum0;
2569 u32 tx_sw_if_index0;
2571 pi0 = to_next[0] = from[0];
2581 error0 = IP4_ERROR_NONE;
2589 checksum0 = ip0->
checksum + clib_host_to_net_u16 (0x0100);
2591 checksum0 += checksum0 >= 0xffff;
2602 (p0->
flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2610 error0 = IP4_ERROR_TIME_EXPIRED;
2614 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2620 p0->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2625 thread_index, adj_index0);
2638 rw_len0 = adj0[0].rewrite_header.data_bytes;
2639 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2644 thread_index, adj_index0, 1,
2649 > adj0[0].rewrite_header.max_l3_packet_bytes
2650 ? IP4_ERROR_MTU_EXCEEDED : error0);
2653 error0 = ((adj0[0].rewrite_header.sw_if_index ==
2655 IP4_ERROR_SAME_INTERFACE : error0);
2665 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2668 next0 = adj0[0].rewrite_header.next_index;
2678 tx_sw_if_index0, &next0, p0);
2685 n_left_to_next -= 1;
2688 to_next, n_left_to_next,
2777 .name =
"ip4-rewrite",
2778 .vector_size =
sizeof (
u32),
2792 .name =
"ip4-rewrite-mcast",
2793 .vector_size =
sizeof (
u32),
2796 .sibling_of =
"ip4-rewrite",
2802 .name =
"ip4-mcast-midchain",
2803 .vector_size =
sizeof (
u32),
2806 .sibling_of =
"ip4-rewrite",
2812 .name =
"ip4-midchain",
2813 .vector_size =
sizeof (
u32),
2815 .sibling_of =
"ip4-rewrite",
2852 if (
unformat (input,
"table %d", &table_id))
2856 if ((fib) && (fib->
index != table_id))
2860 else if (
unformat (input,
"count %f", &count))
2873 for (i = 0; i < n; i++)
2878 ip4_base_address.
as_u32 =
2879 clib_host_to_net_u32 (1 +
2880 clib_net_to_host_u32 (ip4_base_address.
as_u32));
2911 .path =
"test lookup",
2912 .short_help =
"test lookup <ipv4-addr> [table <fib-id>] [count <nn>]",
2924 if (~0 == fib_index)
2925 return VNET_API_ERROR_NO_SUCH_FIB;
2940 u32 flow_hash_config = 0;
2945 if (
unformat (input,
"table %d", &table_id))
2948 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;} 2965 case VNET_API_ERROR_NO_SUCH_FIB:
2969 clib_warning (
"BUG: illegal flow hash config 0x%x", flow_hash_config);
3062 .path =
"set ip flow-hash",
3064 "set ip flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
3081 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3084 return VNET_API_ERROR_NO_SUCH_ENTRY;
3091 if (
NULL != if_addr)
3096 .fp_addr.ip4 = *if_addr,
3104 if (table_index != (
u32) ~ 0)
3134 u32 table_index = ~0;
3135 int table_index_set = 0;
3136 u32 sw_if_index = ~0;
3141 if (
unformat (input,
"table-index %d", &table_index))
3142 table_index_set = 1;
3150 if (table_index_set == 0)
3153 if (sw_if_index == ~0)
3163 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3166 case VNET_API_ERROR_NO_SUCH_ENTRY:
3185 .path =
"set ip classify",
3187 "set ip classify intfc <interface> table-index <classify-idx>",
3204 "invalid heap-size parameter `%U'",
static 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 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.
vlib_combined_counter_main_t lbm_to_counters
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)
sll srl srl sll sra u16x4 i
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.
ip4_add_del_interface_address_callback_t * add_del_interface_address_callbacks
Functions to call when interface address changes.
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)
ip_interface_address_t * if_address_pool
Pool of addresses that are assigned to interfaces.
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)
adj_index_t adj_glean_add_or_lock(fib_protocol_t proto, u32 sw_if_index, const ip46_address_t *nh_addr)
Glean Adjacency.
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
static uword ip4_midchain(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
vlib_node_registration_t ip4_lookup_node
(constructor) VLIB_REGISTER_NODE (ip4_lookup_node)
#define vnet_fixup_one_header(rw0, addr, p0)
static int ip4_header_bytes(ip4_header_t *i)
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)
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.
static void * clib_random_buffer_get_data(clib_random_buffer_t *b, uword n_bytes)
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.
#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)
#define vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, bi2, bi3, next0, next1, next2, next3)
Finish enqueueing four buffers forward in the graph.
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, mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags)
Update the entry to have just one path.
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.
unformat_function_t unformat_vnet_sw_interface
static uword ip4_arp(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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.
VNET_FEATURE_ARC_INIT(ip4_unicast, static)
struct ip_adjacency_t_::@38::@40 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
u8 mcast_feature_arc_index
Feature arc indices.
#define hash_v3_mix32(a, b, c)
format_function_t format_vnet_sw_if_index_name
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
ip_lookup_next_t
An adjacency is a representation of an attached L3 peer.
static pg_node_t * pg_get_node(uword node_index)
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.
#define VLIB_BUFFER_NEXT_PRESENT
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.
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
void * vlib_packet_template_get_packet(vlib_main_t *vm, vlib_packet_template_t *t, u32 *bi_result)
#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...
ip_csum_t ip_incremental_checksum(ip_csum_t sum, void *_data, uword n_bytes)
#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.
#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_next_header(ip4_header_t *i)
struct ip_adjacency_t_::@38::@41 glean
IP_LOOKUP_NEXT_GLEAN.
#define clib_error_create(args...)
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)
static int ip4_is_fragment(ip4_header_t *i)
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.
vlib_node_registration_t ip4_input_node
Global ip4 input node.
u16 current_length
Nbytes between current data and the end of this buffer.
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)
clib_error_t * arp_notrace_init(vlib_main_t *vm)
struct ip_adjacency_t_::@38::@39 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
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)
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_local_end_of_arc(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static uword ip4_glean(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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)
ip4_main_t ip4_main
Global ip4 main structure.
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 ...
static uword ip4_load_balance(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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.
load_balance_main_t load_balance_main
The one instance of load-balance main.
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
#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).
vlib_combined_counter_main_t adjacency_counters
Adjacency packet counters.
ip4_fib_mtrie_t mtrie
Mtrie for fast lookups.
vlib_error_t error
Error code for buffers to be enqueued to error handler.
static u8 * format_ip4_lookup_trace(u8 *s, va_list *args)
union ip_adjacency_t_::@38 sub_type
clib_error_t * ip4_probe_neighbor(vlib_main_t *vm, ip4_address_t *dst, u32 sw_if_index)
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)
static uword ip4_policer_classify(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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,...)
static void vlib_buffer_copy_trace_flag(vlib_main_t *vm, vlib_buffer_t *b, u32 bi_target)
static_always_inline uword vlib_get_thread_index(void)
#define CLIB_PREFETCH(addr, size, type)
#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.
#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)
int ip4_lookup_validate(ip4_address_t *a, u32 fib_index0)
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.
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 void ip4_addr_fib_init(ip4_address_fib_t *addr_fib, ip4_address_t *address, u32 fib_index)
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)
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
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 uword ip4_drop(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static load_balance_t * load_balance_get(index_t lbi)
#define hash_v3_finalize32(a, b, c)
The default route source.
static clib_error_t * fib_module_init(vlib_main_t *vm)
vlib_node_registration_t ip4_glean_node
(constructor) VLIB_REGISTER_NODE (ip4_glean_node)
VLIB_NODE_FUNCTION_MULTIARCH(ip4_lookup_node, ip4_lookup)
u32 next_buffer
Next buffer for this linked-list of buffers.
#define ip4_local_do_l4_check(is_tcp_udp, flags)
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.
#define VLIB_NODE_FLAG_TRACE
vnet_classify_main_t vnet_classify_main
vlib_node_registration_t ip4_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip4_rewrite_mcast_node)
Route added as a result of interface configuration.
clib_error_t * ip4_lookup_init(vlib_main_t *vm)
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
#define VNET_FEATURES(...)
static vlib_main_t * vlib_get_main(void)
static uword is_pow2(uword x)
static uword ip4_local(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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.
u8 ucast_feature_arc_index
u16 ip4_tcp_udp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip4_header_t *ip0)
index_t dpoi_index
the index of objects of that type
static void ip4_local_validate_l4(vlib_main_t *vm, vlib_buffer_t *p, ip4_header_t *ip, u8 is_udp, u8 *error, u8 *good_tcp_udp)
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.
#define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
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.
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_physmem_alloc, char *fmt,...)
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 uword ip4_flow_classify(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define clib_mem_unaligned(pointer, type)
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)
#define VLIB_REGISTER_NODE(x,...)
static uword ip4_mcast_midchain(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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)
static uword ip4_rewrite_mcast(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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 void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
static uword ip4_lookup(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
IPv4 lookup node.
static uword ip4_rewrite(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
IPv4 rewrite node.
#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)
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
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 uword ip4_vxlan_bypass(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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)
clib_random_buffer_t random_buffer
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[]
static uword ip4_lookup_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int lookup_for_responses_to_locally_received_packets)
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)
static vlib_node_registration_t ip4_local_end_of_arc_node
(constructor) VLIB_REGISTER_NODE (ip4_local_end_of_arc_node)
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.