54 #ifndef CLIB_MARCH_VARIANT 61 #define OI_DECAP 0x80000000 75 .fp_len = address_length,
79 address->as_u64[0] & im->
fib_masks[address_length].as_u64[0],
80 address->as_u64[1] & im->
fib_masks[address_length].as_u64[1],
104 if (address_length < 128)
143 if (classify_table_index != (
u32) ~ 0)
182 .fp_len = address_length,
186 address->as_u64[0] & im->
fib_masks[address_length].as_u64[0],
187 address->as_u64[1] & im->
fib_masks[address_length].as_u64[1],
209 if (address_length <= 128)
232 address, address_length);
237 #ifndef CLIB_MARCH_VARIANT 268 sw_if_index, !is_enable, 0, 0);
282 ip6_address_t *result = 0;
300 u32 address_length,
u32 is_del)
306 u32 if_address_index;
307 ip6_address_fib_t ip6_af, *addr_fib = 0;
308 const ip6_address_t *ll_addr;
311 if (sw_if_index == 0)
319 if (address_length != 128)
321 vnm->
api_errno = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
324 (
"prefix length of link-local address must be 128");
343 vnm->
api_errno = VNET_API_ERROR_ADDRESS_NOT_DELETABLE;
348 vnm->
api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
373 if (im->fib_index_by_sw_if_index[sw_if_index] ==
374 im->fib_index_by_sw_if_index[sif->sw_if_index])
376 foreach_ip_interface_address
377 (&im->lookup_main, ia, sif->sw_if_index,
381 ip_interface_address_get_address
382 (&im->lookup_main, ia);
384 if (ip6_destination_matches_route
385 (im, address, x, ia->address_length) ||
386 ip6_destination_matches_route (im,
392 if ((sw_if_index == sif->sw_if_index) &&
393 (ia->address_length == address_length) &&
394 !ip6_address_is_equal (x, address))
397 if (ia->flags & IP_INTERFACE_ADDRESS_FLAG_STALE)
406 vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
407 error = clib_error_create
408 (
"failed to add %U which conflicts with %U for interface %U",
409 format_ip6_address_and_length, address,
411 format_ip6_address_and_length, x,
413 format_vnet_sw_if_index_name, vnm,
427 if (~0 == if_address_index)
429 vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
431 lm->format_address_and_length,
432 addr_fib, address_length,
445 if (~0 != if_address_index)
470 addr_fib, address_length,
476 vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
478 (
"Prefix %U already found on interface %U",
479 lm->format_address_and_length, addr_fib, address_length,
485 addr_fib, address_length,
505 im, ip6_af.fib_index,
511 vec_foreach (cb, im->add_del_interface_address_callbacks)
513 address, address_length, if_address_index, is_del);
531 u32 is_admin_up, fib_index;
537 lookup_main.if_address_pool_index_by_sw_if_index,
548 a = ip_interface_address_get_address (&im->lookup_main, ia);
550 ip6_add_interface_routes (vnm, sw_if_index,
554 ip6_del_interface_routes (sw_if_index, im, fib_index,
555 a, ia->address_length);
568 .arc_name =
"ip6-unicast",
570 .last_in_arc =
"ip6-lookup",
576 .arc_name =
"ip6-unicast",
577 .node_name =
"ip6-flow-classify",
583 .arc_name =
"ip6-unicast",
584 .node_name =
"ip6-inacl",
590 .arc_name =
"ip6-unicast",
591 .node_name =
"ip6-policer-classify",
597 .arc_name =
"ip6-unicast",
598 .node_name =
"ipsec6-input-feature",
604 .arc_name =
"ip6-unicast",
605 .node_name =
"l2tp-decap",
611 .arc_name =
"ip6-unicast",
612 .node_name =
"vpath-input-ip6",
618 .arc_name =
"ip6-unicast",
619 .node_name =
"ip6-vxlan-bypass",
625 .arc_name =
"ip6-unicast",
626 .node_name =
"ip6-not-enabled",
632 .arc_name =
"ip6-unicast",
633 .node_name =
"ip6-lookup",
640 .arc_name =
"ip6-multicast",
642 .last_in_arc =
"ip6-mfib-forward-lookup",
647 .arc_name =
"ip6-multicast",
648 .node_name =
"vpath-input-ip6",
653 .arc_name =
"ip6-multicast",
654 .node_name =
"ip6-not-enabled",
659 .arc_name =
"ip6-multicast",
660 .node_name =
"ip6-mfib-forward-lookup",
667 .arc_name =
"ip6-output",
668 .start_nodes =
VNET_FEATURES (
"ip6-rewrite",
"ip6-midchain",
"ip6-dvr-dpo"),
669 .last_in_arc =
"interface-output",
674 .arc_name =
"ip6-output",
675 .node_name =
"ip6-outacl",
680 .arc_name =
"ip6-output",
681 .node_name =
"ipsec6-output-feature",
686 .arc_name =
"ip6-output",
687 .node_name =
"interface-output",
724 sw_if_index, is_add, 0, 0);
743 .name =
"ip6-lookup",
744 .vector_size =
sizeof (
u32),
745 .format_trace = format_ip6_lookup_trace,
763 n_left =
frame->n_vectors;
772 u32 lbi0, hc0, lbi1, hc1;
924 return frame->n_vectors;
930 .name =
"ip6-load-balance",
931 .vector_size =
sizeof (
u32),
932 .sibling_of =
"ip6-lookup",
933 .format_trace = format_ip6_lookup_trace,
945 u8 packet_data[128 - 1 *
sizeof (
u32)];
949 #ifndef CLIB_MARCH_VARIANT 955 ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
970 ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
973 s =
format (s,
"fib %d dpo-idx %d flow hash: 0x%08x",
987 ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
990 s =
format (s,
"tx_sw_if_index %d adj-idx %d : %U flow hash: 0x%08x",
1001 #ifndef CLIB_MARCH_VARIANT 1017 ip6_forward_next_trace_t *t0, *t1;
1029 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1044 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
1067 ip6_forward_next_trace_t *t0;
1073 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1099 u16 payload_length, payload_length_host_byte_order;
1101 u32 headers_size =
sizeof (ip0[0]);
1102 u8 *data_this_buffer;
1108 payload_length_host_byte_order = clib_net_to_host_u16 (ip0->
payload_length);
1109 data_this_buffer = (
u8 *) (ip0 + 1);
1114 if (
PREDICT_FALSE (next_hdr == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
1117 ip6_hop_by_hop_ext_t *ext_hdr =
1118 (ip6_hop_by_hop_ext_t *) data_this_buffer;
1121 ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1122 || (ext_hdr->next_hdr == IP_PROTOCOL_UDP));
1124 skip_bytes = 8 * (1 + ext_hdr->n_data_u64s);
1125 data_this_buffer = (
void *) ((
u8 *) data_this_buffer + skip_bytes);
1127 payload_length_host_byte_order -= skip_bytes;
1128 headers_size += skip_bytes;
1134 payload_length = clib_host_to_net_u16 (payload_length_host_byte_order);
1135 next_hdr = ext_hdr->next_hdr;
1139 sum0 = payload_length + clib_host_to_net_u16 (next_hdr);
1151 payload_length_host_byte_order,
1152 (
u8 *) ip0, headers_size, NULL);
1155 payload_length_host_byte_order, NULL, 0,
1169 || ip0->
protocol == IP_PROTOCOL_ICMP6
1170 || ip0->
protocol == IP_PROTOCOL_UDP
1171 || ip0->
protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS);
1173 udp0 = (
void *) (ip0 + 1);
1176 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1177 | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1183 p0->
flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1184 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1218 if (proto0 != IP_PROTOCOL_UDP)
1221 proto0 = (proto0 == IP_PROTOCOL_TCP) ? proto0 : 0;
1229 .arc_name =
"ip6-local",
1238 u16 payload_length_host_byte_order;
1239 u32 n_this_buffer, n_bytes_left;
1241 u32 headers_size =
sizeof (ip0[0]);
1242 u8 *data_this_buffer;
1245 data_this_buffer = (
u8 *) (ip0 + 1);
1247 ip6_hop_by_hop_ext_t *ext_hdr = (ip6_hop_by_hop_ext_t *) data_this_buffer;
1251 if (!(ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1252 || (ext_hdr->next_hdr == IP_PROTOCOL_UDP))
1256 payload_length_host_byte_order = clib_net_to_host_u16 (ip0->
payload_length);
1257 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1260 u32 n_ip_bytes_this_buffer =
1262 if (n_this_buffer + headers_size > n_ip_bytes_this_buffer)
1265 n_ip_bytes_this_buffer - headers_size : 0;
1268 n_bytes_left -= n_this_buffer;
1271 if (n_bytes_left == 0)
1284 u32 *from, n_left_from;
1287 u8 arc_index = vnet_feat_arc_ip6_local.feature_arc_index;
1301 while (n_left_from > 2)
1304 if (n_left_from >= 6)
1313 error[0] = IP6_ERROR_UNKNOWN_PROTOCOL;
1314 error[1] = IP6_ERROR_UNKNOWN_PROTOCOL;
1320 if (head_of_feature_arc)
1330 flags[0] = b[0]->
flags;
1331 flags[1] = b[1]->
flags;
1333 u32 good_l4_csum[2];
1335 flags[0] & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT |
1336 VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
1337 VNET_BUFFER_F_OFFLOAD_UDP_CKSUM);
1339 flags[1] & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT |
1340 VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
1341 VNET_BUFFER_F_OFFLOAD_UDP_CKSUM);
1343 u32 udp_offset[2] = { };
1349 i16 len_diff[2] = { 0 };
1357 u16 ip_len, udp_len;
1358 ip_len = clib_net_to_host_u16 (ip[0]->payload_length);
1359 udp_len = clib_net_to_host_u16 (udp->
length);
1360 len_diff[0] = ip_len - udp_len;
1369 u16 ip_len, udp_len;
1370 ip_len = clib_net_to_host_u16 (ip[1]->payload_length);
1371 udp_len = clib_net_to_host_u16 (udp->
length);
1372 len_diff[1] = ip_len - udp_len;
1384 && !(flags[0] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1387 && !(flags[1] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1391 good_l4_csum[0] = flags[0] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1392 error[0] = IP6_ERROR_UNKNOWN_PROTOCOL;
1397 error[0] = IP6_ERROR_BAD_LENGTH;
1402 good_l4_csum[1] = flags[1] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1403 error[1] = IP6_ERROR_UNKNOWN_PROTOCOL;
1408 error[1] = IP6_ERROR_BAD_LENGTH;
1412 error[0] = len_diff[0] < 0 ? IP6_ERROR_UDP_LENGTH : error[0];
1414 error[1] = len_diff[1] < 0 ? IP6_ERROR_UDP_LENGTH : error[1];
1417 IP6_ERROR_UDP_CHECKSUM,
1418 "Wrong IP6 errors constants");
1420 IP6_ERROR_ICMP_CHECKSUM,
1421 "Wrong IP6 errors constants");
1424 !good_l4_csum[0] ? IP6_ERROR_UDP_CHECKSUM + type[0] : error[0];
1426 !good_l4_csum[1] ? IP6_ERROR_UDP_CHECKSUM + type[1] : error[1];
1431 unroutable[0] = error[0] == IP6_ERROR_UNKNOWN_PROTOCOL
1434 unroutable[1] = error[1] == IP6_ERROR_UNKNOWN_PROTOCOL
1441 ip[0]) ? IP6_ERROR_SRC_LOOKUP_MISS
1448 ip[1]) ? IP6_ERROR_SRC_LOOKUP_MISS
1472 if (head_of_feature_arc)
1475 ip6_unknown[0] = error[0] == (
u8) IP6_ERROR_UNKNOWN_PROTOCOL;
1476 ip6_unknown[1] = error[1] == (
u8) IP6_ERROR_UNKNOWN_PROTOCOL;
1479 u32 next32 = next[0];
1487 u32 next32 = next[1];
1504 error = IP6_ERROR_UNKNOWN_PROTOCOL;
1509 if (head_of_feature_arc)
1516 flags & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT |
1517 VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
1518 VNET_BUFFER_F_OFFLOAD_UDP_CKSUM);
1530 u16 ip_len, udp_len;
1532 udp_len = clib_net_to_host_u16 (udp->
length);
1533 len_diff = ip_len - udp_len;
1540 && !(flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1544 good_l4_csum = flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1545 error = IP6_ERROR_UNKNOWN_PROTOCOL;
1550 error = IP6_ERROR_BAD_LENGTH;
1555 error = len_diff < 0 ? IP6_ERROR_UDP_LENGTH : error;
1558 IP6_ERROR_UDP_CHECKSUM,
1559 "Wrong IP6 errors constants");
1561 IP6_ERROR_ICMP_CHECKSUM,
1562 "Wrong IP6 errors constants");
1564 error = !good_l4_csum ? IP6_ERROR_UDP_CHECKSUM +
type : error;
1568 u8 unroutable = error == IP6_ERROR_UNKNOWN_PROTOCOL
1575 ip) ? IP6_ERROR_SRC_LOOKUP_MISS :
1591 if (head_of_feature_arc)
1595 u32 next32 = next[0];
1622 .name =
"ip6-local",
1623 .vector_size =
sizeof (
u32),
1646 .name =
"ip6-local-end-of-arc",
1647 .vector_size =
sizeof (
u32),
1650 .sibling_of =
"ip6-local",
1654 .arc_name =
"ip6-local",
1655 .node_name =
"ip6-local-end-of-arc",
1660 #ifdef CLIB_MARCH_VARIANT 1698 #define IP6_MCAST_ADDR_MASK 0xffffffff 1702 u16 adj_packet_bytes,
bool is_locally_generated,
1703 u32 * next,
u8 is_midchain,
u32 * error)
1705 if (adj_packet_bytes >= 1280 && packet_bytes > adj_packet_bytes)
1707 if (is_locally_generated)
1715 *error = IP6_ERROR_MTU_EXCEEDED;
1719 *error = IP6_ERROR_MTU_EXCEEDED;
1731 int do_counters,
int is_midchain,
int is_mcast)
1735 u32 n_left_from, n_left_to_next, *to_next, next_index;
1743 while (n_left_from > 0)
1747 while (n_left_from >= 4 && n_left_to_next >= 2)
1752 u32 pi0, rw_len0, next0, error0, adj_index0;
1753 u32 pi1, rw_len1, next1, error1, adj_index1;
1754 u32 tx_sw_if_index0, tx_sw_if_index1;
1755 bool is_locally_originated0, is_locally_originated1;
1774 pi0 = to_next[0] = from[0];
1775 pi1 = to_next[1] = from[1];
1780 n_left_to_next -= 2;
1791 error0 = error1 = IP6_ERROR_NONE;
1794 is_locally_originated0 =
1795 p0->
flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
1813 error0 = IP6_ERROR_TIME_EXPIRED;
1817 ICMP6_time_exceeded_ttl_exceeded_in_transit,
1822 is_locally_originated1 =
1823 p1->
flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
1841 error1 = IP6_ERROR_TIME_EXPIRED;
1845 ICMP6_time_exceeded_ttl_exceeded_in_transit,
1853 rw_len0 = adj0[0].rewrite_header.data_bytes;
1854 rw_len1 = adj1[0].rewrite_header.data_bytes;
1855 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
1856 vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
1862 thread_index, adj_index0, 1,
1866 thread_index, adj_index1, 1,
1877 if (p0->
flags & VNET_BUFFER_F_GSO)
1879 if (p1->
flags & VNET_BUFFER_F_GSO)
1885 adj0[0].rewrite_header.max_l3_packet_bytes,
1886 is_locally_originated0, &next0, is_midchain,
1889 adj1[0].rewrite_header.max_l3_packet_bytes,
1890 is_locally_originated1, &next1, is_midchain,
1900 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
1902 next0 = adj0[0].rewrite_header.next_index;
1919 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
1921 next1 = adj1[0].rewrite_header.next_index;
1968 rewrite_header.dst_mcast_offset,
1973 rewrite_header.dst_mcast_offset,
1979 to_next, n_left_to_next,
1980 pi0, pi1, next0, next1);
1983 while (n_left_from > 0 && n_left_to_next > 0)
1989 u32 adj_index0, next0, error0;
1990 u32 tx_sw_if_index0;
1991 bool is_locally_originated0;
1993 pi0 = to_next[0] = from[0];
2003 error0 = IP6_ERROR_NONE;
2007 is_locally_originated0 =
2008 p0->
flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
2025 error0 = IP6_ERROR_TIME_EXPIRED;
2029 ICMP6_time_exceeded_ttl_exceeded_in_transit,
2048 rw_len0 = adj0[0].rewrite_header.data_bytes;
2049 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2055 thread_index, adj_index0, 1,
2063 if (p0->
flags & VNET_BUFFER_F_GSO)
2067 adj0[0].rewrite_header.max_l3_packet_bytes,
2068 is_locally_originated0, &next0, is_midchain,
2078 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2081 next0 = adj0[0].rewrite_header.next_index;
2104 rewrite_header.dst_mcast_offset,
2112 n_left_to_next -= 1;
2115 to_next, n_left_to_next,
2133 int do_counters,
int is_midchain,
int is_mcast)
2136 is_midchain, is_mcast);
2192 .name =
"ip6-midchain",
2193 .vector_size =
sizeof (
u32),
2195 .sibling_of =
"ip6-rewrite",
2200 .name =
"ip6-rewrite",
2201 .vector_size =
sizeof (
u32),
2213 .name =
"ip6-rewrite-bcast",
2214 .vector_size =
sizeof (
u32),
2217 .sibling_of =
"ip6-rewrite",
2222 .name =
"ip6-rewrite-mcast",
2223 .vector_size =
sizeof (
u32),
2225 .sibling_of =
"ip6-rewrite",
2231 .name =
"ip6-mcast-midchain",
2232 .vector_size =
sizeof (
u32),
2234 .sibling_of =
"ip6-rewrite",
2242 #ifndef CLIB_MARCH_VARIANT 2246 #define foreach_ip6_hop_by_hop_error \ 2247 _(PROCESSED, "pkts with ip6 hop-by-hop options") \ 2248 _(FORMAT, "incorrectly formatted hop-by-hop options") \ 2249 _(UNKNOWN_OPTION, "unknown ip6 hop-by-hop options") 2254 #define _(sym,str) IP6_HOP_BY_HOP_ERROR_##sym, 2275 #define _(sym,string) string, 2280 #ifndef CLIB_MARCH_VARIANT 2285 int total_len = va_arg (*args,
int);
2290 s =
format (s,
"IP6_HOP_BY_HOP: next protocol %d len %d total %d",
2296 while (opt0 < limit0)
2306 if (hm->
trace[type0])
2308 s = (*hm->
trace[type0]) (s, opt0);
2313 format (s,
"\n unrecognized option %d length %d", type0,
2340 s =
format (s,
"IP6_HOP_BY_HOP: next index %d len %d traced %d",
2346 while (opt0 < limit0)
2356 if (hm->
trace[type0])
2358 s = (*hm->
trace[type0]) (s, opt0);
2363 format (s,
"\n unrecognized option %d length %d", type0,
2386 while (opt0 < limit0)
2399 if ((*hm->
options[type0]) (b0, ip0, opt0) < 0)
2401 error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2413 error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2417 error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2420 ICMP6_parameter_problem_unrecognized_option,
2421 (
u8 *) opt0 - (
u8 *) ip0);
2424 error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2429 ICMP6_parameter_problem,
2430 ICMP6_parameter_problem_unrecognized_option,
2431 (
u8 *) opt0 - (
u8 *) ip0);
2459 u32 n_left_from, *from, *to_next;
2463 n_left_from =
frame->n_vectors;
2464 next_index = node->cached_next_index;
2466 while (n_left_from > 0)
2472 while (n_left_from >= 4 && n_left_to_next >= 2)
2480 u8 error0 = 0, error1 = 0;
2497 to_next[0] = bi0 = from[0];
2498 to_next[1] = bi1 = from[1];
2502 n_left_to_next -= 2;
2525 ((hbh0->
length + 1) << 3));
2528 ((hbh1->
length + 1) << 3));
2533 if ((hbh0->
length + 1) << 3 >
2536 error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2543 if ((hbh1->
length + 1) << 3 >
2546 error1 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2568 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
2572 u32 trace_len = (hbh0->
length + 1) << 3;
2582 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
2586 u32 trace_len = (hbh1->
length + 1) << 3;
2604 n_left_to_next, bi0, bi1, next0,
2608 while (n_left_from > 0 && n_left_to_next > 0)
2624 n_left_to_next -= 1;
2640 ((hbh0->
length + 1) << 3));
2645 if ((hbh0->
length + 1) << 3 >
2648 error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2667 u32 trace_len = (hbh0->
length + 1) << 3;
2682 n_left_to_next, bi0, next0);
2686 return frame->n_vectors;
2692 .name =
"ip6-hop-by-hop",
2693 .sibling_of =
"ip6-lookup",
2694 .vector_size =
sizeof (
u32),
2697 .n_errors =
ARRAY_LEN (ip6_hop_by_hop_error_strings),
2715 #ifndef CLIB_MARCH_VARIANT 2761 hm->
trace[option] = NULL;
2766 for (i = 0; i < 256; i++)
2801 for (j = 0; j < i0; j++)
2806 clib_host_to_net_u32 (
pow2_mask (i1) << (32 - i1));
2820 "ip6 FIB fwding table",
2823 "ip6 FIB non-fwding table",
2849 #ifndef CLIB_MARCH_VARIANT 2857 if (~0 == fib_index)
2858 return VNET_API_ERROR_NO_SUCH_FIB;
2874 u32 flow_hash_config = 0;
2879 if (
unformat (input,
"table %d", &table_id))
2882 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;} 2903 clib_warning (
"BUG: illegal flow hash config 0x%x", flow_hash_config);
2988 .path =
"set ip6 flow-hash",
2990 "set ip6 flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
3010 ip6_local_node.index)->
3037 .path =
"show ip6 local",
3039 .short_help =
"show ip6 local",
3043 #ifndef CLIB_MARCH_VARIANT 3053 ip6_address_t *if_addr;
3056 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3059 return VNET_API_ERROR_NO_SUCH_ENTRY;
3066 if (NULL != if_addr)
3071 .fp_addr.ip6 = *if_addr,
3079 if (table_index != (
u32) ~ 0)
3110 u32 table_index = ~0;
3111 int table_index_set = 0;
3117 if (
unformat (input,
"table-index %d", &table_index))
3118 table_index_set = 1;
3126 if (table_index_set == 0)
3129 if (sw_if_index == ~0)
3139 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3142 case VNET_API_ERROR_NO_SUCH_ENTRY:
3161 .path =
"set ip6 classify",
3163 "set ip6 classify intfc <interface> table-index <classify-idx>",
3178 if (
unformat (input,
"hash-buckets %d", &tmp))
3180 else if (
unformat (input,
"heap-size %U",
static vlib_cli_command_t set_ip6_flow_hash_command
(constructor) VLIB_CLI_COMMAND (set_ip6_flow_hash_command)
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 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.
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP
static ip_interface_prefix_t * ip_get_interface_prefix(ip_lookup_main_t *lm, ip_interface_prefix_key_t *k)
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.
static uword ip6_local_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int head_of_feature_arc)
static vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
static clib_error_t * ip6_sw_interface_admin_up_down(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
static u8 * format_ip6_lookup_trace(u8 *s, va_list *args)
static u32 ip6_fib_table_fwding_lookup(u32 fib_index, const ip6_address_t *dst)
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)
int ip6_link_enable(u32 sw_if_index, const ip6_address_t *link_local_addr)
IPv6 Configuration on an interface.
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)
vl_api_wireguard_peer_flags_t flags
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.
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
#define IP6_LOOKUP_NEXT_NODES
Route added as a result of interface configuration.
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
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)
int ip6_link_set_local_address(u32 sw_if_index, const ip6_address_t *address)
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
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
static void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
vlib_node_registration_t ip6_lookup_node
(constructor) VLIB_REGISTER_NODE (ip6_lookup_node)
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)
#define clib_memcpy_fast(a, b, c)
static u8 * format_ip6_rewrite_trace(u8 *s, va_list *args)
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
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)
u8 * ip_enabled_by_sw_if_index
u16 current_length
Nbytes between current data and the end of this buffer.
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)
static clib_error_t * ip6_config(vlib_main_t *vm, unformat_input_t *input)
static uword ip6_lookup_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
int ip6_link_disable(u32 sw_if_index)
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
unformat_function_t unformat_vnet_sw_interface
vlib_node_registration_t ip6_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_mcast_node)
#define VLIB_NODE_FN(node)
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.
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
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)
ip_lookup_next_t
An adjacency is a representation of an attached L3 peer.
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(ip6_sw_interface_add_del)
static pg_node_t * pg_get_node(uword node_index)
#define clib_memcpy(d, s, n)
VNET_FEATURE_ARC_INIT(ip6_unicast, static)
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.
u32 ip6_tcp_udp_icmp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
u8 output_feature_arc_index
static u16 ip_calculate_l4_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip_csum_t sum0, u32 payload_length, u8 *iph, u32 ip_header_size, u8 *l4h)
vl_api_ip_proto_t protocol
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
static u8 * format_ip6_hop_by_hop_trace(u8 *s, va_list *args)
#define static_always_inline
clib_bihash_24_8_t ip6_hash
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
#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)
#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 uword ip6_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)
u16 lb_n_buckets_minus_1
number of buckets in the load-balance - 1.
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
Aggregate type for a prefix.
#define clib_error_return(e, args...)
static_always_inline u8 ip6_tcp_udp_icmp_bad_length(vlib_main_t *vm, vlib_buffer_t *p0)
#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)
static clib_error_t * ip6_sw_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
u8 * format_ip6_hop_by_hop_ext_hdr(u8 *s, va_list *args)
void ip6_unregister_protocol(u32 protocol)
struct ip_adjacency_t_::@149::@151 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
static clib_error_t * vnet_feature_init(vlib_main_t *vm)
union ip_adjacency_t_::@149 sub_type
void icmp6_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
u32 lookup_table_nbuckets
vl_api_fib_path_type_t type
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...
static vlib_cli_command_t show_ip6_local
(constructor) VLIB_CLI_COMMAND (show_ip6_local)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
vlib_node_registration_t ip6_rewrite_bcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_bcast_node)
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 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
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)
#define pool_put(P, E)
Free an object E in pool P.
static_always_inline void * vnet_feature_arc_start_w_cfg_index(u8 arc, u32 sw_if_index, u32 *next, vlib_buffer_t *b, u32 cfg_index)
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)
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_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.
ip_interface_address_flags_t flags
#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.
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
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))
vlib_combined_counter_main_t adjacency_counters
Adjacency packet counters.
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)
u8 packet_data[128 - 1 *sizeof(u32)]
static void ip6_add_interface_prefix_routes(ip6_main_t *im, u32 sw_if_index, u32 fib_index, ip6_address_t *address, u32 address_length)
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.
u32 ip_interface_address_find(ip_lookup_main_t *lm, void *addr_fib, u32 address_length)
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
Adjacency to drop this packet.
#define VLIB_REGISTER_NODE(x,...)
#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
static_always_inline void vlib_buffer_enqueue_to_next(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u16 *nexts, uword count)
sll srl srl sll sra u16x4 i
#define vec_free(V)
Free vector's memory (no header).
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.
clib_error_t * ip_interface_address_add(ip_lookup_main_t *lm, u32 sw_if_index, void *addr_fib, u32 address_length, u32 *result_if_address_index)
static void ip6_del_interface_prefix_routes(ip6_main_t *im, u32 sw_if_index, u32 fib_index, ip6_address_t *address, u32 address_length)
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.
vlib_node_registration_t ip6_midchain_node
(constructor) VLIB_REGISTER_NODE (ip6_midchain_node)
#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.
This table stores the routes that are used to forward traffic.
unformat_function_t * unformat_edit
#define vlib_prefetch_buffer_data(b, type)
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.
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
vlib_main_t vlib_node_runtime_t * node
u8 builtin_protocol_by_ip_protocol[256]
IP_BUILTIN_PROTOCOL_{TCP,UDP,ICMP,OTHER} by protocol in IP header.
clib_error_t * ip_interface_address_del(ip_lookup_main_t *lm, vnet_main_t *vnm, u32 address_index, void *addr_fib, u32 address_length, u32 sw_if_index)
static void ip6_del_interface_routes(u32 sw_if_index, ip6_main_t *im, u32 fib_index, ip6_address_t *address, u32 address_length)
#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)
index_t lb_urpf
This is the index of the uRPF list for this LB.
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
manual_print typedef address
u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]
Space for inserting data before buffer start.
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)
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)
static void ip6_addr_fib_init(ip6_address_fib_t *addr_fib, const ip6_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 ip6_hop_by_hop_node
(constructor) VLIB_REGISTER_NODE (ip6_hop_by_hop_node)
u32 ia_cfg_index
feature [arc] config index
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP_NOT_MCAST
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 uword ip6_address_is_link_local_unicast(const ip6_address_t *a)
#define clib_mem_unaligned(pointer, type)
static uword ip6_address_is_equal(const ip6_address_t *a, const ip6_address_t *b)
static uword ip6_address_is_multicast(const ip6_address_t *a)
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 vnet_sw_interface_is_admin_up(vnet_main_t *vnm, u32 sw_if_index)
#define vec_elt(v, i)
Get vector value at index i.
struct _vlib_node_registration vlib_node_registration_t
u8 ucast_feature_arc_index
This packets needs to go to ICMP error.
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
static void vnet_ip_mcast_fixup_header(u32 dst_mcast_mask, u32 dst_mcast_offset, u32 *addr, u8 *packet0)
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN
index_t dpoi_index
the index of objects of that type
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
const ip6_address_t * ip6_get_link_local_address(u32 sw_if_index)
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
#define STATIC_ASSERT(truth,...)
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
static uword max_log2(uword x)
#define IP6_MCAST_ADDR_MASK
This bits of an IPv6 address to mask to construct a multicast MAC address.
#define foreach_ip_interface_address(lm, a, sw_if_index, loop, body)
mhash_t prefix_to_if_prefix_index
Hash table mapping prefix to index in interface prefix pool.
ip_interface_prefix_key_t key
VLIB buffer representation.
vnet_sw_interface_t * sw_interfaces
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
The default route source.
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
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)
A collection of combined counters.
static_always_inline void vnet_calc_checksums_inline(vlib_main_t *vm, vlib_buffer_t *b, int is_ip4, int is_ip6)
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
static vlib_cli_command_t set_ip6_classify_command
(constructor) VLIB_CLI_COMMAND (set_ip6_classify_command)
ip6_mfib_table_instance_t ip6_mtable
the single MFIB table
u8 *(* trace[256])(u8 *s, ip6_hop_by_hop_option_t *opt)
static struct option options[]
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
static void ip6_mtu_check(vlib_buffer_t *b, u16 packet_bytes, u16 adj_packet_bytes, bool is_locally_generated, u32 *next, u8 is_midchain, u32 *error)
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.
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
u16 dpoi_next_node
The next VLIB node to follow.
static u32 ip6_lookup(gid_ip6_table_t *db, u32 vni, ip_prefix_t *key)
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_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
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)
#define vnet_rewrite_two_headers(rw0, rw1, p0, p1, most_likely_size)
#define CLIB_CACHE_LINE_BYTES
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
vlib_node_registration_t ip6_load_balance_node
(constructor) VLIB_REGISTER_NODE (ip6_load_balance_node)
This adjacency/interface has output features configured.
u32 * fib_index_by_sw_if_index
ip_interface_prefix_t * if_prefix_pool
Pool of prefixes containing addresses assigned to interfaces.
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
static int adj_are_counters_enabled(void)
Get the global configuration option for enabling per-adj counters.
vl_api_interface_index_t sw_if_index
clib_bihash_40_8_t ip6_mhash
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)