#include <vnet/dpo/interface_rx_dpo.h>
#include <vnet/dpo/mpls_disposition.h>
#include <vnet/dpo/dvr_dpo.h>
-#include <vnet/dpo/drop_dpo.h>
+#include <vnet/dpo/ip_null_dpo.h>
+#include <vnet/dpo/classify_dpo.h>
+#include <vnet/dpo/pw_cw.h>
#include <vnet/adj/adj.h>
#include <vnet/adj/adj_mcast.h>
#include <vnet/fib/fib_internal.h>
#include <vnet/fib/fib_urpf_list.h>
#include <vnet/fib/mpls_fib.h>
+#include <vnet/fib/fib_path_ext.h>
#include <vnet/udp/udp_encap.h>
#include <vnet/bier/bier_fmask.h>
#include <vnet/bier/bier_table.h>
* via a DVR.
*/
FIB_PATH_TYPE_DVR,
- /**
- * Marker. Add new types before this one, then update it.
- */
- FIB_PATH_TYPE_LAST = FIB_PATH_TYPE_BIER_FMASK,
} __attribute__ ((packed)) fib_path_type_t;
-/**
- * The maximum number of path_types
- */
-#define FIB_PATH_TYPE_MAX (FIB_PATH_TYPE_LAST + 1)
-
#define FIB_PATH_TYPES { \
[FIB_PATH_TYPE_ATTACHED_NEXT_HOP] = "attached-nexthop", \
[FIB_PATH_TYPE_ATTACHED] = "attached", \
[FIB_PATH_TYPE_DVR] = "dvr", \
}
-#define FOR_EACH_FIB_PATH_TYPE(_item) \
- for (_item = FIB_PATH_TYPE_FIRST; \
- _item <= FIB_PATH_TYPE_LAST; \
- _item++)
-
/**
* Enurmeration of path operational (i.e. derived) attributes
*/
u32 fp_interface;
} attached_next_hop;
struct {
+ /**
+ * The Connected local address
+ */
+ fib_prefix_t fp_connected;
/**
* The interface
*/
*/
u32 fp_udp_encap_id;
} udp_encap;
+ struct {
+ /**
+ * The UDP Encap object this path resolves through
+ */
+ u32 fp_classify_table_id;
+ } classify;
struct {
/**
* The interface
vnm,
path->dvr.fp_interface));
break;
+ case FIB_PATH_TYPE_DEAG:
+ s = format (s, " %sfib-index:%d",
+ (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ? "m" : ""),
+ path->deag.fp_tbl_id);
+ break;
case FIB_PATH_TYPE_RECEIVE:
case FIB_PATH_TYPE_INTF_RX:
case FIB_PATH_TYPE_SPECIAL:
- case FIB_PATH_TYPE_DEAG:
case FIB_PATH_TYPE_EXCLUSIVE:
if (dpo_id_is_valid(&path->fp_dpo))
{
ASSERT(0);
}
-static const adj_index_t
+static fib_path_t*
fib_path_attached_next_hop_get_adj (fib_path_t *path,
- vnet_link_t link)
+ vnet_link_t link,
+ dpo_id_t *dpo)
{
+ fib_node_index_t fib_path_index;
+ fib_protocol_t nh_proto;
+ adj_index_t ai;
+
+ fib_path_index = fib_path_get_index(path);
+ nh_proto = dpo_proto_to_fib(path->fp_nh_proto);
+
if (vnet_sw_interface_is_p2p(vnet_get_main(),
path->attached_next_hop.fp_interface))
{
* 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(dpo_proto_to_fib(path->fp_nh_proto),
- link,
- &zero_addr,
- path->attached_next_hop.fp_interface));
+ ai = adj_nbr_add_or_lock(nh_proto, link, &zero_addr,
+ path->attached_next_hop.fp_interface);
}
else
{
- 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));
+ ai = adj_nbr_add_or_lock(nh_proto, link,
+ &path->attached_next_hop.fp_nh,
+ path->attached_next_hop.fp_interface);
}
+
+ dpo_set(dpo, DPO_ADJACENCY, vnet_link_to_dpo_proto(link), ai);
+ adj_unlock(ai);
+
+ return (fib_path_get(fib_path_index));
}
static void
fib_path_attached_next_hop_set (fib_path_t *path)
{
/*
- * resolve directly via the adjacnecy discribed by the
+ * resolve directly via the adjacency discribed by the
* interface and next-hop
*/
- dpo_set(&path->fp_dpo,
- DPO_ADJACENCY,
- path->fp_nh_proto,
- fib_path_attached_next_hop_get_adj(
- path,
- dpo_proto_to_link(path->fp_nh_proto)));
+ path = fib_path_attached_next_hop_get_adj(path,
+ dpo_proto_to_link(path->fp_nh_proto),
+ &path->fp_dpo);
+
+ ASSERT(dpo_is_adj(&path->fp_dpo));
/*
* become a child of the adjacency so we receive updates
FIB_NODE_TYPE_PATH,
fib_path_get_index(path));
- if (!vnet_sw_interface_is_admin_up(vnet_get_main(),
- path->attached_next_hop.fp_interface) ||
+ if (!vnet_sw_interface_is_up(vnet_get_main(),
+ path->attached_next_hop.fp_interface) ||
!adj_is_up(path->fp_dpo.dpoi_index))
{
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
}
}
-static const adj_index_t
+static void
fib_path_attached_get_adj (fib_path_t *path,
- vnet_link_t link)
+ vnet_link_t link,
+ dpo_id_t *dpo)
{
+ fib_protocol_t nh_proto;
+
+ nh_proto = dpo_proto_to_fib(path->fp_nh_proto);
+
if (vnet_sw_interface_is_p2p(vnet_get_main(),
path->attached.fp_interface))
{
* 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(dpo_proto_to_fib(path->fp_nh_proto),
- link,
- &zero_addr,
- path->attached.fp_interface));
+ adj_index_t ai;
+
+ ai = adj_nbr_add_or_lock(nh_proto, link, &zero_addr,
+ path->attached.fp_interface);
+
+ dpo_set(dpo, DPO_ADJACENCY, vnet_link_to_dpo_proto(link), ai);
+ adj_unlock(ai);
+ }
+ else if (vnet_sw_interface_is_nbma(vnet_get_main(),
+ path->attached.fp_interface))
+ {
+ dpo_copy(dpo, drop_dpo_get(path->fp_nh_proto));
}
else
{
- return (adj_glean_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
- link,
- path->attached.fp_interface,
- NULL));
+ adj_index_t ai;
+
+ ai = adj_glean_add_or_lock(nh_proto, link,
+ path->attached.fp_interface,
+ &path->attached.fp_connected);
+ dpo_set(dpo, DPO_ADJACENCY_GLEAN, vnet_link_to_dpo_proto(link), ai);
+ adj_unlock(ai);
}
}
{
fib_entry_child_remove(path->fp_via_fib,
path->fp_sibling);
- fib_table_entry_special_remove(path->recursive.fp_tbl_id,
- fib_entry_get_prefix(path->fp_via_fib),
+ fib_table_entry_special_remove(path->recursive.fp_tbl_id,
+ fib_entry_get_prefix(path->fp_via_fib),
FIB_SOURCE_RR);
fib_table_unlock(path->recursive.fp_tbl_id,
dpo_proto_to_fib(path->fp_nh_proto),
bier_table_ecmp_unlock(path->fp_via_bier_tbl);
break;
case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
- adj_child_remove(path->fp_dpo.dpoi_index,
- path->fp_sibling);
- adj_unlock(path->fp_dpo.dpoi_index);
- break;
case FIB_PATH_TYPE_ATTACHED:
- adj_child_remove(path->fp_dpo.dpoi_index,
- path->fp_sibling);
- adj_unlock(path->fp_dpo.dpoi_index);
+ if (dpo_is_adj(&path->fp_dpo))
+ adj_child_remove(path->fp_dpo.dpoi_index,
+ path->fp_sibling);
break;
case FIB_PATH_TYPE_UDP_ENCAP:
udp_encap_unlock(path->fp_dpo.dpoi_index);
* restack the DPO to pick up the correct DPO sub-type
*/
uword if_is_up;
- adj_index_t ai;
- if_is_up = vnet_sw_interface_is_admin_up(
+ if_is_up = vnet_sw_interface_is_up(
vnet_get_main(),
path->attached_next_hop.fp_interface);
- ai = fib_path_attached_next_hop_get_adj(
- path,
- dpo_proto_to_link(path->fp_nh_proto));
+ path = fib_path_attached_next_hop_get_adj(
+ path,
+ dpo_proto_to_link(path->fp_nh_proto),
+ &path->fp_dpo);
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
- if (if_is_up && adj_is_up(ai))
+ if (if_is_up && adj_is_up(path->fp_dpo.dpoi_index))
{
path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
}
- dpo_set(&path->fp_dpo, DPO_ADJACENCY, path->fp_nh_proto, ai);
- adj_unlock(ai);
-
if (!if_is_up)
{
/*
{
fib_path_cfg_flags_t cfg_flags = FIB_PATH_CFG_FLAG_NONE;
+ if (rpath->frp_flags & FIB_ROUTE_PATH_POP_PW_CW)
+ cfg_flags |= FIB_PATH_CFG_FLAG_POP_PW_CW;
if (rpath->frp_flags & FIB_ROUTE_PATH_RESOLVE_VIA_HOST)
cfg_flags |= FIB_PATH_CFG_FLAG_RESOLVE_HOST;
if (rpath->frp_flags & FIB_ROUTE_PATH_RESOLVE_VIA_ATTACHED)
cfg_flags |= FIB_PATH_CFG_FLAG_DROP;
if (rpath->frp_flags & FIB_ROUTE_PATH_SOURCE_LOOKUP)
cfg_flags |= FIB_PATH_CFG_FLAG_DEAG_SRC;
+ if (rpath->frp_flags & FIB_ROUTE_PATH_ICMP_UNREACH)
+ cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_UNREACH;
+ if (rpath->frp_flags & FIB_ROUTE_PATH_ICMP_PROHIBIT)
+ cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_PROHIBIT;
+ if (rpath->frp_flags & FIB_ROUTE_PATH_GLEAN)
+ cfg_flags |= FIB_PATH_CFG_FLAG_GLEAN;
return (cfg_flags);
}
fib_path_t *path;
pool_get(fib_path_pool, path);
- memset(path, 0, sizeof(*path));
+ clib_memset(path, 0, sizeof(*path));
fib_node_init(&path->fp_node,
FIB_NODE_TYPE_PATH);
path->fp_type = FIB_PATH_TYPE_EXCLUSIVE;
dpo_copy(&path->exclusive.fp_ex_dpo, &rpath->dpo);
}
+ else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT) ||
+ (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH))
+ {
+ path->fp_type = FIB_PATH_TYPE_SPECIAL;
+ }
+ else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY))
+ {
+ path->fp_type = FIB_PATH_TYPE_SPECIAL;
+ path->classify.fp_classify_table_id = rpath->frp_classify_table_id;
+ }
+ else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_GLEAN)
+ {
+ path->fp_type = FIB_PATH_TYPE_ATTACHED;
+ path->attached.fp_interface = rpath->frp_sw_if_index;
+ path->attached.fp_connected = rpath->frp_connected;
+ }
else if (~0 != rpath->frp_sw_if_index)
{
if (ip46_address_is_zero(&rpath->frp_addr))
fib_path_t *path;
pool_get(fib_path_pool, path);
- memset(path, 0, sizeof(*path));
+ clib_memset(path, 0, sizeof(*path));
fib_node_init(&path->fp_node,
FIB_NODE_TYPE_PATH);
orig_path = fib_path_get(path_index);
ASSERT(NULL != orig_path);
- memcpy(path, orig_path, sizeof(*path));
+ clib_memcpy(path, orig_path, sizeof(*path));
FIB_PATH_DBG(path, "create-copy:%d", path_index);
path->fp_oper_flags = FIB_PATH_OPER_FLAG_NONE;
path->fp_pl_index = path_list_index;
path->fp_via_fib = FIB_NODE_INDEX_INVALID;
- memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
+ clib_memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
dpo_reset(&path->fp_dpo);
return (fib_path_get_index(path));
path2->attached.fp_interface);
break;
case FIB_PATH_TYPE_RECURSIVE:
- res = ip46_address_cmp(&path1->recursive.fp_nh,
- &path2->recursive.fp_nh);
+ res = ip46_address_cmp(&path1->recursive.fp_nh.fp_ip,
+ &path2->recursive.fp_nh.fp_ip);
if (0 == res)
{
case FIB_PATH_TYPE_EXCLUSIVE:
res = dpo_cmp(&path->exclusive.fp_ex_dpo, &rpath->dpo);
break;
- case FIB_PATH_TYPE_SPECIAL:
case FIB_PATH_TYPE_RECEIVE:
+ if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL)
+ {
+ res = 0;
+ }
+ else
+ {
+ res = 1;
+ }
+ break;
+ case FIB_PATH_TYPE_SPECIAL:
res = 0;
break;
}
{
/*
* no loop here yet. keep forward walking the graph.
- */
+ */
if (fib_entry_recursive_loop_detect(path->fp_via_fib, entry_indicies))
{
FIB_PATH_DBG(path, "recursive loop formed");
}
case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
case FIB_PATH_TYPE_ATTACHED:
+ if (dpo_is_adj(&path->fp_dpo) &&
+ adj_recursive_loop_detect(path->fp_dpo.dpoi_index,
+ entry_indicies))
+ {
+ FIB_PATH_DBG(path, "recursive loop formed");
+ path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
+ }
+ else
+ {
+ FIB_PATH_DBG(path, "recursive loop cleared");
+ path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
+ }
+ break;
case FIB_PATH_TYPE_SPECIAL:
case FIB_PATH_TYPE_DEAG:
case FIB_PATH_TYPE_DVR:
fib_path_attached_next_hop_set(path);
break;
case FIB_PATH_TYPE_ATTACHED:
+ {
+ dpo_id_t tmp = DPO_INVALID;
+
/*
* path->attached.fp_interface
*/
- if (!vnet_sw_interface_is_admin_up(vnet_get_main(),
- path->attached.fp_interface))
+ if (!vnet_sw_interface_is_up(vnet_get_main(),
+ path->attached.fp_interface))
{
path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
}
- dpo_set(&path->fp_dpo,
- DPO_ADJACENCY,
- path->fp_nh_proto,
- fib_path_attached_get_adj(path,
- dpo_proto_to_link(path->fp_nh_proto)));
+ fib_path_attached_get_adj(path,
+ dpo_proto_to_link(path->fp_nh_proto),
+ &tmp);
+
+ /*
+ * re-fetch after possible mem realloc
+ */
+ path = fib_path_get(path_index);
+ dpo_copy(&path->fp_dpo, &tmp);
/*
* become a child of the adjacency so we receive updates
* when the interface state changes
*/
- path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
- FIB_NODE_TYPE_PATH,
- fib_path_get_index(path));
+ if (dpo_is_adj(&path->fp_dpo))
+ {
+ path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
+ FIB_NODE_TYPE_PATH,
+ fib_path_get_index(path));
+ }
+ dpo_reset(&tmp);
break;
+ }
case FIB_PATH_TYPE_RECURSIVE:
{
/*
break;
}
case FIB_PATH_TYPE_SPECIAL:
- /*
- * Resolve via the drop
- */
- dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
- break;
+ if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT)
+ {
+ ip_null_dpo_add_and_lock (path->fp_nh_proto,
+ IP_NULL_ACTION_SEND_ICMP_PROHIBIT,
+ &path->fp_dpo);
+ }
+ else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH)
+ {
+ ip_null_dpo_add_and_lock (path->fp_nh_proto,
+ IP_NULL_ACTION_SEND_ICMP_UNREACH,
+ &path->fp_dpo);
+ }
+ else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY)
+ {
+ dpo_set (&path->fp_dpo, DPO_CLASSIFY,
+ path->fp_nh_proto,
+ classify_dpo_create (path->fp_nh_proto,
+ path->classify.fp_classify_table_id));
+ }
+ else
+ {
+ /*
+ * Resolve via the drop
+ */
+ dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
+ }
+ break;
case FIB_PATH_TYPE_DEAG:
{
if (DPO_PROTO_BIER == path->fp_nh_proto)
break;
}
case FIB_PATH_TYPE_DVR:
- dvr_dpo_add_or_lock(path->attached.fp_interface,
+ dvr_dpo_add_or_lock(path->dvr.fp_interface,
path->fp_nh_proto,
&path->fp_dpo);
break;
path = fib_path_get(path_index);
- ASSERT(dpo_is_adj(&path->fp_dpo));
if (dpo_is_adj(&path->fp_dpo))
{
return (path->fp_dpo.dpoi_index);
case FIB_PATH_TYPE_DVR:
break;
}
+
+ if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_POP_PW_CW)
+ {
+ dpo_id_t tmp = DPO_INVALID;
+
+ dpo_copy(&tmp, dpo);
+
+ pw_cw_dpo_create(&tmp, dpo);
+ dpo_reset(&tmp);
+ }
}
void
case FIB_FORW_CHAIN_TYPE_NSH:
case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
- {
- adj_index_t ai;
-
- /*
- * get a appropriate link type adj.
- */
- ai = fib_path_attached_next_hop_get_adj(
- path,
- fib_forw_chain_type_to_link_type(fct));
- dpo_set(dpo, DPO_ADJACENCY,
- fib_forw_chain_type_to_dpo_proto(fct), ai);
- adj_unlock(ai);
-
+ path = fib_path_attached_next_hop_get_adj(
+ path,
+ fib_forw_chain_type_to_link_type(fct),
+ dpo);
break;
- }
case FIB_FORW_CHAIN_TYPE_BIER:
break;
}
case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
- dpo_copy(dpo, &path->fp_dpo);
- break;
case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
+ dpo_copy(dpo, &path->fp_dpo);
+ break;
case FIB_FORW_CHAIN_TYPE_BIER:
break;
case FIB_FORW_CHAIN_TYPE_ETHERNET:
case FIB_FORW_CHAIN_TYPE_ETHERNET:
case FIB_FORW_CHAIN_TYPE_NSH:
case FIB_FORW_CHAIN_TYPE_BIER:
- {
- adj_index_t ai;
-
- /*
- * get a appropriate link type adj.
- */
- ai = fib_path_attached_get_adj(
- path,
- fib_forw_chain_type_to_link_type(fct));
- dpo_set(dpo, DPO_ADJACENCY,
- fib_forw_chain_type_to_dpo_proto(fct), ai);
- adj_unlock(ai);
- break;
- }
+ fib_path_attached_get_adj(path,
+ fib_forw_chain_type_to_link_type(fct),
+ dpo);
+ break;
case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
{
/*
* Create the adj needed for sending IP multicast traffic
*/
- 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);
+ if (vnet_sw_interface_is_p2p(vnet_get_main(),
+ path->attached.fp_interface))
+ {
+ /*
+ * point-2-point interfaces do not require a glean, since
+ * there is nothing to ARP. Install a rewrite/nbr adj instead
+ */
+ ai = adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
+ fib_forw_chain_type_to_link_type(fct),
+ &zero_addr,
+ path->attached.fp_interface);
+ }
+ else
+ {
+ 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,
fib_forw_chain_type_to_dpo_proto(fct),
ai);
fib_path_list_walk_rc_t
fib_path_encode (fib_node_index_t path_list_index,
- fib_node_index_t path_index,
- void *ctx)
+ fib_node_index_t path_index,
+ const fib_path_ext_t *path_ext,
+ void *args)
{
- fib_route_path_encode_t **api_rpaths = ctx;
- fib_route_path_encode_t *api_rpath;
+ fib_path_encode_ctx_t *ctx = args;
+ fib_route_path_t *rpath;
fib_path_t *path;
path = fib_path_get(path_index);
if (!path)
return (FIB_PATH_LIST_WALK_CONTINUE);
- vec_add2(*api_rpaths, api_rpath, 1);
- api_rpath->rpath.frp_weight = path->fp_weight;
- api_rpath->rpath.frp_preference = path->fp_preference;
- api_rpath->rpath.frp_proto = path->fp_nh_proto;
- api_rpath->rpath.frp_sw_if_index = ~0;
- api_rpath->rpath.frp_fib_index = 0;
- api_rpath->dpo = path->fp_dpo;
+
+ vec_add2(ctx->rpaths, rpath, 1);
+ rpath->frp_weight = path->fp_weight;
+ rpath->frp_preference = path->fp_preference;
+ rpath->frp_proto = path->fp_nh_proto;
+ rpath->frp_sw_if_index = ~0;
+ rpath->frp_fib_index = 0;
switch (path->fp_type)
- {
+ {
case FIB_PATH_TYPE_RECEIVE:
- api_rpath->rpath.frp_addr = path->receive.fp_addr;
- api_rpath->rpath.frp_sw_if_index = path->receive.fp_interface;
+ rpath->frp_addr = path->receive.fp_addr;
+ rpath->frp_sw_if_index = path->receive.fp_interface;
+ rpath->frp_flags |= FIB_ROUTE_PATH_LOCAL;
break;
case FIB_PATH_TYPE_ATTACHED:
- api_rpath->rpath.frp_sw_if_index = path->attached.fp_interface;
+ rpath->frp_sw_if_index = path->attached.fp_interface;
break;
case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
- api_rpath->rpath.frp_sw_if_index = path->attached_next_hop.fp_interface;
- api_rpath->rpath.frp_addr = path->attached_next_hop.fp_nh;
+ rpath->frp_sw_if_index = path->attached_next_hop.fp_interface;
+ rpath->frp_addr = path->attached_next_hop.fp_nh;
break;
case FIB_PATH_TYPE_BIER_FMASK:
- api_rpath->rpath.frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
+ rpath->frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
break;
case FIB_PATH_TYPE_SPECIAL:
break;
case FIB_PATH_TYPE_DEAG:
- api_rpath->rpath.frp_fib_index = path->deag.fp_tbl_id;
+ rpath->frp_fib_index = path->deag.fp_tbl_id;
+ if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID)
+ {
+ rpath->frp_flags |= FIB_ROUTE_PATH_RPF_ID;
+ }
break;
case FIB_PATH_TYPE_RECURSIVE:
- api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip;
- api_rpath->rpath.frp_fib_index = path->recursive.fp_tbl_id;
+ rpath->frp_addr = path->recursive.fp_nh.fp_ip;
+ rpath->frp_fib_index = path->recursive.fp_tbl_id;
break;
case FIB_PATH_TYPE_DVR:
- api_rpath->rpath.frp_sw_if_index = path->dvr.fp_interface;
- api_rpath->rpath.frp_flags |= FIB_ROUTE_PATH_DVR;
+ rpath->frp_sw_if_index = path->dvr.fp_interface;
+ rpath->frp_flags |= FIB_ROUTE_PATH_DVR;
break;
case FIB_PATH_TYPE_UDP_ENCAP:
- api_rpath->rpath.frp_udp_encap_id = path->udp_encap.fp_udp_encap_id;
- api_rpath->rpath.frp_flags |= FIB_ROUTE_PATH_UDP_ENCAP;
+ rpath->frp_udp_encap_id = path->udp_encap.fp_udp_encap_id;
+ rpath->frp_flags |= FIB_ROUTE_PATH_UDP_ENCAP;
break;
+ case FIB_PATH_TYPE_INTF_RX:
+ rpath->frp_sw_if_index = path->receive.fp_interface;
+ rpath->frp_flags |= FIB_ROUTE_PATH_INTF_RX;
+ break;
+ case FIB_PATH_TYPE_EXCLUSIVE:
+ rpath->frp_flags |= FIB_ROUTE_PATH_EXCLUSIVE;
default:
break;
- }
+ }
+
+ if (path_ext && path_ext->fpe_type == FIB_PATH_EXT_MPLS)
+ {
+ rpath->frp_label_stack = path_ext->fpe_path.frp_label_stack;
+ }
+
+ if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DROP)
+ rpath->frp_flags |= FIB_ROUTE_PATH_DROP;
+ if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH)
+ rpath->frp_flags |= FIB_ROUTE_PATH_ICMP_UNREACH;
+ if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT)
+ rpath->frp_flags |= FIB_ROUTE_PATH_ICMP_PROHIBIT;
return (FIB_PATH_LIST_WALK_CONTINUE);
}
path = fib_path_get(pi);
u8 *s = format(NULL, "%U", format_fib_path, pi, 1,
FIB_PATH_FORMAT_FLAGS_NONE);
- s = format(s, "children:");
+ s = format(s, "\n children:");
s = fib_node_children_format(path->fp_node.fn_children, s);
- vlib_cli_output (vm, "%s", s);
+ vlib_cli_output (vm, "%v", s);
vec_free(s);
}
else
Code Review / vpp.git / blobdiff