55 #define OI_DECAP 0x80000000 71 u32 n_left_from, n_left_to_next, *from, *to_next;
79 while (n_left_from > 0)
83 while (n_left_from >= 4 && n_left_to_next >= 2)
86 u32 pi0, pi1, lbi0, lbi1, wrong_next;
90 u32 fib_index0, fib_index1;
91 u32 flow_hash_config0, flow_hash_config1;
108 pi0 = to_next[0] = from[0];
109 pi1 = to_next[1] = from[1];
177 (ip0->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
183 (ip1->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
201 wrong_next = (next0 != next) + 2 * (next1 != next);
239 while (n_left_from > 0 && n_left_to_next > 0)
247 u32 fib_index0, flow_hash_config0;
297 (ip0->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
343 .fp_addr.ip6 = *address,
365 u32 classify_table_index =
367 if (classify_table_index != (
u32) ~ 0)
402 .fp_addr.ip6 = *address,
470 u32 address_length,
u32 is_del)
476 u32 if_address_index;
477 ip6_address_fib_t ip6_af, *addr_fib = 0;
480 if (sw_if_index == 0)
497 (lm, sw_if_index, addr_fib, address_length, is_del, &if_address_index);
512 im, ip6_af.fib_index,
520 address, address_length, if_address_index, is_del);
534 u32 is_admin_up, fib_index;
540 lookup_main.if_address_pool_index_by_sw_if_index,
551 a = ip_interface_address_get_address (&im->lookup_main, ia);
553 ip6_add_interface_routes (vnm, sw_if_index,
557 ip6_del_interface_routes (im, fib_index,
558 a, ia->address_length);
571 .arc_name =
"ip6-unicast",
578 .arc_name =
"ip6-unicast",
579 .node_name =
"ip6-flow-classify",
585 .arc_name =
"ip6-unicast",
586 .node_name =
"ip6-inacl",
592 .arc_name =
"ip6-unicast",
593 .node_name =
"ip6-policer-classify",
599 .arc_name =
"ip6-unicast",
600 .node_name =
"ipsec-input-ip6",
606 .arc_name =
"ip6-unicast",
607 .node_name =
"l2tp-decap",
613 .arc_name =
"ip6-unicast",
614 .node_name =
"vpath-input-ip6",
620 .arc_name =
"ip6-unicast",
621 .node_name =
"ip6-vxlan-bypass",
627 .arc_name =
"ip6-unicast",
628 .node_name =
"ip6-drop",
634 .arc_name =
"ip6-unicast",
635 .node_name =
"ip6-lookup",
642 .arc_name =
"ip6-multicast",
648 .arc_name =
"ip6-multicast",
649 .node_name =
"vpath-input-ip6",
654 .arc_name =
"ip6-multicast",
655 .node_name =
"ip6-drop",
660 .arc_name =
"ip6-multicast",
661 .node_name =
"ip6-mfib-forward-lookup",
668 .arc_name =
"ip6-output",
669 .start_nodes =
VNET_FEATURES (
"ip6-rewrite",
"ip6-midchain"),
674 .arc_name =
"ip6-output",
675 .node_name =
"ipsec-output-ip6",
680 .arc_name =
"ip6-output",
681 .node_name =
"interface-output",
738 .name =
"ip6-lookup",
739 .vector_size =
sizeof (
u32),
740 .format_trace = format_ip6_lookup_trace,
753 u32 n_left_from, n_left_to_next, *from, *to_next;
765 while (n_left_from > 0)
770 while (n_left_from >= 4 && n_left_to_next >= 2)
775 u32 pi0, lbi0, hc0, pi1, lbi1, hc1;
793 pi0 = to_next[0] = from[0];
794 pi1 = to_next[1] = from[1];
868 (ip0->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
875 (ip1->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
890 to_next, n_left_to_next,
891 pi0, pi1, next0, next1);
894 while (n_left_from > 0 && n_left_to_next > 0)
945 (ip0->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
955 to_next, n_left_to_next,
969 .name =
"ip6-load-balance",
970 .vector_size =
sizeof (
u32),
971 .sibling_of =
"ip6-lookup",
972 .format_trace = format_ip6_lookup_trace,
986 u8 packet_data[128 - 1 *
sizeof (
u32)];
995 ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
1009 ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
1012 s =
format (s,
"fib %d dpo-idx %d flow hash: 0x%08x",
1026 ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
1029 s =
format (s,
"tx_sw_if_index %d adj-idx %d : %U flow hash: 0x%08x",
1055 ip6_forward_next_trace_t *t0, *t1;
1105 ip6_forward_next_trace_t *t0;
1137 u16 sum16, payload_length_host_byte_order;
1138 u32 i, n_this_buffer, n_bytes_left;
1139 u32 headers_size =
sizeof (ip0[0]);
1140 void *data_this_buffer;
1147 payload_length_host_byte_order = clib_net_to_host_u16 (ip0->
payload_length);
1148 data_this_buffer = (
void *) (ip0 + 1);
1154 src_address.as_uword[i],
1167 ip6_hop_by_hop_ext_t *ext_hdr =
1168 (ip6_hop_by_hop_ext_t *) data_this_buffer;
1171 ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1172 || (ext_hdr->next_hdr == IP_PROTOCOL_UDP));
1174 skip_bytes = 8 * (1 + ext_hdr->n_data_u64s);
1175 data_this_buffer = (
void *) ((
u8 *) data_this_buffer + skip_bytes);
1177 payload_length_host_byte_order -= skip_bytes;
1178 headers_size += skip_bytes;
1181 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1189 n_bytes_left -= n_this_buffer;
1190 if (n_bytes_left == 0)
1218 || ip0->
protocol == IP_PROTOCOL_ICMP6
1219 || ip0->
protocol == IP_PROTOCOL_UDP
1220 || ip0->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS);
1222 udp0 = (
void *) (ip0 + 1);
1225 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1226 | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1232 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1233 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1263 if (proto0 != IP_PROTOCOL_UDP)
1266 proto0 = (proto0 == IP_PROTOCOL_TCP) ? proto0 : 0;
1274 .arc_name =
"ip6-local",
1286 u32 *from, *to_next, n_left_from, n_left_to_next;
1289 u8 arc_index = vnet_feat_arc_ip6_local.feature_arc_index;
1298 while (n_left_from > 0)
1302 while (n_left_from >= 4 && n_left_to_next >= 2)
1307 u32 pi0, ip_len0, udp_len0, flags0, next0;
1308 u32 pi1, ip_len1, udp_len1, flags1, next1;
1309 i32 len_diff0, len_diff1;
1310 u8 error0, type0, good_l4_csum0, is_tcp_udp0;
1311 u8 error1, type1, good_l4_csum1, is_tcp_udp1;
1312 u32 udp_offset0, udp_offset1;
1314 pi0 = to_next[0] = from[0];
1315 pi1 = to_next[1] = from[1];
1319 n_left_to_next -= 2;
1321 error0 = error1 = IP6_ERROR_UNKNOWN_PROTOCOL;
1329 if (head_of_feature_arc == 0)
1344 good_l4_csum0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT
1345 || (flags0 & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM
1346 || flags0 & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
1348 good_l4_csum1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT
1349 || (flags1 & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM
1350 || flags1 & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
1362 if (is_tcp_udp0 == IP_PROTOCOL_UDP)
1365 udp_len0 = clib_net_to_host_u16 (udp0->
length);
1366 len_diff0 = ip_len0 - udp_len0;
1376 if (is_tcp_udp1 == IP_PROTOCOL_UDP)
1379 udp_len1 = clib_net_to_host_u16 (udp1->
length);
1380 len_diff1 = ip_len1 - udp_len1;
1393 VNET_BUFFER_F_L4_CHECKSUM_COMPUTED)))
1397 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1402 VNET_BUFFER_F_L4_CHECKSUM_COMPUTED)))
1406 (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1409 error0 = error1 = IP6_ERROR_UNKNOWN_PROTOCOL;
1410 error0 = len_diff0 < 0 ? IP6_ERROR_UDP_LENGTH : error0;
1411 error1 = len_diff1 < 0 ? IP6_ERROR_UDP_LENGTH : error1;
1414 IP6_ERROR_UDP_CHECKSUM);
1416 IP6_ERROR_ICMP_CHECKSUM);
1417 error0 = (!good_l4_csum0 ? IP6_ERROR_UDP_CHECKSUM + type0 : error0);
1418 error1 = (!good_l4_csum1 ? IP6_ERROR_UDP_CHECKSUM + type1 : error1);
1422 if (error0 == IP6_ERROR_UNKNOWN_PROTOCOL &&
1427 ? IP6_ERROR_SRC_LOOKUP_MISS : error0);
1429 if (error1 == IP6_ERROR_UNKNOWN_PROTOCOL &&
1434 ? IP6_ERROR_SRC_LOOKUP_MISS : error1);
1468 if (head_of_feature_arc)
1473 [VLIB_RX], &next0, p0);
1477 [VLIB_RX], &next1, p1);
1481 to_next, n_left_to_next,
1482 pi0, pi1, next0, next1);
1485 while (n_left_from > 0 && n_left_to_next > 0)
1490 u32 pi0, ip_len0, udp_len0, flags0, next0;
1492 u8 error0, type0, good_l4_csum0;
1496 pi0 = to_next[0] = from[0];
1500 n_left_to_next -= 1;
1502 error0 = IP6_ERROR_UNKNOWN_PROTOCOL;
1507 if (head_of_feature_arc == 0)
1515 good_l4_csum0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT
1516 || (flags0 & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM
1517 || flags0 & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
1529 if (is_tcp_udp0 == IP_PROTOCOL_UDP)
1532 udp_len0 = clib_net_to_host_u16 (udp0->
length);
1533 len_diff0 = ip_len0 - udp_len0;
1543 VNET_BUFFER_F_L4_CHECKSUM_COMPUTED)))
1547 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1550 error0 = IP6_ERROR_UNKNOWN_PROTOCOL;
1551 error0 = len_diff0 < 0 ? IP6_ERROR_UDP_LENGTH : error0;
1554 IP6_ERROR_UDP_CHECKSUM);
1556 IP6_ERROR_ICMP_CHECKSUM);
1557 error0 = (!good_l4_csum0 ? IP6_ERROR_UDP_CHECKSUM + type0 : error0);
1560 if (error0 == IP6_ERROR_UNKNOWN_PROTOCOL &&
1565 ? IP6_ERROR_SRC_LOOKUP_MISS : error0);
1583 if (head_of_feature_arc)
1588 [VLIB_RX], &next0, p0);
1592 to_next, n_left_to_next,
1612 .name =
"ip6-local",
1613 .vector_size =
sizeof (
u32),
1639 .name =
"ip6-local-end-of-arc",
1640 .vector_size =
sizeof (
u32),
1643 .sibling_of =
"ip6-local",
1649 .arc_name =
"ip6-local",
1650 .node_name =
"ip6-local-end-of-arc",
1689 u32 *from, *to_next_drop;
1690 uword n_left_from, n_left_to_next_drop;
1691 static f64 time_last_seed_change = -1e100;
1692 static u32 hash_seeds[3];
1701 if (time_now - time_last_seed_change > 1e-3)
1705 sizeof (hash_seeds));
1706 for (i = 0; i <
ARRAY_LEN (hash_seeds); i++)
1707 hash_seeds[i] = r[i];
1710 for (i = 0; i <
ARRAY_LEN (hash_bitmap); i++)
1713 time_last_seed_change = time_now;
1719 while (n_left_from > 0)
1722 to_next_drop, n_left_to_next_drop);
1724 while (n_left_from > 0 && n_left_to_next_drop > 0)
1728 u32 pi0, adj_index0, a0, b0, c0, m0, sw_if_index0, drop0;
1756 sw_if_index0 = adj0->rewrite_header.sw_if_index;
1770 c0 &=
BITS (hash_bitmap) - 1;
1774 bm0 = hash_bitmap[c0];
1775 drop0 = (bm0 & m0) != 0;
1778 hash_bitmap[c0] = bm0 | m0;
1782 to_next_drop[0] = pi0;
1784 n_left_to_next_drop -= 1;
1807 icmp6_neighbor_solicitation_header_t *h0;
1820 &h0->ip.src_address))
1840 clib_memcpy (h0->link_layer_option.ethernet_address,
1844 h0->neighbor.icmp.checksum = 0;
1845 h0->neighbor.icmp.checksum =
1849 ASSERT (bogus_length == 0);
1867 n_left_to_next_drop);
1890 =
"no source address for ND solicitation",
1897 .name =
"ip6-discover-neighbor",
1898 .vector_size =
sizeof (
u32),
1900 .n_errors =
ARRAY_LEN (ip6_discover_neighbor_error_strings),
1915 .name =
"ip6-glean",
1916 .vector_size =
sizeof (
u32),
1918 .n_errors =
ARRAY_LEN (ip6_discover_neighbor_error_strings),
1934 icmp6_neighbor_solicitation_header_t *
h;
1959 vnm->
api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE;
1961 (0,
"no matching interface address for destination %U (interface %U)",
1975 h->ip.dst_address.as_u8[13] = dst->
as_u8[13];
1976 h->ip.dst_address.as_u8[14] = dst->
as_u8[14];
1977 h->ip.dst_address.as_u8[15] = dst->
as_u8[15];
1979 h->ip.src_address = src[0];
1980 h->neighbor.target_address = dst[0];
1993 h->neighbor.icmp.checksum =
1995 ASSERT (bogus_length == 0);
2002 ip46_address_t nh = {
2043 int do_counters,
int is_midchain,
int is_mcast)
2047 u32 n_left_from, n_left_to_next, *to_next, next_index;
2055 while (n_left_from > 0)
2059 while (n_left_from >= 4 && n_left_to_next >= 2)
2064 u32 pi0, rw_len0, next0, error0, adj_index0;
2065 u32 pi1, rw_len1, next1, error1, adj_index1;
2066 u32 tx_sw_if_index0, tx_sw_if_index1;
2085 pi0 = to_next[0] = from[0];
2086 pi1 = to_next[1] = from[1];
2091 n_left_to_next -= 2;
2102 error0 = error1 = IP6_ERROR_NONE;
2122 error0 = IP6_ERROR_TIME_EXPIRED;
2126 ICMP6_time_exceeded_ttl_exceeded_in_transit,
2132 p0->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2151 error1 = IP6_ERROR_TIME_EXPIRED;
2155 ICMP6_time_exceeded_ttl_exceeded_in_transit,
2161 p1->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2166 rw_len0 = adj0[0].rewrite_header.data_bytes;
2167 rw_len1 = adj1[0].rewrite_header.data_bytes;
2168 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2169 vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
2175 thread_index, adj_index0, 1,
2179 thread_index, adj_index1, 1,
2187 rewrite_header.max_l3_packet_bytes ? IP6_ERROR_MTU_EXCEEDED :
2192 rewrite_header.max_l3_packet_bytes ? IP6_ERROR_MTU_EXCEEDED :
2202 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2204 next0 = adj0[0].rewrite_header.next_index;
2209 tx_sw_if_index0, &next0, p0);
2216 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
2218 next1 = adj1[0].rewrite_header.next_index;
2223 tx_sw_if_index1, &next1, p1);
2245 to_next, n_left_to_next,
2246 pi0, pi1, next0, next1);
2249 while (n_left_from > 0 && n_left_to_next > 0)
2255 u32 adj_index0, next0, error0;
2256 u32 tx_sw_if_index0;
2258 pi0 = to_next[0] = from[0];
2268 error0 = IP6_ERROR_NONE;
2288 error0 = IP6_ERROR_TIME_EXPIRED;
2292 ICMP6_time_exceeded_ttl_exceeded_in_transit,
2298 p0->
flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2305 rw_len0 = adj0[0].rewrite_header.data_bytes;
2306 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2312 thread_index, adj_index0, 1,
2320 rewrite_header.max_l3_packet_bytes ? IP6_ERROR_MTU_EXCEEDED :
2330 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2333 next0 = adj0[0].rewrite_header.next_index;
2338 tx_sw_if_index0, &next0, p0);
2355 n_left_to_next -= 1;
2358 to_next, n_left_to_next,
2416 .name =
"ip6-midchain",
2417 .vector_size =
sizeof (
u32),
2419 .sibling_of =
"ip6-rewrite",
2429 .name =
"ip6-rewrite",
2430 .vector_size =
sizeof (
u32),
2447 .name =
"ip6-rewrite-mcast",
2448 .vector_size =
sizeof (
u32),
2450 .sibling_of =
"ip6-rewrite",
2460 .name =
"ip6-mcast-midchain",
2461 .vector_size =
sizeof (
u32),
2463 .sibling_of =
"ip6-rewrite",
2474 #define foreach_ip6_hop_by_hop_error \ 2475 _(PROCESSED, "pkts with ip6 hop-by-hop options") \ 2476 _(FORMAT, "incorrectly formatted hop-by-hop options") \ 2477 _(UNKNOWN_OPTION, "unknown ip6 hop-by-hop options") 2482 #define _(sym,str) IP6_HOP_BY_HOP_ERROR_##sym, 2503 #define _(sym,string) string, 2512 int total_len = va_arg (*args,
int);
2517 s =
format (s,
"IP6_HOP_BY_HOP: next protocol %d len %d total %d",
2523 while (opt0 < limit0)
2533 if (hm->
trace[type0])
2535 s = (*hm->
trace[type0]) (s, opt0);
2540 format (s,
"\n unrecognized option %d length %d", type0,
2566 s =
format (s,
"IP6_HOP_BY_HOP: next index %d len %d traced %d",
2572 while (opt0 < limit0)
2582 if (hm->
trace[type0])
2584 s = (*hm->
trace[type0]) (s, opt0);
2589 format (s,
"\n unrecognized option %d length %d", type0,
2612 while (opt0 < limit0)
2625 if ((*hm->
options[type0]) (b0, ip0, opt0) < 0)
2627 error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2639 error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2643 error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2646 ICMP6_parameter_problem_unrecognized_option,
2647 (
u8 *) opt0 - (
u8 *) ip0);
2650 error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2655 ICMP6_parameter_problem,
2656 ICMP6_parameter_problem_unrecognized_option,
2657 (
u8 *) opt0 - (
u8 *) ip0);
2685 u32 n_left_from, *from, *to_next;
2692 while (n_left_from > 0)
2698 while (n_left_from >= 4 && n_left_to_next >= 2)
2706 u8 error0 = 0, error1 = 0;
2723 to_next[0] = bi0 = from[0];
2724 to_next[1] = bi1 = from[1];
2728 n_left_to_next -= 2;
2751 ((hbh0->
length + 1) << 3));
2754 ((hbh1->
length + 1) << 3));
2759 if ((hbh0->
length + 1) << 3 >
2762 error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2769 if ((hbh1->
length + 1) << 3 >
2772 error1 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2798 u32 trace_len = (hbh0->
length + 1) << 3;
2812 u32 trace_len = (hbh1->
length + 1) << 3;
2830 n_left_to_next, bi0, bi1, next0,
2834 while (n_left_from > 0 && n_left_to_next > 0)
2850 n_left_to_next -= 1;
2866 ((hbh0->
length + 1) << 3));
2871 if ((hbh0->
length + 1) << 3 >
2874 error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2893 u32 trace_len = (hbh0->
length + 1) << 3;
2908 n_left_to_next, bi0, next0);
2919 .name =
"ip6-hop-by-hop",
2920 .sibling_of =
"ip6-lookup",
2921 .vector_size =
sizeof (
u32),
2924 .n_errors =
ARRAY_LEN (ip6_hop_by_hop_error_strings),
2967 hm->
options[option] = options;
2994 for (i = 0; i < 256; i++)
3028 for (j = 0; j < i0; j++)
3033 clib_host_to_net_u32 (
pow2_mask (i1) << (32 - i1));
3047 "ip6 FIB fwding table",
3050 "ip6 FIB non-fwding table",
3069 icmp6_neighbor_solicitation_header_t p;
3071 memset (&p, 0,
sizeof (p));
3073 p.ip.ip_version_traffic_class_and_flow_label =
3074 clib_host_to_net_u32 (0x6 << 28);
3075 p.ip.payload_length =
3076 clib_host_to_net_u16 (
sizeof (p) -
3078 (icmp6_neighbor_solicitation_header_t, neighbor));
3079 p.ip.protocol = IP_PROTOCOL_ICMP6;
3080 p.ip.hop_limit = 255;
3083 p.neighbor.icmp.type = ICMP6_neighbor_solicitation;
3085 p.link_layer_option.header.type =
3086 ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address;
3087 p.link_layer_option.header.n_data_u64s =
3088 sizeof (p.link_layer_option) /
sizeof (
u64);
3094 "ip6 neighbor discovery");
3106 ip->
as_u64[0] = clib_host_to_net_u64 (0xFE80000000000000ULL);
3108 ip->
as_u8[8] = mac[0] ^ (1 << 1);
3109 ip->
as_u8[9] = mac[1];
3110 ip->
as_u8[10] = mac[2];
3111 ip->
as_u8[11] = 0xFF;
3112 ip->
as_u8[12] = 0xFE;
3113 ip->
as_u8[13] = mac[3];
3114 ip->
as_u8[14] = mac[4];
3115 ip->
as_u8[15] = mac[5];
3123 mac[0] = ip->
as_u8[8] ^ (1 << 1);
3124 mac[1] = ip->
as_u8[9];
3125 mac[2] = ip->
as_u8[10];
3126 mac[3] = ip->
as_u8[13];
3127 mac[4] = ip->
as_u8[14];
3128 mac[5] = ip->
as_u8[15];
3164 .path =
"test ip6 link",
3166 .short_help =
"test ip6 link <mac-address>",
3177 if (~0 == fib_index)
3178 return VNET_API_ERROR_NO_SUCH_FIB;
3193 u32 flow_hash_config = 0;
3198 if (
unformat (input,
"table %d", &table_id))
3201 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;} 3222 clib_warning (
"BUG: illegal flow hash config 0x%x", flow_hash_config);
3307 .path =
"set ip6 flow-hash",
3309 "set ip6 flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
3356 .path =
"show ip6 local",
3358 .short_help =
"show ip6 local",
3374 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3377 return VNET_API_ERROR_NO_SUCH_ENTRY;
3384 if (
NULL != if_addr)
3389 .fp_addr.ip6 = *if_addr,
3397 if (table_index != (
u32) ~ 0)
3427 u32 table_index = ~0;
3428 int table_index_set = 0;
3429 u32 sw_if_index = ~0;
3434 if (
unformat (input,
"table-index %d", &table_index))
3435 table_index_set = 1;
3443 if (table_index_set == 0)
3446 if (sw_if_index == ~0)
3456 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3459 case VNET_API_ERROR_NO_SUCH_ENTRY:
3478 .path =
"set ip6 classify",
3480 "set ip6 classify intfc <interface> table-index <classify-idx>",
3495 if (
unformat (input,
"hash-buckets %d", &tmp))
3497 else if (
unformat (input,
"heap-size %U",
static uword ip6_rewrite(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u8 * format_ip6_forward_next_trace(u8 *s, va_list *args)
#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.
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP
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
static uword ip6_local_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int head_of_feature_arc)
sll srl srl sll sra u16x4 i
static u8 * format_ip6_lookup_trace(u8 *s, va_list *args)
static int fib_urpf_check_size(index_t ui)
Data-Plane function to check the size of an uRPF list, (i.e.
format_function_t format_vlib_node_name
static u8 ip6_next_proto_is_tcp_udp(vlib_buffer_t *p0, ip6_header_t *ip0, u32 *udp_offset0)
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 vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
static uword ip6_midchain(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
#define IP6_LOOKUP_NEXT_NODES
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
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 uword ip6_glean(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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 * set_ip6_classify_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
vnet_interface_main_t interface_main
static u8 ip6_scan_hbh_options(vlib_buffer_t *b0, ip6_header_t *ip0, ip6_hop_by_hop_header_t *hbh0, ip6_hop_by_hop_option_t *opt0, ip6_hop_by_hop_option_t *limit0, u32 *next0)
The table that stores ALL routes learned by the DP.
#define foreach_ip6_hop_by_hop_error
static ip6_address_t * ip6_interface_address_matching_destination(ip6_main_t *im, ip6_address_t *dst, u32 sw_if_index, ip_interface_address_t **result_ia)
vlib_node_registration_t ip6_lookup_node
(constructor) VLIB_REGISTER_NODE (ip6_lookup_node)
#define vnet_fixup_one_header(rw0, addr, p0)
static uword ip6_rewrite_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int do_counters, int is_midchain, int is_mcast)
static u8 * format_ip6_rewrite_trace(u8 *s, va_list *args)
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)
u8 * ip_enabled_by_sw_if_index
This packet is to be rewritten and forwarded to the next processing node.
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
int ip6_hbh_unregister_option(u8 option)
struct _vlib_node_registration vlib_node_registration_t
static clib_error_t * ip6_config(vlib_main_t *vm, unformat_input_t *input)
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.
#define STRUCT_OFFSET_OF(t, f)
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static clib_error_t * test_ip6_link_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
u32 ip6_neighbor_sw_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
create and initialize router advertisement parameters with default values for this intfc ...
unformat_function_t unformat_vnet_sw_interface
vlib_node_registration_t ip6_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_mcast_node)
#define VNET_HW_INTERFACE_FLAG_LINK_UP
static u32 ip6_fib_table_fwding_lookup(ip6_main_t *im, u32 fib_index, const ip6_address_t *dst)
vlib_error_t * errors
Vector of errors for this node.
static char * ip6_hop_by_hop_error_strings[]
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
static uword ip6_load_balance(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
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)
static uword ip6_hop_by_hop(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
ip_lookup_next_t
An adjacency is a representation of an attached L3 peer.
uword as_uword[16/sizeof(uword)]
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(ip6_sw_interface_add_del)
static pg_node_t * pg_get_node(uword node_index)
static uword ip6_vxlan_bypass(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
VNET_FEATURE_ARC_INIT(ip6_unicast, static)
ip6_discover_neighbor_error_t
vlib_packet_template_t discover_neighbor_packet_template
u32 ip6_tcp_udp_icmp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
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.
clib_error_t * ip6_sw_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
#define VLIB_BUFFER_NEXT_PRESENT
static u8 * format_ip6_hop_by_hop_trace(u8 *s, va_list *args)
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
u8 * format_ethernet_address(u8 *s, va_list *args)
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...
static clib_error_t * show_ip6_local_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
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)
u16 lb_n_buckets_minus_1
number of buckets in the load-balance - 1.
static vlib_node_registration_t ip6_mcast_midchain_node
(constructor) VLIB_REGISTER_NODE (ip6_mcast_midchain_node)
static clib_error_t * set_ip6_flow_hash_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
#define IP6_FIB_DEFAULT_HASH_NUM_BUCKETS
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...)
u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]
Space for inserting data before buffer start.
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
#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)
u8 * format_ip6_hop_by_hop_ext_hdr(u8 *s, va_list *args)
static clib_error_t * vnet_feature_init(vlib_main_t *vm)
static uword ip6_discover_neighbor_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int is_glean)
static uword ip6_flow_classify(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
void icmp6_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
u32 lookup_table_nbuckets
static int ip6_src_address_for_packet(ip_lookup_main_t *lm, u32 sw_if_index, ip6_address_t *src)
u8 packet_data[128-1 *sizeof(u32)]
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.
u16 current_length
Nbytes between current data and the end of this buffer.
VLIB_NODE_FUNCTION_MULTIARCH(ip6_lookup_node, ip6_lookup)
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.
index_t classify_dpo_create(dpo_proto_t proto, u32 classify_table_index)
static void ip6_del_interface_routes(ip6_main_t *im, u32 fib_index, ip6_address_t *address, u32 address_length)
struct ip_adjacency_t_::@38::@39 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
vlib_node_registration_t ip6_input_node
(constructor) VLIB_REGISTER_NODE (ip6_input_node)
#define IP6_FIB_DEFAULT_HASH_MEMORY_SIZE
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.
int vnet_set_ip6_flow_hash(u32 table_id, u32 flow_hash_config)
static u32 ip6_compute_flow_hash(const ip6_header_t *ip, flow_hash_config_t flow_hash_config)
u8 local_next_by_ip_protocol[256]
Table mapping ip protocol to ip[46]-local node next index.
static clib_error_t * ip6_hop_by_hop_init(vlib_main_t *vm)
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.
VNET_FEATURE_INIT(ip6_flow_classify, static)
#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).
int ip6_hbh_register_option(u8 option, int options(vlib_buffer_t *b, ip6_header_t *ip, ip6_hop_by_hop_option_t *opt), u8 *trace(u8 *s, ip6_hop_by_hop_option_t *opt))
void clib_bihash_init(clib_bihash *h, char *name, u32 nbuckets, uword memory_size)
initialize a bounded index extensible hash table
vlib_combined_counter_main_t adjacency_counters
Adjacency packet counters.
ip6_add_del_interface_address_callback_t * add_del_interface_address_callbacks
void ip6_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
vlib_error_t error
Error code for buffers to be enqueued to error handler.
union ip_adjacency_t_::@38 sub_type
static uword ip6_local(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
ip6_address_t fib_masks[129]
void ip6_mfib_interface_enable_disable(u32 sw_if_index, int is_enable)
Add/remove the interface from the accepting list of the special MFIB entries.
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
Adjacency to drop this packet.
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)
ip6_address_t * ip6_interface_first_address(ip6_main_t *im, u32 sw_if_index)
get first IPv6 interface address
#define vec_free(V)
Free vector's memory (no header).
static vlib_node_registration_t ip6_local_node
(constructor) VLIB_REGISTER_NODE (ip6_local_node)
void fib_table_entry_delete(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Delete a FIB entry.
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.
clib_error_t * ip6_sw_interface_admin_up_down(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
vlib_node_registration_t ip6_midchain_node
(constructor) VLIB_REGISTER_NODE (ip6_midchain_node)
#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.
clib_error_t * ip6_probe_neighbor(vlib_main_t *vm, ip6_address_t *dst, u32 sw_if_index)
This table stores the routes that are used to forward traffic.
#define clib_memcpy(a, b, c)
unformat_function_t * unformat_edit
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.
static void ip6_addr_fib_init(ip6_address_fib_t *addr_fib, ip6_address_t *address, u32 fib_index)
void ip6_ethernet_mac_address_from_link_local_address(u8 *mac, ip6_address_t *ip)
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
u8 builtin_protocol_by_ip_protocol[256]
IP_BUILTIN_PROTOCOL_{TCP,UDP,ICMP,OTHER} by protocol in IP header.
#define VLIB_CLI_COMMAND(x,...)
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...
ip6_add_del_interface_address_function_t * function
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
void ip6_register_protocol(u32 protocol, u32 node_index)
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
static uword ip6_local_end_of_arc(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
uword unformat_ethernet_address(unformat_input_t *input, va_list *args)
vlib_node_registration_t ip6_discover_neighbor_node
(constructor) VLIB_REGISTER_NODE (ip6_discover_neighbor_node)
index_t lb_urpf
This is the index of the uRPF list for this LB.
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(ip6_sw_interface_admin_up_down)
ip6_hop_by_hop_main_t ip6_hop_by_hop_main
ip_lookup_main_t lookup_main
void ip6_hbh_set_next_override(uword next)
static vlib_node_registration_t ip6_local_end_of_arc_node
(constructor) VLIB_REGISTER_NODE (ip6_local_end_of_arc_node)
static load_balance_t * load_balance_get(index_t lbi)
#define hash_v3_finalize32(a, b, c)
The default route source.
static uword ip6_discover_neighbor(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
vlib_node_registration_t ip6_glean_node
(constructor) VLIB_REGISTER_NODE (ip6_glean_node)
u32 next_buffer
Next buffer for this linked-list of buffers.
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 ip6_hop_by_hop_node
(constructor) VLIB_REGISTER_NODE (ip6_hop_by_hop_node)
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP_NOT_MCAST
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
int vnet_set_ip6_classify_intfc(vlib_main_t *vm, u32 sw_if_index, u32 table_index)
static char * ip6_discover_neighbor_error_strings[]
Route added as a result of interface configuration.
ip6_fib_table_instance_t ip6_table[IP6_FIB_NUM_TABLES]
The two FIB tables; fwding and non-fwding.
#define VNET_FEATURES(...)
static int ip6_locate_header(vlib_buffer_t *p0, ip6_header_t *ip0, int find_hdr_type, u32 *offset)
static vlib_main_t * vlib_get_main(void)
vlib_node_registration_t ip6_rewrite_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_node)
static uword is_pow2(uword x)
static uword ip6_mcast_midchain(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
static uword ip6_lookup_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
This packets needs to go to ICMP error.
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
u32 ip6_fib_table_fwding_lookup_with_if_index(ip6_main_t *im, u32 sw_if_index, const ip6_address_t *dst)
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN
static uword ip6_address_is_multicast(ip6_address_t *a)
index_t dpoi_index
the index of objects of that type
static void ip6_set_solicited_node_multicast_address(ip6_address_t *a, u32 id)
static uword ip6_address_is_link_local_unicast(ip6_address_t *a)
static uword ip6_rewrite_mcast(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#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.
static uword max_log2(uword x)
void ip6_link_local_address_from_ethernet_mac_address(ip6_address_t *ip, u8 *mac)
vnet_sw_interface_t * sw_interfaces
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
#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,...)
static void ip6_add_interface_routes(vnet_main_t *vnm, u32 sw_if_index, ip6_main_t *im, u32 fib_index, ip_interface_address_t *a)
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.
#define clib_mem_unaligned(pointer, type)
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
static uword ip6_policer_classify(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u8 *(* trace[256])(u8 *s, ip6_hop_by_hop_option_t *opt)
#define VLIB_REGISTER_NODE(x,...)
static int ip6_urpf_loose_check(ip6_main_t *im, vlib_buffer_t *b, ip6_header_t *i)
returns number of links on which src is reachable.
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
#define HBH_OPTION_TYPE_SKIP_UNKNOWN
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.
u16 flags
Copy of main node flags.
static uword ip6_drop(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u16 dpoi_next_node
The next VLIB node to follow.
static void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
int(* options[256])(vlib_buffer_t *b, ip6_header_t *ip, ip6_hop_by_hop_option_t *opt)
clib_error_t * ip6_add_del_interface_address(vlib_main_t *vm, u32 sw_if_index, ip6_address_t *address, u32 address_length, u32 is_del)
static clib_error_t * ip6_lookup_init(vlib_main_t *vm)
#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)
static uword ip6_lookup(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define vnet_rewrite_two_headers(rw0, rw1, p0, p1, most_likely_size)
#define CLIB_CACHE_LINE_BYTES
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
vlib_node_registration_t ip6_load_balance_node
(constructor) VLIB_REGISTER_NODE (ip6_load_balance_node)
This adjacency/interface has output features configured.
ip6_discover_neighbor_next_t
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
u32 * fib_index_by_sw_if_index
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
#define HBH_OPTION_TYPE_HIGH_ORDER_BITS
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.
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_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.