fib_node_index_t mfei;
adj_index_t ai;
fib_route_path_t path = {
- .frp_proto = fp,
+ .frp_proto = fib_proto_to_dpo (fp),
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL |
FIB_ENTRY_FLAG_EXCLUSIVE),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
sw_if_index,
~0,
mpls_label_t *next_hop_out_label_stack = NULL;
mpls_label_t local_label = MPLS_LABEL_INVALID;
u8 is_eos = 0;
- u8 next_hop_proto_is_ip4 = 1;
+ dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
&v4_next_hop_address))
{
next_hop_set = 1;
- next_hop_proto_is_ip4 = 1;
+ next_hop_proto = DPO_PROTO_IP4;
}
else if (unformat (i, "via %U", unformat_ip6_address,
&v6_next_hop_address))
{
next_hop_set = 1;
- next_hop_proto_is_ip4 = 0;
+ next_hop_proto = DPO_PROTO_IP6;
}
else if (unformat (i, "weight %d", &next_hop_weight))
;
else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
{
next_hop_set = 1;
- next_hop_proto_is_ip4 = 1;
+ next_hop_proto = DPO_PROTO_IP4;
}
else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
{
next_hop_set = 1;
- next_hop_proto_is_ip4 = 0;
+ next_hop_proto = DPO_PROTO_IP6;
}
else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
;
mp->mr_create_table_if_needed = create_table_if_needed;
mp->mr_is_add = is_add;
- mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
+ mp->mr_next_hop_proto = next_hop_proto;
mp->mr_is_classify = is_classify;
mp->mr_is_multipath = is_multipath;
mp->mr_is_resolve_host = resolve_host;
if (next_hop_set)
{
- if (next_hop_proto_is_ip4)
+ if (DPO_PROTO_IP4 == next_hop_proto)
{
clib_memcpy (mp->mr_next_hop,
&v4_next_hop_address,
sizeof (v4_next_hop_address));
}
- else
+ else if (DPO_PROTO_IP6 == next_hop_proto)
+
{
clib_memcpy (mp->mr_next_hop,
&v6_next_hop_address,
&all_0s,
FIB_SOURCE_DHCP,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh,
c->sw_if_index,
~0,
c->sw_if_index),
&all_0s,
FIB_SOURCE_DHCP,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh,
c->sw_if_index,
~0,
c->sw_if_index),
&all_0s,
FIB_SOURCE_DHCP,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh,
c->sw_if_index,
~0,
else
{
const fib_route_path_t path_for_us = {
- .frp_proto = FIB_PROTOCOL_IP6,
+ .frp_proto = DPO_PROTO_IP6,
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
return (0);
}
+vnet_link_t
+dpo_proto_to_link (dpo_proto_t dp)
+{
+ switch (dp)
+ {
+ case DPO_PROTO_IP6:
+ return (VNET_LINK_IP6);
+ case DPO_PROTO_IP4:
+ return (VNET_LINK_IP4);
+ case DPO_PROTO_MPLS:
+ return (VNET_LINK_MPLS);
+ case DPO_PROTO_ETHERNET:
+ return (VNET_LINK_ETHERNET);
+ case DPO_PROTO_NSH:
+ return (VNET_LINK_NSH);
+ }
+ return (~0);
+}
+
u8 *
format_dpo_type (u8 * s, va_list * args)
{
*/
typedef enum dpo_proto_t_
{
-#if CLIB_DEBUG > 0
- DPO_PROTO_IP4 = 1,
-#else
DPO_PROTO_IP4 = 0,
-#endif
DPO_PROTO_IP6,
- DPO_PROTO_ETHERNET,
DPO_PROTO_MPLS,
+ DPO_PROTO_ETHERNET,
DPO_PROTO_NSH,
} __attribute__((packed)) dpo_proto_t;
*/
extern u8 *format_dpo_proto(u8 * s, va_list * args);
+/**
+ * @brief format a DPO protocol
+ */
+extern vnet_link_t dpo_proto_to_link(dpo_proto_t dp);
+
/**
* @brief
* Set and stack a DPO.
"interface-dpo-ip4",
NULL,
};
+const static char* const interface_dpo_l2_nodes[] =
+{
+ "interface-dpo-l2",
+ NULL,
+};
const static char* const * const interface_dpo_nodes[DPO_PROTO_NUM] =
{
[DPO_PROTO_IP4] = interface_dpo_ip4_nodes,
[DPO_PROTO_IP6] = interface_dpo_ip6_nodes,
+ [DPO_PROTO_ETHERNET] = interface_dpo_l2_nodes,
[DPO_PROTO_MPLS] = NULL,
};
return (interface_dpo_inline(vm, node, from_frame));
}
+static uword
+interface_dpo_l2 (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
+{
+ return (interface_dpo_inline(vm, node, from_frame));
+}
+
VLIB_REGISTER_NODE (interface_dpo_ip4_node) = {
.function = interface_dpo_ip4,
.name = "interface-dpo-ip4",
VLIB_NODE_FUNCTION_MULTIARCH (interface_dpo_ip6_node,
interface_dpo_ip6)
+VLIB_REGISTER_NODE (interface_dpo_l2_node) = {
+ .function = interface_dpo_l2,
+ .name = "interface-dpo-l2",
+ .vector_size = sizeof (u32),
+ .format_trace = format_interface_dpo_trace,
+
+ .n_next_nodes = 2,
+ .next_nodes = {
+ [INTERFACE_DPO_DROP] = "error-drop",
+ [INTERFACE_DPO_INPUT] = "l2-input",
+ },
+};
+
+VLIB_NODE_FUNCTION_MULTIARCH (interface_dpo_l2_node,
+ interface_dpo_l2)
+
vlib_node_runtime_t * node,
vlib_frame_t * from_frame,
u8 payload_is_ip4,
- u8 payload_is_ip6)
+ u8 payload_is_ip6,
+ u8 payload_is_ethernet)
{
u32 n_left_from, next_index, * from, * to_next;
ttl2 = ip2->hop_limit;
ttl3 = ip3->hop_limit;
}
+ else if (payload_is_ethernet)
+ {
+ /*
+ * nothing to chang ein the ethernet header
+ */
+ ttl0 = ttl1 = ttl2 = ttl3 = 255;
+ }
else
{
/*
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
- return (mpls_label_imposition_inline(vm, node, frame, 0, 0));
+ return (mpls_label_imposition_inline(vm, node, frame, 0, 0, 0));
}
VLIB_REGISTER_NODE (mpls_label_imposition_node) = {
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
- return (mpls_label_imposition_inline(vm, node, frame, 1, 0));
+ return (mpls_label_imposition_inline(vm, node, frame, 1, 0, 0));
}
VLIB_REGISTER_NODE (ip4_mpls_label_imposition_node) = {
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
- return (mpls_label_imposition_inline(vm, node, frame, 0, 1));
+ return (mpls_label_imposition_inline(vm, node, frame, 0, 1, 0));
}
VLIB_REGISTER_NODE (ip6_mpls_label_imposition_node) = {
VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_node,
ip6_mpls_label_imposition)
+static uword
+ethernet_mpls_label_imposition (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ return (mpls_label_imposition_inline(vm, node, frame, 0, 0, 1));
+}
+
+VLIB_REGISTER_NODE (ethernet_mpls_label_imposition_node) = {
+ .function = ethernet_mpls_label_imposition,
+ .name = "ethernet-mpls-label-imposition",
+ .vector_size = sizeof (u32),
+
+ .format_trace = format_mpls_label_imposition_trace,
+ .n_next_nodes = 1,
+ .next_nodes = {
+ [0] = "error-drop",
+ }
+};
+VLIB_NODE_FUNCTION_MULTIARCH (ethernet_mpls_label_imposition_node,
+ ethernet_mpls_label_imposition)
+
static void
mpls_label_dpo_mem_show (void)
{
"mpls-label-imposition",
NULL,
};
+const static char* const mpls_label_imp_ethernet_nodes[] =
+{
+ "ethernet-mpls-label-imposition",
+ NULL,
+};
+
const static char* const * const mpls_label_imp_nodes[DPO_PROTO_NUM] =
{
[DPO_PROTO_IP4] = mpls_label_imp_ip4_nodes,
[DPO_PROTO_IP6] = mpls_label_imp_ip6_nodes,
[DPO_PROTO_MPLS] = mpls_label_imp_mpls_nodes,
+ [DPO_PROTO_ETHERNET] = mpls_label_imp_ethernet_nodes,
};
e->fib_entry_index =
fib_table_entry_path_add (fib_index, &pfx, FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4, &pfx.fp_addr,
+ DPO_PROTO_IP4, &pfx.fp_addr,
e->sw_if_index, ~0, 1, NULL,
FIB_ROUTE_PATH_FLAG_NONE);
}
fib_table_entry_path_remove (fib_index, &pfx,
FIB_SOURCE_ADJ,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx.fp_addr,
e->sw_if_index, ~0, 1,
FIB_ROUTE_PATH_FLAG_NONE);
add_del_route_check (fib_protocol_t table_proto,
u32 table_id,
u32 next_hop_sw_if_index,
- fib_protocol_t next_hop_table_proto,
+ dpo_proto_t next_hop_table_proto,
u32 next_hop_table_id,
u8 create_missing_tables,
u8 is_rpf_id,
u8 is_rpf_id,
u32 fib_index,
const fib_prefix_t * prefix,
- u8 next_hop_proto_is_ip4,
+ dpo_proto_t next_hop_proto,
const ip46_address_t * next_hop,
u32 next_hop_sw_if_index,
u8 next_hop_fib_index,
return (fib_entry - fib_entry_pool);
}
-static fib_protocol_t
+fib_protocol_t
fib_entry_get_proto (const fib_entry_t * fib_entry)
{
return (fib_entry->fe_prefix.fp_proto);
}
+dpo_proto_t
+fib_entry_get_dpo_proto (const fib_entry_t * fib_entry)
+{
+ return (fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto));
+}
+
fib_forward_chain_type_t
fib_entry_get_default_chain_type (const fib_entry_t *fib_entry)
{
*/
static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX];
-static fib_protocol_t
-fib_entry_get_proto (const fib_entry_t * fib_entry)
-{
- return (fib_entry->fe_prefix.fp_proto);
-}
-
void
fib_entry_src_register (fib_source_t source,
const fib_entry_src_vft_t *vft)
fib_entry_src_vft[source].fesv_add(esrc,
fib_entry,
flags,
- fib_entry_get_proto(fib_entry),
+ fib_entry_get_dpo_proto(fib_entry),
dpo);
}
fib_entry_src_vft[source].fesv_add(esrc,
fib_entry,
flags,
- fib_entry_get_proto(fib_entry),
+ fib_entry_get_dpo_proto(fib_entry),
dpo);
}
source,
flags,
drop_dpo_get(
- fib_proto_to_dpo(
- fib_entry_get_proto(fib_entry))));
+ fib_entry_get_dpo_proto(fib_entry)));
esrc = fib_entry_src_find(fib_entry, source, NULL);
}
source,
flags,
drop_dpo_get(
- fib_proto_to_dpo(
- fib_entry_get_proto(fib_entry))));
+ fib_entry_get_dpo_proto(fib_entry)));
esrc = fib_entry_src_find(fib_entry, source, NULL);
}
typedef void (*fib_entry_src_add_t)(fib_entry_src_t *src,
const fib_entry_t *entry,
fib_entry_flag_t flags,
- fib_protocol_t proto,
+ dpo_proto_t proto,
const dpo_id_t *dpo);
/**
fib_forward_chain_type_t fct,
dpo_id_t *dpo_lb);
+extern fib_protocol_t fib_entry_get_proto(const fib_entry_t * fib_entry);
+extern dpo_proto_t fib_entry_get_dpo_proto(const fib_entry_t * fib_entry);
/*
* Per-source registration. declared here so we save a separate .h file for each
fib_entry_src_api_add (fib_entry_src_t *src,
const fib_entry_t *entry,
fib_entry_flag_t flags,
- fib_protocol_t proto,
+ dpo_proto_t proto,
const dpo_id_t *dpo)
{
if (FIB_ENTRY_FLAG_NONE != flags)
fib_entry_src_default_route_add (fib_entry_src_t *src,
const fib_entry_t *entry,
fib_entry_flag_t flags,
- fib_protocol_t proto,
+ dpo_proto_t proto,
const dpo_id_t *dpo)
{
src->fes_pl = fib_path_list_create_special(proto,
fib_entry_src_interface_add (fib_entry_src_t *src,
const fib_entry_t *entry,
fib_entry_flag_t flags,
- fib_protocol_t proto,
+ dpo_proto_t proto,
const dpo_id_t *dpo)
{
src->fes_pl = fib_path_list_create_special(
static void
fib_entry_src_lisp_add (fib_entry_src_t *src,
- const fib_entry_t *entry,
- fib_entry_flag_t flags,
- fib_protocol_t proto,
- const dpo_id_t *dpo)
+ const fib_entry_t *entry,
+ fib_entry_flag_t flags,
+ dpo_proto_t proto,
+ const dpo_id_t *dpo)
{
if (FIB_ENTRY_FLAG_NONE != flags)
{
fib_entry_src_mpls_add (fib_entry_src_t *src,
const fib_entry_t *entry,
fib_entry_flag_t flags,
- fib_protocol_t proto,
+ dpo_proto_t proto,
const dpo_id_t *dpo)
{
src->fes_pl =
fib_path_list_create_special(proto,
FIB_PATH_LIST_FLAG_DROP,
- drop_dpo_get(fib_proto_to_dpo(proto)));
+ drop_dpo_get(proto));
}
static void
const fib_entry_t *cover)
{
const fib_route_path_t path = {
- .frp_proto = fib_entry->fe_prefix.fp_proto,
+ .frp_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto),
.frp_addr = fib_entry->fe_prefix.fp_addr,
.frp_sw_if_index = fib_entry_get_resolving_interface(
fib_entry_get_index(cover)),
const fib_entry_t *cover)
{
fib_node_index_t *entries = NULL;
- fib_protocol_t proto;
+ dpo_proto_t proto;
- proto = fib_entry->fe_prefix.fp_proto;
+ proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
vec_add1(entries, fib_entry_get_index(fib_entry));
if (fib_path_list_recursive_loop_detect(cover->fe_parent,
&entries))
{
- src->fes_pl = fib_path_list_create_special(
- proto,
- FIB_PATH_LIST_FLAG_DROP,
- drop_dpo_get(fib_proto_to_dpo(proto)));
+ src->fes_pl = fib_path_list_create_special(proto,
+ FIB_PATH_LIST_FLAG_DROP,
+ drop_dpo_get(proto));
}
else
{
*/
if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto)
{
- src->fes_pl = fib_path_list_create_special(FIB_PROTOCOL_MPLS,
+ src->fes_pl = fib_path_list_create_special(DPO_PROTO_MPLS,
FIB_PATH_LIST_FLAG_DROP,
NULL);
fib_path_list_lock(src->fes_pl);
fib_entry_src_special_add (fib_entry_src_t *src,
const fib_entry_t *entry,
fib_entry_flag_t flags,
- fib_protocol_t proto,
+ dpo_proto_t proto,
const dpo_id_t *dpo)
{
src->fes_pl =
* next-hop's address. We can't derive this from the address itself
* since the address can be all zeros
*/
- fib_protocol_t fp_nh_proto;
+ dpo_proto_t fp_nh_proto;
/**
* UCMP [unnormalised] weigth
s = format (s, " index:%d ", fib_path_get_index(path));
s = format (s, "pl-index:%d ", path->fp_pl_index);
- s = format (s, "%U ", format_fib_protocol, path->fp_nh_proto);
+ s = format (s, "%U ", format_dpo_proto, path->fp_nh_proto);
s = format (s, "weight=%d ", path->fp_weight);
s = format (s, "pref=%d ", path->fp_preference);
s = format (s, "%s: ", fib_path_type_names[path->fp_type]);
}
break;
case FIB_PATH_TYPE_RECURSIVE:
- if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+ if (DPO_PROTO_MPLS == path->fp_nh_proto)
{
s = format (s, "via %U %U",
format_mpls_unicast_label,
* the subnet address (the attached route) links to the
* auto-adj (see below), we want that adj here too.
*/
- return (adj_nbr_add_or_lock(path->fp_nh_proto,
+ return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
link,
&zero_addr,
path->attached_next_hop.fp_interface));
}
else
{
- return (adj_nbr_add_or_lock(path->fp_nh_proto,
+ return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
link,
&path->attached_next_hop.fp_nh,
path->attached_next_hop.fp_interface));
*/
dpo_set(&path->fp_dpo,
DPO_ADJACENCY,
- fib_proto_to_dpo(path->fp_nh_proto),
+ path->fp_nh_proto,
fib_path_attached_next_hop_get_adj(
path,
- fib_proto_to_link(path->fp_nh_proto)));
+ dpo_proto_to_link(path->fp_nh_proto)));
/*
* become a child of the adjacency so we receive updates
* point-2-point interfaces do not require a glean, since
* there is nothing to ARP. Install a rewrite/nbr adj instead
*/
- return (adj_nbr_add_or_lock(path->fp_nh_proto,
+ return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
link,
&zero_addr,
path->attached.fp_interface));
}
else
{
- return (adj_glean_add_or_lock(path->fp_nh_proto,
+ return (adj_glean_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
path->attached.fp_interface,
NULL));
}
if (path->fp_oper_flags & FIB_PATH_OPER_FLAG_RECURSIVE_LOOP)
{
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
- dpo_copy(&via_dpo, drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
}
else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RESOLVE_HOST)
{
if (fib_entry_get_best_source(path->fp_via_fib) >= FIB_SOURCE_RR)
{
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
- dpo_copy(&via_dpo, drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
/*
* PIC edge trigger. let the load-balance maps know
if (!(FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags(path->fp_via_fib)))
{
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
- dpo_copy(&via_dpo, drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
/*
* PIC edge trigger. let the load-balance maps know
if (!fib_entry_is_resolved(path->fp_via_fib))
{
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
- dpo_copy(&via_dpo, drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
/*
* PIC edge trigger. let the load-balance maps know
*/
dpo_copy(dpo, &via_dpo);
- FIB_PATH_DBG(path, "recursive update: %U",
- fib_get_lookup_main(path->fp_nh_proto),
- &path->fp_dpo, 2);
+ FIB_PATH_DBG(path, "recursive update:");
dpo_reset(&via_dpo);
}
static fib_forward_chain_type_t
fib_path_to_chain_type (const fib_path_t *path)
{
- switch (path->fp_nh_proto)
+ if (DPO_PROTO_MPLS == path->fp_nh_proto)
{
- case FIB_PROTOCOL_IP4:
- return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
- case FIB_PROTOCOL_IP6:
- return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
- case FIB_PROTOCOL_MPLS:
if (FIB_PATH_TYPE_RECURSIVE == path->fp_type &&
MPLS_EOS == path->recursive.fp_nh.fp_eos)
{
return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
}
}
- return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
+ else
+ {
+ return (fib_forw_chain_type_from_dpo_proto(path->fp_nh_proto));
+ }
}
/*
ai = fib_path_attached_next_hop_get_adj(
path,
- fib_proto_to_link(path->fp_nh_proto));
+ dpo_proto_to_link(path->fp_nh_proto));
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
if (if_is_up && adj_is_up(ai))
path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
}
- dpo_set(&path->fp_dpo, DPO_ADJACENCY,
- fib_proto_to_dpo(path->fp_nh_proto),
- ai);
+ dpo_set(&path->fp_dpo, DPO_ADJACENCY, path->fp_nh_proto, ai);
adj_unlock(ai);
if (!if_is_up)
else
{
path->fp_type = FIB_PATH_TYPE_RECURSIVE;
- if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+ if (DPO_PROTO_MPLS == path->fp_nh_proto)
{
path->recursive.fp_nh.fp_local_label = rpath->frp_local_label;
path->recursive.fp_nh.fp_eos = rpath->frp_eos;
*/
fib_node_index_t
fib_path_create_special (fib_node_index_t pl_index,
- fib_protocol_t nh_proto,
+ dpo_proto_t nh_proto,
fib_path_cfg_flags_t flags,
const dpo_id_t *dpo)
{
res = (path->attached.fp_interface - rpath->frp_sw_if_index);
break;
case FIB_PATH_TYPE_RECURSIVE:
- if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+ if (DPO_PROTO_MPLS == path->fp_nh_proto)
{
res = path->recursive.fp_nh.fp_local_label - rpath->frp_local_label;
FIB_PATH_DBG(path, "recursive loop formed");
path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
- dpo_copy(&path->fp_dpo,
- drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
}
else
{
*/
if (fib_path_is_permanent_drop(path))
{
- dpo_copy(&path->fp_dpo,
- drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
return (fib_path_is_resolved(path_index));
}
}
dpo_set(&path->fp_dpo,
DPO_ADJACENCY,
- fib_proto_to_dpo(path->fp_nh_proto),
+ path->fp_nh_proto,
fib_path_attached_get_adj(path,
- fib_proto_to_link(path->fp_nh_proto)));
+ dpo_proto_to_link(path->fp_nh_proto)));
/*
* become a child of the adjacency so we receive updates
ASSERT(FIB_NODE_INDEX_INVALID == path->fp_via_fib);
- if (FIB_PROTOCOL_MPLS == path->fp_nh_proto)
+ if (DPO_PROTO_MPLS == path->fp_nh_proto)
{
fib_prefix_from_mpls_label(path->recursive.fp_nh.fp_local_label,
path->recursive.fp_nh.fp_eos,
/*
* Resolve via the drop
*/
- dpo_copy(&path->fp_dpo,
- drop_dpo_get(fib_proto_to_dpo(path->fp_nh_proto)));
+ dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
break;
case FIB_PATH_TYPE_DEAG:
{
LOOKUP_UNICAST);
lookup_dpo_add_or_lock_w_fib_index(path->deag.fp_tbl_id,
- fib_proto_to_dpo(path->fp_nh_proto),
+ path->fp_nh_proto,
cast,
LOOKUP_INPUT_DST_ADDR,
LOOKUP_TABLE_FROM_CONFIG,
/*
* Resolve via a receive DPO.
*/
- receive_dpo_add_or_lock(fib_proto_to_dpo(path->fp_nh_proto),
+ receive_dpo_add_or_lock(path->fp_nh_proto,
path->receive.fp_interface,
&path->receive.fp_addr,
&path->fp_dpo);
/*
* Resolve via a receive DPO.
*/
- interface_dpo_add_or_lock(fib_proto_to_dpo(path->fp_nh_proto),
+ interface_dpo_add_or_lock(path->fp_nh_proto,
path->intf_rx.fp_interface,
&path->fp_dpo);
break;
/*
* Create the adj needed for sending IP multicast traffic
*/
- ai = adj_mcast_add_or_lock(path->fp_nh_proto,
+ ai = adj_mcast_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
fib_forw_chain_type_to_link_type(fct),
path->attached.fp_interface);
dpo_set(dpo, DPO_ADJACENCY,
return (FIB_PATH_LIST_WALK_CONTINUE);
}
-fib_protocol_t
+dpo_proto_t
fib_path_get_proto (fib_node_index_t path_index)
{
fib_path_t *path;
* The path is an interface recieve
*/
FIB_PATH_CFG_ATTRIBUTE_LOCAL,
+ /**
+ * The path is L2. i.e. the parameters therein are to be interpreted as
+ * pertaining to L2 config.
+ */
+ FIB_PATH_CFG_ATTRIBUTE_L2,
/**
* Marker. Add new types before this one, then update it.
*/
[FIB_PATH_CFG_ATTRIBUTE_ATTACHED] = "attached", \
[FIB_PATH_CFG_ATTRIBUTE_INTF_RX] = "interface-rx", \
[FIB_PATH_CFG_ATTRIBUTE_RPF_ID] = "rpf-id", \
+ [FIB_PATH_CFG_ATTRIBUTE_L2] = "l2", \
}
#define FOR_EACH_FIB_PATH_CFG_ATTRIBUTE(_item) \
FIB_PATH_CFG_FLAG_ATTACHED = (1 << FIB_PATH_CFG_ATTRIBUTE_ATTACHED),
FIB_PATH_CFG_FLAG_INTF_RX = (1 << FIB_PATH_CFG_ATTRIBUTE_INTF_RX),
FIB_PATH_CFG_FLAG_RPF_ID = (1 << FIB_PATH_CFG_ATTRIBUTE_RPF_ID),
+ FIB_PATH_CFG_FLAG_L2 = (1 << FIB_PATH_CFG_ATTRIBUTE_L2),
} __attribute__ ((packed)) fib_path_cfg_flags_t;
extern fib_node_index_t fib_path_create(fib_node_index_t pl_index,
const fib_route_path_t *path);
extern fib_node_index_t fib_path_create_special(fib_node_index_t pl_index,
- fib_protocol_t nh_proto,
+ dpo_proto_t nh_proto,
fib_path_cfg_flags_t flags,
const dpo_id_t *dpo);
extern int fib_path_is_exclusive(fib_node_index_t path_index);
extern int fib_path_is_deag(fib_node_index_t path_index);
extern int fib_path_is_looped(fib_node_index_t path_index);
-extern fib_protocol_t fib_path_get_proto(fib_node_index_t path_index);
+extern dpo_proto_t fib_path_get_proto(fib_node_index_t path_index);
extern void fib_path_destroy(fib_node_index_t path_index);
extern uword fib_path_hash(fib_node_index_t path_index);
extern load_balance_path_t * fib_path_append_nh_for_multipath_hash(
case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
parent_fct = child_fct;
break;
+ case FIB_FORW_CHAIN_TYPE_ETHERNET:
+ parent_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS;
+ break;
default:
return (nhs);
break;
return (sw_if_index);
}
-fib_protocol_t
+dpo_proto_t
fib_path_list_get_proto (fib_node_index_t path_list_index)
{
fib_path_list_t *path_list;
}
fib_node_index_t
-fib_path_list_create_special (fib_protocol_t nh_proto,
+fib_path_list_create_special (dpo_proto_t nh_proto,
fib_path_list_flags_t flags,
const dpo_id_t *dpo)
{
extern fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags,
const fib_route_path_t *paths);
-extern fib_node_index_t fib_path_list_create_special(fib_protocol_t nh_proto,
+extern fib_node_index_t fib_path_list_create_special(dpo_proto_t nh_proto,
fib_path_list_flags_t flags,
const dpo_id_t *dpo);
extern u32 fib_path_list_get_resolving_interface(fib_node_index_t path_list_index);
extern int fib_path_list_is_looped(fib_node_index_t path_list_index);
extern int fib_path_list_is_popular(fib_node_index_t path_list_index);
-extern fib_protocol_t fib_path_list_get_proto(fib_node_index_t path_list_index);
+extern dpo_proto_t fib_path_list_get_proto(fib_node_index_t path_list_index);
extern u8 * fib_path_list_format(fib_node_index_t pl_index,
u8 * s);
extern index_t fib_path_list_lb_map_add_or_lock(fib_node_index_t pl_index,
const fib_prefix_t *prefix,
fib_source_t source,
fib_entry_flag_t flags,
- fib_protocol_t next_hop_proto,
+ dpo_proto_t next_hop_proto,
const ip46_address_t *next_hop,
u32 next_hop_sw_if_index,
u32 next_hop_fib_index,
fib_table_entry_path_remove (u32 fib_index,
const fib_prefix_t *prefix,
fib_source_t source,
- fib_protocol_t next_hop_proto,
+ dpo_proto_t next_hop_proto,
const ip46_address_t *next_hop,
u32 next_hop_sw_if_index,
u32 next_hop_fib_index,
const fib_prefix_t *prefix,
fib_source_t source,
fib_entry_flag_t flags,
- fib_protocol_t next_hop_proto,
+ dpo_proto_t next_hop_proto,
const ip46_address_t *next_hop,
u32 next_hop_sw_if_index,
u32 next_hop_fib_index,
const fib_prefix_t *prefix,
fib_source_t source,
fib_entry_flag_t flags,
- fib_protocol_t next_hop_proto,
+ dpo_proto_t next_hop_proto,
const ip46_address_t *next_hop,
u32 next_hop_sw_if_index,
u32 next_hop_fib_index,
extern void fib_table_entry_path_remove(u32 fib_index,
const fib_prefix_t *prefix,
fib_source_t source,
- fib_protocol_t next_hop_proto,
+ dpo_proto_t next_hop_proto,
const ip46_address_t *next_hop,
u32 next_hop_sw_if_index,
u32 next_hop_fib_index,
const fib_prefix_t *prefix,
fib_source_t source,
fib_entry_flag_t flags,
- fib_protocol_t next_hop_proto,
+ dpo_proto_t next_hop_proto,
const ip46_address_t *next_hop,
u32 next_hop_sw_if_index,
u32 next_hop_fib_index,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_add(fib_index, &pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
pfx.fp_len = 0;
fib_table_entry_path_remove(fib_index, &pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // non-recursive path, so no FIB index
&pfx_11_11_11_11_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_1_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_1_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_1_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_11_11_11_11_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_1_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_2_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_2_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_2_0_s_24,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_2_0_s_24,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_1_1_2_0_s_24,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0,
&bgp_100_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_1_1_1_1,
~0, // no index provided.
fib_index, // nexthop in same fib as route
&bgp_101_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_1_1_1_1,
~0, // no index provided.
fib_index, // nexthop in same fib as route
&bgp_200_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0, // no index provided.
fib_index, // nexthop in same fib as route
&pfx_1_2_3_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_1_2_3_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_12_12_12_12,
tm->hw[1]->sw_if_index,
~0,
&pfx_1_2_3_5_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_12_12_12_12,
tm->hw[1]->sw_if_index,
~0,
&pfx_1_2_3_5_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_6_6_6_6_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_6_6_6_6_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_6_6_6_6_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_12_12_12_12,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_6_6_6_6_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_12_12_12_12,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_6_6_6_6_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&bgp_44_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_2_3_4_s_32.fp_addr,
~0,
fib_index,
&bgp_44_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_2_3_5_s_32.fp_addr,
~0,
fib_index,
&bgp_201_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_200_s_32.fp_addr,
~0, // no index provided.
fib_index, // nexthop in same fib as route
&pfx_1_1_1_0_s_24,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_0_s_28,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_0_s_28,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_0_s_24,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_1_1_1_2_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&bgp_201_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&bgp_201_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&bgp_201_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_200_s_32.fp_addr,
~0, // no index provided.
fib_index,
fib_table_entry_path_remove(fib_index,
&bgp_200_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0, // no index provided.
fib_index,
&bgp_102,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route
&bgp_102,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&bgp_102,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&bgp_102,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&bgp_100_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&bgp_101_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
&bgp_200_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
~0, // no index provided.
fib_index, // Same as route's FIB
&bgp_201_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
~0, // no index provided.
fib_index,
fib_table_entry_path_remove(fib_index,
&bgp_200_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&bgp_201_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
~0, // no index provided.
fib_index, // same as route's FIB
&pfx_5_5_5_5_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_6_s_32.fp_addr,
~0, // no index provided.
fib_index,
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_7_s_32.fp_addr,
~0, // no index provided.
fib_index,
&pfx_5_5_5_7_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_5_s_32.fp_addr,
~0, // no index provided.
fib_index,
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
fib_table_entry_path_remove(fib_index,
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_5_5_5_5_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_5_5_5_5_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_6_s_32.fp_addr,
~0, // no index provided.
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_5_5_5_5_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_6_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_7_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&pfx_5_5_5_7_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_5_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
fib_table_entry_path_remove(fib_index,
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
~0, // no index provided.
fib_index, // same as route's FIB
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_6_s_32.fp_addr,
~0, // no index provided.
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_5_5_5_6_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_5_5_5_6_s_32.fp_addr,
~0, // no index provided.
fib_index, // same as route's FIB
&pfx_23_23_23_0_s_24,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_23_23_23_23_s_32.fp_addr,
~0, // recursive
fib_index,
&pfx_0_0_0_0_s_0,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_23_23_23_23_s_32.fp_addr,
~0, // recursive
fib_index,
&bgp_200_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_1_1_1_1,
~0,
fib_index,
&pfx_1_1_1_0_s_28,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_3_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&bgp_200_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_3_s_32.fp_addr,
~0,
fib_index,
&bgp_78s[ii],
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_3_s_32.fp_addr,
~0,
fib_index,
&bgp_78s[ii],
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_1_1_1_1,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&bgp_200_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0,
fib_index,
&bgp_78s[ii],
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
fib_table_entry_path_remove(fib_index,
&bgp_200_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&bgp_200_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_1_1_1_1,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&bgp_200_pfx,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_3_s_32.fp_addr,
~0,
fib_index,
&pfx_4_4_4_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_4_4_4_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0,
&pfx_4_4_4_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
tm->hw[0]->sw_if_index,
~0,
for (ii = 0; ii < 4; ii++)
{
fib_route_path_t r_path = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_addr = {
.ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02 + ii),
},
&pfx_4_4_4_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&zero_addr,
~0,
fib_index,
&pfx_34_34_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
0,
&pfx_34_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_34_34_1_1_s_32.fp_addr,
~0,
fib_index,
&pfx_34_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_34_34_1_1_s_32.fp_addr,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_2_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_2_0_s_24,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0,
&pfx_4_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&zero_addr,
tm->hw[0]->sw_if_index,
fib_index,
&pfx_2001_s_64,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
fib_index,
&pfx_12_10_10_2_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_12_10_10_2_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_127_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_127_s_32.fp_addr,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
tm->hw[0]->sw_if_index,
fib_index,
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_12_12_12_12,
tm->hw[1]->sw_if_index,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
tm->hw[0]->sw_if_index,
fib_index,
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
tm->hw[0]->sw_if_index,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_12_12_12_12,
tm->hw[1]->sw_if_index,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_3,
tm->hw[0]->sw_if_index,
fib_index,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
NULL,
tm->hw[0]->sw_if_index,
~0,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_add(fib_index, &pfx_0_0,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh_2001_2,
tm->hw[0]->sw_if_index,
~0,
*/
fib_table_entry_path_remove(fib_index, &pfx_0_0,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh_2001_2,
tm->hw[0]->sw_if_index,
~0,
&pfx_2001_1_2_s_128,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&pfx_2001_1_2_s_128.fp_addr,
tm->hw[0]->sw_if_index,
~0,
&pfx_2001_1_3_s_128,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&pfx_2001_1_3_s_128.fp_addr,
tm->hw[0]->sw_if_index,
~0,
&pfx_2001_a_s_64,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh_2001_2,
tm->hw[0]->sw_if_index,
~0,
&pfx_2001_b_s_64,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh_2001_2,
tm->hw[0]->sw_if_index,
~0,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh_2001_2,
tm->hw[0]->sw_if_index,
~0,
&pfx_2001_c_s_64,
FIB_SOURCE_CLI,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
NULL,
tm->hw[0]->sw_if_index,
~0,
fib_table_entry_path_remove(fib_index,
&pfx_2001_c_s_64,
FIB_SOURCE_CLI,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
NULL,
tm->hw[0]->sw_if_index,
~0,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
NULL,
tm->hw[1]->sw_if_index,
~0,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_1_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_1_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&local_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_2_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_2_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&local_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_3_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_3_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&local_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_2_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&local_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_0_0_0_s_8,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_3_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&local_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_10_10_10_1_s_32.fp_addr,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&local_pfx,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0,
* 2 high, 2 medium and 2 low preference non-recursive paths
*/
fib_route_path_t nr_path_hi_1 = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = tm->hw[0]->sw_if_index,
.frp_fib_index = ~0,
.frp_weight = 1,
},
};
fib_route_path_t nr_path_hi_2 = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = tm->hw[0]->sw_if_index,
.frp_fib_index = ~0,
.frp_weight = 1,
},
};
fib_route_path_t nr_path_med_1 = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = tm->hw[1]->sw_if_index,
.frp_fib_index = ~0,
.frp_weight = 1,
},
};
fib_route_path_t nr_path_med_2 = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = tm->hw[1]->sw_if_index,
.frp_fib_index = ~0,
.frp_weight = 1,
},
};
fib_route_path_t nr_path_low_1 = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = tm->hw[2]->sw_if_index,
.frp_fib_index = ~0,
.frp_weight = 1,
},
};
fib_route_path_t nr_path_low_2 = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = tm->hw[2]->sw_if_index,
.frp_fib_index = ~0,
.frp_weight = 1,
},
};
fib_route_path_t r_path_hi = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = ~0,
.frp_fib_index = 0,
.frp_weight = 1,
.frp_addr = pfx_1_1_1_1_s_32.fp_addr,
};
fib_route_path_t r_path_med = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = ~0,
.frp_fib_index = 0,
.frp_weight = 1,
.frp_addr = pfx_1_1_1_2_s_32.fp_addr,
};
fib_route_path_t r_path_low = {
- .frp_proto = FIB_PROTOCOL_IP4,
+ .frp_proto = DPO_PROTO_IP4,
.frp_sw_if_index = ~0,
.frp_fib_index = 0,
.frp_weight = 1,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[1]->sw_if_index,
~0,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_11_1,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_11_2,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_2_2_2_2_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0,
fib_index,
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
fib_table_entry_path_remove(fib_index,
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_11_1,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_1_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_2_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_2_2_2_2_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_2_s_32.fp_addr,
~0,
fib_index,
&pfx_1_1_1_2_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_11_1,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_1_1_1_2_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_11_1,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
&pfx_2_2_2_3_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0,
fib_index,
&pfx_2_2_2_4_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx_1_1_1_1_s_32.fp_addr,
~0,
fib_index,
&pfx_2_2_5_5_s_32,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_11_1,
tm->hw[1]->sw_if_index,
~0, // invalid fib index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_1_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_2_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_10_10_10_2_s_32,
FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_200_0_0_0_s_24,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
~0, // recursive
0, // default fib index
&pfx_200_0_0_0_s_24,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
~0, // recursive
0, // default fib index
&pfx_5_5_5_5_s_32,
FIB_SOURCE_CLI,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_5_5_5_5_s_32,
FIB_SOURCE_CLI,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_2,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx,
FIB_SOURCE_CLI,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&zero_addr,
~0,
fib_index,
&pfx,
FIB_SOURCE_CLI,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&zero_addr,
~0,
lfib_index,
&pfx_1200,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
},
};
fib_route_path_t *rpaths = NULL, rpath = {
- .frp_proto = FIB_PROTOCOL_MPLS,
+ .frp_proto = DPO_PROTO_MPLS,
.frp_local_label = 1200,
.frp_eos = MPLS_NON_EOS,
.frp_sw_if_index = ~0, // recurive
&pfx_2500,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_3500,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_MULTICAST,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_3500,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_MULTICAST,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
&pfx_3500,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_MULTICAST,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
NULL,
5, // rpf-id
0, // default table
* Protocol Type. packed so it consumes a u8 only
*/
typedef enum fib_protocol_t_ {
- FIB_PROTOCOL_IP4 = 0,
- FIB_PROTOCOL_IP6,
- FIB_PROTOCOL_MPLS,
+ FIB_PROTOCOL_IP4 = DPO_PROTO_IP4,
+ FIB_PROTOCOL_IP6 = DPO_PROTO_IP6,
+ FIB_PROTOCOL_MPLS = DPO_PROTO_MPLS,
} __attribute__ ((packed)) fib_protocol_t;
#define FIB_PROTOCOLS { \
* The protocol of the address below. We need this since the all
* zeros address is ambiguous.
*/
- fib_protocol_t frp_proto;
+ dpo_proto_t frp_proto;
union {
/**
{
vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
u32 sw_if_index = va_arg (*args, u32);
- return format (s, "%U",
- format_vnet_sw_interface_name, vnm,
- vnet_get_sw_interface (vnm, sw_if_index));
+ vnet_sw_interface_t *si;
+
+ si = vnet_get_sw_interface_safe (vnm, sw_if_index);
+
+ if (NULL == si)
+ {
+ return format (s, "DELETED");
+ }
+ return format (s, "%U", format_vnet_sw_interface_name, vnm, si);
}
u8 *
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
/* No next-hop address */
NULL,
sw_if_index,
fib_table_entry_update_one_path (fib_index, &net_pfx,
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&net_pfx.fp_addr,
sw_if_index,
// invalid FIB index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&pfx.fp_addr,
sw_if_index,
// invalid FIB index
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_ATTACHED),
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
/* No next-hop address */
NULL, sw_if_index,
/* invalid FIB index */
FIB_SOURCE_INTERFACE,
(FIB_ENTRY_FLAG_CONNECTED |
FIB_ENTRY_FLAG_LOCAL),
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&pfx.fp_addr,
sw_if_index, ~0,
1, NULL, FIB_ROUTE_PATH_FLAG_NONE);
(ip6_fib_table_get_index_for_sw_if_index (n->key.sw_if_index),
&pfx,
FIB_SOURCE_ADJ,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&pfx.fp_addr,
n->key.sw_if_index, ~0, 1, FIB_ROUTE_PATH_FLAG_NONE);
pool_put (nm->neighbor_pool, n);
n->fib_entry_index =
fib_table_entry_path_add (fib_index, &pfx, FIB_SOURCE_ADJ,
FIB_ENTRY_FLAG_ATTACHED,
- FIB_PROTOCOL_IP6, &pfx.fp_addr,
+ DPO_PROTO_IP6, &pfx.fp_addr,
n->key.sw_if_index, ~0, 1, NULL,
FIB_ROUTE_PATH_FLAG_NONE);
}
(ip6_fib_table_get_index_for_sw_if_index (n->key.sw_if_index),
&pfx,
FIB_SOURCE_ADJ,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&pfx.fp_addr, n->key.sw_if_index, ~0, 1, FIB_ROUTE_PATH_FLAG_NONE);
}
pool_put (nm->neighbor_pool, n);
fib_table_entry_path_remove (fib_index,
&pfx,
FIB_SOURCE_IP6_ND_PROXY,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh,
sw_if_index,
~0, 1, FIB_ROUTE_PATH_FLAG_NONE);
&pfx,
FIB_SOURCE_IP6_ND_PROXY,
FIB_ENTRY_FLAG_NONE,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
&nh,
sw_if_index,
~0, 1, NULL, FIB_ROUTE_PATH_FLAG_NONE);
int is_ip4;
vl_api_fib_path_t *fp = (vl_api_fib_path_t *) fp_arg;
- if (api_rpath->rpath.frp_proto == FIB_PROTOCOL_IP4)
+ if (api_rpath->rpath.frp_proto == DPO_PROTO_IP4)
fp->afi = IP46_TYPE_IP4;
- else if (api_rpath->rpath.frp_proto == FIB_PROTOCOL_IP6)
+ else if (api_rpath->rpath.frp_proto == DPO_PROTO_IP6)
fp->afi = IP46_TYPE_IP6;
else
{
u8 is_rpf_id,
u32 fib_index,
const fib_prefix_t * prefix,
- u8 next_hop_proto_is_ip4,
+ dpo_proto_t next_hop_proto,
const ip46_address_t * next_hop,
u32 next_hop_sw_if_index,
u8 next_hop_fib_index,
vnet_classify_main_t *cm = &vnet_classify_main;
fib_route_path_flags_t path_flags = FIB_ROUTE_PATH_FLAG_NONE;
fib_route_path_t path = {
- .frp_proto = (next_hop_proto_is_ip4 ?
- FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6),
+ .frp_proto = next_hop_proto,
.frp_addr = (NULL == next_hop ? zero_addr : *next_hop),
.frp_sw_if_index = next_hop_sw_if_index,
.frp_fib_index = next_hop_fib_index,
if (MPLS_LABEL_INVALID != next_hop_via_label)
{
- path.frp_proto = FIB_PROTOCOL_MPLS;
+ path.frp_proto = DPO_PROTO_MPLS;
path.frp_local_label = next_hop_via_label;
path.frp_eos = MPLS_NON_EOS;
}
add_del_route_check (fib_protocol_t table_proto,
u32 table_id,
u32 next_hop_sw_if_index,
- fib_protocol_t next_hop_table_proto,
+ dpo_proto_t next_hop_table_proto,
u32 next_hop_table_id,
u8 create_missing_tables,
u8 is_rpf_id, u32 * fib_index, u32 * next_hop_fib_index)
}
else
{
+ fib_protocol_t fib_nh_proto;
+
+ if (next_hop_table_proto > DPO_PROTO_MPLS)
+ return (0);
+
+ fib_nh_proto = dpo_proto_to_fib (next_hop_table_proto);
+
if (is_rpf_id)
- *next_hop_fib_index = mfib_table_find (next_hop_table_proto,
+ *next_hop_fib_index = mfib_table_find (fib_nh_proto,
ntohl (next_hop_table_id));
else
- *next_hop_fib_index = fib_table_find (next_hop_table_proto,
+ *next_hop_fib_index = fib_table_find (fib_nh_proto,
ntohl (next_hop_table_id));
if (~0 == *next_hop_fib_index)
{
if (is_rpf_id)
*next_hop_fib_index =
- mfib_table_find_or_create_and_lock (next_hop_table_proto,
+ mfib_table_find_or_create_and_lock (fib_nh_proto,
ntohl
(next_hop_table_id));
else
*next_hop_fib_index =
- fib_table_find_or_create_and_lock (next_hop_table_proto,
+ fib_table_find_or_create_and_lock (fib_nh_proto,
ntohl
(next_hop_table_id));
}
rv = add_del_route_check (FIB_PROTOCOL_IP4,
mp->table_id,
mp->next_hop_sw_if_index,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
mp->next_hop_table_id,
mp->create_vrf_if_needed, 0,
&fib_index, &next_hop_fib_index);
mp->classify_table_index,
mp->is_resolve_host,
mp->is_resolve_attached, 0, 0,
- fib_index, &pfx, 1,
+ fib_index, &pfx, DPO_PROTO_IP4,
&nh,
ntohl (mp->next_hop_sw_if_index),
next_hop_fib_index,
rv = add_del_route_check (FIB_PROTOCOL_IP6,
mp->table_id,
mp->next_hop_sw_if_index,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
mp->next_hop_table_id,
mp->create_vrf_if_needed, 0,
&fib_index, &next_hop_fib_index);
mp->classify_table_index,
mp->is_resolve_host,
mp->is_resolve_attached, 0, 0,
- fib_index, &pfx, 0,
+ fib_index, &pfx, DPO_PROTO_IP6,
&nh, ntohl (mp->next_hop_sw_if_index),
next_hop_fib_index,
mp->next_hop_weight,
fib_route_path_t path = {
.frp_sw_if_index = next_hop_sw_if_index,
- .frp_proto = prefix->fp_proto,
+ .frp_proto = fib_proto_to_dpo (prefix->fp_proto),
};
if (is_local)
{
rpath.frp_weight = 1;
rpath.frp_eos = MPLS_NON_EOS;
- rpath.frp_proto = FIB_PROTOCOL_MPLS;
+ rpath.frp_proto = DPO_PROTO_MPLS;
rpath.frp_sw_if_index = ~0;
vec_add1 (rpaths, rpath);
}
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1 (rpaths, rpath);
}
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1 (rpaths, rpath);
}
else if (unformat (line_input, "weight %u", &weight))
{
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1 (rpaths, rpath);
}
else if (unformat (line_input, "via %U next-hop-table %d",
{
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1 (rpaths, rpath);
}
else if (unformat (line_input, "via %U",
rpath.frp_fib_index = table_id;
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1 (rpaths, rpath);
}
else if (unformat (line_input, "via %U",
rpath.frp_fib_index = table_id;
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1 (rpaths, rpath);
}
else if (unformat (line_input,
"lookup in table %d", &rpath.frp_fib_index))
{
- rpath.frp_proto = pfx.fp_proto;
+ rpath.frp_proto = fib_proto_to_dpo (pfx.fp_proto);
rpath.frp_sw_if_index = ~0;
vec_add1 (rpaths, rpath);
}
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = prefixs[0].fp_proto;
+ rpath.frp_proto = fib_proto_to_dpo (prefixs[0].fp_proto);
vec_add1 (rpaths, rpath);
}
else if (vec_len (prefixs) > 0 &&
fib_route_path_t *rpath;
u8 ip_version;
- ip_version = a->rpath.frp_proto == FIB_PROTOCOL_IP4 ? IP4 : IP6;
+ ip_version = a->rpath.frp_proto == DPO_PROTO_IP4 ? IP4 : IP6;
if (a->is_add)
{
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
}
else if (unformat (line_input, "via %U %U",
unformat_ip6_address,
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
}
else if (unformat (line_input, "via %U",
unformat_ip4_address, &rpath.frp_addr.ip4))
{
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
}
else if (unformat (line_input, "via %U",
unformat_ip6_address, &rpath.frp_addr.ip6))
{
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
}
else
{
}
else
{
- rpath.frp_fib_index = fib_table_find (rpath.frp_proto, table_id);
+ rpath.frp_fib_index =
+ fib_table_find (dpo_proto_to_fib (rpath.frp_proto), table_id);
if ((u32) ~ 0 == rpath.frp_fib_index)
{
error = clib_error_return (0, "Nonexistent table id %d", table_id);
clib_memcpy (&a->rpath.frp_addr.ip6, mp->nh_addr, sizeof (ip6_address_t));
a->is_add = mp->is_add;
- a->rpath.frp_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
- a->rpath.frp_fib_index = fib_table_find (a->rpath.frp_proto,
- clib_net_to_host_u32
- (mp->table_id));
+ a->rpath.frp_proto = mp->is_ip4 ? DPO_PROTO_IP4 : DPO_PROTO_IP6;
+ a->rpath.frp_fib_index =
+ fib_table_find (dpo_proto_to_fib (a->rpath.frp_proto),
+ clib_net_to_host_u32 (mp->table_id));
if (~0 == a->rpath.frp_fib_index)
{
rv = VNET_API_ERROR_INVALID_VALUE;
vec_foreach (e, src)
{
memset (&dst[i], 0, sizeof (*dst));
- table = fib_table_get (e->frp_fib_index, e->frp_proto);
+ table = fib_table_get (e->frp_fib_index, dpo_proto_to_fib (e->frp_proto));
dst[i].fib_index = table->ft_table_id;
dst[i].nh_sw_if_index = e->frp_sw_if_index;
dst[i].is_ip4 = is_ip4;
{
const lisp_gpe_adjacency_t *ladj;
fib_route_path_t *rpaths = NULL;
+ fib_protocol_t fp;
u8 best_priority;
u32 ii;
ladj = lisp_gpe_adjacency_get (paths[ii].lisp_adj);
- ip_address_to_46 (&ladj->remote_rloc,
- &rpaths[ii].frp_addr, &rpaths[ii].frp_proto);
+ ip_address_to_46 (&ladj->remote_rloc, &rpaths[ii].frp_addr, &fp);
+ rpaths[ii].frp_proto = fib_proto_to_dpo (fp);
rpaths[ii].frp_sw_if_index = ladj->sw_if_index;
rpaths[ii].frp_weight = (paths[ii].weight ? paths[ii].weight : 1);
}
.fp_proto = FIB_PROTOCOL_IP6,
};
const fib_route_path_t path_for_us = {
- .frp_proto = FIB_PROTOCOL_IP6,
+ .frp_proto = DPO_PROTO_IP6,
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
.fp_proto = FIB_PROTOCOL_IP6,
};
const fib_route_path_t path_for_us = {
- .frp_proto = FIB_PROTOCOL_IP6,
+ .frp_proto = DPO_PROTO_IP6,
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
ip6_mfib_interface_enable_disable (u32 sw_if_index, int is_enable)
{
const fib_route_path_t path = {
- .frp_proto = FIB_PROTOCOL_IP6,
+ .frp_proto = DPO_PROTO_IP6,
.frp_addr = zero_addr,
.frp_sw_if_index = sw_if_index,
.frp_fib_index = ~0,
* entry
*/
fib_node_index_t old_pl_index;
- fib_protocol_t fp;
+ dpo_proto_t dp;
dpo_id_t dpo = DPO_INVALID;
- fp = mfib_entry_get_proto(mfib_entry);
+ dp = fib_proto_to_dpo(mfib_entry_get_proto(mfib_entry));
old_pl_index = msrc->mfes_pl;
- dpo_set(&dpo, DPO_REPLICATE,
- fib_proto_to_dpo(fp),
- repi);
+ dpo_set(&dpo, DPO_REPLICATE, dp, repi);
msrc->mfes_pl =
- fib_path_list_create_special(fp,
+ fib_path_list_create_special(dp,
FIB_PATH_LIST_FLAG_EXCLUSIVE,
&dpo);
fib_route_path_t path_via_if0 = {
- .frp_proto = PROTO,
+ .frp_proto = fib_proto_to_dpo(PROTO),
.frp_addr = zero_addr,
.frp_sw_if_index = tm->hw[0]->sw_if_index,
.frp_fib_index = ~0,
MFIB_ITF_FLAG_ACCEPT));
fib_route_path_t path_via_if1 = {
- .frp_proto = PROTO,
+ .frp_proto = fib_proto_to_dpo(PROTO),
.frp_addr = zero_addr,
.frp_sw_if_index = tm->hw[1]->sw_if_index,
.frp_fib_index = ~0,
.frp_flags = 0,
};
fib_route_path_t path_via_if2 = {
- .frp_proto = PROTO,
+ .frp_proto = fib_proto_to_dpo(PROTO),
.frp_addr = zero_addr,
.frp_sw_if_index = tm->hw[2]->sw_if_index,
.frp_fib_index = ~0,
.frp_flags = 0,
};
fib_route_path_t path_via_if3 = {
- .frp_proto = PROTO,
+ .frp_proto = fib_proto_to_dpo(PROTO),
.frp_addr = zero_addr,
.frp_sw_if_index = tm->hw[3]->sw_if_index,
.frp_fib_index = ~0,
.frp_flags = 0,
};
fib_route_path_t path_for_us = {
- .frp_proto = PROTO,
+ .frp_proto = fib_proto_to_dpo(PROTO),
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
&pfx_3500,
FIB_SOURCE_API,
FIB_ENTRY_FLAG_MULTICAST,
- FIB_PROTOCOL_IP4,
+ DPO_PROTO_IP4,
&nh_10_10_10_1,
tm->hw[0]->sw_if_index,
~0, // invalid fib index
* An (S,G) that resolves via the mLDP head-end
*/
fib_route_path_t path_via_mldp = {
- .frp_proto = FIB_PROTOCOL_MPLS,
+ .frp_proto = DPO_PROTO_MPLS,
.frp_local_label = pfx_3500.fp_label,
.frp_eos = MPLS_EOS,
.frp_sw_if_index = 0xffffffff,
@param mr_is_interface_rx - Interface Receive path
@param mr_is_interface_rx - RPF-ID Receive path. The next-hop interface
is used as the RPF-ID
- @param mr_next_hop_proto_is_ip4 - The next-hop is IPV4
+ @param mr_next_hop_proto - The next-hop protocol, of type dpo_proto_t
@param mr_next_hop_weight - The weight, for UCMP
@param mr_next_hop[16] - the nextop address
@param mr_next_hop_sw_if_index - the next-hop SW interface
u8 mr_is_resolve_attached;
u8 mr_is_interface_rx;
u8 mr_is_rpf_id;
- u8 mr_next_hop_proto_is_ip4;
+ u8 mr_next_hop_proto;
u8 mr_next_hop_weight;
u8 mr_next_hop_preference;
u8 mr_next_hop[16];
&rpath.frp_sw_if_index,
&rpath.frp_weight))
{
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1(rpaths, rpath);
}
&rpath.frp_sw_if_index,
&rpath.frp_weight))
{
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1(rpaths, rpath);
}
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1(rpaths, rpath);
}
else if (unformat (line_input, "rx-ip4 %U",
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
rpath.frp_flags = FIB_ROUTE_PATH_INTF_RX;
vec_add1(rpaths, rpath);
}
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1(rpaths, rpath);
}
else if (unformat (line_input, "via %U next-hop-table %d",
{
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1(rpaths, rpath);
}
else if (unformat (line_input, "via %U next-hop-table %d",
{
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1(rpaths, rpath);
}
else if (unformat (line_input, "via %U",
rpath.frp_fib_index = table_id;
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
vec_add1(rpaths, rpath);
}
else if (unformat (line_input, "via %U",
rpath.frp_fib_index = table_id;
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
vec_add1(rpaths, rpath);
}
else if (unformat (line_input, "%d", &local_label))
"ip4-lookup-in-table %d",
&rpath.frp_fib_index))
{
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID;
pfx.fp_payload_proto = DPO_PROTO_IP4;
vec_add1(rpaths, rpath);
"ip6-lookup-in-table %d",
&rpath.frp_fib_index))
{
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID;
vec_add1(rpaths, rpath);
pfx.fp_payload_proto = DPO_PROTO_IP6;
"mpls-lookup-in-table %d",
&rpath.frp_fib_index))
{
- rpath.frp_proto = FIB_PROTOCOL_MPLS;
+ rpath.frp_proto = DPO_PROTO_MPLS;
rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID;
pfx.fp_payload_proto = DPO_PROTO_MPLS;
vec_add1(rpaths, rpath);
}
+ else if (unformat (line_input,
+ "l2-input-on %U",
+ unformat_vnet_sw_interface, vnm,
+ &rpath.frp_sw_if_index))
+ {
+ rpath.frp_proto = DPO_PROTO_ETHERNET;
+ pfx.fp_payload_proto = DPO_PROTO_ETHERNET;
+ rpath.frp_flags = FIB_ROUTE_PATH_INTF_RX;
+ vec_add1(rpaths, rpath);
+ }
else if (unformat (line_input, "out-label %U",
unformat_mpls_unicast_label,
&out_label))
pfx.fp_proto = FIB_PROTOCOL_MPLS;
pfx.fp_len = 21;
pfx.fp_label = local_label;
- pfx.fp_payload_proto = fib_proto_to_dpo(rpaths[0].frp_proto);
+ pfx.fp_payload_proto = rpaths[0].frp_proto;
/*
* the CLI parsing stored table Ids, swap to FIB indicies
};
if (pfx.fp_eos)
{
- if (mp->mr_next_hop_proto_is_ip4)
- {
- pfx.fp_payload_proto = DPO_PROTO_IP4;
- }
- else
- {
- pfx.fp_payload_proto = DPO_PROTO_IP6;
- }
+ pfx.fp_payload_proto = mp->mr_next_hop_proto;
}
else
{
rv = add_del_route_check (FIB_PROTOCOL_MPLS,
mp->mr_table_id,
mp->mr_next_hop_sw_if_index,
- dpo_proto_to_fib (pfx.fp_payload_proto),
+ pfx.fp_payload_proto,
mp->mr_next_hop_table_id,
mp->mr_create_table_if_needed,
mp->mr_is_rpf_id,
ip46_address_t nh;
memset (&nh, 0, sizeof (nh));
- if (mp->mr_next_hop_proto_is_ip4)
+ if (DPO_PROTO_IP4 == mp->mr_next_hop_proto)
memcpy (&nh.ip4, mp->mr_next_hop, sizeof (nh.ip4));
- else
+ else if (DPO_PROTO_IP6 == mp->mr_next_hop_proto)
memcpy (&nh.ip6, mp->mr_next_hop, sizeof (nh.ip6));
n_labels = mp->mr_next_hop_n_out_labels;
mp->mr_is_interface_rx,
mp->mr_is_rpf_id,
fib_index, &pfx,
- mp->mr_next_hop_proto_is_ip4,
+ mp->mr_next_hop_proto,
&nh, ntohl (mp->mr_next_hop_sw_if_index),
next_hop_fib_index,
mp->mr_next_hop_weight,
if (mp->mt_next_hop_proto_is_ip4)
{
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
clib_memcpy (&rpath.frp_addr.ip4,
mp->mt_next_hop, sizeof (rpath.frp_addr.ip4));
}
else
{
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
clib_memcpy (&rpath.frp_addr.ip6,
mp->mt_next_hop, sizeof (rpath.frp_addr.ip6));
}
vec_validate(ctx.next_hops, fib_path_list_get_n_paths(mt->mt_path_list));
vec_reset_length(ctx.next_hops);
- lb_proto = vnet_link_to_dpo_proto(linkt);
+ lb_proto = fib_forw_chain_type_to_dpo_proto(fct);
fib_path_list_walk(mt->mt_path_list,
mpls_tunnel_collect_forwarding,
/*
* walk all the adjacencies on the MPLS interface and restack them
*/
- FOR_EACH_FIB_PROTOCOL(proto)
+ if (mt->mt_flags & MPLS_TUNNEL_FLAG_L2)
{
- adj_nbr_walk(mt->mt_sw_if_index,
- proto,
- mpls_adj_walk_cb,
- NULL);
+ /*
+ * Stack a load-balance that drops, whilst we have no paths
+ */
+ vnet_hw_interface_t * hi;
+ dpo_id_t dpo = DPO_INVALID;
+
+ mpls_tunnel_mk_lb(mt,
+ VNET_LINK_MPLS,
+ FIB_FORW_CHAIN_TYPE_ETHERNET,
+ &dpo);
+
+ hi = vnet_get_hw_interface(vnet_get_main(), mt->mt_hw_if_index);
+ dpo_stack_from_node(hi->tx_node_index,
+ &mt->mt_l2_lb,
+ &dpo);
+ dpo_reset(&dpo);
+ }
+ else
+ {
+ FOR_EACH_FIB_PROTOCOL(proto)
+ {
+ adj_nbr_walk(mt->mt_sw_if_index,
+ proto,
+ mpls_adj_walk_cb,
+ NULL);
+ }
}
}
b0 = vlib_get_buffer(vm, bi0);
- vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_adj;
+ vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_lb.dpoi_index;
if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
{
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
to_next, n_left_to_next,
- bi0, mt->mt_l2_tx_arc);
+ bi0, mt->mt_l2_lb.dpoi_next_node);
}
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
if (FIB_NODE_INDEX_INVALID != mt->mt_path_list)
fib_path_list_child_remove(mt->mt_path_list,
mt->mt_sibling_index);
- if (ADJ_INDEX_INVALID != mt->mt_l2_adj)
- adj_unlock(mt->mt_l2_adj);
+ dpo_reset(&mt->mt_l2_lb);
vec_add1 (mpls_tunnel_free_hw_if_indices, mt->mt_hw_if_index);
pool_put(mpls_tunnel_pool, mt);
memset (mt, 0, sizeof (*mt));
mti = mt - mpls_tunnel_pool;
fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL);
- mt->mt_l2_adj = ADJ_INDEX_INVALID;
mt->mt_path_list = FIB_NODE_INDEX_INVALID;
mt->mt_sibling_index = FIB_NODE_INDEX_INVALID;
if (is_multicast)
mt->mt_flags |= MPLS_TUNNEL_FLAG_MCAST;
+ if (l2_only)
+ mt->mt_flags |= MPLS_TUNNEL_FLAG_L2;
/*
* Create a new, or re=use and old, tunnel HW interface
mti,
mpls_tunnel_hw_interface_class.index,
mti);
- hi = vnet_get_hw_interface(vnm, mt->mt_hw_if_index);
+ hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index);
}
/*
vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0);
mpls_tunnel_db[mt->mt_sw_if_index] = mti;
- if (l2_only)
- {
- mt->mt_l2_adj =
- adj_nbr_add_or_lock(fib_path_list_get_proto(mt->mt_path_list),
- VNET_LINK_ETHERNET,
- &zero_addr,
- mt->mt_sw_if_index);
-
- mt->mt_l2_tx_arc = vlib_node_add_named_next(vlib_get_main(),
- hi->tx_node_index,
- "adj-l2-midchain");
- }
-
return (mt->mt_sw_if_index);
}
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
}
else if (unformat (line_input, "via %U %U",
&rpath.frp_sw_if_index))
{
rpath.frp_weight = 1;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
}
else if (unformat (line_input, "via %U",
unformat_ip6_address,
rpath.frp_fib_index = 0;
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP6;
+ rpath.frp_proto = DPO_PROTO_IP6;
}
else if (unformat (line_input, "via %U",
unformat_ip4_address,
rpath.frp_fib_index = 0;
rpath.frp_weight = 1;
rpath.frp_sw_if_index = ~0;
- rpath.frp_proto = FIB_PROTOCOL_IP4;
+ rpath.frp_proto = DPO_PROTO_IP4;
}
else if (unformat (line_input, "l2-only"))
l2_only = 1;
s = format(s, "%U", format_fib_path_ext_list, &mt->mt_path_exts);
s = format(s, "\n");
+ if (mt->mt_flags & MPLS_TUNNEL_FLAG_L2)
+ {
+ s = format(s, " forwarding: %U\n",
+ format_fib_forw_chain_type,
+ FIB_FORW_CHAIN_TYPE_ETHERNET);
+ s = format(s, " %U\n", format_dpo_id, &mt->mt_l2_lb, 2);
+ }
+
return (s);
}
typedef enum mpls_tunnel_attribute_t_
{
MPLS_TUNNEL_ATTRIBUTE_FIRST = 0,
+ /**
+ * @brief The tunnel is L2 only
+ */
+ MPLS_TUNNEL_ATTRIBUTE_L2 = MPLS_TUNNEL_ATTRIBUTE_FIRST,
/**
* @brief The tunnel has an underlying multicast LSP
*/
- MPLS_TUNNEL_ATTRIBUTE_MCAST = MPLS_TUNNEL_ATTRIBUTE_FIRST,
+ MPLS_TUNNEL_ATTRIBUTE_MCAST,
MPLS_TUNNEL_ATTRIBUTE_LAST = MPLS_TUNNEL_ATTRIBUTE_MCAST,
} mpls_tunnel_attribute_t;
#define MPLS_TUNNEL_ATTRIBUTES { \
[MPLS_TUNNEL_ATTRIBUTE_MCAST] = "multicast", \
+ [MPLS_TUNNEL_ATTRIBUTE_L2] = "L2", \
}
#define FOR_EACH_MPLS_TUNNEL_ATTRIBUTE(_item) \
for (_item = MPLS_TUNNEL_ATTRIBUTE_FIRST; \
typedef enum mpls_tunnel_flag_t_ {
MPLS_TUNNEL_FLAG_NONE = 0,
+ MPLS_TUNNEL_FLAG_L2 = (1 << MPLS_TUNNEL_ATTRIBUTE_L2),
MPLS_TUNNEL_FLAG_MCAST = (1 << MPLS_TUNNEL_ATTRIBUTE_MCAST),
} __attribute__ ((packed)) mpls_tunnel_flags_t;
/**
* @brief If the tunnel is an L2 tunnel, this is the link type ETHERNET
- * adjacency
+ * load-balance
+ */
+ dpo_id_t mt_l2_lb;
+
+ /**
+ * @brief The HW interface index of the tunnel interfaces
*/
- adj_index_t mt_l2_adj;
+ u32 mt_hw_if_index;
/**
- * @brief on a L2 tunnel this is the VLIB arc from the L2-tx to the l2-midchain
+ * @brief The SW interface index of the tunnel interfaces
*/
- u32 mt_l2_tx_arc;
+ u32 mt_sw_if_index;
/**
* @brief The path-list over which the tunnel's destination is reachable
* A vector of path extensions o hold the label stack for each path
*/
fib_path_ext_list_t mt_path_exts;
-
- /**
- * @brief Flag to indicate the tunnel is only for L2 traffic, that is
- * this tunnel belongs in a bridge domain.
- */
- u8 mt_l2_only;
-
- /**
- * @brief The HW interface index of the tunnel interfaces
- */
- u32 mt_hw_if_index;
-
- /**
- * @brief The SW interface index of the tunnel interfaces
- */
- u32 mt_sw_if_index;
-
} mpls_tunnel_t;
/**
segment_list->segments = vec_dup (sl);
fib_route_path_t path = {
- .frp_proto = FIB_PROTOCOL_MPLS,
+ .frp_proto = DPO_PROTO_MPLS,
.frp_sw_if_index = ~0,
.frp_fib_index = 0,
.frp_weight = segment_list->weight,
segment_list = pool_elt_at_index (sm->sid_lists, *sl_index);
fib_route_path_t path = {
- .frp_proto = FIB_PROTOCOL_MPLS,
+ .frp_proto = DPO_PROTO_MPLS,
.frp_sw_if_index = ~0,
.frp_fib_index = 0,
.frp_weight = segment_list->weight,
mpls_eos_bit_t eos;
fib_route_path_t path = {
- .frp_proto = FIB_PROTOCOL_MPLS,
+ .frp_proto = DPO_PROTO_MPLS,
.frp_sw_if_index = ~0,
.frp_fib_index = 0,
.frp_weight = segment_list->weight,
update_fib:;
fib_route_path_t path = {
- .frp_proto = FIB_PROTOCOL_MPLS,
+ .frp_proto = DPO_PROTO_MPLS,
.frp_local_label = sr_policy->bsid,
.frp_eos = MPLS_EOS,
.frp_sw_if_index = ~0,
table_id : 0)),
&pfx, FIB_SOURCE_SR,
FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
(ip46_address_t *) & sr_policy->bsid, ~0,
sm->fib_table_ip6, 1, NULL,
FIB_ROUTE_PATH_FLAG_NONE);
table_id : 0)),
&pfx, FIB_SOURCE_SR,
FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT,
- FIB_PROTOCOL_IP6,
+ DPO_PROTO_IP6,
(ip46_address_t *) & sr_policy->bsid, ~0,
sm->fib_table_ip4, 1, NULL,
FIB_ROUTE_PATH_FLAG_NONE);
fib_node_index_t mfei;
adj_index_t ai;
fib_route_path_t path = {
- .frp_proto = fp,
+ .frp_proto = fib_proto_to_dpo(fp),
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
fib_node_index_t mfei;
adj_index_t ai;
fib_route_path_t path = {
- .frp_proto = fp,
+ .frp_proto = fib_proto_to_dpo(fp),
.frp_addr = zero_addr,
.frp_sw_if_index = 0xffffffff,
.frp_fib_index = ~0,
vec_add2 (rpaths, rpath, 1);
- rpath->frp_proto = FIB_PROTOCOL_IP4;
+ rpath->frp_proto = DPO_PROTO_IP4;
rpath->frp_addr = next_hops[i];
rpath->frp_sw_if_index = sw_if_index;
rpath->frp_fib_index = ~0;
from vpp_lo_interface import VppLoInterface
from util import ppp
from vpp_papi_provider import UnexpectedApiReturnValueError
-from vpp_ip_route import VppIpRoute, VppRoutePath
+from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto
USEC_IN_SEC = 1000000
ip_2001_s_64 = VppIpRoute(self, "2001::", 64,
[VppRoutePath(self.pg0.remote_ip6,
self.pg0.sw_if_index,
- is_ip6=1)],
+ proto=DPO_PROTO_IP6)],
is_ip6=1)
ip_2002_s_64 = VppIpRoute(self, "2002::", 64,
[VppRoutePath(self.pg0.remote_ip6,
0xffffffff,
- is_ip6=1)],
+ proto=DPO_PROTO_IP6)],
is_ip6=1)
ip_2001_s_64.add_vpp_config()
ip_2002_s_64.add_vpp_config()
from framework import VppTestCase, VppTestRunner
from vpp_sub_interface import VppDot1QSubint
from vpp_gre_interface import VppGreInterface, VppGre6Interface
-from vpp_ip_route import VppIpRoute, VppRoutePath
+from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto
from vpp_papi_provider import L2_VTR_OP
from scapy.packet import Raw
gre_if.admin_up()
gre_if.config_ip6()
- route_via_tun = VppIpRoute(self, "4004::1", 128,
- [VppRoutePath("0::0",
- gre_if.sw_if_index,
- is_ip6=1)],
- is_ip6=1)
+ route_via_tun = VppIpRoute(
+ self, "4004::1", 128,
+ [VppRoutePath("0::0",
+ gre_if.sw_if_index,
+ proto=DpoProto.DPO_PROTO_IP6)],
+ is_ip6=1)
route_via_tun.add_vpp_config()
#
# Add a route that resolves the tunnel's destination
#
- route_tun_dst = VppIpRoute(self, "1002::1", 128,
- [VppRoutePath(self.pg2.remote_ip6,
- self.pg2.sw_if_index,
- is_ip6=1)],
- is_ip6=1)
+ route_tun_dst = VppIpRoute(
+ self, "1002::1", 128,
+ [VppRoutePath(self.pg2.remote_ip6,
+ self.pg2.sw_if_index,
+ proto=DpoProto.DPO_PROTO_IP6)],
+ is_ip6=1)
route_tun_dst.add_vpp_config()
#
from vpp_pg_interface import is_ipv6_misc
from vpp_ip_route import VppIpRoute, VppRoutePath, find_route, VppIpMRoute, \
VppMRoutePath, MRouteItfFlags, MRouteEntryFlags, VppMplsIpBind, \
- VppMplsRoute
+ VppMplsRoute, DpoProto
from vpp_neighbor import find_nbr, VppNeighbor
from scapy.packet import Raw
inet=AF_INET6))
def test_ns_duplicates(self):
- """ ARP Duplicates"""
+ """ ND Duplicates"""
#
# Generate some hosts on the LAN
#
# remove the duplicate on pg1
- # packet stream shoud generate ARPs out of pg1
+ # packet stream shoud generate NSs out of pg1
#
ns_pg1.remove_vpp_config()
route_3000_1 = VppIpRoute(self, "3000::1", 128,
[VppRoutePath(self.pg1.remote_ip6,
self.pg1.sw_if_index,
- is_ip6=1),
+ proto=DpoProto.DPO_PROTO_IP6),
VppRoutePath(self.pg2.remote_ip6,
self.pg2.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_3000_1.add_vpp_config()
[VppRoutePath(self.pg1.remote_ip6,
self.pg1.sw_if_index,
labels=[67],
- is_ip6=1),
+ proto=DpoProto.DPO_PROTO_IP6),
VppRoutePath(self.pg2.remote_ip6,
self.pg2.sw_if_index,
labels=[67],
- is_ip6=1)])
+ proto=DpoProto.DPO_PROTO_IP6)])
route_67.add_vpp_config()
#
route_3000_2 = VppIpRoute(self, "3000::2", 128,
[VppRoutePath(self.pg3.remote_ip6,
self.pg3.sw_if_index,
- is_ip6=1),
+ proto=DpoProto.DPO_PROTO_IP6),
VppRoutePath(self.pg4.remote_ip6,
self.pg4.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_3000_2.add_vpp_config()
route_4000_1 = VppIpRoute(self, "4000::1", 128,
[VppRoutePath("3000::1",
0xffffffff,
- is_ip6=1),
+ proto=DpoProto.DPO_PROTO_IP6),
VppRoutePath("3000::2",
0xffffffff,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_4000_1.add_vpp_config()
route_5000_2 = VppIpRoute(self, "5000::2", 128,
[VppRoutePath(self.pg3.remote_ip6,
self.pg3.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_5000_2.add_vpp_config()
route_6000_1 = VppIpRoute(self, "6000::1", 128,
[VppRoutePath("5000::2",
0xffffffff,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_6000_1.add_vpp_config()
import socket
from framework import VppTestCase, VppTestRunner
-from vpp_ip_route import VppIpRoute, VppRoutePath
+from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto
from scapy.layers.l2 import Ether, Raw
from scapy.layers.inet import IP, UDP, ICMP
map_br_pfx_len,
[VppRoutePath(self.pg1.remote_ip6,
self.pg1.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
map_route.add_vpp_config()
# Add a route to 4001::1. Expect the encapped traffic to be
# sent via that routes next-hop
#
- pre_res_route = VppIpRoute(self,
- "4001::1",
- 128,
- [VppRoutePath(self.pg1.remote_hosts[2].ip6,
- self.pg1.sw_if_index,
- is_ip6=1)],
- is_ip6=1)
+ pre_res_route = VppIpRoute(
+ self, "4001::1", 128,
+ [VppRoutePath(self.pg1.remote_hosts[2].ip6,
+ self.pg1.sw_if_index,
+ proto=DpoProto.DPO_PROTO_IP6)],
+ is_ip6=1)
pre_res_route.add_vpp_config()
self.send_and_assert_encapped(v4, map_src,
#
pre_res_route.modify([VppRoutePath(self.pg1.remote_hosts[3].ip6,
self.pg1.sw_if_index,
- is_ip6=1)])
+ proto=DpoProto.DPO_PROTO_IP6)])
pre_res_route.add_vpp_config()
self.send_and_assert_encapped(v4, map_src,
from framework import VppTestCase, VppTestRunner
from vpp_ip_route import VppIpRoute, VppRoutePath, VppMplsRoute, \
VppMplsIpBind, VppIpMRoute, VppMRoutePath, \
- MRouteItfFlags, MRouteEntryFlags
+ MRouteItfFlags, MRouteEntryFlags, DpoProto
from vpp_mpls_tunnel_interface import VppMPLSTunnelInterface
from scapy.packet import Raw
from scapy.contrib.mpls import MPLS
+def verify_filter(capture, sent):
+ if not len(capture) == len(sent):
+ # filter out any IPv6 RAs from the capture
+ for p in capture:
+ if p.haslayer(IPv6):
+ capture.remove(p)
+ return capture
+
+
+def verify_mpls_stack(tst, rx, mpls_labels, ttl=255, num=0):
+ # the rx'd packet has the MPLS label popped
+ eth = rx[Ether]
+ tst.assertEqual(eth.type, 0x8847)
+
+ rx_mpls = rx[MPLS]
+
+ for ii in range(len(mpls_labels)):
+ tst.assertEqual(rx_mpls.label, mpls_labels[ii])
+ tst.assertEqual(rx_mpls.cos, 0)
+ if ii == num:
+ tst.assertEqual(rx_mpls.ttl, ttl)
+ else:
+ tst.assertEqual(rx_mpls.ttl, 255)
+ if ii == len(mpls_labels) - 1:
+ tst.assertEqual(rx_mpls.s, 1)
+ else:
+ # not end of stack
+ tst.assertEqual(rx_mpls.s, 0)
+ # pop the label to expose the next
+ rx_mpls = rx_mpls[MPLS].payload
+
+
class TestMPLS(VppTestCase):
""" MPLS Test Case """
pkts.append(p)
return pkts
- @staticmethod
- def verify_filter(capture, sent):
- if not len(capture) == len(sent):
- # filter out any IPv6 RAs from the capture
- for p in capture:
- if p.haslayer(IPv6):
- capture.remove(p)
- return capture
-
def verify_capture_ip4(self, src_if, capture, sent, ping_resp=0):
try:
- capture = self.verify_filter(capture, sent)
+ capture = verify_filter(capture, sent)
self.assertEqual(len(capture), len(sent))
except:
raise
- def verify_mpls_stack(self, rx, mpls_labels, ttl=255, num=0):
- # the rx'd packet has the MPLS label popped
- eth = rx[Ether]
- self.assertEqual(eth.type, 0x8847)
-
- rx_mpls = rx[MPLS]
-
- for ii in range(len(mpls_labels)):
- self.assertEqual(rx_mpls.label, mpls_labels[ii])
- self.assertEqual(rx_mpls.cos, 0)
- if ii == num:
- self.assertEqual(rx_mpls.ttl, ttl)
- else:
- self.assertEqual(rx_mpls.ttl, 255)
-
- if ii == len(mpls_labels) - 1:
- self.assertEqual(rx_mpls.s, 1)
- else:
- # not end of stack
- self.assertEqual(rx_mpls.s, 0)
- # pop the label to expose the next
- rx_mpls = rx_mpls[MPLS].payload
-
def verify_capture_labelled_ip4(self, src_if, capture, sent,
mpls_labels):
try:
- capture = self.verify_filter(capture, sent)
+ capture = verify_filter(capture, sent)
self.assertEqual(len(capture), len(sent))
rx_ip = rx[IP]
# the MPLS TTL is copied from the IP
- self.verify_mpls_stack(
- rx, mpls_labels, rx_ip.ttl, len(mpls_labels) - 1)
+ verify_mpls_stack(self, rx, mpls_labels, rx_ip.ttl,
+ len(mpls_labels) - 1)
self.assertEqual(rx_ip.src, tx_ip.src)
self.assertEqual(rx_ip.dst, tx_ip.dst)
if top is None:
top = len(mpls_labels) - 1
try:
- capture = self.verify_filter(capture, sent)
+ capture = verify_filter(capture, sent)
self.assertEqual(len(capture), len(sent))
rx_ip = rx[IP]
# the MPLS TTL is 255 since it enters a new tunnel
- self.verify_mpls_stack(
- rx, mpls_labels, ttl, top)
+ verify_mpls_stack(self, rx, mpls_labels, ttl, top)
self.assertEqual(rx_ip.src, tx_ip.src)
self.assertEqual(rx_ip.dst, tx_ip.dst)
def verify_capture_labelled(self, src_if, capture, sent,
mpls_labels, ttl=254, num=0):
try:
- capture = self.verify_filter(capture, sent)
+ capture = verify_filter(capture, sent)
self.assertEqual(len(capture), len(sent))
for i in range(len(capture)):
rx = capture[i]
- self.verify_mpls_stack(rx, mpls_labels, ttl, num)
+ verify_mpls_stack(self, rx, mpls_labels, ttl, num)
except:
raise
self.pg1.sw_if_index,
nh_table_id=1,
rpf_id=55,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_multicast=1)
route_34_eos.add_vpp_config()
for ii in range(64):
dst = "3000::%d" % ii
local_label = 1600 + ii
- vpn_routes.append(VppIpRoute(self, dst, 128,
- [VppRoutePath(self.pg2.remote_ip6,
- 0xffffffff,
- nh_table_id=1,
- is_resolve_attached=1,
- is_ip6=1),
- VppRoutePath(self.pg3.remote_ip6,
- 0xffffffff,
- nh_table_id=1,
- is_ip6=1,
- is_resolve_attached=1)],
- table_id=1,
- is_ip6=1))
+ vpn_routes.append(VppIpRoute(
+ self, dst, 128,
+ [VppRoutePath(self.pg2.remote_ip6,
+ 0xffffffff,
+ nh_table_id=1,
+ is_resolve_attached=1,
+ proto=DpoProto.DPO_PROTO_IP6),
+ VppRoutePath(self.pg3.remote_ip6,
+ 0xffffffff,
+ nh_table_id=1,
+ proto=DpoProto.DPO_PROTO_IP6,
+ is_resolve_attached=1)],
+ table_id=1,
+ is_ip6=1))
vpn_routes[ii].add_vpp_config()
vpn_bindings.append(VppMplsIpBind(self, local_label, dst, 128,
self.assertNotEqual(0, len(rx1))
+class TestMPLSL2(VppTestCase):
+ """ MPLS-L2 """
+
+ def setUp(self):
+ super(TestMPLSL2, self).setUp()
+
+ # create 2 pg interfaces
+ self.create_pg_interfaces(range(2))
+
+ # use pg0 as the core facing interface
+ self.pg0.admin_up()
+ self.pg0.config_ip4()
+ self.pg0.resolve_arp()
+ self.pg0.enable_mpls()
+
+ # use the other 2 for customer facg L2 links
+ for i in self.pg_interfaces[1:]:
+ i.admin_up()
+
+ def tearDown(self):
+ super(TestMPLSL2, self).tearDown()
+ for i in self.pg_interfaces[1:]:
+ i.admin_down()
+
+ self.pg0.disable_mpls()
+ self.pg0.unconfig_ip4()
+ self.pg0.admin_down()
+
+ def verify_capture_tunneled_ethernet(self, capture, sent, mpls_labels,
+ ttl=255, top=None):
+ if top is None:
+ top = len(mpls_labels) - 1
+
+ capture = verify_filter(capture, sent)
+
+ self.assertEqual(len(capture), len(sent))
+
+ for i in range(len(capture)):
+ tx = sent[i]
+ rx = capture[i]
+
+ # the MPLS TTL is 255 since it enters a new tunnel
+ verify_mpls_stack(self, rx, mpls_labels, ttl, top)
+
+ tx_eth = tx[Ether]
+ rx_eth = Ether(str(rx[MPLS].payload))
+
+ self.assertEqual(rx_eth.src, tx_eth.src)
+ self.assertEqual(rx_eth.dst, tx_eth.dst)
+
+ def test_vpws(self):
+ """ Virtual Private Wire Service """
+
+ #
+ # Create an MPLS tunnel that pushes 1 label
+ #
+ mpls_tun_1 = VppMPLSTunnelInterface(self,
+ [VppRoutePath(self.pg0.remote_ip4,
+ self.pg0.sw_if_index,
+ labels=[42])],
+ is_l2=1)
+ mpls_tun_1.add_vpp_config()
+ mpls_tun_1.admin_up()
+
+ #
+ # Create a label entry to for 55 that does L2 input to the tunnel
+ #
+ route_55_eos = VppMplsRoute(
+ self, 55, 1,
+ [VppRoutePath("0.0.0.0",
+ mpls_tun_1.sw_if_index,
+ is_interface_rx=1,
+ proto=DpoProto.DPO_PROTO_ETHERNET)])
+ route_55_eos.add_vpp_config()
+
+ #
+ # Cross-connect the tunnel with one of the customers L2 interfaces
+ #
+ self.vapi.sw_interface_set_l2_xconnect(self.pg1.sw_if_index,
+ mpls_tun_1.sw_if_index,
+ enable=1)
+ self.vapi.sw_interface_set_l2_xconnect(mpls_tun_1.sw_if_index,
+ self.pg1.sw_if_index,
+ enable=1)
+
+ #
+ # inject a packet from the core
+ #
+ pcore = (Ether(dst=self.pg0.local_mac,
+ src=self.pg0.remote_mac) /
+ MPLS(label=55, ttl=64) /
+ Ether(dst="00:00:de:ad:ba:be",
+ src="00:00:de:ad:be:ef") /
+ IP(src="10.10.10.10", dst="11.11.11.11") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+
+ self.pg0.add_stream(pcore * 65)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ rx0 = self.pg1.get_capture(65)
+ tx = pcore[MPLS].payload
+
+ self.assertEqual(rx0[0][Ether].dst, tx[Ether].dst)
+ self.assertEqual(rx0[0][Ether].src, tx[Ether].src)
+
+ #
+ # Inject a packet from the custoer/L2 side
+ #
+ self.pg1.add_stream(tx * 65)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ rx0 = self.pg0.get_capture(65)
+
+ self.verify_capture_tunneled_ethernet(rx0, tx*65, [42])
+
+ def test_vpls(self):
+ """ Virtual Private LAN Service """
+ #
+ # Create an L2 MPLS tunnel
+ #
+ mpls_tun = VppMPLSTunnelInterface(self,
+ [VppRoutePath(self.pg0.remote_ip4,
+ self.pg0.sw_if_index,
+ labels=[42])],
+ is_l2=1)
+ mpls_tun.add_vpp_config()
+ mpls_tun.admin_up()
+
+ #
+ # Create a label entry to for 55 that does L2 input to the tunnel
+ #
+ route_55_eos = VppMplsRoute(
+ self, 55, 1,
+ [VppRoutePath("0.0.0.0",
+ mpls_tun.sw_if_index,
+ is_interface_rx=1,
+ proto=DpoProto.DPO_PROTO_ETHERNET)])
+ route_55_eos.add_vpp_config()
+
+ #
+ # add to tunnel to the customers bridge-domain
+ #
+ self.vapi.sw_interface_set_l2_bridge(mpls_tun.sw_if_index,
+ bd_id=1)
+ self.vapi.sw_interface_set_l2_bridge(self.pg1.sw_if_index,
+ bd_id=1)
+
+ #
+ # Packet from the customer interface and from the core
+ #
+ p_cust = (Ether(dst="00:00:de:ad:ba:be",
+ src="00:00:de:ad:be:ef") /
+ IP(src="10.10.10.10", dst="11.11.11.11") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+ p_core = (Ether(src="00:00:de:ad:ba:be",
+ dst="00:00:de:ad:be:ef") /
+ IP(dst="10.10.10.10", src="11.11.11.11") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+
+ #
+ # The BD is learning, so send in one of each packet to learn
+ #
+ p_core_encap = (Ether(dst=self.pg0.local_mac,
+ src=self.pg0.remote_mac) /
+ MPLS(label=55, ttl=64) /
+ p_core)
+
+ self.pg1.add_stream(p_cust)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+ self.pg0.add_stream(p_core_encap)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ # we've learnt this so expect it be be forwarded
+ rx0 = self.pg1.get_capture(1)
+
+ self.assertEqual(rx0[0][Ether].dst, p_core[Ether].dst)
+ self.assertEqual(rx0[0][Ether].src, p_core[Ether].src)
+
+ #
+ # now a stream in each direction
+ #
+ self.pg1.add_stream(p_cust * 65)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ rx0 = self.pg0.get_capture(65)
+
+ self.verify_capture_tunneled_ethernet(rx0, p_cust*65, [42])
+
+ #
+ # remove interfaces from customers bridge-domain
+ #
+ self.vapi.sw_interface_set_l2_bridge(mpls_tun.sw_if_index,
+ bd_id=1,
+ enable=0)
+ self.vapi.sw_interface_set_l2_bridge(self.pg1.sw_if_index,
+ bd_id=1,
+ enable=0)
+
if __name__ == '__main__':
unittest.main(testRunner=VppTestRunner)
from framework import VppTestCase, VppTestRunner, running_extended_tests
from vpp_sub_interface import VppP2PSubint
-from vpp_ip_route import VppIpRoute, VppRoutePath
+from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto
from util import mactobinary
route_8000 = VppIpRoute(self, "8000::", 64,
[VppRoutePath(self.pg0.remote_ip6,
self.pg0.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_8000.add_vpp_config()
route_9001 = VppIpRoute(self, "9001::", 64,
[VppRoutePath(self.pg1.remote_ip6,
self.pg1.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_9001.add_vpp_config()
route_3 = VppIpRoute(self, "9000::", 64,
[VppRoutePath(self.pg1._remote_hosts[0].ip6,
self.pg1.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_3.add_vpp_config()
route_9001 = VppIpRoute(self, "9000::", 64,
[VppRoutePath(self.pg1._remote_hosts[0].ip6,
self.pg1.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_9001.add_vpp_config()
route_8000 = VppIpRoute(self, "8000::", 64,
[VppRoutePath(self.pg0.remote_ip6,
self.pg0.sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_8000.add_vpp_config()
route_8001 = VppIpRoute(self, "8001::", 64,
[VppRoutePath(self.p2p_sub_ifs[0].remote_ip6,
self.p2p_sub_ifs[0].sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_8001.add_vpp_config()
route_8002 = VppIpRoute(self, "8002::", 64,
[VppRoutePath(self.p2p_sub_ifs[1].remote_ip6,
self.p2p_sub_ifs[1].sw_if_index,
- is_ip6=1)],
+ proto=DpoProto.DPO_PROTO_IP6)],
is_ip6=1)
route_8002.add_vpp_config()
MFIB_ENTRY_FLAG_INHERIT_ACCEPT = 8
+class DpoProto:
+ DPO_PROTO_IP4 = 0
+ DPO_PROTO_IP6 = 1
+ DPO_PROTO_MPLS = 2
+ DPO_PROTO_ETHERNET = 3
+ DPO_PROTO_NSH = 4
+
+
def find_route(test, ip_addr, len, table_id=0, inet=AF_INET):
if inet == AF_INET:
s = 4
nh_table_id=0,
labels=[],
nh_via_label=MPLS_LABEL_INVALID,
- is_ip6=0,
rpf_id=0,
is_interface_rx=0,
is_resolve_host=0,
- is_resolve_attached=0):
+ is_resolve_attached=0,
+ proto=DpoProto.DPO_PROTO_IP4):
self.nh_itf = nh_sw_if_index
self.nh_table_id = nh_table_id
self.nh_via_label = nh_via_label
self.nh_labels = labels
self.weight = 1
self.rpf_id = rpf_id
- self.is_ip4 = 1 if is_ip6 == 0 else 0
- if self.is_ip4:
+ self.proto = proto
+ if self.proto is DpoProto.DPO_PROTO_IP6:
+ self.nh_addr = inet_pton(AF_INET6, nh_addr)
+ elif self.proto is DpoProto.DPO_PROTO_IP4:
self.nh_addr = inet_pton(AF_INET, nh_addr)
else:
- self.nh_addr = inet_pton(AF_INET6, nh_addr)
+ self.nh_addr = inet_pton(AF_INET6, "::")
self.is_resolve_host = is_resolve_host
self.is_resolve_attached = is_resolve_attached
self.is_interface_rx = is_interface_rx
self._test.vapi.mpls_route_add_del(
self.local_label,
self.eos_bit,
- path.is_ip4,
+ path.proto,
path.nh_addr,
path.nh_itf,
is_multicast=self.is_multicast,
for path in self.paths:
self._test.vapi.mpls_route_add_del(self.local_label,
self.eos_bit,
- 1,
+ path.proto,
path.nh_addr,
path.nh_itf,
is_rpf_id=path.is_rpf_id,
VPP MPLS Tunnel interface
"""
- def __init__(self, test, paths, is_multicast=0):
+ def __init__(self, test, paths, is_multicast=0, is_l2=0):
""" Create MPLS Tunnel interface """
self._sw_if_index = 0
super(VppMPLSTunnelInterface, self).__init__(test)
self._test = test
self.t_paths = paths
self.is_multicast = is_multicast
+ self.is_l2 = is_l2
def add_vpp_config(self):
self._sw_if_index = 0xffffffff
path.weight,
next_hop_out_label_stack=path.nh_labels,
next_hop_n_out_labels=len(path.nh_labels),
- is_multicast=self.is_multicast)
+ is_multicast=self.is_multicast,
+ l2_only=self.is_l2)
self._sw_if_index = reply.sw_if_index
def remove_vpp_config(self):
self,
label,
eos,
- next_hop_proto_is_ip4,
+ next_hop_proto,
next_hop_address,
next_hop_sw_if_index=0xFFFFFFFF,
table_id=0,
'mr_is_resolve_attached': is_resolve_attached,
'mr_is_interface_rx': is_interface_rx,
'mr_is_rpf_id': is_rpf_id,
- 'mr_next_hop_proto_is_ip4': next_hop_proto_is_ip4,
+ 'mr_next_hop_proto': next_hop_proto,
'mr_next_hop_weight': next_hop_weight,
'mr_next_hop': next_hop_address,
'mr_next_hop_n_out_labels': next_hop_n_out_labels,