#include "lib/prefix.h"
#include "lib/memory.h"
#include "lib/linklist.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/plist.h"
#include "lib/routemap.h"
struct rfapi_nve_group_cfg *rfg_vn = NULL;
struct rfapi_nve_group_cfg *rfg_un = NULL;
- struct route_table *rt_vn;
- struct route_table *rt_un;
- struct route_node *rn_vn;
- struct route_node *rn_un;
+ struct agg_table *rt_vn;
+ struct agg_table *rt_un;
+ struct agg_node *rn_vn;
+ struct agg_node *rn_un;
struct rfapi_nve_group_cfg *rfg;
struct listnode *node, *nnode;
return NULL;
}
- rn_vn = route_node_match(rt_vn, vn); /* NB locks node */
+ rn_vn = agg_node_match(rt_vn, vn); /* NB locks node */
if (rn_vn) {
rfg_vn = rn_vn->info;
- route_unlock_node(rn_vn);
+ agg_unlock_node(rn_vn);
}
- rn_un = route_node_match(rt_un, un); /* NB locks node */
+ rn_un = agg_node_match(rt_un, un); /* NB locks node */
if (rn_un) {
rfg_un = rn_un->info;
- route_unlock_node(rn_un);
+ agg_unlock_node(rn_un);
}
#if BGP_VNC_DEBUG_MATCH_GROUP
if (rfg->vn_node) {
rfg->vn_node->info = NULL;
- route_unlock_node(rfg->vn_node); /* frees */
+ agg_unlock_node(rfg->vn_node); /* frees */
}
if (rfg->un_node) {
rfg->un_node->info = NULL;
- route_unlock_node(rfg->un_node); /* frees */
+ agg_unlock_node(rfg->un_node); /* frees */
}
if (rfg->rfp_cfg)
XFREE(MTYPE_RFAPI_RFP_GROUP_CFG, rfg->rfp_cfg);
VTY_DECLVAR_CONTEXT_SUB(rfapi_nve_group_cfg, rfg);
struct prefix p;
afi_t afi;
- struct route_table *rt;
- struct route_node *rn;
+ struct agg_table *rt;
+ struct agg_node *rn;
int is_un_prefix = 0;
/* make sure it's still in list */
rt = bgp->rfapi_cfg->nve_groups_vn[afi];
}
- rn = route_node_get(rt, &p); /* NB locks node */
+ rn = agg_node_get(rt, &p); /* NB locks node */
if (rn->info) {
/*
* There is already a group with this prefix
*/
- route_unlock_node(rn);
+ agg_unlock_node(rn);
if (rn->info != rfg) {
/*
* different group name: fail
/* detach rfg from previous route table location */
if (rfg->un_node) {
rfg->un_node->info = NULL;
- route_unlock_node(rfg->un_node); /* frees */
+ agg_unlock_node(rfg->un_node); /* frees */
}
rfg->un_node = rn; /* back ref */
rfg->un_prefix = p;
/* detach rfg from previous route table location */
if (rfg->vn_node) {
rfg->vn_node->info = NULL;
- route_unlock_node(rfg->vn_node); /* frees */
+ agg_unlock_node(rfg->vn_node); /* frees */
}
rfg->vn_node = rn; /* back ref */
rfg->vn_prefix = p;
h->nve_groups_sequential = list_new();
assert(h->nve_groups_sequential);
for (afi = AFI_IP; afi < AFI_MAX; afi++) {
- h->nve_groups_vn[afi] = route_table_init();
- h->nve_groups_un[afi] = route_table_init();
+ h->nve_groups_vn[afi] = agg_table_init();
+ h->nve_groups_un[afi] = agg_table_init();
}
h->default_response_lifetime =
BGP_VNC_DEFAULT_RESPONSE_LIFETIME_DEFAULT;
if (h->default_rfp_cfg)
XFREE(MTYPE_RFAPI_RFP_GROUP_CFG, h->default_rfp_cfg);
for (afi = AFI_IP; afi < AFI_MAX; afi++) {
- route_table_finish(h->nve_groups_vn[afi]);
- route_table_finish(h->nve_groups_un[afi]);
+ agg_table_finish(h->nve_groups_vn[afi]);
+ agg_table_finish(h->nve_groups_un[afi]);
}
XFREE(MTYPE_RFAPI_CFG, h);
}
} rfapi_group_cfg_type_t;
struct rfapi_nve_group_cfg {
- struct route_node *vn_node; /* backref */
- struct route_node *un_node; /* backref */
+ struct agg_node *vn_node; /* backref */
+ struct agg_node *un_node; /* backref */
rfapi_group_cfg_type_t type; /* NVE|VPN */
char *name; /* unique by type! */
struct list *l2_groups; /* rfapi_l2_group_cfg list */
/* three views into the same collection of rfapi_nve_group_cfg */
struct list *nve_groups_sequential;
- struct route_table *nve_groups_vn[AFI_MAX];
- struct route_table *nve_groups_un[AFI_MAX];
+ struct agg_table *nve_groups_vn[AFI_MAX];
+ struct agg_table *nve_groups_un[AFI_MAX];
/*
* For Single VRF export to ordinary routing protocols. This is
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/routemap.h"
static int rfapi_find_node(struct bgp *bgp, struct rfapi_ip_addr *vn_addr,
struct rfapi_ip_addr *un_addr,
- struct route_node **node)
+ struct agg_node **node)
{
struct rfapi *h;
struct prefix p;
- struct route_node *rn;
+ struct agg_node *rn;
int rc;
afi_t afi;
if ((rc = rfapiRaddr2Qprefix(un_addr, &p)))
return rc;
- rn = route_node_lookup(h->un[afi], &p);
+ rn = agg_node_lookup(h->un[afi], &p);
if (!rn)
return ENOENT;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
*node = rn;
int rfapi_find_rfd(struct bgp *bgp, struct rfapi_ip_addr *vn_addr,
struct rfapi_ip_addr *un_addr, struct rfapi_descriptor **rfd)
{
- struct route_node *rn;
+ struct agg_node *rn;
int rc;
rc = rfapi_find_node(bgp, vn_addr, un_addr, &rn);
#define RFD_RTINIT_AFI(rh, ary, afi) \
do { \
if (!ary[afi]) { \
- ary[afi] = route_table_init(); \
- ary[afi]->info = rh; \
+ ary[afi] = agg_table_init(); \
+ agg_set_table_info(ary[afi], rh); \
} \
} while (0)
char buf_un[BUFSIZ];
afi_t afi_vn, afi_un;
struct prefix pfx_un;
- struct route_node *rn;
+ struct agg_node *rn;
rfapi_time(&rfd->open_time);
assert(afi_vn && afi_un);
assert(!rfapiRaddr2Qprefix(&rfd->un_addr, &pfx_un));
- rn = route_node_get(h->un[afi_un], &pfx_un);
+ rn = agg_node_get(h->un[afi_un], &pfx_un);
assert(rn);
rfd->next = rn->info;
rn->info = rfd;
afi_t afi;
struct prefix p;
struct prefix p_original;
- struct route_node *rn;
+ struct agg_node *rn;
struct rfapi_descriptor *rfd = (struct rfapi_descriptor *)handle;
struct bgp *bgp = rfd->bgp;
struct rfapi_next_hop_entry *pNHE = NULL;
}
if (rn) {
- route_lock_node(rn); /* so we can unlock below */
+ agg_lock_node(rn); /* so we can unlock below */
} else {
/*
* returns locked node. Don't unlock yet because the
assert(rn);
if (!rn->info) {
- route_unlock_node(rn);
+ agg_unlock_node(rn);
vnc_zlog_debug_verbose(
"%s: VPN route not found, returning ENOENT", __func__);
return ENOENT;
&p_original);
}
- route_unlock_node(rn);
+ agg_unlock_node(rn);
done:
if (ppNextHopEntry) {
{
struct rfapi_descriptor *rfd = (struct rfapi_descriptor *)handle;
int rc;
- struct route_node *node;
+ struct agg_node *node;
struct bgp *bgp;
struct rfapi *h;
}
}
}
- route_unlock_node(node);
+ agg_unlock_node(node);
}
/*
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/routemap.h"
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/log.h"
*/
struct rfapi_withdraw {
struct rfapi_import_table *import_table;
- struct route_node *node;
+ struct agg_node *node;
struct bgp_info *info;
safi_t safi; /* used only for bulk operations */
/*
* Normally when a timer expires, lockoffset should be 0. However, if
* the timer expiration function is called directly (e.g.,
* rfapiExpireVpnNow), the node could be locked by a preceding
- * route_top() or route_next() in a loop, so we need to pass this
- * value in.
+ * agg_route_top() or agg_route_next() in a loop, so we need to pass
+ * this value in.
*/
int lockoffset;
};
for (it = h->imports; it; it = it->next) {
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_table *rt;
- struct route_node *rn;
+ struct agg_table *rt;
+ struct agg_node *rn;
int holddown_count = 0;
int local_count = 0;
rt = it->imported_vpn[afi];
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn;
+ rn = agg_route_next(rn)) {
struct bgp_info *bi;
struct bgp_info *next;
* Validate reference count for a node in an import table
*
* Normally lockoffset is 0 for nodes in quiescent state. However,
- * route_unlock_node will delete the node if it is called when
+ * agg_unlock_node will delete the node if it is called when
* node->lock == 1, and we have to validate the refcount before
* the node is deleted. In this case, we specify lockoffset 1.
*/
-void rfapiCheckRefcount(struct route_node *rn, safi_t safi, int lockoffset)
+void rfapiCheckRefcount(struct agg_node *rn, safi_t safi, int lockoffset)
{
unsigned int count_bi = 0;
unsigned int count_monitor = 0;
it->rt_import_list = enew;
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- it->imported_vpn[afi] = route_table_init();
- it->imported_encap[afi] = route_table_init();
+ it->imported_vpn[afi] = agg_table_init();
+ it->imported_encap[afi] = agg_table_init();
}
it->l2_logical_net_id = lni;
* Returns pointer to the list of moved monitors
*/
static struct rfapi_monitor_vpn *
-rfapiMonitorMoveShorter(struct route_node *original_vpn_node, int lockoffset)
+rfapiMonitorMoveShorter(struct agg_node *original_vpn_node, int lockoffset)
{
struct bgp_info *bi;
- struct route_node *par;
+ struct agg_node *par;
struct rfapi_monitor_vpn *m;
struct rfapi_monitor_vpn *mlast;
struct rfapi_monitor_vpn *moved;
* one route (even if it is only a withdrawn route) with a
* valid UN address. Call this node "Node P."
*/
- for (par = original_vpn_node->parent; par; par = par->parent) {
+ for (par = agg_node_parent(original_vpn_node); par;
+ par = agg_node_parent(par)) {
for (bi = par->info; bi; bi = bi->next) {
struct prefix pfx;
if (!rfapiGetUnAddrOfVpnBi(bi, &pfx)) {
*/
if (!par) {
/* this isn't necessarily 0/0 */
- par = route_top(original_vpn_node->table);
+ par = agg_route_table_top(original_vpn_node);
/*
* If we got the top node but it wasn't 0/0,
* ignore it
*/
if (par && par->p.prefixlen) {
- route_unlock_node(par); /* maybe free */
+ agg_unlock_node(par); /* maybe free */
par = NULL;
}
pfx_default.family = original_vpn_node->p.family;
/* creates default node if none exists */
- par = route_node_get(original_vpn_node->table, &pfx_default);
+ par = agg_node_get(agg_get_table(original_vpn_node),
+ &pfx_default);
++parent_already_refcounted;
}
RFAPI_CHECK_REFCOUNT(par, SAFI_MPLS_VPN,
parent_already_refcounted - movecount);
while (movecount > parent_already_refcounted) {
- route_lock_node(par);
+ agg_lock_node(par);
++parent_already_refcounted;
}
while (movecount < parent_already_refcounted) {
/* unlikely, but code defensively */
- route_unlock_node(par);
+ agg_unlock_node(par);
--parent_already_refcounted;
}
RFAPI_CHECK_REFCOUNT(original_vpn_node, SAFI_MPLS_VPN,
movecount + lockoffset);
while (movecount--) {
- route_unlock_node(original_vpn_node);
+ agg_unlock_node(original_vpn_node);
}
#if DEBUG_MONITOR_MOVE_SHORTER
* Implement MONITOR_MOVE_LONGER(new_node) from
* RFAPI-Import-Event-Handling.txt
*/
-static void rfapiMonitorMoveLonger(struct route_node *new_vpn_node)
+static void rfapiMonitorMoveLonger(struct agg_node *new_vpn_node)
{
struct rfapi_monitor_vpn *monitor;
struct rfapi_monitor_vpn *mlast;
struct bgp_info *bi;
- struct route_node *par;
+ struct agg_node *par;
RFAPI_CHECK_REFCOUNT(new_vpn_node, SAFI_MPLS_VPN, 0);
/*
* Find first parent node that has monitors
*/
- for (par = new_vpn_node->parent; par; par = par->parent) {
+ for (par = agg_node_parent(new_vpn_node); par;
+ par = agg_node_parent(par)) {
if (RFAPI_MONITOR_VPN(par))
break;
}
RFAPI_MONITOR_VPN_W_ALLOC(new_vpn_node) = monitor;
monitor->node = new_vpn_node;
- route_lock_node(new_vpn_node); /* incr refcount */
+ agg_lock_node(new_vpn_node); /* incr refcount */
monitor = mlast ? mlast->next : RFAPI_MONITOR_VPN(par);
RFAPI_CHECK_REFCOUNT(par, SAFI_MPLS_VPN, 1);
/* decr refcount after we're done with par as this might
* free it */
- route_unlock_node(par);
+ agg_unlock_node(par);
continue;
}
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_node *rn;
+ struct agg_node *rn;
- for (rn = route_top(it->imported_vpn[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(it->imported_vpn[afi]); rn;
+ rn = agg_route_next(rn)) {
/*
* Each route_node has:
* aggregate: points to rfapi_it_extra with monitor
rfapiMonitorExtraFlush(SAFI_MPLS_VPN, rn);
}
- for (rn = route_top(it->imported_encap[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(it->imported_encap[afi]); rn;
+ rn = agg_route_next(rn)) {
/* free bgp_info and its children */
rfapiBgpInfoChainFree(rn->info);
rn->info = NULL;
rfapiMonitorExtraFlush(SAFI_ENCAP, rn);
}
- route_table_finish(it->imported_vpn[afi]);
- route_table_finish(it->imported_encap[afi]);
+ agg_table_finish(it->imported_vpn[afi]);
+ agg_table_finish(it->imported_encap[afi]);
}
if (it->monitor_exterior_orphans) {
skiplist_free(it->monitor_exterior_orphans);
static struct rfapi_next_hop_entry *
rfapiRouteInfo2NextHopEntry(struct rfapi_ip_prefix *rprefix,
- struct bgp_info *bi, /* route to encode */
- uint32_t lifetime, /* use this in nhe */
- struct route_node *rn) /* req for L2 eth addr */
+ struct bgp_info *bi, /* route to encode */
+ uint32_t lifetime, /* use this in nhe */
+ struct agg_node *rn) /* req for L2 eth addr */
{
struct rfapi_next_hop_entry *new;
int have_vnc_tunnel_un = 0;
return new;
}
-int rfapiHasNonRemovedRoutes(struct route_node *rn)
+int rfapiHasNonRemovedRoutes(struct agg_node *rn)
{
struct bgp_info *bi;
/*
* DEBUG FUNCTION
*/
-void rfapiDumpNode(struct route_node *rn)
+void rfapiDumpNode(struct agg_node *rn)
{
struct bgp_info *bi;
#endif
static int rfapiNhlAddNodeRoutes(
- struct route_node *rn, /* in */
+ struct agg_node *rn, /* in */
struct rfapi_ip_prefix *rprefix, /* in */
uint32_t lifetime, /* in */
int removed, /* in */
struct rfapi_next_hop_entry **head, /* in/out */
struct rfapi_next_hop_entry **tail, /* in/out */
struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_node *rfd_rib_node, /* preload this NVE rib node */
+ struct agg_node *rfd_rib_node, /* preload this NVE rib node */
struct prefix *pfx_target_original) /* query target */
{
struct bgp_info *bi;
int count = 0;
int is_l2 = (rn->p.family == AF_ETHERNET);
- if (rfd_rib_node && rfd_rib_node->table && rfd_rib_node->table->info) {
+ if (rfd_rib_node) {
+ struct agg_table *atable = agg_get_table(rfd_rib_node);
struct rfapi_descriptor *rfd;
- rfd = (struct rfapi_descriptor *)(rfd_rib_node->table->info);
+ if (atable) {
+ rfd = agg_get_table_info(atable);
- if (rfapiRibFTDFilterRecentPrefix(
- rfd, rn, pfx_target_original))
-
- return 0;
+ if (rfapiRibFTDFilterRecentPrefix(rfd, rn,
+ pfx_target_original))
+ return 0;
+ }
}
seen_nexthops =
* matches (of course, we still travel down its child subtrees).
*/
static int rfapiNhlAddSubtree(
- struct route_node *rn, /* in */
+ struct agg_node *rn, /* in */
uint32_t lifetime, /* in */
struct rfapi_next_hop_entry **head, /* in/out */
struct rfapi_next_hop_entry **tail, /* in/out */
- struct route_node *omit_node, /* in */
+ struct agg_node *omit_node, /* in */
struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload here */
+ struct agg_table *rfd_rib_table, /* preload here */
struct prefix *pfx_target_original) /* query target */
{
struct rfapi_ip_prefix rprefix;
/* FIXME: need to find a better way here to work without sticking our
* hands in node->link */
- if (rn->l_left && rn->l_left != omit_node) {
- if (rn->l_left->info) {
+ if (agg_node_left(rn) && agg_node_left(rn) != omit_node) {
+ if (agg_node_left(rn)->info) {
int count = 0;
- struct route_node *rib_rn = NULL;
+ struct agg_node *rib_rn = NULL;
- rfapiQprefix2Rprefix(&rn->l_left->p, &rprefix);
+ rfapiQprefix2Rprefix(&agg_node_left(rn)->p, &rprefix);
if (rfd_rib_table) {
- rib_rn = route_node_get(rfd_rib_table,
- &rn->l_left->p);
+ rib_rn = agg_node_get(rfd_rib_table,
+ &agg_node_left(rn)->p);
}
count = rfapiNhlAddNodeRoutes(
- rn->l_left, &rprefix, lifetime, 0, head, tail,
- exclude_vnaddr, rib_rn, pfx_target_original);
+ agg_node_left(rn), &rprefix, lifetime, 0, head,
+ tail, exclude_vnaddr, rib_rn,
+ pfx_target_original);
if (!count) {
count = rfapiNhlAddNodeRoutes(
- rn->l_left, &rprefix, lifetime, 1, head,
- tail, exclude_vnaddr, rib_rn,
+ agg_node_left(rn), &rprefix, lifetime,
+ 1, head, tail, exclude_vnaddr, rib_rn,
pfx_target_original);
}
rcount += count;
if (rib_rn)
- route_unlock_node(rib_rn);
+ agg_unlock_node(rib_rn);
}
}
- if (rn->l_right && rn->l_right != omit_node) {
- if (rn->l_right->info) {
+ if (agg_node_right(rn) && agg_node_right(rn) != omit_node) {
+ if (agg_node_right(rn)->info) {
int count = 0;
- struct route_node *rib_rn = NULL;
+ struct agg_node *rib_rn = NULL;
- rfapiQprefix2Rprefix(&rn->l_right->p, &rprefix);
+ rfapiQprefix2Rprefix(&agg_node_right(rn)->p, &rprefix);
if (rfd_rib_table) {
- rib_rn = route_node_get(rfd_rib_table,
- &rn->l_right->p);
+ rib_rn = agg_node_get(rfd_rib_table,
+ &agg_node_right(rn)->p);
}
count = rfapiNhlAddNodeRoutes(
- rn->l_right, &rprefix, lifetime, 0, head, tail,
- exclude_vnaddr, rib_rn, pfx_target_original);
+ agg_node_right(rn), &rprefix, lifetime, 0, head,
+ tail, exclude_vnaddr, rib_rn,
+ pfx_target_original);
if (!count) {
count = rfapiNhlAddNodeRoutes(
- rn->l_right, &rprefix, lifetime, 1,
- head, tail, exclude_vnaddr, rib_rn,
+ agg_node_right(rn), &rprefix, lifetime,
+ 1, head, tail, exclude_vnaddr, rib_rn,
pfx_target_original);
}
rcount += count;
if (rib_rn)
- route_unlock_node(rib_rn);
+ agg_unlock_node(rib_rn);
}
}
- if (rn->l_left) {
+ if (agg_node_left(rn)) {
rcount += rfapiNhlAddSubtree(
- rn->l_left, lifetime, head, tail, omit_node,
+ agg_node_left(rn), lifetime, head, tail, omit_node,
exclude_vnaddr, rfd_rib_table, pfx_target_original);
}
- if (rn->l_right) {
+ if (agg_node_right(rn)) {
rcount += rfapiNhlAddSubtree(
- rn->l_right, lifetime, head, tail, omit_node,
+ agg_node_right(rn), lifetime, head, tail, omit_node,
exclude_vnaddr, rfd_rib_table, pfx_target_original);
}
* next less-specific node (i.e., this node's parent) at the end.
*/
struct rfapi_next_hop_entry *rfapiRouteNode2NextHopList(
- struct route_node *rn, uint32_t lifetime, /* put into nexthop entries */
- struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload here */
- struct prefix *pfx_target_original) /* query target */
+ struct agg_node *rn, uint32_t lifetime, /* put into nexthop entries */
+ struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
+ struct agg_table *rfd_rib_table, /* preload here */
+ struct prefix *pfx_target_original) /* query target */
{
struct rfapi_ip_prefix rprefix;
struct rfapi_next_hop_entry *answer = NULL;
struct rfapi_next_hop_entry *last = NULL;
- struct route_node *parent;
+ struct agg_node *parent;
int count = 0;
- struct route_node *rib_rn;
+ struct agg_node *rib_rn;
#if DEBUG_RETURNED_NHL
{
rfapiQprefix2Rprefix(&rn->p, &rprefix);
- rib_rn = rfd_rib_table ? route_node_get(rfd_rib_table, &rn->p) : NULL;
+ rib_rn = rfd_rib_table ? agg_node_get(rfd_rib_table, &rn->p) : NULL;
/*
* Add non-withdrawn routes at this node
rfapiPrintNhl(NULL, answer);
#endif
if (rib_rn)
- route_unlock_node(rib_rn);
+ agg_unlock_node(rib_rn);
return answer;
}
exclude_vnaddr, rib_rn,
pfx_target_original);
if (rib_rn)
- route_unlock_node(rib_rn);
+ agg_unlock_node(rib_rn);
// rfapiPrintNhl(NULL, answer);
* walk up the tree until we find a node with non-deleted
* routes, then add them
*/
- for (parent = rn->parent; parent; parent = parent->parent) {
+ for (parent = agg_node_parent(rn); parent;
+ parent = agg_node_parent(parent)) {
if (rfapiHasNonRemovedRoutes(parent)) {
break;
}
* Add non-withdrawn routes from less-specific prefix
*/
if (parent) {
- rib_rn = rfd_rib_table
- ? route_node_get(rfd_rib_table, &parent->p)
- : NULL;
+ rib_rn = rfd_rib_table ? agg_node_get(rfd_rib_table, &parent->p)
+ : NULL;
rfapiQprefix2Rprefix(&parent->p, &rprefix);
count += rfapiNhlAddNodeRoutes(parent, &rprefix, lifetime, 0,
&answer, &last, exclude_vnaddr,
rn, exclude_vnaddr, rfd_rib_table,
pfx_target_original);
if (rib_rn)
- route_unlock_node(rib_rn);
+ agg_unlock_node(rib_rn);
} else {
/*
* There is no parent with non-removed routes. Still need to
* Construct nexthop list of all routes in table
*/
struct rfapi_next_hop_entry *rfapiRouteTable2NextHopList(
- struct route_table *rt,
- uint32_t lifetime, /* put into nexthop entries */
- struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload this NVE rib table */
- struct prefix *pfx_target_original) /* query target */
+ struct agg_table *rt, uint32_t lifetime, /* put into nexthop entries */
+ struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
+ struct agg_table *rfd_rib_table, /* preload this NVE rib table */
+ struct prefix *pfx_target_original) /* query target */
{
- struct route_node *rn;
+ struct agg_node *rn;
struct rfapi_next_hop_entry *biglist = NULL;
struct rfapi_next_hop_entry *nhl;
struct rfapi_next_hop_entry *tail = NULL;
int count = 0;
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
nhl = rfapiRouteNode2NextHopList(rn, lifetime, exclude_vnaddr,
rfd_rib_table,
}
struct rfapi_next_hop_entry *rfapiEthRouteNode2NextHopList(
- struct route_node *rn, struct rfapi_ip_prefix *rprefix,
+ struct agg_node *rn, struct rfapi_ip_prefix *rprefix,
uint32_t lifetime, /* put into nexthop entries */
struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload NVE rib table */
+ struct agg_table *rfd_rib_table, /* preload NVE rib table */
struct prefix *pfx_target_original) /* query target */
{
int count = 0;
struct rfapi_next_hop_entry *answer = NULL;
struct rfapi_next_hop_entry *last = NULL;
- struct route_node *rib_rn;
+ struct agg_node *rib_rn;
- rib_rn = rfd_rib_table ? route_node_get(rfd_rib_table, &rn->p) : NULL;
+ rib_rn = rfd_rib_table ? agg_node_get(rfd_rib_table, &rn->p) : NULL;
count = rfapiNhlAddNodeRoutes(rn, rprefix, lifetime, 0, &answer, &last,
NULL, rib_rn, pfx_target_original);
}
if (rib_rn)
- route_unlock_node(rib_rn);
+ agg_unlock_node(rib_rn);
#if DEBUG_RETURNED_NHL
rfapiPrintNhl(NULL, answer);
uint32_t logical_net_id, struct rfapi_ip_prefix *rprefix,
uint32_t lifetime, /* put into nexthop entries */
struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload NVE rib node */
+ struct agg_table *rfd_rib_table, /* preload NVE rib node */
struct prefix *pfx_target_original) /* query target */
{
struct rfapi_import_table *it;
struct bgp *bgp = bgp_get_default();
- struct route_table *rt;
- struct route_node *rn;
+ struct agg_table *rt;
+ struct agg_node *rn;
struct rfapi_next_hop_entry *biglist = NULL;
struct rfapi_next_hop_entry *nhl;
struct rfapi_next_hop_entry *tail = NULL;
it = rfapiMacImportTableGet(bgp, logical_net_id);
rt = it->imported_vpn[AFI_L2VPN];
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
nhl = rfapiEthRouteNode2NextHopList(
rn, rprefix, lifetime, exclude_vnaddr, rfd_rib_table,
* Insert a new bi to the imported route table node,
* keeping the list of BIs sorted best route first
*/
-static void rfapiBgpInfoAttachSorted(struct route_node *rn,
+static void rfapiBgpInfoAttachSorted(struct agg_node *rn,
struct bgp_info *info_new, afi_t afi,
safi_t safi)
{
bgp_attr_intern(info_new->attr);
}
-static void rfapiBgpInfoDetach(struct route_node *rn, struct bgp_info *bi)
+static void rfapiBgpInfoDetach(struct agg_node *rn, struct bgp_info *bi)
{
/*
* Remove the route (doubly-linked)
/*
* Index on RD and Peer
*/
-static void rfapiItBiIndexAdd(struct route_node *rn, /* Import table VPN node */
- struct bgp_info *bi) /* new BI */
+static void rfapiItBiIndexAdd(struct agg_node *rn, /* Import table VPN node */
+ struct bgp_info *bi) /* new BI */
{
struct skiplist *sl;
sl = skiplist_new(0, rfapi_bi_peer_rd_cmp, NULL);
}
RFAPI_IT_EXTRA_GET(rn)->u.vpn.idx_rd = sl;
- route_lock_node(rn); /* for skiplist */
+ agg_lock_node(rn); /* for skiplist */
}
assert(!skiplist_insert(sl, (void *)bi, (void *)bi));
- route_lock_node(rn); /* for skiplist entry */
+ agg_lock_node(rn); /* for skiplist entry */
/* NB: BIs in import tables are not refcounted */
}
-static void rfapiItBiIndexDump(struct route_node *rn)
+static void rfapiItBiIndexDump(struct agg_node *rn)
{
struct skiplist *sl;
void *cursor = NULL;
}
static struct bgp_info *rfapiItBiIndexSearch(
- struct route_node *rn, /* Import table VPN node */
+ struct agg_node *rn, /* Import table VPN node */
struct prefix_rd *prd, struct peer *peer,
struct prefix *aux_prefix) /* optional L3 addr for L2 ITs */
{
return bi_result;
}
-static void rfapiItBiIndexDel(struct route_node *rn, /* Import table VPN node */
- struct bgp_info *bi) /* old BI */
+static void rfapiItBiIndexDel(struct agg_node *rn, /* Import table VPN node */
+ struct bgp_info *bi) /* old BI */
{
struct skiplist *sl;
int rc;
}
assert(!rc);
- route_unlock_node(rn); /* for skiplist entry */
+ agg_unlock_node(rn); /* for skiplist entry */
/* NB: BIs in import tables are not refcounted */
}
* refers to it
*/
static void rfapiMonitorEncapAdd(struct rfapi_import_table *import_table,
- struct prefix *p, /* VN address */
- struct route_node *vpn_rn, /* VPN node */
- struct bgp_info *vpn_bi) /* VPN bi/route */
+ struct prefix *p, /* VN address */
+ struct agg_node *vpn_rn, /* VPN node */
+ struct bgp_info *vpn_bi) /* VPN bi/route */
{
afi_t afi = family2afi(p->family);
- struct route_node *rn;
+ struct agg_node *rn;
struct rfapi_monitor_encap *m;
assert(afi);
- rn = route_node_get(import_table->imported_encap[afi],
- p); /* locks rn */
+ rn = agg_node_get(import_table->imported_encap[afi], p); /* locks rn */
assert(rn);
m = XCALLOC(MTYPE_RFAPI_MONITOR_ENCAP,
* freed */
rfapiMonitorExtraPrune(SAFI_ENCAP, hme->rn);
- route_unlock_node(hme->rn); /* decr ref count */
+ agg_unlock_node(hme->rn); /* decr ref count */
XFREE(MTYPE_RFAPI_MONITOR_ENCAP, hme);
vpn_bi->extra->vnc.import.hme = NULL;
}
}
RFAPI_CHECK_REFCOUNT(wcb->node, SAFI_MPLS_VPN, 1 + wcb->lockoffset);
- route_unlock_node(wcb->node); /* decr ref count */
+ agg_unlock_node(wcb->node); /* decr ref count */
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
return 0;
}
*/
static int rfapiWithdrawEncapUpdateCachedUn(
struct rfapi_import_table *import_table, struct bgp_info *encap_bi,
- struct route_node *vpn_rn, struct bgp_info *vpn_bi)
+ struct agg_node *vpn_rn, struct bgp_info *vpn_bi)
{
if (!encap_bi) {
/*
* for each VPN node referenced in the ENCAP monitors:
*/
- struct route_node *rn;
+ struct agg_node *rn;
while (!skiplist_first(vpn_node_sl, (void **)&rn, NULL)) {
if (!wcb->node->info) {
struct rfapi_monitor_vpn *moved;
done:
RFAPI_CHECK_REFCOUNT(wcb->node, SAFI_ENCAP, 1);
- route_unlock_node(wcb->node); /* decr ref count */
+ agg_unlock_node(wcb->node); /* decr ref count */
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
skiplist_free(vpn_node_sl);
return 0;
*/
static void
rfapiBiStartWithdrawTimer(struct rfapi_import_table *import_table,
- struct route_node *rn, struct bgp_info *bi, afi_t afi,
+ struct agg_node *rn, struct bgp_info *bi, afi_t afi,
safi_t safi,
int (*timer_service_func)(struct thread *))
{
static void rfapiExpireEncapNow(struct rfapi_import_table *it,
- struct route_node *rn, struct bgp_info *bi)
+ struct agg_node *rn, struct bgp_info *bi)
{
struct rfapi_withdraw *wcb;
struct thread t;
uint8_t sub_type, /* part of bgp_info */
uint32_t *label) /* part of bgp_info */
{
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct bgp_info *info_new;
struct bgp_info *bi;
struct bgp_info *next;
}
/*
- * route_node_lookup returns a node only if there is at least
+ * agg_node_lookup returns a node only if there is at least
* one route attached.
*/
- rn = route_node_lookup(rt, p);
+ rn = agg_node_lookup(rt, p);
#if DEBUG_ENCAP_MONITOR
vnc_zlog_debug_verbose("%s: initial encap lookup(it=%p) rn=%p",
if (rn) {
RFAPI_CHECK_REFCOUNT(rn, SAFI_ENCAP, 1);
- route_unlock_node(rn); /* undo lock in route_node_lookup */
+ agg_unlock_node(rn); /* undo lock in agg_node_lookup */
/*
if (rn) {
if (!replacing)
- route_lock_node(rn); /* incr ref count for new BI */
+ agg_lock_node(rn); /* incr ref count for new BI */
} else {
- rn = route_node_get(rt, p);
+ rn = agg_node_get(rt, p);
}
vnc_zlog_debug_verbose(
struct rfapi_monitor_encap *m;
struct rfapi_monitor_encap *mnext;
- struct route_node *referenced_vpn_prefix;
+ struct agg_node *referenced_vpn_prefix;
/*
* Optimized approach: build radix tree on the fly to
* struct rfapi_monitor_encap, each of which refers to a
* specific VPN node.
*/
- struct route_table *referenced_vpn_table;
+ struct agg_table *referenced_vpn_table;
- referenced_vpn_table = route_table_init();
+ referenced_vpn_table = agg_table_init();
assert(referenced_vpn_table);
/*
* per prefix.
*/
- referenced_vpn_prefix = route_node_get(
- referenced_vpn_table, &m->node->p);
+ referenced_vpn_prefix =
+ agg_node_get(referenced_vpn_table, &m->node->p);
assert(referenced_vpn_prefix);
for (mnext = referenced_vpn_prefix->info; mnext;
mnext = mnext->next) {
/*
* already have an entry for this VPN node
*/
- route_unlock_node(referenced_vpn_prefix);
+ agg_unlock_node(referenced_vpn_prefix);
} else {
mnext = XCALLOC(
MTYPE_RFAPI_MONITOR_ENCAP,
/*
* for each VPN node referenced in the ENCAP monitors:
*/
- for (referenced_vpn_prefix = route_top(referenced_vpn_table);
- referenced_vpn_prefix; referenced_vpn_prefix = route_next(
- referenced_vpn_prefix)) {
+ for (referenced_vpn_prefix =
+ agg_route_top(referenced_vpn_table);
+ referenced_vpn_prefix;
+ referenced_vpn_prefix =
+ agg_route_next(referenced_vpn_prefix)) {
while ((m = referenced_vpn_prefix->info)) {
- struct route_node *n;
+ struct agg_node *n;
rfapiMonitorMoveLonger(m->node);
- for (n = m->node; n; n = n->parent) {
+ for (n = m->node; n; n = agg_node_parent(n)) {
// rfapiDoRouteCallback(import_table, n,
// NULL);
}
NULL);
referenced_vpn_prefix->info = m->next;
- route_unlock_node(referenced_vpn_prefix);
+ agg_unlock_node(referenced_vpn_prefix);
XFREE(MTYPE_RFAPI_MONITOR_ENCAP, m);
}
}
- route_table_finish(referenced_vpn_table);
+ agg_table_finish(referenced_vpn_table);
}
RFAPI_CHECK_REFCOUNT(rn, SAFI_ENCAP, 0);
}
static void rfapiExpireVpnNow(struct rfapi_import_table *it,
- struct route_node *rn, struct bgp_info *bi,
+ struct agg_node *rn, struct bgp_info *bi,
int lockoffset)
{
struct rfapi_withdraw *wcb;
uint8_t sub_type, /* part of bgp_info */
uint32_t *label) /* part of bgp_info */
{
- struct route_table *rt = NULL;
- struct route_node *rn;
- struct route_node *n;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
+ struct agg_node *n;
struct bgp_info *info_new;
struct bgp_info *bi;
struct bgp_info *next;
struct prefix vn_prefix;
struct prefix un_prefix;
int un_prefix_valid = 0;
- struct route_node *ern;
+ struct agg_node *ern;
int replacing = 0;
int original_had_routes = 0;
struct prefix original_nexthop;
memset(&original_nexthop, 0, sizeof(original_nexthop));
/*
- * route_node_lookup returns a node only if there is at least
+ * agg_node_lookup returns a node only if there is at least
* one route attached.
*/
- rn = route_node_lookup(rt, p);
+ rn = agg_node_lookup(rt, p);
vnc_zlog_debug_verbose("%s: rn=%p", __func__, rn);
if (rn) {
RFAPI_CHECK_REFCOUNT(rn, SAFI_MPLS_VPN, 1);
- route_unlock_node(rn); /* undo lock in route_node_lookup */
+ agg_unlock_node(rn); /* undo lock in agg_node_lookup */
if (rn->info)
original_had_routes = 1;
/*
* lookup un address in encap table
*/
- ern = route_node_match(import_table->imported_encap[afi], &vn_prefix);
+ ern = agg_node_match(import_table->imported_encap[afi], &vn_prefix);
if (ern) {
rfapiCopyUnEncap2VPN(ern->info, info_new);
- route_unlock_node(ern); /* undo lock in route_note_match */
+ agg_unlock_node(ern); /* undo lock in route_note_match */
} else {
char buf[PREFIX_STRLEN];
if (rn) {
if (!replacing)
- route_lock_node(rn);
+ agg_lock_node(rn);
} else {
/*
* No need to increment reference count, so only "get"
* if the node is not there already
*/
- rn = route_node_get(rt, p);
+ rn = agg_node_get(rt, p);
}
/*
}
if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)) {
- for (n = rn; n; n = n->parent) {
+ for (n = rn; n; n = agg_node_parent(n)) {
// rfapiDoRouteCallback(import_table, n, NULL);
}
rfapiMonitorItNodeChanged(import_table, rn, NULL);
struct rfapi_import_table *import_table,
afi_t afi, safi_t safi)
{
- struct route_node *rn;
+ struct agg_node *rn;
struct bgp_info *bi;
- struct route_table *rt;
+ struct agg_table *rt;
int (*timer_service_func)(struct thread *);
assert(afi == AFI_IP || afi == AFI_IP6);
}
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
for (bi = rn->info; bi; bi = bi->next) {
if (bi->peer == peer) {
h = (struct rfapi *)XCALLOC(MTYPE_RFAPI, sizeof(struct rfapi));
for (afi = AFI_IP; afi < AFI_MAX; afi++) {
- h->un[afi] = route_table_init();
+ h->un[afi] = agg_table_init();
}
/*
*/
h->it_ce = XCALLOC(MTYPE_RFAPI_IMPORTTABLE,
sizeof(struct rfapi_import_table));
- h->it_ce->imported_vpn[AFI_IP] = route_table_init();
- h->it_ce->imported_vpn[AFI_IP6] = route_table_init();
- h->it_ce->imported_encap[AFI_IP] = route_table_init();
- h->it_ce->imported_encap[AFI_IP6] = route_table_init();
+ h->it_ce->imported_vpn[AFI_IP] = agg_table_init();
+ h->it_ce->imported_vpn[AFI_IP6] = agg_table_init();
+ h->it_ce->imported_encap[AFI_IP] = agg_table_init();
+ h->it_ce->imported_encap[AFI_IP6] = agg_table_init();
rfapiBgpTableFilteredImport(bgp, h->it_ce, AFI_IP, SAFI_MPLS_VPN);
rfapiBgpTableFilteredImport(bgp, h->it_ce, AFI_IP6, SAFI_MPLS_VPN);
h->resolve_nve_nexthop = NULL;
}
- route_table_finish(h->it_ce->imported_vpn[AFI_IP]);
- route_table_finish(h->it_ce->imported_vpn[AFI_IP6]);
- route_table_finish(h->it_ce->imported_encap[AFI_IP]);
- route_table_finish(h->it_ce->imported_encap[AFI_IP6]);
+ agg_table_finish(h->it_ce->imported_vpn[AFI_IP]);
+ agg_table_finish(h->it_ce->imported_vpn[AFI_IP6]);
+ agg_table_finish(h->it_ce->imported_encap[AFI_IP]);
+ agg_table_finish(h->it_ce->imported_encap[AFI_IP6]);
if (h->import_mac) {
struct rfapi_import_table *it;
rfp_stop(h->rfp);
for (afi = AFI_IP; afi < AFI_MAX; afi++) {
- route_table_finish(h->un[afi]);
+ agg_table_finish(h->un[afi]);
}
XFREE(MTYPE_RFAPI_IMPORTTABLE, h->it_ce);
*/
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- it->imported_vpn[afi] = route_table_init();
- it->imported_encap[afi] = route_table_init();
+ it->imported_vpn[afi] = agg_table_init();
+ it->imported_encap[afi] = agg_table_init();
rfapiBgpTableFilteredImport(bgp, it, afi,
SAFI_MPLS_VPN);
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_table *rt;
- struct route_node *rn;
+ struct agg_table *rt;
+ struct agg_node *rn;
if (p && (family2afi(p->family) != afi)) {
continue;
vnc_zlog_debug_verbose("%s: scanning rt for afi=%d", __func__,
afi);
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
struct bgp_info *bi;
struct bgp_info *next;
struct ecommunity *rt_import_list; /* copied from nve grp */
int refcount; /* nve grps and nves */
uint32_t l2_logical_net_id; /* L2 only: EVPN Eth Seg Id */
- struct route_table *imported_vpn[AFI_MAX];
+ struct agg_table *imported_vpn[AFI_MAX];
struct rfapi_monitor_vpn *vpn0_queries[AFI_MAX];
struct rfapi_monitor_eth *eth0_queries;
- struct route_table *imported_encap[AFI_MAX];
+ struct agg_table *imported_encap[AFI_MAX];
struct skiplist *monitor_exterior_orphans;
int local_count[AFI_MAX];
int remote_count[AFI_MAX];
extern void rfapiPrintBi(void *stream, struct bgp_info *bi);
extern void rfapiShowImportTable(void *stream, const char *label,
- struct route_table *rt, int isvpn);
+ struct agg_table *rt, int isvpn);
extern struct rfapi_import_table *
rfapiImportTableRefAdd(struct bgp *bgp, struct ecommunity *rt_import_list,
* next less-specific node (i.e., this node's parent) at the end.
*/
extern struct rfapi_next_hop_entry *rfapiRouteNode2NextHopList(
- struct route_node *rn, uint32_t lifetime, /* put into nexthop entries */
- struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload this NVE rib table */
- struct prefix *pfx_target_original); /* query target */
+ struct agg_node *rn, uint32_t lifetime, /* put into nexthop entries */
+ struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
+ struct agg_table *rfd_rib_table, /* preload this NVE rib table */
+ struct prefix *pfx_target_original); /* query target */
extern struct rfapi_next_hop_entry *rfapiRouteTable2NextHopList(
- struct route_table *rt,
- uint32_t lifetime, /* put into nexthop entries */
- struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rfd_rib_table, /* preload this NVE rib table */
- struct prefix *pfx_target_original); /* query target */
+ struct agg_table *rt, uint32_t lifetime, /* put into nexthop entries */
+ struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
+ struct agg_table *rfd_rib_table, /* preload this NVE rib table */
+ struct prefix *pfx_target_original); /* query target */
extern struct rfapi_next_hop_entry *rfapiEthRouteTable2NextHopList(
uint32_t logical_net_id, struct rfapi_ip_prefix *rprefix,
uint32_t lifetime, /* put into nexthop entries */
struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rib_route_table, /* preload NVE rib node */
+ struct agg_table *rib_route_table, /* preload NVE rib node */
struct prefix *pfx_target_original); /* query target */
extern int rfapiEcommunitiesIntersect(struct ecommunity *e1,
struct ecommunity *e2);
-extern void rfapiCheckRefcount(struct route_node *rn, safi_t safi,
+extern void rfapiCheckRefcount(struct agg_node *rn, safi_t safi,
int lockoffset);
-extern int rfapiHasNonRemovedRoutes(struct route_node *rn);
+extern int rfapiHasNonRemovedRoutes(struct agg_node *rn);
extern int rfapiProcessDeferredClose(struct thread *t);
uint32_t *label); /* part of bgp_info */
extern struct rfapi_next_hop_entry *rfapiEthRouteNode2NextHopList(
- struct route_node *rn, struct rfapi_ip_prefix *rprefix,
+ struct agg_node *rn, struct rfapi_ip_prefix *rprefix,
uint32_t lifetime, /* put into nexthop entries */
struct rfapi_ip_addr *exclude_vnaddr, /* omit routes to same NVE */
- struct route_table *rib_route_table, /* preload NVE rib table */
+ struct agg_table *rib_route_table, /* preload NVE rib table */
struct prefix *pfx_target_original); /* query target */
extern struct rfapi_import_table *rfapiMacImportTableGetNoAlloc(struct bgp *bgp,
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/log.h"
/*
* Debug function, special case
*/
-void rfapiMonitorEthSlCheck(struct route_node *rn, const char *tag1,
+void rfapiMonitorEthSlCheck(struct agg_node *rn, const char *tag1,
const char *tag2)
{
- struct route_node *rn_saved = NULL;
+ struct agg_node *rn_saved = NULL;
static struct skiplist *sl_saved = NULL;
struct skiplist *sl;
struct rfapi_descriptor *rfd;
for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, hnode, rfd)) {
- struct route_node *mrn;
+ struct agg_node *mrn;
if (!rfd->mon)
continue;
- for (mrn = route_top(rfd->mon); mrn; mrn = route_next(mrn)) {
+ for (mrn = agg_route_top(rfd->mon); mrn;
+ mrn = agg_route_next(mrn)) {
struct rfapi_monitor_vpn *m;
for (m = (struct rfapi_monitor_vpn *)(mrn->info); m;
m = m->next)
}
for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, hnode, rfd)) {
- struct route_node *mrn;
+ struct agg_node *mrn;
if (!rfd->mon)
continue;
- for (mrn = route_top(rfd->mon); mrn; mrn = route_next(mrn)) {
+ for (mrn = agg_route_top(rfd->mon); mrn;
+ mrn = agg_route_next(mrn)) {
struct rfapi_monitor_vpn *m;
for (m = (struct rfapi_monitor_vpn *)(mrn->info); m;
assert(!rfd->import_table->vpn0_queries[AFI_IP]);
assert(!rfd->import_table->vpn0_queries[AFI_IP6]);
- struct route_node *rn;
+ struct agg_node *rn;
- for (rn = route_top(rfd->import_table->imported_vpn[AFI_IP]);
- rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(
+ rfd->import_table->imported_vpn[AFI_IP]);
+ rn; rn = agg_route_next(rn)) {
assert(!RFAPI_MONITOR_VPN(rn));
}
- for (rn = route_top(rfd->import_table->imported_vpn[AFI_IP6]);
- rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(
+ rfd->import_table->imported_vpn[AFI_IP6]);
+ rn; rn = agg_route_next(rn)) {
assert(!RFAPI_MONITOR_VPN(rn));
}
assert(!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE));
}
-void rfapiMonitorExtraFlush(safi_t safi, struct route_node *rn)
+void rfapiMonitorExtraFlush(safi_t safi, struct agg_node *rn)
{
struct rfapi_it_extra *hie;
struct rfapi_monitor_vpn *v;
e_next = e->next;
e->next = NULL;
XFREE(MTYPE_RFAPI_MONITOR_ENCAP, e);
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
hie->u.encap.e = NULL;
break;
v_next = v->next;
v->next = NULL;
XFREE(MTYPE_RFAPI_MONITOR, e);
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
hie->u.vpn.v = NULL;
if (hie->u.vpn.e.source) {
while (!skiplist_delete_first(hie->u.vpn.e.source)) {
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
skiplist_free(hie->u.vpn.e.source);
hie->u.vpn.e.source = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
if (hie->u.vpn.idx_rd) {
/* looping through bi->extra->vnc.import.rd is tbd */
while (!skiplist_delete_first(hie->u.vpn.idx_rd)) {
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
skiplist_free(hie->u.vpn.idx_rd);
hie->u.vpn.idx_rd = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
if (hie->u.vpn.mon_eth) {
while (!skiplist_delete_first(hie->u.vpn.mon_eth)) {
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
skiplist_free(hie->u.vpn.mon_eth);
hie->u.vpn.mon_eth = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
break;
}
XFREE(MTYPE_RFAPI_IT_EXTRA, hie);
rn->aggregate = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
/*
* If the child lists are empty, release the rfapi_it_extra struct
*/
-void rfapiMonitorExtraPrune(safi_t safi, struct route_node *rn)
+void rfapiMonitorExtraPrune(safi_t safi, struct agg_node *rn)
{
struct rfapi_it_extra *hie;
return;
skiplist_free(hie->u.vpn.mon_eth);
hie->u.vpn.mon_eth = NULL;
- route_unlock_node(rn); /* uncount skiplist */
+ agg_unlock_node(rn); /* uncount skiplist */
}
if (hie->u.vpn.e.source) {
if (skiplist_count(hie->u.vpn.e.source))
return;
skiplist_free(hie->u.vpn.e.source);
hie->u.vpn.e.source = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
if (hie->u.vpn.idx_rd) {
if (skiplist_count(hie->u.vpn.idx_rd))
return;
skiplist_free(hie->u.vpn.idx_rd);
hie->u.vpn.idx_rd = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
if (hie->u.vpn.mon_eth) {
if (skiplist_count(hie->u.vpn.mon_eth))
return;
skiplist_free(hie->u.vpn.mon_eth);
hie->u.vpn.mon_eth = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
break;
}
XFREE(MTYPE_RFAPI_IT_EXTRA, hie);
rn->aggregate = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
/*
* returns locked node
*/
-struct route_node *rfapiMonitorGetAttachNode(struct rfapi_descriptor *rfd,
- struct prefix *p)
+struct agg_node *rfapiMonitorGetAttachNode(struct rfapi_descriptor *rfd,
+ struct prefix *p)
{
afi_t afi;
- struct route_node *rn;
+ struct agg_node *rn;
if (RFAPI_0_PREFIX(p)) {
assert(1);
* if a monitor is moved to another node, there must be
* corresponding unlock/locks
*/
- for (rn = route_node_match(rfd->import_table->imported_vpn[afi], p);
+ for (rn = agg_node_match(rfd->import_table->imported_vpn[afi], p);
rn;) {
struct bgp_info *bi;
if (bi)
break;
- route_unlock_node(rn);
- if ((rn = rn->parent)) {
- route_lock_node(rn);
+ agg_unlock_node(rn);
+ if ((rn = agg_node_parent(rn))) {
+ agg_lock_node(rn);
}
}
/* creates default node if none exists, and increments ref count
*/
- rn = route_node_get(rfd->import_table->imported_vpn[afi],
- &pfx_default);
+ rn = agg_node_get(rfd->import_table->imported_vpn[afi],
+ &pfx_default);
}
return rn;
* returned (for the benefit of caller which might like to use it
* to generate an immediate query response).
*/
-static struct route_node *rfapiMonitorAttachImport(struct rfapi_descriptor *rfd,
- struct rfapi_monitor_vpn *m)
+static struct agg_node *rfapiMonitorAttachImport(struct rfapi_descriptor *rfd,
+ struct rfapi_monitor_vpn *m)
{
- struct route_node *rn;
+ struct agg_node *rn;
rfapiMonitorCheckAttachAllowed();
*/
void rfapiMonitorAttachImportHd(struct rfapi_descriptor *rfd)
{
- struct route_node *mrn;
+ struct agg_node *mrn;
if (!rfd->mon) {
/*
return;
}
- for (mrn = route_top(rfd->mon); mrn; mrn = route_next(mrn)) {
+ for (mrn = agg_route_top(rfd->mon); mrn; mrn = agg_route_next(mrn)) {
if (!mrn->info)
continue;
* are disabled, this function will not perform a lookup, and the
* caller will have to do its own lookup.
*/
-struct route_node *
-rfapiMonitorAdd(struct bgp *bgp, struct rfapi_descriptor *rfd, struct prefix *p)
+struct agg_node *rfapiMonitorAdd(struct bgp *bgp, struct rfapi_descriptor *rfd,
+ struct prefix *p)
{
struct rfapi_monitor_vpn *m;
- struct route_node *rn;
+ struct agg_node *rn;
/*
* Initialize nve's monitor list if needed
* or be 0/0 so they won't get mixed up.
*/
if (!rfd->mon) {
- rfd->mon = route_table_init();
+ rfd->mon = agg_table_init();
}
- rn = route_node_get(rfd->mon, p);
+ rn = agg_node_get(rfd->mon, p);
if (rn->info) {
/*
* received this query before, no further action needed
*/
rfapiMonitorTimerRestart((struct rfapi_monitor_vpn *)rn->info);
- route_unlock_node(rn);
+ agg_unlock_node(rn);
return NULL;
}
this->next;
}
RFAPI_CHECK_REFCOUNT(m->node, SAFI_MPLS_VPN, 1);
- route_unlock_node(m->node);
+ agg_unlock_node(m->node);
}
m->node = NULL;
}
void rfapiMonitorDetachImportHd(struct rfapi_descriptor *rfd)
{
- struct route_node *rn;
+ struct agg_node *rn;
if (!rfd->mon)
return;
- for (rn = route_top(rfd->mon); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->mon); rn; rn = agg_route_next(rn)) {
if (rn->info) {
rfapiMonitorDetachImport(
(struct rfapi_monitor_vpn *)(rn->info));
void rfapiMonitorDel(struct bgp *bgp, struct rfapi_descriptor *rfd,
struct prefix *p)
{
- struct route_node *rn;
+ struct agg_node *rn;
struct rfapi_monitor_vpn *m;
assert(rfd->mon);
- rn = route_node_get(rfd->mon, p); /* locks node */
+ rn = agg_node_get(rfd->mon, p); /* locks node */
m = rn->info;
assert(m);
*/
XFREE(MTYPE_RFAPI_MONITOR, m);
rn->info = NULL;
- route_unlock_node(rn); /* undo original lock when created */
- route_unlock_node(rn); /* undo lock in route_node_get */
+ agg_unlock_node(rn); /* undo original lock when created */
+ agg_unlock_node(rn); /* undo lock in agg_node_get */
--rfd->monitor_count;
--bgp->rfapi->monitor_count;
*/
int rfapiMonitorDelHd(struct rfapi_descriptor *rfd)
{
- struct route_node *rn;
+ struct agg_node *rn;
struct bgp *bgp;
int count = 0;
bgp = bgp_get_default();
if (rfd->mon) {
- for (rn = route_top(rfd->mon); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->mon); rn;
+ rn = agg_route_next(rn)) {
struct rfapi_monitor_vpn *m;
if ((m = rn->info)) {
if (!(bgp->rfapi_cfg->flags
XFREE(MTYPE_RFAPI_MONITOR, m);
rn->info = NULL;
- route_unlock_node(rn); /* undo original lock
+ agg_unlock_node(rn); /* undo original lock
when created */
++count;
--rfd->monitor_count;
--bgp->rfapi->monitor_count;
}
}
- route_table_finish(rfd->mon);
+ agg_table_finish(rfd->mon);
rfd->mon = NULL;
}
*/
void rfapiMonitorTimersRestart(struct rfapi_descriptor *rfd, struct prefix *p)
{
- struct route_node *rn;
+ struct agg_node *rn;
if (AF_ETHERNET == p->family) {
struct rfapi_monitor_eth *mon_eth;
}
} else {
- for (rn = route_top(rfd->mon); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->mon); rn;
+ rn = agg_route_next(rn)) {
struct rfapi_monitor_vpn *m;
if (!((m = rn->info)))
* rfapiRibUpdatePendingNode with this node and all corresponding NVEs.
*/
void rfapiMonitorItNodeChanged(
- struct rfapi_import_table *import_table, struct route_node *it_node,
+ struct rfapi_import_table *import_table, struct agg_node *it_node,
struct rfapi_monitor_vpn *monitor_list) /* for base it node, NULL=all */
{
struct skiplist *nves_seen;
- struct route_node *rn = it_node;
+ struct agg_node *rn = it_node;
struct bgp *bgp = bgp_get_default();
afi_t afi = family2afi(rn->p.family);
#if DEBUG_L2_EXTRA
* to them
* because we haven't sent them an initial route.
*/
- if (!rn->parent && !rn->info && it_node->parent)
+ if (!agg_node_parent(rn) && !rn->info
+ && it_node->parent)
break;
for (; m; m = m->next) {
m->rfd->response_lifetime);
}
}
- rn = rn->parent;
+ rn = agg_node_parent(rn);
if (rn)
m = RFAPI_MONITOR_VPN(rn);
} while (rn);
* omit old node and its subtree
*/
void rfapiMonitorMovedUp(struct rfapi_import_table *import_table,
- struct route_node *old_node,
- struct route_node *new_node,
+ struct agg_node *old_node, struct agg_node *new_node,
struct rfapi_monitor_vpn *monitor_list)
{
struct bgp *bgp = bgp_get_default();
static void rfapiMonitorEthAttachImport(
struct rfapi_import_table *it,
- struct route_node *rn, /* it node attach point if non-0 */
+ struct agg_node *rn, /* it node attach point if non-0 */
struct rfapi_monitor_eth *mon) /* monitor struct to attach */
{
struct skiplist *sl;
if (!sl) {
sl = RFAPI_MONITOR_ETH_W_ALLOC(rn) =
skiplist_new(0, NULL, NULL);
- route_lock_node(rn); /* count skiplist mon_eth */
+ agg_lock_node(rn); /* count skiplist mon_eth */
}
#if DEBUG_L2_EXTRA
assert(!rc);
/* count eth monitor */
- route_lock_node(rn);
+ agg_lock_node(rn);
}
/*
struct rfapi_import_table *it;
struct prefix pfx_mac_buf;
- struct route_node *rn;
+ struct agg_node *rn;
it = rfapiMacImportTableGet(bgp, mon->logical_net_id);
assert(it);
pfx_mac_buf.prefixlen = 48;
pfx_mac_buf.u.prefix_eth = mon->macaddr;
- rn = route_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf);
+ rn = agg_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf);
assert(rn);
(void)rfapiMonitorEthAttachImport(it, rn, mon);
struct rfapi_import_table *it;
struct prefix pfx_mac_buf;
struct skiplist *sl;
- struct route_node *rn;
+ struct agg_node *rn;
int rc;
it = rfapiMacImportTableGet(bgp, mon->logical_net_id);
pfx_mac_buf.prefixlen = 48;
pfx_mac_buf.u.prefix_eth = mon->macaddr;
- rn = route_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf);
+ rn = agg_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf);
assert(rn);
#if DEBUG_L2_EXTRA
assert(!rc);
/* uncount eth monitor */
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
-struct route_node *rfapiMonitorEthAdd(struct bgp *bgp,
- struct rfapi_descriptor *rfd,
- struct ethaddr *macaddr,
- uint32_t logical_net_id)
+struct agg_node *rfapiMonitorEthAdd(struct bgp *bgp,
+ struct rfapi_descriptor *rfd,
+ struct ethaddr *macaddr,
+ uint32_t logical_net_id)
{
int rc;
struct rfapi_monitor_eth mon_buf;
struct rfapi_monitor_eth *val;
struct rfapi_import_table *it;
- struct route_node *rn = NULL;
+ struct agg_node *rn = NULL;
struct prefix pfx_mac_buf;
if (!rfd->mon_eth) {
pfx_mac_buf.u.prefix_eth = *macaddr;
if (!RFAPI_0_ETHERADDR(macaddr)) {
- rn = route_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf);
+ rn = agg_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf);
assert(rn);
}
{
struct rfapi_import_table *it;
afi_t afi;
- struct route_table *rt;
- struct route_node *rn;
+ struct agg_table *rt;
+ struct agg_node *rn;
void *cursor;
int rc;
struct rfapi *h = bgp->rfapi;
rt = it->imported_vpn[afi];
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn;
+ rn = agg_route_next(rn)) {
m = RFAPI_MONITOR_VPN(rn);
if (RFAPI_MONITOR_VPN(rn))
RFAPI_MONITOR_VPN_W_ALLOC(rn) = NULL;
m->next =
NULL; /* gratuitous safeness */
m->node = NULL;
- route_unlock_node(rn); /* uncount */
+ agg_unlock_node(rn); /* uncount */
}
}
* Find non-0 monitors (i.e., actual addresses, not FTD
* monitors)
*/
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
struct skiplist *sl;
sl = RFAPI_MONITOR_ETH(rn);
while (!skiplist_delete_first(sl)) {
- route_unlock_node(rn); /* uncount monitor */
+ agg_unlock_node(rn); /* uncount monitor */
}
}
* to indicate which nves are interested in a prefix/target
*/
struct rfapi_monitor_vpn {
- struct rfapi_monitor_vpn *next; /* chain from struct route_node */
+ struct rfapi_monitor_vpn *next; /* chain from struct agg_node */
struct rfapi_descriptor *rfd; /* which NVE requested the route */
struct prefix p; /* constant: pfx in original request */
- struct route_node *node; /* node we're currently attached to */
+ struct agg_node *node; /* node we're currently attached to */
uint32_t flags;
#define RFAPI_MON_FLAG_NEEDCALLBACK 0x00000001 /* deferred callback */
struct rfapi_monitor_encap {
struct rfapi_monitor_encap *next;
struct rfapi_monitor_encap *prev;
- struct route_node *node; /* VPN node */
+ struct agg_node *node; /* VPN node */
struct bgp_info *bi; /* VPN bi */
- struct route_node *rn; /* parent node */
+ struct agg_node *rn; /* parent node */
};
struct rfapi_monitor_eth {
((struct rfapi_it_extra \
*)((rn)->aggregate \
? (rn)->aggregate \
- : (route_lock_node(rn), \
+ : (agg_lock_node(rn), \
(rn)->aggregate = XCALLOC( \
MTYPE_RFAPI_IT_EXTRA, \
sizeof(struct rfapi_it_extra)))))
extern void rfapiMonitorCheckAttachAllowed(void);
-extern void rfapiMonitorExtraFlush(safi_t safi, struct route_node *rn);
+extern void rfapiMonitorExtraFlush(safi_t safi, struct agg_node *rn);
-extern struct route_node *
-rfapiMonitorGetAttachNode(struct rfapi_descriptor *rfd, struct prefix *p);
+extern struct agg_node *rfapiMonitorGetAttachNode(struct rfapi_descriptor *rfd,
+ struct prefix *p);
extern void rfapiMonitorAttachImportHd(struct rfapi_descriptor *rfd);
-extern struct route_node *rfapiMonitorAdd(struct bgp *bgp,
- struct rfapi_descriptor *rfd,
- struct prefix *p);
+extern struct agg_node *rfapiMonitorAdd(struct bgp *bgp,
+ struct rfapi_descriptor *rfd,
+ struct prefix *p);
extern void rfapiMonitorDetachImportHd(struct rfapi_descriptor *rfd);
extern void rfapiMonitorResponseRemovalOn(struct bgp *bgp);
-extern void rfapiMonitorExtraPrune(safi_t safi, struct route_node *rn);
+extern void rfapiMonitorExtraPrune(safi_t safi, struct agg_node *rn);
extern void rfapiMonitorTimersRestart(struct rfapi_descriptor *rfd,
struct prefix *p);
extern void rfapiMonitorItNodeChanged(struct rfapi_import_table *import_table,
- struct route_node *it_node,
+ struct agg_node *it_node,
struct rfapi_monitor_vpn *monitor_list);
extern void rfapiMonitorMovedUp(struct rfapi_import_table *import_table,
- struct route_node *old_node,
- struct route_node *new_node,
+ struct agg_node *old_node,
+ struct agg_node *new_node,
struct rfapi_monitor_vpn *monitor_list);
-extern struct route_node *rfapiMonitorEthAdd(struct bgp *bgp,
- struct rfapi_descriptor *rfd,
- struct ethaddr *macaddr,
- uint32_t logical_net_id);
+extern struct agg_node *rfapiMonitorEthAdd(struct bgp *bgp,
+ struct rfapi_descriptor *rfd,
+ struct ethaddr *macaddr,
+ uint32_t logical_net_id);
extern void rfapiMonitorEthDel(struct bgp *bgp, struct rfapi_descriptor *rfd,
struct ethaddr *macaddr,
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/skiplist.h"
};
struct rfapi_descriptor {
- struct route_node *un_node; /* backref to un table */
+ struct agg_node *un_node; /* backref to un table */
struct rfapi_descriptor *next; /* next vn_addr */
struct rfapi_import_table *import_table;
uint32_t monitor_count;
- struct route_table *mon; /* rfapi_monitors */
+ struct agg_table *mon; /* rfapi_monitors */
struct skiplist *mon_eth; /* ethernet monitors */
/*
* rsp_times last time we sent response containing pfx
*/
uint32_t rib_prefix_count; /* pfxes with routes */
- struct route_table *rib[AFI_MAX];
- struct route_table *rib_pending[AFI_MAX];
+ struct agg_table *rib[AFI_MAX];
+ struct agg_table *rib_pending[AFI_MAX];
struct work_queue *updated_responses_queue;
- struct route_table *rsp_times[AFI_MAX];
+ struct agg_table *rsp_times[AFI_MAX];
uint32_t rsp_counter; /* dedup initial rsp */
time_t rsp_time; /* dedup initial rsp */
* check vn address to get exact match.
*/
struct rfapi {
- struct route_table *un[AFI_MAX];
+ struct agg_table *un[AFI_MAX];
struct rfapi_import_table *imports; /* IPv4, IPv6 */
struct list descriptors; /* debug & resolve-nve imports */
* bgp unicast or zebra, we need to keep track of information
* related to expiring the routes according to the VNC lifetime
*/
- struct route_table *rt_export_bgp[AFI_MAX];
- struct route_table *rt_export_zebra[AFI_MAX];
+ struct agg_table *rt_export_bgp[AFI_MAX];
+ struct agg_table *rt_export_zebra[AFI_MAX];
/*
* For VNC->BGP unicast exports in CE mode, we need a
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/log.h"
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_node *rn;
+ struct agg_node *rn;
- for (rn = route_top(rfd->rib[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->rib[afi]); rn;
+ rn = agg_route_next(rn)) {
struct skiplist *sl = rn->info;
struct skiplist *dsl = rn->aggregate;
++t_pfx_deleted;
}
}
- for (rn = route_top(rfd->rib_pending[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->rib_pending[afi]); rn;
+ rn = agg_route_next(rn)) {
struct list *l = rn->info; /* sorted by cost */
struct skiplist *sl = rn->aggregate;
struct rfapi_descriptor *rfd;
struct skiplist *sl;
struct rfapi_info *ri;
- struct route_node *rn;
+ struct agg_node *rn;
int flags;
#define RFAPI_RIB_TCB_FLAG_DELETED 0x00000001
};
RFAPI_RIB_PREFIX_COUNT_DECR(tcb->rfd, bgp->rfapi);
}
skiplist_free(tcb->sl);
- route_unlock_node(tcb->rn);
+ agg_unlock_node(tcb->rn);
}
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
return 0;
}
-static void
-rfapiRibStartTimer(struct rfapi_descriptor *rfd, struct rfapi_info *ri,
- struct route_node *rn, /* route node attached to */
- int deleted)
+static void rfapiRibStartTimer(struct rfapi_descriptor *rfd,
+ struct rfapi_info *ri,
+ struct agg_node *rn, /* route node attached to */
+ int deleted)
{
struct thread *t = ri->timer;
struct rfapi_rib_tcb *tcb = NULL;
#endif
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_node *pn;
- struct route_node *rn;
+ struct agg_node *pn;
+ struct agg_node *rn;
if (rfd->rib_pending[afi]) {
- for (pn = route_top(rfd->rib_pending[afi]); pn;
- pn = route_next(pn)) {
+ for (pn = agg_route_top(rfd->rib_pending[afi]); pn;
+ pn = agg_route_next(pn)) {
if (pn->aggregate) {
/*
* free references into the rfapi_info
(struct skiplist
*)(pn->aggregate));
pn->aggregate = NULL;
- route_unlock_node(
+ agg_unlock_node(
pn); /* skiplist deleted */
}
/*
}
pn->info = NULL;
/* linklist or 1 deleted */
- route_unlock_node(pn);
+ agg_unlock_node(pn);
}
}
}
if (rfd->rib[afi]) {
- for (rn = route_top(rfd->rib[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->rib[afi]); rn;
+ rn = agg_route_next(rn)) {
if (rn->info) {
struct rfapi_info *ri;
skiplist_free(
(struct skiplist *)rn->info);
rn->info = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
RFAPI_RIB_PREFIX_COUNT_DECR(rfd,
bgp->rfapi);
}
*)(rn->aggregate));
rn->aggregate = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
}
}
* Free radix trees
*/
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- route_table_finish(rfd->rib_pending[afi]);
+ if (rfd->rib_pending[afi])
+ agg_table_finish(rfd->rib_pending[afi]);
rfd->rib_pending[afi] = NULL;
- route_table_finish(rfd->rib[afi]);
+ if (rfd->rib[afi])
+ agg_table_finish(rfd->rib[afi]);
rfd->rib[afi] = NULL;
- /* NB route_table_finish frees only prefix nodes, not chained
+ /* NB agg_table_finish frees only prefix nodes, not chained
* info */
- route_table_finish(rfd->rsp_times[afi]);
+ if (rfd->rsp_times[afi])
+ agg_table_finish(rfd->rsp_times[afi]);
rfd->rib[afi] = NULL;
}
}
* !0 do not include route in response
*/
int rfapiRibPreloadBi(
- struct route_node *rfd_rib_node, /* NULL = don't preload or filter */
+ struct agg_node *rfd_rib_node, /* NULL = don't preload or filter */
struct prefix *pfx_vn, struct prefix *pfx_un, uint32_t lifetime,
struct bgp_info *bi)
{
struct skiplist *slRibPt = NULL;
struct rfapi_info *ori = NULL;
struct rfapi_rib_key rk;
- struct route_node *trn;
+ struct agg_node *trn;
afi_t afi;
if (!rfd_rib_node)
afi = family2afi(rfd_rib_node->p.family);
- rfd = (struct rfapi_descriptor *)(rfd_rib_node->table->info);
+ rfd = agg_get_table_info(agg_get_table(rfd_rib_node));
memset((void *)&rk, 0, sizeof(rk));
rk.vn = *pfx_vn;
if (!slRibPt) {
slRibPt = skiplist_new(0, rfapi_rib_key_cmp, NULL);
rfd_rib_node->info = slRibPt;
- route_lock_node(rfd_rib_node);
+ agg_lock_node(rfd_rib_node);
RFAPI_RIB_PREFIX_COUNT_INCR(rfd, rfd->bgp->rfapi);
}
skiplist_insert(slRibPt, &ori->rk, ori);
/*
* Update last sent time for prefix
*/
- trn = route_node_get(rfd->rsp_times[afi],
- &rfd_rib_node->p); /* locks trn */
+ trn = agg_node_get(rfd->rsp_times[afi],
+ &rfd_rib_node->p); /* locks trn */
trn->info = (void *)(uintptr_t)bgp_clock();
if (trn->lock > 1)
- route_unlock_node(trn);
+ agg_unlock_node(trn);
return 0;
}
*/
static void process_pending_node(struct bgp *bgp, struct rfapi_descriptor *rfd,
afi_t afi,
- struct route_node *pn, /* pending node */
+ struct agg_node *pn, /* pending node */
struct rfapi_next_hop_entry **head,
struct rfapi_next_hop_entry **tail)
{
struct listnode *nnode = NULL;
struct rfapi_info *ri = NULL; /* happy valgrind */
struct rfapi_ip_prefix hp = {0}; /* pfx to put in NHE */
- struct route_node *rn = NULL;
+ struct agg_node *rn = NULL;
struct skiplist *slRibPt = NULL; /* rib list */
struct skiplist *slPendPt = NULL;
struct list *lPendCost = NULL;
/*
* Find corresponding RIB node
*/
- rn = route_node_get(rfd->rib[afi], &pn->p); /* locks rn */
+ rn = agg_node_get(rfd->rib[afi], &pn->p); /* locks rn */
/*
* RIB skiplist has key=rfapi_addr={vn,un}, val = rfapi_info,
skiplist_free(slRibPt);
rn->info = slRibPt = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
lPendCost = pn->info = NULL;
- route_unlock_node(pn);
+ agg_unlock_node(pn);
goto callback;
}
if (slRibPt) {
skiplist_free(slRibPt);
rn->info = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
assert(!slPendPt);
if (slPendPt) { /* TBD I think we can toss this block */
skiplist_free(slPendPt);
pn->aggregate = NULL;
- route_unlock_node(pn);
+ agg_unlock_node(pn);
}
pn->info = NULL;
- route_unlock_node(pn);
+ agg_unlock_node(pn);
- route_unlock_node(rn); /* route_node_get() */
+ agg_unlock_node(rn); /* agg_node_get() */
if (rib_node_started_nonempty) {
RFAPI_RIB_PREFIX_COUNT_DECR(rfd, bgp->rfapi);
if (skiplist_empty(slRibPt)) {
skiplist_free(slRibPt);
slRibPt = rn->info = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
}
}
slRibPt = skiplist_new(
0, rfapi_rib_key_cmp, NULL);
rn->info = slRibPt;
- route_lock_node(rn);
+ agg_lock_node(rn);
}
skiplist_insert(slRibPt, &ori->rk, ori);
for (ALL_LIST_ELEMENTS(lPendCost, node, nnode, ri)) {
struct rfapi_next_hop_entry *new;
- struct route_node *trn;
+ struct agg_node *trn;
new = XCALLOC(MTYPE_RFAPI_NEXTHOP,
sizeof(struct rfapi_next_hop_entry));
/*
* update this NVE's timestamp for this prefix
*/
- trn = route_node_get(rfd->rsp_times[afi],
- &pn->p); /* locks trn */
+ trn = agg_node_get(rfd->rsp_times[afi],
+ &pn->p); /* locks trn */
trn->info = (void *)(uintptr_t)bgp_clock();
if (trn->lock > 1)
- route_unlock_node(trn);
+ agg_unlock_node(trn);
rfapiRfapiIpAddr2Str(&new->vn_address, buf, BUFSIZ);
rfapiRfapiIpAddr2Str(&new->un_address, buf2, BUFSIZ);
0, rfapi_rib_key_cmp,
(void (*)(void *))
rfapi_info_free);
- route_lock_node(rn);
+ agg_lock_node(rn);
}
RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);
RFAPI_RIB_CHECK_COUNTS(0, 0);
/*
- * Reset pending lists. The final route_unlock_node() will probably
+ * Reset pending lists. The final agg_unlock_node() will probably
* cause the pending node to be released.
*/
if (slPendPt) {
skiplist_free(slPendPt);
pn->aggregate = NULL;
- route_unlock_node(pn);
+ agg_unlock_node(pn);
}
if (lPendCost) {
list_delete_and_null(&lPendCost);
pn->info = NULL;
- route_unlock_node(pn);
+ agg_unlock_node(pn);
}
RFAPI_RIB_CHECK_COUNTS(0, 0);
if (sendingsomeroutes)
rfapiMonitorTimersRestart(rfd, &pn->p);
- route_unlock_node(rn); /* route_node_get() */
+ agg_unlock_node(rn); /* agg_node_get() */
RFAPI_RIB_CHECK_COUNTS(1, 0);
}
struct bgp *bgp = bgp_get_default();
struct rfapi_next_hop_entry *head = NULL;
struct rfapi_next_hop_entry *tail = NULL;
- struct route_node *rn;
+ struct agg_node *rn;
#if DEBUG_L2_EXTRA
vnc_zlog_debug_verbose("%s: rfd=%p, afi=%d", __func__, rfd, afi);
assert(bgp->rfapi);
- for (rn = route_top(rfd->rib_pending[afi]); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->rib_pending[afi]); rn;
+ rn = agg_route_next(rn)) {
process_pending_node(bgp, rfd, afi, rn, &head, &tail);
}
void rfapiRibUpdatePendingNode(
struct bgp *bgp, struct rfapi_descriptor *rfd,
struct rfapi_import_table *it, /* needed for L2 */
- struct route_node *it_node, uint32_t lifetime)
+ struct agg_node *it_node, uint32_t lifetime)
{
struct prefix *prefix;
struct bgp_info *bi;
- struct route_node *pn;
+ struct agg_node *pn;
afi_t afi;
uint32_t queued_flag;
int count = 0;
prefix2str(prefix, buf, sizeof(buf));
vnc_zlog_debug_verbose("%s: prefix=%s", __func__, buf);
- pn = route_node_get(rfd->rib_pending[afi], prefix);
+ pn = agg_node_get(rfd->rib_pending[afi], prefix);
assert(pn);
vnc_zlog_debug_verbose("%s: pn->info=%p, pn->aggregate=%p", __func__,
*/
skiplist_free((struct skiplist *)(pn->aggregate));
pn->aggregate = NULL;
- route_unlock_node(pn); /* skiplist deleted */
+ agg_unlock_node(pn); /* skiplist deleted */
}
list_delete_and_null((struct list **)(&pn->info));
}
pn->info = NULL;
- route_unlock_node(pn); /* linklist or 1 deleted */
+ agg_unlock_node(pn); /* linklist or 1 deleted */
}
/*
if (!pn->aggregate) {
pn->aggregate =
skiplist_new(0, rfapi_rib_key_cmp, NULL);
- route_lock_node(pn);
+ agg_lock_node(pn);
}
/*
pn->info = list_new();
((struct list *)(pn->info))->del =
(void (*)(void *))rfapi_info_free;
- route_lock_node(pn);
+ agg_lock_node(pn);
}
listnode_add((struct list *)(pn->info), ri);
assert(!pn->aggregate);
pn->info = (void *)1; /* magic value means this node has no
routes */
- route_lock_node(pn);
+ agg_lock_node(pn);
}
- route_unlock_node(pn); /* route_node_get */
+ agg_unlock_node(pn); /* agg_node_get */
queued_flag = RFAPI_QUEUED_FLAG(afi);
void rfapiRibUpdatePendingNodeSubtree(
struct bgp *bgp, struct rfapi_descriptor *rfd,
- struct rfapi_import_table *it, struct route_node *it_node,
- struct route_node *omit_subtree, /* may be NULL */
+ struct rfapi_import_table *it, struct agg_node *it_node,
+ struct agg_node *omit_subtree, /* may be NULL */
uint32_t lifetime)
{
/* FIXME: need to find a better way here to work without sticking our
* hands in node->link */
- if (it_node->l_left && (it_node->l_left != omit_subtree)) {
- if (it_node->l_left->info)
- rfapiRibUpdatePendingNode(bgp, rfd, it, it_node->l_left,
- lifetime);
- rfapiRibUpdatePendingNodeSubtree(bgp, rfd, it, it_node->l_left,
+ if (agg_node_left(it_node)
+ && (agg_node_left(it_node) != omit_subtree)) {
+ if (agg_node_left(it_node)->info)
+ rfapiRibUpdatePendingNode(
+ bgp, rfd, it, agg_node_left(it_node), lifetime);
+ rfapiRibUpdatePendingNodeSubtree(bgp, rfd, it,
+ agg_node_left(it_node),
omit_subtree, lifetime);
}
- if (it_node->l_right && (it_node->l_right != omit_subtree)) {
- if (it_node->l_right->info)
+ if (agg_node_right(it_node)
+ && (agg_node_right(it_node) != omit_subtree)) {
+ if (agg_node_right(it_node)->info)
rfapiRibUpdatePendingNode(bgp, rfd, it,
- it_node->l_right, lifetime);
- rfapiRibUpdatePendingNodeSubtree(bgp, rfd, it, it_node->l_right,
+ agg_node_right(it_node),
+ lifetime);
+ rfapiRibUpdatePendingNodeSubtree(bgp, rfd, it,
+ agg_node_right(it_node),
omit_subtree, lifetime);
}
}
*/
int rfapiRibFTDFilterRecentPrefix(
struct rfapi_descriptor *rfd,
- struct route_node *it_rn, /* import table node */
+ struct agg_node *it_rn, /* import table node */
struct prefix *pfx_target_original) /* query target */
{
struct bgp *bgp = rfd->bgp;
afi_t afi = family2afi(it_rn->p.family);
time_t prefix_time;
- struct route_node *trn;
+ struct agg_node *trn;
/*
* Not in FTD mode, so allow prefix
/*
* check this NVE's timestamp for this prefix
*/
- trn = route_node_get(rfd->rsp_times[afi], &it_rn->p); /* locks trn */
+ trn = agg_node_get(rfd->rsp_times[afi], &it_rn->p); /* locks trn */
prefix_time = (time_t)trn->info;
if (trn->lock > 1)
- route_unlock_node(trn);
+ agg_unlock_node(trn);
#if DEBUG_FTD_FILTER_RECENT
vnc_zlog_debug_verbose("%s: last sent time %lu, last allowed time %lu",
afi_t afi;
struct rfapi_info *ri;
int need_insert;
- struct route_node *rn;
+ struct agg_node *rn;
int rib_node_started_nonempty = 0;
- struct route_node *trn;
+ struct agg_node *trn;
int allowed = 0;
/* save in case we delete nhp */
/*
* Look up prefix in RIB
*/
- rn = route_node_get(rfd->rib[afi], &pfx); /* locks rn */
+ rn = agg_node_get(rfd->rib[afi], &pfx); /* locks rn */
if (rn->info) {
rib_node_started_nonempty = 1;
} else {
rn->info = skiplist_new(0, rfapi_rib_key_cmp, NULL);
- route_lock_node(rn);
+ agg_lock_node(rn);
}
/*
rfapiRibStartTimer(rfd, ri, rn, 0);
RFAPI_RIB_CHECK_COUNTS(0, 0);
- route_unlock_node(rn);
+ agg_unlock_node(rn);
/*
* update this NVE's timestamp for this prefix
*/
- trn = route_node_get(rfd->rsp_times[afi], &pfx); /* locks trn */
+ trn = agg_node_get(rfd->rsp_times[afi], &pfx); /* locks trn */
trn->info = (void *)(uintptr_t)bgp_clock();
if (trn->lock > 1)
- route_unlock_node(trn);
+ agg_unlock_node(trn);
{
char str_pfx[PREFIX_STRLEN];
}
void rfapiRibPendingDeleteRoute(struct bgp *bgp, struct rfapi_import_table *it,
- afi_t afi, struct route_node *it_node)
+ afi_t afi, struct agg_node *it_node)
{
struct rfapi_descriptor *rfd;
struct listnode *node;
* identifies the rfd that owns it.
*/
struct rfapi_monitor_eth *m;
- struct route_node *rn;
+ struct agg_node *rn;
struct skiplist *sl;
void *cursor;
int rc;
* NVE, it's OK to send an update with the
* delete
*/
- if ((rn = route_node_lookup(m->rfd->rib[afi],
- &it_node->p))) {
+ if ((rn = agg_node_lookup(m->rfd->rib[afi],
+ &it_node->p))) {
rfapiRibUpdatePendingNode(
bgp, m->rfd, it, it_node,
m->rfd->response_lifetime);
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
}
}
* this
* NVE, it's OK to send an update with the delete
*/
- if ((rn = route_node_lookup(m->rfd->rib[afi],
- &it_node->p))) {
+ if ((rn = agg_node_lookup(m->rfd->rib[afi],
+ &it_node->p))) {
rfapiRibUpdatePendingNode(
bgp, m->rfd, it, it_node,
m->rfd->response_lifetime);
for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, node,
rfd)) {
- struct route_node *rn;
+ struct agg_node *rn;
vnc_zlog_debug_verbose(
"%s: comparing rfd(%p)->import_table=%p to it=%p",
* prefix
* previously, we should send an updated response.
*/
- if ((rn = route_node_lookup(rfd->rib[afi],
- &it_node->p))) {
+ if ((rn = agg_node_lookup(rfd->rib[afi],
+ &it_node->p))) {
rfapiRibUpdatePendingNode(
bgp, rfd, it, it_node,
rfd->response_lifetime);
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
}
}
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_node *rn;
+ struct agg_node *rn;
if (!rfd->rib[afi])
continue;
- for (rn = route_top(rfd->rib[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->rib[afi]); rn;
+ rn = agg_route_next(rn)) {
struct skiplist *sl;
char str_pfx[PREFIX_STRLEN];
extern void rfapiRibUpdatePendingNode(struct bgp *bgp,
struct rfapi_descriptor *rfd,
struct rfapi_import_table *it,
- struct route_node *it_node,
+ struct agg_node *it_node,
uint32_t lifetime);
extern void rfapiRibUpdatePendingNodeSubtree(struct bgp *bgp,
struct rfapi_descriptor *rfd,
struct rfapi_import_table *it,
- struct route_node *it_node,
- struct route_node *omit_subtree,
+ struct agg_node *it_node,
+ struct agg_node *omit_subtree,
uint32_t lifetime);
-extern int rfapiRibPreloadBi(struct route_node *rfd_rib_node,
+extern int rfapiRibPreloadBi(struct agg_node *rfd_rib_node,
struct prefix *pfx_vn, struct prefix *pfx_un,
uint32_t lifetime, struct bgp_info *bi);
extern void rfapiRibPendingDeleteRoute(struct bgp *bgp,
struct rfapi_import_table *it, afi_t afi,
- struct route_node *it_node);
+ struct agg_node *it_node);
extern void rfapiRibShowResponsesSummary(void *stream);
extern int rfapiRibFTDFilterRecentPrefix(
struct rfapi_descriptor *rfd,
- struct route_node *it_rn, /* import table node */
+ struct agg_node *it_rn, /* import table node */
struct prefix *pfx_target_original); /* query target */
extern void rfapiFreeRfapiUnOptionChain(struct rfapi_un_option *p);
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/routemap.h"
m->bi, HVTYNL);
}
-void rfapiShowItNode(void *stream, struct route_node *rn)
+void rfapiShowItNode(void *stream, struct agg_node *rn)
{
struct bgp_info *bi;
char buf[BUFSIZ];
/* doesn't show montors */
}
-void rfapiShowImportTable(void *stream, const char *label,
- struct route_table *rt, int isvpn)
+void rfapiShowImportTable(void *stream, const char *label, struct agg_table *rt,
+ int isvpn)
{
- struct route_node *rn;
+ struct agg_node *rn;
char buf[BUFSIZ];
int (*fp)(void *, const char *, ...);
fp(out, "Import Table [%s]%s", label, HVTYNL);
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
struct bgp_info *bi;
if (rn->p.family == AF_ETHERNET) {
for (ALL_LIST_ELEMENTS_RO(&h->descriptors, node, rfd)) {
- struct route_node *rn;
+ struct agg_node *rn;
int printedquerier = 0;
* IP Queries
*/
if (rfd->mon) {
- for (rn = route_top(rfd->mon); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(rfd->mon); rn;
+ rn = agg_route_next(rn)) {
struct rfapi_monitor_vpn *m;
char buf_remain[BUFSIZ];
char buf_pfx[BUFSIZ];
}
static int rfapiPrintRemoteRegBi(struct bgp *bgp, void *stream,
- struct route_node *rn, struct bgp_info *bi)
+ struct agg_node *rn, struct bgp_info *bi)
{
int (*fp)(void *, const char *, ...);
struct vty *vty;
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- struct route_node *rn;
+ struct agg_node *rn;
if (!it->imported_vpn[afi])
continue;
- for (rn = route_top(it->imported_vpn[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(it->imported_vpn[afi]); rn;
+ rn = agg_route_next(rn)) {
struct bgp_info *bi;
int count_only;
extern const char *rfapiRfapiIpPrefix2Str(struct rfapi_ip_prefix *p, char *buf,
int bufsize);
-extern void rfapiShowItNode(void *stream, struct route_node *rn);
+extern void rfapiShowItNode(void *stream, struct agg_node *rn);
extern char *rfapiEthAddr2Str(const struct ethaddr *ea, char *buf, int bufsize);
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/log.h"
#include "lib/stream.h"
static void vnc_direct_add_rn_group_rd(struct bgp *bgp,
struct rfapi_nve_group_cfg *rfg,
- struct route_node *rn, struct attr *attr,
+ struct agg_node *rn, struct attr *attr,
afi_t afi,
struct rfapi_descriptor *irfd);
}
-void vnc_direct_bgp_add_route_ce(struct bgp *bgp, struct route_node *rn,
+void vnc_direct_bgp_add_route_ce(struct bgp *bgp, struct agg_node *rn,
struct bgp_info *bi)
{
struct attr *attr = bi->attr;
/*
* "Withdrawing a Route" export process
*/
-void vnc_direct_bgp_del_route_ce(struct bgp *bgp, struct route_node *rn,
+void vnc_direct_bgp_del_route_ce(struct bgp *bgp, struct agg_node *rn,
struct bgp_info *bi)
{
afi_t afi = family2afi(rn->p.family);
static void vnc_direct_bgp_vpn_enable_ce(struct bgp *bgp, afi_t afi)
{
- struct route_node *rn;
+ struct agg_node *rn;
struct bgp_info *ri;
vnc_zlog_debug_verbose("%s: entry, afi=%d", __func__, afi);
/*
* Go through entire ce import table and export to BGP unicast.
*/
- for (rn = route_top(bgp->rfapi->it_ce->imported_vpn[afi]); rn;
- rn = route_next(rn)) {
+ for (rn = agg_route_top(bgp->rfapi->it_ce->imported_vpn[afi]); rn;
+ rn = agg_route_next(rn)) {
if (!rn->info)
continue;
* Export methods that proxy nexthop BEGIN
***********************************************************************/
-static struct ecommunity *vnc_route_origin_ecom(struct route_node *rn)
+static struct ecommunity *vnc_route_origin_ecom(struct agg_node *rn)
{
struct ecommunity *new;
struct bgp_info *bi;
static int
encap_attr_export(struct attr *new, struct attr *orig,
struct prefix *new_nexthop,
- struct route_node *rn) /* for VN addrs for ecom list */
- /* if rn is 0, use route's nexthop */
+ struct agg_node *rn) /* for VN addrs for ecom list */
+ /* if rn is 0, use route's nexthop */
{
struct prefix orig_nexthop;
struct prefix *use_nexthop;
*/
void vnc_direct_bgp_add_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn)
+ struct agg_node *rn)
{
struct attr attr = {0};
struct listnode *node, *nnode;
*/
void vnc_direct_bgp_del_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn)
+ struct agg_node *rn)
{
struct listnode *node, *nnode;
struct rfapi_rfg_name *rfgn;
*/
if (rfgn->rfg == rfg) {
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct attr attr = {0};
struct rfapi_import_table *import_table;
/*
* Walk the NVE-Group's VNC Import table
*/
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn;
+ rn = agg_route_next(rn)) {
if (rn->info) {
*/
if (rfg && rfgn->rfg == rfg) {
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct rfapi_import_table *import_table;
import_table = rfg->rfapi_import_table;
/*
* Walk the NVE-Group's VNC Import table
*/
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn;
+ rn = agg_route_next(rn)) {
if (rn->info) {
static void vnc_direct_add_rn_group_rd(struct bgp *bgp,
struct rfapi_nve_group_cfg *rfg,
- struct route_node *rn, struct attr *attr,
+ struct agg_node *rn, struct attr *attr,
afi_t afi, struct rfapi_descriptor *irfd)
{
struct prefix nhp;
struct rfapi_nve_group_cfg *rfg,
afi_t afi)
{
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct attr attr = {0};
struct rfapi_import_table *import_table;
/*
* Walk the NVE-Group's VNC Import table
*/
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
if (rn->info) {
static void vnc_direct_del_rn_group_rd(struct bgp *bgp,
struct rfapi_nve_group_cfg *rfg,
- struct route_node *rn, afi_t afi,
+ struct agg_node *rn, afi_t afi,
struct rfapi_descriptor *irfd)
{
if (irfd == NULL)
struct rfapi_nve_group_cfg *rfg,
afi_t afi)
{
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct rfapi_import_table *import_table;
vnc_zlog_debug_verbose("%s: entry", __func__);
/*
* Walk the NVE-Group's VNC Import table
*/
- for (rn = route_top(rt); rn; rn = route_next(rn))
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn))
if (rn->info) {
if (rfg->type == RFAPI_GROUP_CFG_VRF)
vnc_direct_del_rn_group_rd(bgp, rfg, rn, afi,
}
-static void vnc_direct_bgp_unexport_table(afi_t afi, struct route_table *rt,
+static void vnc_direct_bgp_unexport_table(afi_t afi, struct agg_table *rt,
struct list *nve_list)
{
if (nve_list) {
- struct route_node *rn;
+ struct agg_node *rn;
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) {
if (rn->info) {
#include "rfapi_private.h"
-extern void vnc_direct_bgp_add_route_ce(struct bgp *bgp, struct route_node *rn,
+extern void vnc_direct_bgp_add_route_ce(struct bgp *bgp, struct agg_node *rn,
struct bgp_info *bi);
-extern void vnc_direct_bgp_del_route_ce(struct bgp *bgp, struct route_node *rn,
+extern void vnc_direct_bgp_del_route_ce(struct bgp *bgp, struct agg_node *rn,
struct bgp_info *bi);
extern void vnc_direct_bgp_add_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn);
+ struct agg_node *rn);
extern void vnc_direct_bgp_del_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn);
+ struct agg_node *rn);
extern void vnc_direct_bgp_add_nve(struct bgp *bgp,
struct rfapi_descriptor *rfd);
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/memory.h"
#include "lib/vty.h"
#include "bgpd/rfapi/rfapi_import.h"
#include "bgpd/rfapi/vnc_debug.h"
-struct route_node *vnc_etn_get(struct bgp *bgp, vnc_export_type_t type,
- struct prefix *p)
+struct agg_node *vnc_etn_get(struct bgp *bgp, vnc_export_type_t type,
+ struct prefix *p)
{
- struct route_table *t = NULL;
- struct route_node *rn = NULL;
+ struct agg_table *t = NULL;
+ struct agg_node *rn = NULL;
afi_t afi;
if (!bgp || !bgp->rfapi)
switch (type) {
case EXPORT_TYPE_BGP:
if (!bgp->rfapi->rt_export_bgp[afi])
- bgp->rfapi->rt_export_bgp[afi] = route_table_init();
+ bgp->rfapi->rt_export_bgp[afi] = agg_table_init();
t = bgp->rfapi->rt_export_bgp[afi];
break;
case EXPORT_TYPE_ZEBRA:
if (!bgp->rfapi->rt_export_zebra[afi])
- bgp->rfapi->rt_export_zebra[afi] = route_table_init();
+ bgp->rfapi->rt_export_zebra[afi] = agg_table_init();
t = bgp->rfapi->rt_export_zebra[afi];
break;
}
if (t)
- rn = route_node_get(t, p);
+ rn = agg_node_get(t, p);
return rn;
}
-struct route_node *vnc_etn_lookup(struct bgp *bgp, vnc_export_type_t type,
- struct prefix *p)
+struct agg_node *vnc_etn_lookup(struct bgp *bgp, vnc_export_type_t type,
+ struct prefix *p)
{
- struct route_table *t = NULL;
- struct route_node *rn = NULL;
+ struct agg_table *t = NULL;
+ struct agg_node *rn = NULL;
afi_t afi;
if (!bgp || !bgp->rfapi)
switch (type) {
case EXPORT_TYPE_BGP:
if (!bgp->rfapi->rt_export_bgp[afi])
- bgp->rfapi->rt_export_bgp[afi] = route_table_init();
+ bgp->rfapi->rt_export_bgp[afi] = agg_table_init();
t = bgp->rfapi->rt_export_bgp[afi];
break;
case EXPORT_TYPE_ZEBRA:
if (!bgp->rfapi->rt_export_zebra[afi])
- bgp->rfapi->rt_export_zebra[afi] = route_table_init();
+ bgp->rfapi->rt_export_zebra[afi] = agg_table_init();
t = bgp->rfapi->rt_export_zebra[afi];
break;
}
if (t)
- rn = route_node_lookup(t, p);
+ rn = agg_node_lookup(t, p);
return rn;
}
struct prefix *p, struct peer *peer,
uint8_t type, uint8_t subtype)
{
- struct route_node *etn;
+ struct agg_node *etn;
struct vnc_export_info *eti;
etn = vnc_etn_get(bgp, etype, p);
}
if (eti) {
- route_unlock_node(etn);
+ agg_unlock_node(etn);
} else {
eti = XCALLOC(MTYPE_RFAPI_ETI, sizeof(struct vnc_export_info));
assert(eti);
void vnc_eti_delete(struct vnc_export_info *goner)
{
- struct route_node *etn;
+ struct agg_node *etn;
struct vnc_export_info *eti;
struct vnc_export_info *eti_prev = NULL;
goner->node = NULL;
XFREE(MTYPE_RFAPI_ETI, goner);
- route_unlock_node(etn);
+ agg_unlock_node(etn);
}
struct vnc_export_info *vnc_eti_checktimer(struct bgp *bgp,
struct prefix *p, struct peer *peer,
uint8_t type, uint8_t subtype)
{
- struct route_node *etn;
+ struct agg_node *etn;
struct vnc_export_info *eti;
etn = vnc_etn_lookup(bgp, etype, p);
}
}
- route_unlock_node(etn);
+ agg_unlock_node(etn);
if (eti && eti->timer)
return eti;
struct vnc_export_info {
struct vnc_export_info *next;
- struct route_node *node;
+ struct agg_node *node;
struct peer *peer;
uint8_t type;
uint8_t subtype;
struct thread *timer;
};
-extern struct route_node *vnc_etn_get(struct bgp *bgp, vnc_export_type_t type,
- struct prefix *p);
+extern struct agg_node *vnc_etn_get(struct bgp *bgp, vnc_export_type_t type,
+ struct prefix *p);
-extern struct route_node *
-vnc_etn_lookup(struct bgp *bgp, vnc_export_type_t type, struct prefix *p);
+extern struct agg_node *vnc_etn_lookup(struct bgp *bgp, vnc_export_type_t type,
+ struct prefix *p);
extern struct vnc_export_info *vnc_eti_get(struct bgp *bgp,
vnc_export_type_t etype,
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/log.h"
#include "lib/memory.h"
rfapiUnicastNexthop2Prefix(afi, info->attr, &pfx_orig_nexthop);
for (it = h->imports; it; it = it->next) {
- struct route_table *table;
- struct route_node *rn;
- struct route_node *par;
+ struct agg_table *table;
+ struct agg_node *rn;
+ struct agg_node *par;
struct bgp_info *bi_interior;
int have_usable_route;
table = it->imported_vpn[afi];
- for (rn = route_node_match(table, &pfx_orig_nexthop),
+ for (rn = agg_node_match(table, &pfx_orig_nexthop),
have_usable_route = 0;
(!have_usable_route) && rn;) {
0, NULL,
(void (*)(void *))
prefix_free);
- route_lock_node(rn); /* for skiplist */
+ agg_lock_node(rn); /* for skiplist */
}
- route_lock_node(rn); /* for skiplist entry */
+ agg_lock_node(rn); /* for skiplist entry */
prefix_copy(pfx_mon, prefix);
if (!skiplist_insert(
RFAPI_MONITOR_EXTERIOR(rn)->source,
bgp_info_lock(info);
}
}
- par = rn->parent;
+ par = agg_node_parent(rn);
if (par)
- route_lock_node(par);
- route_unlock_node(rn);
+ agg_lock_node(par);
+ agg_unlock_node(rn);
rn = par;
}
if (rn)
- route_unlock_node(rn);
+ agg_unlock_node(rn);
if (!have_usable_route) {
struct prefix *pfx_mon = prefix_new();
rfapiUnicastNexthop2Prefix(afi, info->attr, &pfx_orig_nexthop);
for (it = h->imports; it; it = it->next) {
- struct route_table *table;
- struct route_node *rn;
- struct route_node *par;
+ struct agg_table *table;
+ struct agg_node *rn;
+ struct agg_node *par;
struct bgp_info *bi_interior;
int have_usable_route;
table = it->imported_vpn[afi];
- for (rn = route_node_match(table, &pfx_orig_nexthop),
+ for (rn = agg_node_match(table, &pfx_orig_nexthop),
have_usable_route = 0;
(!have_usable_route) && rn;) {
info, NULL)) {
bgp_info_unlock(info);
- route_unlock_node(
+ agg_unlock_node(
rn); /* sl entry
- */
+ */
}
if (skiplist_empty(
RFAPI_MONITOR_EXTERIOR(
RFAPI_MONITOR_EXTERIOR(
rn)
->source = NULL;
- route_unlock_node(
+ agg_unlock_node(
rn); /* skiplist
itself
*/
}
}
}
- par = rn->parent;
+ par = agg_node_parent(rn);
if (par)
- route_lock_node(par);
- route_unlock_node(rn);
+ agg_lock_node(par);
+ agg_unlock_node(rn);
rn = par;
}
if (rn)
- route_unlock_node(rn);
+ agg_unlock_node(rn);
if (!have_usable_route) {
if (!skiplist_delete(it->monitor_exterior_orphans, info,
*/
void vnc_import_bgp_exterior_add_route_interior(
struct bgp *bgp, struct rfapi_import_table *it,
- struct route_node *rn_interior, /* VPN IT node */
- struct bgp_info *bi_interior) /* VPN IT route */
+ struct agg_node *rn_interior, /* VPN IT node */
+ struct bgp_info *bi_interior) /* VPN IT route */
{
afi_t afi = family2afi(rn_interior->p.family);
- struct route_node *par;
+ struct agg_node *par;
struct bgp_info *bi_exterior;
struct prefix *pfx_exterior; /* exterior pfx */
void *cursor;
* Look up the tree for possible pulldown candidates.
* Find nearest parent with an exterior route monitor
*/
- for (par = rn_interior->parent; par; par = par->parent) {
+ for (par = agg_node_parent(rn_interior); par;
+ par = agg_node_parent(par)) {
if (RFAPI_HAS_MONITOR_EXTERIOR(par))
break;
}
->source = skiplist_new(
0, NULL,
(void (*)(void *))prefix_free);
- route_lock_node(rn_interior);
+ agg_lock_node(rn_interior);
}
skiplist_insert(
RFAPI_MONITOR_EXTERIOR(rn_interior)
->source,
bi_exterior, pfx_mon);
- route_lock_node(rn_interior);
+ agg_lock_node(rn_interior);
/*
* Delete constructed exterior routes based on
skiplist_delete(RFAPI_MONITOR_EXTERIOR(par)->source,
bi_exterior, NULL);
- route_unlock_node(par); /* sl entry */
+ agg_unlock_node(par); /* sl entry */
}
if (skiplist_empty(RFAPI_MONITOR_EXTERIOR(par)->source)) {
skiplist_free(RFAPI_MONITOR_EXTERIOR(par)->source);
RFAPI_MONITOR_EXTERIOR(par)->source = NULL;
- route_unlock_node(par); /* sl itself */
+ agg_unlock_node(par); /* sl itself */
}
}
skiplist_new(
0, NULL,
(void (*)(void *))prefix_free);
- route_lock_node(rn_interior); /* sl */
+ agg_lock_node(rn_interior); /* sl */
}
skiplist_insert(
RFAPI_MONITOR_EXTERIOR(rn_interior)->source,
bi_exterior, pfx_mon);
- route_lock_node(rn_interior); /* sl entry */
+ agg_lock_node(rn_interior); /* sl entry */
if (!list_adopted) {
list_adopted = list_new();
}
}
if (list_adopted) {
struct listnode *node;
- struct route_node *bi_exterior;
+ struct agg_node *bi_exterior;
for (ALL_LIST_ELEMENTS_RO(list_adopted, node, bi_exterior)) {
skiplist_delete(it->monitor_exterior_orphans,
*/
void vnc_import_bgp_exterior_del_route_interior(
struct bgp *bgp, struct rfapi_import_table *it,
- struct route_node *rn_interior, /* VPN IT node */
- struct bgp_info *bi_interior) /* VPN IT route */
+ struct agg_node *rn_interior, /* VPN IT node */
+ struct bgp_info *bi_interior) /* VPN IT route */
{
afi_t afi = family2afi(rn_interior->p.family);
- struct route_node *par;
+ struct agg_node *par;
struct bgp_info *bi_exterior;
struct prefix *pfx_exterior; /* exterior pfx */
void *cursor;
* If none is found, par will end up NULL, and we will move
* the monitors to the orphan list for this import table
*/
- for (par = rn_interior->parent; par; par = par->parent) {
+ for (par = agg_node_parent(rn_interior); par;
+ par = agg_node_parent(par)) {
if (RFAPI_MONITOR_EXTERIOR(par)->valid_interior_count)
break;
}
skiplist_new(
0, NULL,
(void (*)(void *))prefix_free);
- route_lock_node(par); /* sl */
+ agg_lock_node(par); /* sl */
}
skiplist_insert(RFAPI_MONITOR_EXTERIOR(par)->source,
bi_exterior, pfx_mon);
- route_lock_node(par); /* sl entry */
+ agg_lock_node(par); /* sl entry */
/* Add constructed exterior routes based on parent */
for (bi = par->info; bi; bi = bi->next) {
skiplist_delete_first(
RFAPI_MONITOR_EXTERIOR(rn_interior)->source);
- route_unlock_node(rn_interior); /* sl entry */
+ agg_unlock_node(rn_interior); /* sl entry */
}
if (skiplist_empty(RFAPI_MONITOR_EXTERIOR(rn_interior)->source)) {
skiplist_free(RFAPI_MONITOR_EXTERIOR(rn_interior)->source);
RFAPI_MONITOR_EXTERIOR(rn_interior)->source = NULL;
- route_unlock_node(rn_interior); /* sl itself */
+ agg_unlock_node(rn_interior); /* sl itself */
}
}
extern void vnc_import_bgp_exterior_add_route_interior(
struct bgp *bgp, struct rfapi_import_table *it,
- struct route_node *rn_interior, /* VPN IT node */
- struct bgp_info *bi_interior); /* VPN IT route */
+ struct agg_node *rn_interior, /* VPN IT node */
+ struct bgp_info *bi_interior); /* VPN IT route */
extern void vnc_import_bgp_exterior_del_route_interior(
struct bgp *bgp, struct rfapi_import_table *it,
- struct route_node *rn_interior, /* VPN IT node */
- struct bgp_info *bi_interior); /* VPN IT route */
+ struct agg_node *rn_interior, /* VPN IT node */
+ struct bgp_info *bi_interior); /* VPN IT route */
extern void
vnc_import_bgp_exterior_redist_enable_it(struct bgp *bgp, afi_t afi,
#include "lib/zebra.h"
#include "lib/prefix.h"
-#include "lib/table.h"
+#include "lib/agg_table.h"
#include "lib/log.h"
#include "lib/command.h"
#include "lib/zclient.h"
static void vnc_zebra_add_del_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn,
+ struct agg_node *rn,
int add) /* !0 = add, 0 = del */
{
struct list *nves;
void vnc_zebra_add_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn)
+ struct agg_node *rn)
{
vnc_zebra_add_del_prefix(bgp, import_table, rn, 1);
}
void vnc_zebra_del_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn)
+ struct agg_node *rn)
{
vnc_zebra_add_del_prefix(bgp, import_table, rn, 0);
}
*/
if (rfgn->rfg == rfg) {
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct rfapi_import_table *import_table;
import_table = rfg->rfapi_import_table;
/*
* Walk the NVE-Group's VNC Import table
*/
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn;
+ rn = agg_route_next(rn)) {
if (rn->info) {
struct rfapi_nve_group_cfg *rfg,
afi_t afi, int add)
{
- struct route_table *rt = NULL;
- struct route_node *rn;
+ struct agg_table *rt = NULL;
+ struct agg_node *rn;
struct rfapi_import_table *import_table;
uint8_t family = afi2family(afi);
/*
* Walk the NVE-Group's VNC Import table
*/
- for (rn = route_top(rt); rn; rn = route_next(rn)) {
+ for (rn = agg_route_top(rt); rn;
+ rn = agg_route_next(rn)) {
if (rn->info) {
vnc_zebra_route_msg(&rn->p,
nexthop_count,
extern void vnc_zebra_add_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn);
+ struct agg_node *rn);
extern void vnc_zebra_del_prefix(struct bgp *bgp,
struct rfapi_import_table *import_table,
- struct route_node *rn);
+ struct agg_node *rn);
extern void vnc_zebra_add_nve(struct bgp *bgp, struct rfapi_descriptor *rfd);
/* initilize struct rfapi_rfp_cfg, see rfapi.h */
global_rfi.rfapi_config.download_type =
- RFAPI_RFP_DOWNLOAD_FULL; /* default=partial */
+ RFAPI_RFP_DOWNLOAD_PARTIAL; /* default=partial */
global_rfi.rfapi_config.ftd_advertisement_interval =
RFAPI_RFP_CFG_DEFAULT_FTD_ADVERTISEMENT_INTERVAL;
global_rfi.rfapi_config.holddown_factor =
#include "stream.h"
#include "zclient.h"
#include "command.h"
-#include "table.h"
+#include "agg_table.h"
#include "thread.h"
#include "privs.h"
#include "vrf.h"
static int ripng_if_down(struct interface *ifp)
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_interface *ri;
struct list *list = NULL;
struct listnode *listnode = NULL, *nextnode = NULL;
if (ripng)
- for (rp = route_top(ripng->table); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->table); rp;
+ rp = agg_route_next(rp))
if ((list = rp->info) != NULL)
for (ALL_LIST_ELEMENTS(list, listnode, nextnode,
rinfo))
vector ripng_enable_if;
/* RIPng enable network table. */
-struct route_table *ripng_enable_network;
+struct agg_table *ripng_enable_network;
/* Lookup RIPng enable network. */
/* Check wether the interface has at least a connected prefix that
for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, connected)) {
struct prefix *p;
- struct route_node *n;
+ struct agg_node *n;
p = connected->address;
address.prefix = p->u.prefix6;
address.prefixlen = IPV6_MAX_BITLEN;
- n = route_node_match(ripng_enable_network,
- (struct prefix *)&address);
+ n = agg_node_match(ripng_enable_network,
+ (struct prefix *)&address);
if (n) {
- route_unlock_node(n);
+ agg_unlock_node(n);
return 1;
}
}
p = connected->address;
if (p->family == AF_INET6) {
- struct route_node *node;
+ struct agg_node *node;
address.family = p->family;
address.prefix = p->u.prefix6;
/* LPM on p->family, p->u.prefix6/IPV6_MAX_BITLEN within
* ripng_enable_network */
- node = route_node_match(ripng_enable_network,
- (struct prefix *)&address);
+ node = agg_node_match(ripng_enable_network,
+ (struct prefix *)&address);
if (node) {
- route_unlock_node(node);
+ agg_unlock_node(node);
return 1;
}
}
/* Add RIPng enable network. */
static int ripng_enable_network_add(struct prefix *p)
{
- struct route_node *node;
+ struct agg_node *node;
- node = route_node_get(ripng_enable_network, p);
+ node = agg_node_get(ripng_enable_network, p);
if (node->info) {
- route_unlock_node(node);
+ agg_unlock_node(node);
return -1;
} else
node->info = (void *)1;
/* Delete RIPng enable network. */
static int ripng_enable_network_delete(struct prefix *p)
{
- struct route_node *node;
+ struct agg_node *node;
- node = route_node_lookup(ripng_enable_network, p);
+ node = agg_node_lookup(ripng_enable_network, p);
if (node) {
node->info = NULL;
/* Unlock info lock. */
- route_unlock_node(node);
+ agg_unlock_node(node);
/* Unlock lookup lock. */
- route_unlock_node(node);
+ agg_unlock_node(node);
return 1;
}
{
unsigned int i;
char *str;
- struct route_node *rn;
+ struct agg_node *rn;
/* ripng_enable_network */
- for (rn = route_top(ripng_enable_network); rn; rn = route_next(rn))
+ for (rn = agg_route_top(ripng_enable_network); rn;
+ rn = agg_route_next(rn))
if (rn->info) {
rn->info = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
}
/* ripng_enable_if */
{
unsigned int i;
const char *ifname;
- struct route_node *node;
+ struct agg_node *node;
char buf[BUFSIZ];
/* Write enable network. */
- for (node = route_top(ripng_enable_network); node;
- node = route_next(node))
+ for (node = agg_route_top(ripng_enable_network); node;
+ node = agg_route_next(node))
if (node->info) {
struct prefix *p = &node->p;
vty_out(vty, "%s%s/%d\n",
hook_register_prio(if_del, 0, ripng_if_delete_hook);
/* RIPng enable network init. */
- ripng_enable_network = route_table_init();
+ ripng_enable_network = agg_table_init();
/* RIPng enable interface init. */
ripng_enable_if = vector_init(1);
#include <zebra.h>
#include "prefix.h"
-#include "table.h"
+#include "agg_table.h"
#include "memory.h"
#include "if.h"
#include "vty.h"
}
/* Aggregate count increment check. */
-void ripng_aggregate_increment(struct route_node *child,
- struct ripng_info *rinfo)
+void ripng_aggregate_increment(struct agg_node *child, struct ripng_info *rinfo)
{
- struct route_node *np;
+ struct agg_node *np;
struct ripng_aggregate *aggregate;
- for (np = child; np; np = np->parent)
+ for (np = child; np; np = agg_node_parent(np))
if ((aggregate = np->aggregate) != NULL) {
aggregate->count++;
rinfo->suppress++;
}
/* Aggregate count decrement check. */
-void ripng_aggregate_decrement(struct route_node *child,
- struct ripng_info *rinfo)
+void ripng_aggregate_decrement(struct agg_node *child, struct ripng_info *rinfo)
{
- struct route_node *np;
+ struct agg_node *np;
struct ripng_aggregate *aggregate;
- for (np = child; np; np = np->parent)
+ for (np = child; np; np = agg_node_parent(np))
if ((aggregate = np->aggregate) != NULL) {
aggregate->count--;
rinfo->suppress--;
}
/* Aggregate count decrement check for a list. */
-void ripng_aggregate_decrement_list(struct route_node *child, struct list *list)
+void ripng_aggregate_decrement_list(struct agg_node *child, struct list *list)
{
- struct route_node *np;
+ struct agg_node *np;
struct ripng_aggregate *aggregate;
struct ripng_info *rinfo = NULL;
struct listnode *node = NULL;
- for (np = child; np; np = np->parent)
+ for (np = child; np; np = agg_node_parent(np))
if ((aggregate = np->aggregate) != NULL)
aggregate->count -= listcount(list);
/* RIPng routes treatment. */
int ripng_aggregate_add(struct prefix *p)
{
- struct route_node *top;
- struct route_node *rp;
+ struct agg_node *top;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_aggregate *aggregate;
struct ripng_aggregate *sub;
struct listnode *node = NULL;
/* Get top node for aggregation. */
- top = route_node_get(ripng->table, p);
+ top = agg_node_get(ripng->table, p);
/* Allocate new aggregate. */
aggregate = ripng_aggregate_new();
top->aggregate = aggregate;
/* Suppress routes match to the aggregate. */
- for (rp = route_lock_node(top); rp; rp = route_next_until(rp, top)) {
+ for (rp = agg_lock_node(top); rp; rp = agg_route_next_until(rp, top)) {
/* Suppress normal route. */
if ((list = rp->info) != NULL)
for (ALL_LIST_ELEMENTS_RO(list, node, rinfo)) {
/* Delete RIPng static route. */
int ripng_aggregate_delete(struct prefix *p)
{
- struct route_node *top;
- struct route_node *rp;
+ struct agg_node *top;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_aggregate *aggregate;
struct ripng_aggregate *sub;
struct listnode *node = NULL;
/* Get top node for aggregation. */
- top = route_node_get(ripng->table, p);
+ top = agg_node_get(ripng->table, p);
/* Allocate new aggregate. */
aggregate = top->aggregate;
/* Suppress routes match to the aggregate. */
- for (rp = route_lock_node(top); rp; rp = route_next_until(rp, top)) {
+ for (rp = agg_lock_node(top); rp; rp = agg_route_next_until(rp, top)) {
/* Suppress normal route. */
if ((list = rp->info) != NULL)
for (ALL_LIST_ELEMENTS_RO(list, node, rinfo)) {
top->aggregate = NULL;
ripng_aggregate_free(aggregate);
- route_unlock_node(top);
- route_unlock_node(top);
+ agg_unlock_node(top);
+ agg_unlock_node(top);
return 0;
}
uint16_t tag_out;
};
-extern void ripng_aggregate_increment(struct route_node *rp,
+extern void ripng_aggregate_increment(struct agg_node *rp,
struct ripng_info *rinfo);
-extern void ripng_aggregate_decrement(struct route_node *rp,
+extern void ripng_aggregate_decrement(struct agg_node *rp,
struct ripng_info *rinfo);
-extern void ripng_aggregate_decrement_list(struct route_node *rp,
+extern void ripng_aggregate_decrement_list(struct agg_node *rp,
struct list *list);
extern int ripng_aggregate_add(struct prefix *p);
extern int ripng_aggregate_delete(struct prefix *p);
#include "command.h"
#include "prefix.h"
-#include "table.h"
+#include "agg_table.h"
#include "stream.h"
#include "memory.h"
#include "routemap.h"
struct zclient *zclient = NULL;
/* Send ECMP routes to zebra. */
-static void ripng_zebra_ipv6_send(struct route_node *rp, uint8_t cmd)
+static void ripng_zebra_ipv6_send(struct agg_node *rp, uint8_t cmd)
{
struct list *list = (struct list *)rp->info;
struct zapi_route api;
}
/* Add/update ECMP routes to zebra. */
-void ripng_zebra_ipv6_add(struct route_node *rp)
+void ripng_zebra_ipv6_add(struct agg_node *rp)
{
ripng_zebra_ipv6_send(rp, ZEBRA_ROUTE_ADD);
}
/* Delete ECMP routes from zebra. */
-void ripng_zebra_ipv6_delete(struct route_node *rp)
+void ripng_zebra_ipv6_delete(struct agg_node *rp)
{
ripng_zebra_ipv6_send(rp, ZEBRA_ROUTE_DELETE);
}
#include "memory.h"
#include "if.h"
#include "stream.h"
-#include "table.h"
+#include "agg_table.h"
#include "command.h"
#include "sockopt.h"
#include "distribute.h"
static int ripng_garbage_collect(struct thread *t)
{
struct ripng_info *rinfo;
- struct route_node *rp;
+ struct agg_node *rp;
rinfo = THREAD_ARG(t);
rinfo->t_garbage_collect = NULL;
listnode_delete(rp->info, rinfo);
if (list_isempty((struct list *)rp->info)) {
list_delete_and_null((struct list **)&rp->info);
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
/* Free RIPng routing information. */
*/
struct ripng_info *ripng_ecmp_add(struct ripng_info *rinfo_new)
{
- struct route_node *rp = rinfo_new->rp;
+ struct agg_node *rp = rinfo_new->rp;
struct ripng_info *rinfo = NULL;
struct list *list = NULL;
*/
struct ripng_info *ripng_ecmp_replace(struct ripng_info *rinfo_new)
{
- struct route_node *rp = rinfo_new->rp;
+ struct agg_node *rp = rinfo_new->rp;
struct list *list = (struct list *)rp->info;
struct ripng_info *rinfo = NULL, *tmp_rinfo = NULL;
struct listnode *node = NULL, *nextnode = NULL;
*/
struct ripng_info *ripng_ecmp_delete(struct ripng_info *rinfo)
{
- struct route_node *rp = rinfo->rp;
+ struct agg_node *rp = rinfo->rp;
struct list *list = (struct list *)rp->info;
RIPNG_TIMER_OFF(rinfo->t_timeout);
{
int ret;
struct prefix_ipv6 p;
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo = NULL, newinfo;
struct ripng_interface *ri;
struct in6_addr *nexthop;
nexthop = &from->sin6_addr;
/* Lookup RIPng routing table. */
- rp = route_node_get(ripng->table, (struct prefix *)&p);
+ rp = agg_node_get(ripng->table, (struct prefix *)&p);
newinfo.rp = rp;
newinfo.nexthop = *nexthop;
if (rte->metric > rinfo->metric) {
/* New route has a greater metric.
* Discard it. */
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return;
}
/* Redistributed route check. */
if (rinfo->type != ZEBRA_ROUTE_RIPNG
&& rinfo->metric != RIPNG_METRIC_INFINITY) {
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return;
}
&& ((rinfo->sub_type == RIPNG_ROUTE_STATIC)
|| (rinfo->sub_type == RIPNG_ROUTE_DEFAULT))
&& rinfo->metric != RIPNG_METRIC_INFINITY) {
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return;
}
}
if (rte->metric != RIPNG_METRIC_INFINITY)
ripng_ecmp_add(&newinfo);
else
- route_unlock_node(rp);
+ agg_unlock_node(rp);
} else {
/* If there is an existing route, compare the next hop address
to the address of the router from which the datagram came.
ripng_timeout_update(rinfo);
/* Unlock tempolary lock of the route. */
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
}
ifindex_t ifindex, struct in6_addr *nexthop,
route_tag_t tag)
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo = NULL, newinfo;
struct list *list = NULL;
if (IN6_IS_ADDR_LOOPBACK(&p->prefix))
return;
- rp = route_node_get(ripng->table, (struct prefix *)p);
+ rp = agg_node_get(ripng->table, (struct prefix *)p);
memset(&newinfo, 0, sizeof(struct ripng_info));
newinfo.type = type;
if (rinfo->type == ZEBRA_ROUTE_CONNECT
&& rinfo->sub_type == RIPNG_ROUTE_INTERFACE
&& rinfo->metric != RIPNG_METRIC_INFINITY) {
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return;
}
if (type != ZEBRA_ROUTE_RIPNG
|| ((sub_type != RIPNG_ROUTE_STATIC)
&& (sub_type != RIPNG_ROUTE_DEFAULT))) {
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return;
}
}
ripng_ecmp_replace(&newinfo);
- route_unlock_node(rp);
+ agg_unlock_node(rp);
} else
ripng_ecmp_add(&newinfo);
void ripng_redistribute_delete(int type, int sub_type, struct prefix_ipv6 *p,
ifindex_t ifindex)
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
if (IN6_IS_ADDR_LINKLOCAL(&p->prefix))
if (IN6_IS_ADDR_LOOPBACK(&p->prefix))
return;
- rp = route_node_lookup(ripng->table, (struct prefix *)p);
+ rp = agg_node_lookup(ripng->table, (struct prefix *)p);
if (rp) {
struct list *list = rp->info;
ripng_event(RIPNG_TRIGGERED_UPDATE, 0);
}
}
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
}
/* Withdraw redistributed route. */
void ripng_redistribute_withdraw(int type)
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo = NULL;
struct list *list = NULL;
if (!ripng)
return;
- for (rp = route_top(ripng->table); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->table); rp; rp = agg_route_next(rp))
if ((list = rp->info) != NULL) {
rinfo = listgetdata(listhead(list));
if ((rinfo->type == type)
caddr_t lim;
struct rte *rte;
struct prefix_ipv6 p;
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_interface *ri;
p.prefixlen = rte->prefixlen;
apply_mask_ipv6(&p);
- rp = route_node_lookup(ripng->table,
- (struct prefix *)&p);
+ rp = agg_node_lookup(ripng->table, (struct prefix *)&p);
if (rp) {
rinfo = listgetdata(
listhead((struct list *)rp->info));
rte->metric = rinfo->metric;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
} else
rte->metric = RIPNG_METRIC_INFINITY;
}
/* Walk down the RIPng routing table then clear changed flag. */
static void ripng_clear_changed_flag(void)
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo = NULL;
struct list *list = NULL;
struct listnode *listnode = NULL;
- for (rp = route_top(ripng->table); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->table); rp; rp = agg_route_next(rp))
if ((list = rp->info) != NULL)
for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
UNSET_FLAG(rinfo->flags, RIPNG_RTF_CHANGED);
int route_type)
{
int ret;
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_interface *ri;
struct ripng_aggregate *aggregate;
ripng_rte_list = ripng_rte_new();
- for (rp = route_top(ripng->table); rp; rp = route_next(rp)) {
+ for (rp = agg_route_top(ripng->table); rp; rp = agg_route_next(rp)) {
if ((list = rp->info) != NULL
&& (rinfo = listgetdata(listhead(list))) != NULL
&& rinfo->suppress == 0) {
ripng->obuf = stream_new(RIPNG_MAX_PACKET_SIZE);
/* Initialize RIPng routig table. */
- ripng->table = route_table_init();
- ripng->route = route_table_init();
- ripng->aggregate = route_table_init();
+ ripng->table = agg_table_init();
+ ripng->route = agg_table_init();
+ ripng->aggregate = agg_table_init();
/* Make socket. */
ripng->sock = ripng_make_socket();
IPV6_STR
"Show RIPng routes\n")
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_aggregate *aggregate;
struct prefix_ipv6 *p;
" (i) - interface, (a/S) - aggregated/Suppressed\n\n"
" Network Next Hop Via Metric Tag Time\n");
- for (rp = route_top(ripng->table); rp; rp = route_next(rp)) {
+ for (rp = agg_route_top(ripng->table); rp; rp = agg_route_next(rp)) {
if ((aggregate = rp->aggregate) != NULL) {
p = (struct prefix_ipv6 *)&rp->p;
IPV6_STR
"Clear IPv6 RIP database\n")
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct list *list;
struct listnode *listnode;
/* Clear received RIPng routes */
- for (rp = route_top(ripng->table); rp; rp = route_next(rp)) {
+ for (rp = agg_route_top(ripng->table); rp; rp = agg_route_next(rp)) {
list = rp->info;
if (list == NULL)
continue;
if (list_isempty(list)) {
list_delete_and_null(&list);
rp->info = NULL;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
}
int idx_ipv6addr = 1;
int ret;
struct prefix_ipv6 p;
- struct route_node *rp;
+ struct agg_node *rp;
ret = str2prefix_ipv6(argv[idx_ipv6addr]->arg,
(struct prefix_ipv6 *)&p);
}
apply_mask_ipv6(&p);
- rp = route_node_get(ripng->route, (struct prefix *)&p);
+ rp = agg_node_get(ripng->route, (struct prefix *)&p);
if (rp->info) {
vty_out(vty, "There is already same static route.\n");
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return CMD_WARNING;
}
rp->info = (void *)1;
int idx_ipv6addr = 2;
int ret;
struct prefix_ipv6 p;
- struct route_node *rp;
+ struct agg_node *rp;
ret = str2prefix_ipv6(argv[idx_ipv6addr]->arg,
(struct prefix_ipv6 *)&p);
}
apply_mask_ipv6(&p);
- rp = route_node_lookup(ripng->route, (struct prefix *)&p);
+ rp = agg_node_lookup(ripng->route, (struct prefix *)&p);
if (!rp) {
vty_out(vty, "Can't find static route.\n");
return CMD_WARNING_CONFIG_FAILED;
}
ripng_redistribute_delete(ZEBRA_ROUTE_RIPNG, RIPNG_ROUTE_STATIC, &p, 0);
- route_unlock_node(rp);
+ agg_unlock_node(rp);
rp->info = NULL;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
return CMD_SUCCESS;
}
int idx_ipv6_prefixlen = 1;
int ret;
struct prefix p;
- struct route_node *node;
+ struct agg_node *node;
ret = str2prefix_ipv6(argv[idx_ipv6_prefixlen]->arg,
(struct prefix_ipv6 *)&p);
}
/* Check aggregate alredy exist or not. */
- node = route_node_get(ripng->aggregate, &p);
+ node = agg_node_get(ripng->aggregate, &p);
if (node->info) {
vty_out(vty, "There is already same aggregate route.\n");
- route_unlock_node(node);
+ agg_unlock_node(node);
return CMD_WARNING;
}
node->info = (void *)1;
int idx_ipv6_prefixlen = 2;
int ret;
struct prefix p;
- struct route_node *rn;
+ struct agg_node *rn;
ret = str2prefix_ipv6(argv[idx_ipv6_prefixlen]->arg,
(struct prefix_ipv6 *)&p);
return CMD_WARNING_CONFIG_FAILED;
}
- rn = route_node_lookup(ripng->aggregate, &p);
+ rn = agg_node_lookup(ripng->aggregate, &p);
if (!rn) {
vty_out(vty, "Can't find aggregate route.\n");
return CMD_WARNING_CONFIG_FAILED;
}
- route_unlock_node(rn);
+ agg_unlock_node(rn);
rn->info = NULL;
- route_unlock_node(rn);
+ agg_unlock_node(rn);
ripng_aggregate_delete(&p);
/* Update ECMP routes to zebra when ECMP is disabled. */
static void ripng_ecmp_disable(void)
{
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo, *tmp_rinfo;
struct list *list;
struct listnode *node, *nextnode;
if (!ripng)
return;
- for (rp = route_top(ripng->table); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->table); rp; rp = agg_route_next(rp))
if ((list = rp->info) != NULL && listcount(list) > 1) {
rinfo = listgetdata(listhead(list));
if (!ripng_route_rte(rinfo))
int ripng_network_write(struct vty *, int);
void ripng_redistribute_write(struct vty *, int);
int write = 0;
- struct route_node *rp;
+ struct agg_node *rp;
if (ripng) {
config_write_ripng_offset_list(vty);
/* RIPng aggregate routes. */
- for (rp = route_top(ripng->aggregate); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->aggregate); rp;
+ rp = agg_route_next(rp))
if (rp->info != NULL)
vty_out(vty, " aggregate-address %s/%d\n",
inet6_ntoa(rp->p.u.prefix6),
vty_out(vty, " allow-ecmp\n");
/* RIPng static routes. */
- for (rp = route_top(ripng->route); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->route); rp;
+ rp = agg_route_next(rp))
if (rp->info != NULL)
vty_out(vty, " route %s/%d\n",
inet6_ntoa(rp->p.u.prefix6),
void ripng_clean()
{
int i;
- struct route_node *rp;
+ struct agg_node *rp;
struct ripng_info *rinfo;
struct ripng_aggregate *aggregate;
struct list *list = NULL;
if (ripng) {
/* Clear RIPng routes */
- for (rp = route_top(ripng->table); rp; rp = route_next(rp)) {
+ for (rp = agg_route_top(ripng->table); rp;
+ rp = agg_route_next(rp)) {
if ((list = rp->info) != NULL) {
rinfo = listgetdata(listhead(list));
if (ripng_route_rte(rinfo))
}
list_delete_and_null(&list);
rp->info = NULL;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
if ((aggregate = rp->aggregate) != NULL) {
ripng_aggregate_free(aggregate);
rp->aggregate = NULL;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
}
}
/* Static RIPng route configuration. */
- for (rp = route_top(ripng->route); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->route); rp;
+ rp = agg_route_next(rp))
if (rp->info) {
rp->info = NULL;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
/* RIPng aggregated prefixes */
- for (rp = route_top(ripng->aggregate); rp; rp = route_next(rp))
+ for (rp = agg_route_top(ripng->aggregate); rp;
+ rp = agg_route_next(rp))
if (rp->info) {
rp->info = NULL;
- route_unlock_node(rp);
+ agg_unlock_node(rp);
}
for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
struct stream *obuf;
/* RIPng routing information base. */
- struct route_table *table;
+ struct agg_table *table;
/* RIPng only static route information. */
- struct route_table *route;
+ struct agg_table *route;
/* RIPng aggregate route information. */
- struct route_table *aggregate;
+ struct agg_table *aggregate;
/* RIPng threads. */
struct thread *t_read;
uint8_t metric_out;
uint16_t tag_out;
- struct route_node *rp;
+ struct agg_node *rp;
};
#ifdef notyet
extern void ripng_distribute_update_interface(struct interface *);
extern void ripng_if_rmap_update_interface(struct interface *);
-extern void ripng_zebra_ipv6_add(struct route_node *);
-extern void ripng_zebra_ipv6_delete(struct route_node *);
+extern void ripng_zebra_ipv6_add(struct agg_node *node);
+extern void ripng_zebra_ipv6_delete(struct agg_node *node);
extern void ripng_redistribute_clean(void);
extern int ripng_redistribute_check(int);
projects / matthieu / frr.git / commitdiff