};
/* BGP adjacency linked list. */
-#define BGP_INFO_ADD(N, A, TYPE) \
+#define BGP_PATH_INFO_ADD(N, A, TYPE) \
do { \
(A)->prev = NULL; \
(A)->next = (N)->TYPE; \
(N)->TYPE = (A); \
} while (0)
-#define BGP_INFO_DEL(N, A, TYPE) \
+#define BGP_PATH_INFO_DEL(N, A, TYPE) \
do { \
if ((A)->next) \
(A)->next->prev = (A)->prev; \
(N)->TYPE = (A)->next; \
} while (0)
-#define BGP_ADJ_IN_ADD(N,A) BGP_INFO_ADD(N,A,adj_in)
-#define BGP_ADJ_IN_DEL(N,A) BGP_INFO_DEL(N,A,adj_in)
-#define BGP_ADJ_OUT_ADD(N,A) BGP_INFO_ADD(N,A,adj_out)
-#define BGP_ADJ_OUT_DEL(N,A) BGP_INFO_DEL(N,A,adj_out)
+#define BGP_ADJ_IN_ADD(N, A) BGP_PATH_INFO_ADD(N, A, adj_in)
+#define BGP_ADJ_IN_DEL(N, A) BGP_PATH_INFO_DEL(N, A, adj_in)
+#define BGP_ADJ_OUT_ADD(N, A) BGP_PATH_INFO_ADD(N, A, adj_out)
+#define BGP_ADJ_OUT_DEL(N, A) BGP_PATH_INFO_DEL(N, A, adj_out)
#define BGP_ADV_FIFO_ADD(F, N) \
do { \
/* Utility macro to add and delete BGP dampening information to no
used list. */
-#define BGP_DAMP_LIST_ADD(N,A) BGP_INFO_ADD(N,A,no_reuse_list)
-#define BGP_DAMP_LIST_DEL(N,A) BGP_INFO_DEL(N,A,no_reuse_list)
+#define BGP_DAMP_LIST_ADD(N, A) BGP_PATH_INFO_ADD(N, A, no_reuse_list)
+#define BGP_DAMP_LIST_DEL(N, A) BGP_PATH_INFO_DEL(N, A, no_reuse_list)
/* Calculate reuse list index by penalty value. */
static int bgp_reuse_index(int penalty)
if (bdi->penalty < damp->reuse_limit) {
/* Reuse the route. */
bgp_info_unset_flag(bdi->rn, bdi->binfo,
- BGP_INFO_DAMPED);
+ BGP_PATH_DAMPED);
bdi->suppress_time = 0;
if (bdi->lastrecord == BGP_RECORD_UPDATE) {
bgp_info_unset_flag(bdi->rn, bdi->binfo,
- BGP_INFO_HISTORY);
+ BGP_PATH_HISTORY);
bgp_aggregate_increment(bgp, &bdi->rn->p,
bdi->binfo, bdi->afi,
bdi->safi);
bdi->t_updated = t_now;
/* Make this route as historical status. */
- bgp_info_set_flag(rn, binfo, BGP_INFO_HISTORY);
+ bgp_info_set_flag(rn, binfo, BGP_PATH_HISTORY);
/* Remove the route from a reuse list if it is on one. */
- if (CHECK_FLAG(bdi->binfo->flags, BGP_INFO_DAMPED)) {
+ if (CHECK_FLAG(bdi->binfo->flags, BGP_PATH_DAMPED)) {
/* If decay rate isn't equal to 0, reinsert brn. */
if (bdi->penalty != last_penalty && bdi->index >= 0) {
bgp_reuse_list_delete(bdi);
/* If not suppressed before, do annonunce this withdraw and
insert into reuse_list. */
if (bdi->penalty >= damp->suppress_value) {
- bgp_info_set_flag(rn, binfo, BGP_INFO_DAMPED);
+ bgp_info_set_flag(rn, binfo, BGP_PATH_DAMPED);
bdi->suppress_time = t_now;
BGP_DAMP_LIST_DEL(damp, bdi);
bgp_reuse_list_add(bdi);
return BGP_DAMP_USED;
t_now = bgp_clock();
- bgp_info_unset_flag(rn, binfo, BGP_INFO_HISTORY);
+ bgp_info_unset_flag(rn, binfo, BGP_PATH_HISTORY);
bdi->lastrecord = BGP_RECORD_UPDATE;
bdi->penalty = bgp_damp_decay(t_now - bdi->t_updated, bdi->penalty);
- if (!CHECK_FLAG(bdi->binfo->flags, BGP_INFO_DAMPED)
+ if (!CHECK_FLAG(bdi->binfo->flags, BGP_PATH_DAMPED)
&& (bdi->penalty < damp->suppress_value))
status = BGP_DAMP_USED;
- else if (CHECK_FLAG(bdi->binfo->flags, BGP_INFO_DAMPED)
+ else if (CHECK_FLAG(bdi->binfo->flags, BGP_PATH_DAMPED)
&& (bdi->penalty < damp->reuse_limit)) {
- bgp_info_unset_flag(rn, binfo, BGP_INFO_DAMPED);
+ bgp_info_unset_flag(rn, binfo, BGP_PATH_DAMPED);
bgp_reuse_list_delete(bdi);
BGP_DAMP_LIST_ADD(damp, bdi);
bdi->suppress_time = 0;
t_now = bgp_clock();
bdi = binfo->extra->damp_info;
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED)) {
t_diff = t_now - bdi->suppress_time;
if (t_diff >= damp->max_suppress_time) {
- bgp_info_unset_flag(bdi->rn, binfo, BGP_INFO_DAMPED);
+ bgp_info_unset_flag(bdi->rn, binfo, BGP_PATH_DAMPED);
bgp_reuse_list_delete(bdi);
BGP_DAMP_LIST_ADD(damp, bdi);
bdi->penalty = damp->reuse_limit;
binfo = bdi->binfo;
binfo->extra->damp_info = NULL;
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED))
bgp_reuse_list_delete(bdi);
else
BGP_DAMP_LIST_DEL(damp, bdi);
- bgp_info_unset_flag(bdi->rn, binfo, BGP_INFO_HISTORY | BGP_INFO_DAMPED);
+ bgp_info_unset_flag(bdi->rn, binfo, BGP_PATH_HISTORY | BGP_PATH_DAMPED);
if (bdi->lastrecord == BGP_RECORD_WITHDRAW && withdraw)
bgp_info_delete(bdi->rn, binfo);
peer_uptime(bdi->start_time, timebuf, BGP_UPTIME_LEN, 1,
json_path);
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED)
- && !CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED)
+ && !CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY))
bgp_get_reuse_time(penalty, timebuf, BGP_UPTIME_LEN, 1,
json_path);
} else {
peer_uptime(bdi->start_time, timebuf, BGP_UPTIME_LEN, 0,
json_path));
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED)
- && !CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED)
+ && !CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY))
vty_out(vty, ", reuse in %s",
bgp_get_reuse_time(penalty, timebuf,
BGP_UPTIME_LEN, 0,
&& old_select->type == ZEBRA_ROUTE_BGP
&& old_select->sub_type == BGP_ROUTE_IMPORTED
&& !CHECK_FLAG(rn->flags, BGP_NODE_USER_CLEAR)
- && !CHECK_FLAG(old_select->flags, BGP_INFO_ATTR_CHANGED)
+ && !CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED)
&& !bgp->addpath_tx_used[afi][safi]) {
if (bgp_zebra_has_route_changed(rn, old_select)) {
ret = evpn_es_install_vtep(bgp, es,
(struct prefix_evpn *)&rn->p,
old_select->attr->nexthop);
}
- UNSET_FLAG(old_select->flags, BGP_INFO_MULTIPATH_CHG);
+ UNSET_FLAG(old_select->flags, BGP_PATH_MULTIPATH_CHG);
bgp_zebra_clear_route_change_flags(rn);
return ret;
}
bgp_bump_version(rn);
if (old_select)
- bgp_info_unset_flag(rn, old_select, BGP_INFO_SELECTED);
+ bgp_info_unset_flag(rn, old_select, BGP_PATH_SELECTED);
if (new_select) {
- bgp_info_set_flag(rn, new_select, BGP_INFO_SELECTED);
- bgp_info_unset_flag(rn, new_select, BGP_INFO_ATTR_CHANGED);
- UNSET_FLAG(new_select->flags, BGP_INFO_MULTIPATH_CHG);
+ bgp_info_set_flag(rn, new_select, BGP_PATH_SELECTED);
+ bgp_info_unset_flag(rn, new_select, BGP_PATH_ATTR_CHANGED);
+ UNSET_FLAG(new_select->flags, BGP_PATH_MULTIPATH_CHG);
}
if (new_select && new_select->type == ZEBRA_ROUTE_BGP
bgp_zebra_clear_route_change_flags(rn);
/* Reap old select bgp_info, if it has been removed */
- if (old_select && CHECK_FLAG(old_select->flags, BGP_INFO_REMOVED))
+ if (old_select && CHECK_FLAG(old_select->flags, BGP_PATH_REMOVED))
bgp_info_reap(rn, old_select);
return ret;
&& old_select->type == ZEBRA_ROUTE_BGP
&& old_select->sub_type == BGP_ROUTE_IMPORTED
&& !CHECK_FLAG(rn->flags, BGP_NODE_USER_CLEAR)
- && !CHECK_FLAG(old_select->flags, BGP_INFO_ATTR_CHANGED)
+ && !CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED)
&& !bgp->addpath_tx_used[afi][safi]) {
if (bgp_zebra_has_route_changed(rn, old_select)) {
if (old_select->attr->sticky)
old_select->attr->nexthop, flags,
mac_mobility_seqnum(old_select->attr));
}
- UNSET_FLAG(old_select->flags, BGP_INFO_MULTIPATH_CHG);
+ UNSET_FLAG(old_select->flags, BGP_PATH_MULTIPATH_CHG);
bgp_zebra_clear_route_change_flags(rn);
return ret;
}
bgp_bump_version(rn);
if (old_select)
- bgp_info_unset_flag(rn, old_select, BGP_INFO_SELECTED);
+ bgp_info_unset_flag(rn, old_select, BGP_PATH_SELECTED);
if (new_select) {
- bgp_info_set_flag(rn, new_select, BGP_INFO_SELECTED);
- bgp_info_unset_flag(rn, new_select, BGP_INFO_ATTR_CHANGED);
- UNSET_FLAG(new_select->flags, BGP_INFO_MULTIPATH_CHG);
+ bgp_info_set_flag(rn, new_select, BGP_PATH_SELECTED);
+ bgp_info_unset_flag(rn, new_select, BGP_PATH_ATTR_CHANGED);
+ UNSET_FLAG(new_select->flags, BGP_PATH_MULTIPATH_CHG);
}
if (new_select && new_select->type == ZEBRA_ROUTE_BGP
bgp_zebra_clear_route_change_flags(rn);
/* Reap old select bgp_info, if it has been removed */
- if (old_select && CHECK_FLAG(old_select->flags, BGP_INFO_REMOVED))
+ if (old_select && CHECK_FLAG(old_select->flags, BGP_PATH_REMOVED))
bgp_info_reap(rn, old_select);
return ret;
tmp_ri->type == ZEBRA_ROUTE_BGP &&
tmp_ri->sub_type == BGP_ROUTE_STATIC)
local_ri = tmp_ri;
- if (tmp_ri->type == ZEBRA_ROUTE_BGP &&
- tmp_ri->sub_type == BGP_ROUTE_IMPORTED &&
- CHECK_FLAG(tmp_ri->flags, BGP_INFO_VALID))
+ if (tmp_ri->type == ZEBRA_ROUTE_BGP
+ && tmp_ri->sub_type == BGP_ROUTE_IMPORTED
+ && CHECK_FLAG(tmp_ri->flags, BGP_PATH_VALID))
remote_ri = tmp_ri;
}
/* Create new route with its attribute. */
tmp_ri = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC,
0, bgp->peer_self, attr_new, rn);
- SET_FLAG(tmp_ri->flags, BGP_INFO_VALID);
+ SET_FLAG(tmp_ri->flags, BGP_PATH_VALID);
/* add the newly created path to the route-node */
bgp_info_add(rn, tmp_ri);
} else {
tmp_ri = local_ri;
if (attrhash_cmp(tmp_ri->attr, attr)
- && !CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED))
+ && !CHECK_FLAG(tmp_ri->flags, BGP_PATH_REMOVED))
*route_changed = 0;
else {
/* The attribute has changed.
* Add (or update) attribute to hash. */
attr_new = bgp_attr_intern(attr);
- bgp_info_set_flag(rn, tmp_ri, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(rn, tmp_ri, BGP_PATH_ATTR_CHANGED);
/* Restore route, if needed. */
- if (CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(tmp_ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, tmp_ri);
/* Unintern existing, set to new. */
/* create the route info from attribute */
ri = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0,
bgp_def->peer_self, attr_new, rn);
- SET_FLAG(ri->flags, BGP_INFO_VALID);
+ SET_FLAG(ri->flags, BGP_PATH_VALID);
/* Type-5 routes advertise the L3-VNI */
bgp_info_extra_get(ri);
/* The attribute has changed. */
/* Add (or update) attribute to hash. */
attr_new = bgp_attr_intern(attr);
- bgp_info_set_flag(rn, tmp_ri, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(rn, tmp_ri, BGP_PATH_ATTR_CHANGED);
/* Restore route, if needed. */
- if (CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(tmp_ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, tmp_ri);
/* Unintern existing, set to new. */
/* Create new route with its attribute. */
tmp_ri = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0,
bgp->peer_self, attr_new, rn);
- SET_FLAG(tmp_ri->flags, BGP_INFO_VALID);
+ SET_FLAG(tmp_ri->flags, BGP_PATH_VALID);
bgp_info_extra_get(tmp_ri);
/* The VNI goes into the 'label' field of the route */
} else {
tmp_ri = local_ri;
if (attrhash_cmp(tmp_ri->attr, attr)
- && !CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED))
+ && !CHECK_FLAG(tmp_ri->flags, BGP_PATH_REMOVED))
route_change = 0;
else {
/*
/* The attribute has changed. */
/* Add (or update) attribute to hash. */
attr_new = bgp_attr_intern(attr);
- bgp_info_set_flag(rn, tmp_ri, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(rn, tmp_ri, BGP_PATH_ATTR_CHANGED);
/* Extract MAC mobility sequence number, if any. */
attr_new->mm_seqnum =
attr_new->sticky = sticky;
/* Restore route, if needed. */
- if (CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(tmp_ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, tmp_ri);
/* Unintern existing, set to new. */
/* Create new route with its attribute. */
ri = info_make(parent_ri->type, BGP_ROUTE_IMPORTED, 0,
parent_ri->peer, attr_new, rn);
- SET_FLAG(ri->flags, BGP_INFO_VALID);
+ SET_FLAG(ri->flags, BGP_PATH_VALID);
bgp_info_extra_get(ri);
ri->extra->parent = parent_ri;
bgp_info_add(rn, ri);
} else {
if (attrhash_cmp(ri->attr, parent_ri->attr)
- && !CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) {
+ && !CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)) {
bgp_unlock_node(rn);
return 0;
}
attr_new = bgp_attr_intern(parent_ri->attr);
/* Restore route, if needed. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, ri);
/* Mark if nexthop has changed. */
if (!IPV4_ADDR_SAME(&ri->attr->nexthop, &attr_new->nexthop))
- SET_FLAG(ri->flags, BGP_INFO_IGP_CHANGED);
+ SET_FLAG(ri->flags, BGP_PATH_IGP_CHANGED);
/* Unintern existing, set to new. */
bgp_attr_unintern(&ri->attr);
/* Create new route with its attribute. */
ri = info_make(parent_ri->type, BGP_ROUTE_IMPORTED, 0,
parent_ri->peer, attr_new, rn);
- SET_FLAG(ri->flags, BGP_INFO_VALID);
+ SET_FLAG(ri->flags, BGP_PATH_VALID);
bgp_info_extra_get(ri);
ri->extra->parent = bgp_info_lock(parent_ri);
bgp_lock_node((struct bgp_node *)parent_ri->net);
bgp_info_add(rn, ri);
} else {
if (attrhash_cmp(ri->attr, &attr)
- && !CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) {
+ && !CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)) {
bgp_unlock_node(rn);
return 0;
}
attr_new = bgp_attr_intern(&attr);
/* Restore route, if needed. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, ri);
/* Mark if nexthop has changed. */
(afi == AFI_IP6 &&
!IPV6_ADDR_SAME(&ri->attr->mp_nexthop_global,
&attr_new->mp_nexthop_global)))
- SET_FLAG(ri->flags, BGP_INFO_IGP_CHANGED);
+ SET_FLAG(ri->flags, BGP_PATH_IGP_CHANGED);
/* Unintern existing, set to new. */
bgp_attr_unintern(&ri->attr);
/* Create new route with its attribute. */
ri = info_make(parent_ri->type, BGP_ROUTE_IMPORTED, 0,
parent_ri->peer, attr_new, rn);
- SET_FLAG(ri->flags, BGP_INFO_VALID);
+ SET_FLAG(ri->flags, BGP_PATH_VALID);
bgp_info_extra_get(ri);
ri->extra->parent = bgp_info_lock(parent_ri);
bgp_lock_node((struct bgp_node *)parent_ri->net);
bgp_info_add(rn, ri);
} else {
if (attrhash_cmp(ri->attr, parent_ri->attr)
- && !CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) {
+ && !CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)) {
bgp_unlock_node(rn);
return 0;
}
attr_new = bgp_attr_intern(parent_ri->attr);
/* Restore route, if needed. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, ri);
/* Mark if nexthop has changed. */
if (!IPV4_ADDR_SAME(&ri->attr->nexthop, &attr_new->nexthop))
- SET_FLAG(ri->flags, BGP_INFO_IGP_CHANGED);
+ SET_FLAG(ri->flags, BGP_PATH_IGP_CHANGED);
/* Unintern existing, set to new. */
bgp_attr_unintern(&ri->attr);
* Consider "valid" remote routes applicable for
* this ES.
*/
- if (!(CHECK_FLAG(ri->flags, BGP_INFO_VALID)
+ if (!(CHECK_FLAG(ri->flags, BGP_PATH_VALID)
&& ri->type == ZEBRA_ROUTE_BGP
&& ri->sub_type == BGP_ROUTE_NORMAL))
continue;
/* Consider "valid" remote routes applicable for
* this VRF.
*/
- if (!(CHECK_FLAG(ri->flags, BGP_INFO_VALID)
+ if (!(CHECK_FLAG(ri->flags, BGP_PATH_VALID)
&& ri->type == ZEBRA_ROUTE_BGP
&& ri->sub_type == BGP_ROUTE_NORMAL))
continue;
for (ri = rn->info; ri; ri = ri->next) {
/* Consider "valid" remote routes applicable for
* this VNI. */
- if (!(CHECK_FLAG(ri->flags, BGP_INFO_VALID)
+ if (!(CHECK_FLAG(ri->flags, BGP_PATH_VALID)
&& ri->type == ZEBRA_ROUTE_BGP
&& ri->sub_type == BGP_ROUTE_NORMAL))
continue;
/* Only care about "selected" routes - non-imported. */
/* TODO: Support for AddPath for EVPN. */
for (ri = rn->info; ri; ri = ri->next) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)
&& (!ri->extra || !ri->extra->parent)) {
bgp_evpn_withdraw_type5_route(bgp_vrf, &rn->p,
afi, safi);
* TODO: Support for AddPath for EVPN.
*/
for (ri = rn->info; ri; ri = ri->next) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)
&& (!ri->extra || !ri->extra->parent)) {
/* apply the route-map */
prev->mp_next->mp_prev = mpath;
prev->mp_next = mpath;
- SET_FLAG(binfo->flags, BGP_INFO_MULTIPATH);
+ SET_FLAG(binfo->flags, BGP_PATH_MULTIPATH);
}
/*
if (mpath->mp_next)
mpath->mp_next->mp_prev = mpath->mp_prev;
mpath->mp_next = mpath->mp_prev = NULL;
- UNSET_FLAG(binfo->flags, BGP_INFO_MULTIPATH);
+ UNSET_FLAG(binfo->flags, BGP_PATH_MULTIPATH);
}
/*
bgp_info_mpath_count_set(new_best, mpath_count - 1);
if (mpath_changed
|| (bgp_info_mpath_count(new_best) != old_mpath_count))
- SET_FLAG(new_best->flags, BGP_INFO_MULTIPATH_CHG);
+ SET_FLAG(new_best->flags, BGP_PATH_MULTIPATH_CHG);
}
}
/*
* bgp_mp_dmed_deselect
*
- * Clean up multipath information for BGP_INFO_DMED_SELECTED path that
+ * Clean up multipath information for BGP_PATH_DMED_SELECTED path that
* is not selected as best path
*/
void bgp_mp_dmed_deselect(struct bgp_info *dmed_best)
}
bgp_info_mpath_count_set(dmed_best, 0);
- UNSET_FLAG(dmed_best->flags, BGP_INFO_MULTIPATH_CHG);
+ UNSET_FLAG(dmed_best->flags, BGP_PATH_MULTIPATH_CHG);
assert(bgp_info_mpath_first(dmed_best) == 0);
}
if ((new_attr = bgp_info_mpath_attr(new_best))) {
bgp_attr_unintern(&new_attr);
bgp_info_mpath_attr_set(new_best, NULL);
- SET_FLAG(new_best->flags, BGP_INFO_ATTR_CHANGED);
+ SET_FLAG(new_best->flags, BGP_PATH_ATTR_CHANGED);
}
return;
}
if ((old_attr = bgp_info_mpath_attr(new_best)))
bgp_attr_unintern(&old_attr);
bgp_info_mpath_attr_set(new_best, new_attr);
- SET_FLAG(new_best->flags, BGP_INFO_ATTR_CHANGED);
+ SET_FLAG(new_best->flags, BGP_PATH_ATTR_CHANGED);
} else
bgp_attr_unintern(&new_attr);
}
if (bi) {
bool labelssame = labels_same(bi, label, num_labels);
- if (attrhash_cmp(bi->attr, new_attr)
- && labelssame
- && !CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (attrhash_cmp(bi->attr, new_attr) && labelssame
+ && !CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
bgp_attr_unintern(&new_attr);
if (debug)
}
/* attr is changed */
- bgp_info_set_flag(bn, bi, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(bn, bi, BGP_PATH_ATTR_CHANGED);
/* Rewrite BGP route information. */
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
bgp_info_restore(bn, bi);
else
bgp_aggregate_decrement(bgp, p, bi, afi, safi);
setlabels(bi, label, num_labels);
if (nexthop_self_flag)
- bgp_info_set_flag(bn, bi, BGP_INFO_ANNC_NH_SELF);
+ bgp_info_set_flag(bn, bi, BGP_PATH_ANNC_NH_SELF);
struct bgp *bgp_nexthop = bgp;
int nh_valid;
bgp_nexthop->name_pretty);
if (nh_valid)
- bgp_info_set_flag(bn, bi, BGP_INFO_VALID);
+ bgp_info_set_flag(bn, bi, BGP_PATH_VALID);
/* Process change. */
bgp_aggregate_increment(bgp, p, bi, afi, safi);
bgp->peer_self, new_attr, bn);
if (nexthop_self_flag)
- bgp_info_set_flag(bn, new, BGP_INFO_ANNC_NH_SELF);
+ bgp_info_set_flag(bn, new, BGP_PATH_ANNC_NH_SELF);
bgp_info_extra_get(new);
__func__, (nh_valid ? "" : "not "),
bgp_nexthop->name_pretty);
if (nh_valid)
- bgp_info_set_flag(bn, new, BGP_INFO_VALID);
+ bgp_info_set_flag(bn, new, BGP_PATH_VALID);
bgp_aggregate_increment(bgp, p, new, afi, safi);
bgp_info_add(bn, new);
(bnc_is_valid_nexthop ? "" : "not "));
}
- if ((CHECK_FLAG(path->flags, BGP_INFO_VALID) ? 1 : 0)
+ if ((CHECK_FLAG(path->flags, BGP_PATH_VALID) ? 1 : 0)
!= bnc_is_valid_nexthop) {
- if (CHECK_FLAG(path->flags, BGP_INFO_VALID)) {
+ if (CHECK_FLAG(path->flags, BGP_PATH_VALID)) {
bgp_aggregate_decrement(bgp_path, &rn->p,
path, afi, safi);
- bgp_info_unset_flag(rn, path, BGP_INFO_VALID);
+ bgp_info_unset_flag(rn, path, BGP_PATH_VALID);
} else {
- bgp_info_set_flag(rn, path, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, path, BGP_PATH_VALID);
bgp_aggregate_increment(bgp_path, &rn->p,
path, afi, safi);
}
if (CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_METRIC_CHANGED)
|| CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CHANGED))
- SET_FLAG(path->flags, BGP_INFO_IGP_CHANGED);
+ SET_FLAG(path->flags, BGP_PATH_IGP_CHANGED);
bgp_process(bgp_path, rn, afi, safi);
}
void bgp_info_delete(struct bgp_node *rn, struct bgp_info *ri)
{
- bgp_info_set_flag(rn, ri, BGP_INFO_REMOVED);
+ bgp_info_set_flag(rn, ri, BGP_PATH_REMOVED);
/* set of previous already took care of pcount */
- UNSET_FLAG(ri->flags, BGP_INFO_VALID);
+ UNSET_FLAG(ri->flags, BGP_PATH_VALID);
}
/* undo the effects of a previous call to bgp_info_delete; typically
deletion has been processed */
void bgp_info_restore(struct bgp_node *rn, struct bgp_info *ri)
{
- bgp_info_unset_flag(rn, ri, BGP_INFO_REMOVED);
+ bgp_info_unset_flag(rn, ri, BGP_PATH_REMOVED);
/* unset of previous already took care of pcount */
- SET_FLAG(ri->flags, BGP_INFO_VALID);
+ SET_FLAG(ri->flags, BGP_PATH_VALID);
}
/* Adjust pcount as required */
if (ri->peer == ri->peer->bgp->peer_self)
return;
- if (!BGP_INFO_COUNTABLE(ri)
- && CHECK_FLAG(ri->flags, BGP_INFO_COUNTED)) {
+ if (!BGP_PATH_COUNTABLE(ri)
+ && CHECK_FLAG(ri->flags, BGP_PATH_COUNTED)) {
- UNSET_FLAG(ri->flags, BGP_INFO_COUNTED);
+ UNSET_FLAG(ri->flags, BGP_PATH_COUNTED);
/* slight hack, but more robust against errors. */
if (ri->peer->pcount[table->afi][table->safi])
else
flog_err(EC_LIB_DEVELOPMENT,
"Asked to decrement 0 prefix count for peer");
- } else if (BGP_INFO_COUNTABLE(ri)
- && !CHECK_FLAG(ri->flags, BGP_INFO_COUNTED)) {
- SET_FLAG(ri->flags, BGP_INFO_COUNTED);
+ } else if (BGP_PATH_COUNTABLE(ri)
+ && !CHECK_FLAG(ri->flags, BGP_PATH_COUNTED)) {
+ SET_FLAG(ri->flags, BGP_PATH_COUNTED);
ri->peer->pcount[table->afi][table->safi]++;
}
}
/* early bath if we know it's not a flag that changes countability state
*/
if (!CHECK_FLAG(flag,
- BGP_INFO_VALID | BGP_INFO_HISTORY | BGP_INFO_REMOVED))
+ BGP_PATH_VALID | BGP_PATH_HISTORY | BGP_PATH_REMOVED))
return;
bgp_pcount_adjust(rn, ri);
/* early bath if we know it's not a flag that changes countability state
*/
if (!CHECK_FLAG(flag,
- BGP_INFO_VALID | BGP_INFO_HISTORY | BGP_INFO_REMOVED))
+ BGP_PATH_VALID | BGP_PATH_HISTORY | BGP_PATH_REMOVED))
return;
bgp_pcount_adjust(rn, ri);
preferred route based on the additional decision criteria below. */
if (!bgp_flag_check(bgp, BGP_FLAG_COMPARE_ROUTER_ID)
&& new_sort == BGP_PEER_EBGP && exist_sort == BGP_PEER_EBGP) {
- if (CHECK_FLAG(new->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(new->flags, BGP_PATH_SELECTED)) {
if (debug)
zlog_debug(
"%s: %s wins over %s due to oldest external",
return 1;
}
- if (CHECK_FLAG(exist->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(exist->flags, BGP_PATH_SELECTED)) {
if (debug)
zlog_debug(
"%s: %s loses to %s due to oldest external",
/* Do this only if neither path is "stale" as stale paths do not have
* valid peer information (as the connection may or may not be up).
*/
- if (CHECK_FLAG(exist->flags, BGP_INFO_STALE)) {
+ if (CHECK_FLAG(exist->flags, BGP_PATH_STALE)) {
if (debug)
zlog_debug(
"%s: %s wins over %s due to latter path being STALE",
return 1;
}
- if (CHECK_FLAG(new->flags, BGP_INFO_STALE)) {
+ if (CHECK_FLAG(new->flags, BGP_PATH_STALE)) {
if (debug)
zlog_debug(
"%s: %s loses to %s due to former path being STALE",
/* With addpath we may be asked to TX all kinds of paths so make sure
* ri is valid */
- if (!CHECK_FLAG(ri->flags, BGP_INFO_VALID)
- || CHECK_FLAG(ri->flags, BGP_INFO_HISTORY)
- || CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) {
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_VALID)
+ || CHECK_FLAG(ri->flags, BGP_PATH_HISTORY)
+ || CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)) {
return 0;
}
/* If this is not the bestpath then check to see if there is an enabled
* addpath
* feature that requires us to advertise it */
- if (!CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)) {
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)) {
if (!bgp_addpath_tx_path(peer, afi, safi, ri)) {
return 0;
}
? AF_INET6
: p->family),
attr);
- } else if (CHECK_FLAG(ri->flags, BGP_INFO_ANNC_NH_SELF)) {
+ } else if (CHECK_FLAG(ri->flags, BGP_PATH_ANNC_NH_SELF)) {
/*
* This flag is used for leaked vpn-vrf routes
*/
if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
zlog_debug(
- "%s: BGP_INFO_ANNC_NH_SELF, family=%s",
+ "%s: BGP_PATH_ANNC_NH_SELF, family=%s",
__func__, family2str(family));
subgroup_announce_reset_nhop(family, attr);
}
new_select = NULL;
if (bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED)) {
- /* Clear BGP_INFO_DMED_SELECTED for all paths */
+ /* Clear BGP_PATH_DMED_SELECTED for all paths */
for (ri1 = rn->info; ri1; ri1 = ri1->next)
- bgp_info_unset_flag(rn, ri1, BGP_INFO_DMED_SELECTED);
+ bgp_info_unset_flag(rn, ri1, BGP_PATH_DMED_SELECTED);
for (ri1 = rn->info; ri1; ri1 = ri1->next) {
- if (CHECK_FLAG(ri1->flags, BGP_INFO_DMED_CHECK))
+ if (CHECK_FLAG(ri1->flags, BGP_PATH_DMED_CHECK))
continue;
- if (BGP_INFO_HOLDDOWN(ri1))
+ if (BGP_PATH_HOLDDOWN(ri1))
continue;
if (ri1->peer && ri1->peer != bgp->peer_self)
if (ri1->peer->status != Established)
if (ri1->next) {
for (ri2 = ri1->next; ri2; ri2 = ri2->next) {
if (CHECK_FLAG(ri2->flags,
- BGP_INFO_DMED_CHECK))
+ BGP_PATH_DMED_CHECK))
continue;
- if (BGP_INFO_HOLDDOWN(ri2))
+ if (BGP_PATH_HOLDDOWN(ri2))
continue;
if (ri2->peer
&& ri2->peer != bgp->peer_self
afi, safi)) {
bgp_info_unset_flag(
rn, new_select,
- BGP_INFO_DMED_SELECTED);
+ BGP_PATH_DMED_SELECTED);
new_select = ri2;
}
bgp_info_set_flag(
rn, ri2,
- BGP_INFO_DMED_CHECK);
+ BGP_PATH_DMED_CHECK);
}
}
}
- bgp_info_set_flag(rn, new_select, BGP_INFO_DMED_CHECK);
+ bgp_info_set_flag(rn, new_select, BGP_PATH_DMED_CHECK);
bgp_info_set_flag(rn, new_select,
- BGP_INFO_DMED_SELECTED);
+ BGP_PATH_DMED_SELECTED);
if (debug) {
bgp_info_path_with_addpath_rx_str(new_select,
new_select = NULL;
for (ri = rn->info; (ri != NULL) && (nextri = ri->next, 1);
ri = nextri) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED))
old_select = ri;
- if (BGP_INFO_HOLDDOWN(ri)) {
+ if (BGP_PATH_HOLDDOWN(ri)) {
/* reap REMOVED routes, if needs be
* selected route must stay for a while longer though
*/
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)
&& (ri != old_select))
bgp_info_reap(rn, ri);
}
if (bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED)
- && (!CHECK_FLAG(ri->flags, BGP_INFO_DMED_SELECTED))) {
- bgp_info_unset_flag(rn, ri, BGP_INFO_DMED_CHECK);
+ && (!CHECK_FLAG(ri->flags, BGP_PATH_DMED_SELECTED))) {
+ bgp_info_unset_flag(rn, ri, BGP_PATH_DMED_CHECK);
if (debug)
zlog_debug("%s: ri %p dmed", __func__, ri);
continue;
}
- bgp_info_unset_flag(rn, ri, BGP_INFO_DMED_CHECK);
+ bgp_info_unset_flag(rn, ri, BGP_PATH_DMED_CHECK);
if (bgp_info_cmp(bgp, ri, new_select, &paths_eq, mpath_cfg,
debug, pfx_buf, afi, safi)) {
continue;
}
- if (BGP_INFO_HOLDDOWN(ri))
+ if (BGP_PATH_HOLDDOWN(ri))
continue;
if (ri->peer && ri->peer != bgp->peer_self
struct bgp_info *ri;
for (ri = rn->info; ri; ri = ri->next) {
- if (BGP_INFO_HOLDDOWN(ri))
+ if (BGP_PATH_HOLDDOWN(ri))
continue;
- UNSET_FLAG(ri->flags, BGP_INFO_IGP_CHANGED);
- UNSET_FLAG(ri->flags, BGP_INFO_ATTR_CHANGED);
+ UNSET_FLAG(ri->flags, BGP_PATH_IGP_CHANGED);
+ UNSET_FLAG(ri->flags, BGP_PATH_ATTR_CHANGED);
}
}
* we handle the case of BGP nexthop change. This is the behavior
* when the best path has an attribute change anyway.
*/
- if (CHECK_FLAG(selected->flags, BGP_INFO_IGP_CHANGED)
- || CHECK_FLAG(selected->flags, BGP_INFO_MULTIPATH_CHG))
+ if (CHECK_FLAG(selected->flags, BGP_PATH_IGP_CHANGED)
+ || CHECK_FLAG(selected->flags, BGP_PATH_MULTIPATH_CHG))
return 1;
/*
*/
for (mpinfo = bgp_info_mpath_first(selected); mpinfo;
mpinfo = bgp_info_mpath_next(mpinfo)) {
- if (CHECK_FLAG(mpinfo->flags, BGP_INFO_IGP_CHANGED)
- || CHECK_FLAG(mpinfo->flags, BGP_INFO_ATTR_CHANGED))
+ if (CHECK_FLAG(mpinfo->flags, BGP_PATH_IGP_CHANGED)
+ || CHECK_FLAG(mpinfo->flags, BGP_PATH_ATTR_CHANGED))
return 1;
}
*/
if (old_select && old_select == new_select
&& !CHECK_FLAG(rn->flags, BGP_NODE_USER_CLEAR)
- && !CHECK_FLAG(old_select->flags, BGP_INFO_ATTR_CHANGED)
+ && !CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED)
&& !bgp->addpath_tx_used[afi][safi]) {
if (bgp_zebra_has_route_changed(rn, old_select)) {
#if ENABLE_BGP_VNC
bgp, afi, safi);
}
}
- UNSET_FLAG(old_select->flags, BGP_INFO_MULTIPATH_CHG);
+ UNSET_FLAG(old_select->flags, BGP_PATH_MULTIPATH_CHG);
bgp_zebra_clear_route_change_flags(rn);
/* If there is a change of interest to peers, reannounce the
* route. */
- if (CHECK_FLAG(old_select->flags, BGP_INFO_ATTR_CHANGED)
+ if (CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED)
|| CHECK_FLAG(rn->flags, BGP_NODE_LABEL_CHANGED)) {
group_announce_route(bgp, afi, safi, rn, new_select);
SAFI_LABELED_UNICAST, rn,
new_select);
- UNSET_FLAG(old_select->flags, BGP_INFO_ATTR_CHANGED);
+ UNSET_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED);
UNSET_FLAG(rn->flags, BGP_NODE_LABEL_CHANGED);
}
}
if (old_select)
- bgp_info_unset_flag(rn, old_select, BGP_INFO_SELECTED);
+ bgp_info_unset_flag(rn, old_select, BGP_PATH_SELECTED);
if (new_select) {
if (debug)
zlog_debug("%s: setting SELECTED flag", __func__);
- bgp_info_set_flag(rn, new_select, BGP_INFO_SELECTED);
- bgp_info_unset_flag(rn, new_select, BGP_INFO_ATTR_CHANGED);
- UNSET_FLAG(new_select->flags, BGP_INFO_MULTIPATH_CHG);
+ bgp_info_set_flag(rn, new_select, BGP_PATH_SELECTED);
+ bgp_info_unset_flag(rn, new_select, BGP_PATH_ATTR_CHANGED);
+ UNSET_FLAG(new_select->flags, BGP_PATH_MULTIPATH_CHG);
}
#if ENABLE_BGP_VNC
bgp_zebra_clear_route_change_flags(rn);
/* Reap old select bgp_info, if it has been removed */
- if (old_select && CHECK_FLAG(old_select->flags, BGP_INFO_REMOVED))
+ if (old_select && CHECK_FLAG(old_select->flags, BGP_PATH_REMOVED))
bgp_info_reap(rn, old_select);
UNSET_FLAG(rn->flags, BGP_NODE_PROCESS_SCHEDULED);
{
bgp_aggregate_decrement(peer->bgp, &rn->p, ri, afi, safi);
- if (!CHECK_FLAG(ri->flags, BGP_INFO_HISTORY))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_HISTORY))
bgp_info_delete(rn, ri); /* keep historical info */
bgp_process(peer->bgp, rn, afi, safi);
bgp_unlock_node(prn);
}
if ((afi == AFI_IP || afi == AFI_IP6) && (safi == SAFI_UNICAST)) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)) {
vnc_import_bgp_del_route(peer->bgp, &rn->p, ri);
vnc_import_bgp_exterior_del_route(peer->bgp, &rn->p,
same_attr = attrhash_cmp(ri->attr, attr_new);
/* Same attribute comes in. */
- if (!CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)
&& attrhash_cmp(ri->attr, attr_new)
&& (!has_valid_label
|| memcmp(&(bgp_info_extra_get(ri))->label, label,
if (CHECK_FLAG(bgp->af_flags[afi][safi],
BGP_CONFIG_DAMPENING)
&& peer->sort == BGP_PEER_EBGP
- && CHECK_FLAG(ri->flags, BGP_INFO_HISTORY)) {
+ && CHECK_FLAG(ri->flags, BGP_PATH_HISTORY)) {
if (bgp_debug_update(peer, p, NULL, 1)) {
bgp_debug_rdpfxpath2str(
afi, safi, prd, p, label,
}
/* graceful restart STALE flag unset. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_STALE)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_STALE)) {
bgp_info_unset_flag(rn, ri,
- BGP_INFO_STALE);
+ BGP_PATH_STALE);
bgp_process(bgp, rn, afi, safi);
}
}
}
/* Withdraw/Announce before we fully processed the withdraw */
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)) {
if (bgp_debug_update(peer, p, NULL, 1)) {
bgp_debug_rdpfxpath2str(
afi, safi, prd, p, label, num_labels,
}
/* graceful restart STALE flag unset. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_STALE))
- bgp_info_unset_flag(rn, ri, BGP_INFO_STALE);
+ if (CHECK_FLAG(ri->flags, BGP_PATH_STALE))
+ bgp_info_unset_flag(rn, ri, BGP_PATH_STALE);
/* The attribute is changed. */
- bgp_info_set_flag(rn, ri, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(rn, ri, BGP_PATH_ATTR_CHANGED);
/* implicit withdraw, decrement aggregate and pcount here.
* only if update is accepted, they'll increment below.
/* This is implicit withdraw so we should update
dampening
information. */
- if (!CHECK_FLAG(ri->flags, BGP_INFO_HISTORY))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_HISTORY))
bgp_damp_withdraw(ri, rn, afi, safi, 1);
}
#if ENABLE_BGP_VNC
}
if ((afi == AFI_IP || afi == AFI_IP6)
&& (safi == SAFI_UNICAST)) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)) {
/*
* Implicit withdraw case.
*/
if (bgp_find_or_add_nexthop(bgp, bgp_nexthop, afi,
ri, NULL, connected)
|| CHECK_FLAG(peer->flags, PEER_FLAG_IS_RFAPI_HD))
- bgp_info_set_flag(rn, ri, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, ri, BGP_PATH_VALID);
else {
if (BGP_DEBUG(nht, NHT)) {
char buf1[INET6_ADDRSTRLEN];
zlog_debug("%s(%s): NH unresolved",
__FUNCTION__, buf1);
}
- bgp_info_unset_flag(rn, ri, BGP_INFO_VALID);
+ bgp_info_unset_flag(rn, ri, BGP_PATH_VALID);
}
} else
- bgp_info_set_flag(rn, ri, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, ri, BGP_PATH_VALID);
#if ENABLE_BGP_VNC
if (safi == SAFI_MPLS_VPN) {
if (bgp_find_or_add_nexthop(bgp, bgp, afi, new, NULL, connected)
|| CHECK_FLAG(peer->flags, PEER_FLAG_IS_RFAPI_HD))
- bgp_info_set_flag(rn, new, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, new, BGP_PATH_VALID);
else {
if (BGP_DEBUG(nht, NHT)) {
char buf1[INET6_ADDRSTRLEN];
zlog_debug("%s(%s): NH unresolved",
__FUNCTION__, buf1);
}
- bgp_info_unset_flag(rn, new, BGP_INFO_VALID);
+ bgp_info_unset_flag(rn, new, BGP_PATH_VALID);
}
} else
- bgp_info_set_flag(rn, new, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, new, BGP_PATH_VALID);
/* Addpath ID */
new->addpath_rx_id = addpath_id;
}
/* Withdraw specified route from routing table. */
- if (ri && !CHECK_FLAG(ri->flags, BGP_INFO_HISTORY)) {
+ if (ri && !CHECK_FLAG(ri->flags, BGP_PATH_HISTORY)) {
bgp_rib_withdraw(rn, ri, peer, afi, safi, prd);
if (SAFI_UNICAST == safi
&& (bgp->inst_type == BGP_INSTANCE_TYPE_VRF
/* graceful restart STALE flag set. */
if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)
&& peer->nsf[afi][safi]
- && !CHECK_FLAG(ri->flags, BGP_INFO_STALE)
- && !CHECK_FLAG(ri->flags, BGP_INFO_UNUSEABLE))
- bgp_info_set_flag(rn, ri, BGP_INFO_STALE);
+ && !CHECK_FLAG(ri->flags, BGP_PATH_STALE)
+ && !CHECK_FLAG(ri->flags, BGP_PATH_UNUSEABLE))
+ bgp_info_set_flag(rn, ri, BGP_PATH_STALE);
else {
/* If this is an EVPN route, process for
* un-import. */
if (ri->peer != peer)
continue;
if (!CHECK_FLAG(ri->flags,
- BGP_INFO_STALE))
+ BGP_PATH_STALE))
break;
bgp_rib_remove(rm, ri, peer, afi, safi);
for (ri = rn->info; ri; ri = ri->next) {
if (ri->peer != peer)
continue;
- if (!CHECK_FLAG(ri->flags, BGP_INFO_STALE))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_STALE))
break;
bgp_rib_remove(rn, ri, peer, afi, safi);
break;
for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn))
for (ri = rn->info; ri; ri = next) {
next = ri->next;
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)
&& ri->type == ZEBRA_ROUTE_BGP
&& (ri->sub_type == BGP_ROUTE_NORMAL
|| ri->sub_type == BGP_ROUTE_AGGREGATE
if (ri) {
if (attrhash_cmp(ri->attr, attr_new)
- && !CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)
+ && !CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)
&& !bgp_flag_check(bgp, BGP_FLAG_FORCE_STATIC_PROCESS)) {
bgp_unlock_node(rn);
bgp_attr_unintern(&attr_new);
return;
} else {
/* The attribute is changed. */
- bgp_info_set_flag(rn, ri, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(rn, ri, BGP_PATH_ATTR_CHANGED);
/* Rewrite BGP route information. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, ri);
else
bgp_aggregate_decrement(bgp, p, ri, afi, safi);
#if ENABLE_BGP_VNC
if ((afi == AFI_IP || afi == AFI_IP6)
&& (safi == SAFI_UNICAST)) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)) {
/*
* Implicit withdraw case.
* We have to do this before ri is
if (bgp_find_or_add_nexthop(bgp, bgp_nexthop,
afi, ri, NULL, 0))
bgp_info_set_flag(rn, ri,
- BGP_INFO_VALID);
+ BGP_PATH_VALID);
else {
if (BGP_DEBUG(nht, NHT)) {
char buf1[INET6_ADDRSTRLEN];
__FUNCTION__, buf1);
}
bgp_info_unset_flag(rn, ri,
- BGP_INFO_VALID);
+ BGP_PATH_VALID);
}
} else {
/* Delete the NHT structure if any, if we're
* process interaction
*/
bgp_unlink_nexthop(ri);
- bgp_info_set_flag(rn, ri, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, ri, BGP_PATH_VALID);
}
/* Process change. */
bgp_aggregate_increment(bgp, p, ri, afi, safi);
if (bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK)
&& (safi == SAFI_UNICAST || safi == SAFI_LABELED_UNICAST)) {
if (bgp_find_or_add_nexthop(bgp, bgp, afi, new, NULL, 0))
- bgp_info_set_flag(rn, new, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, new, BGP_PATH_VALID);
else {
if (BGP_DEBUG(nht, NHT)) {
char buf1[INET6_ADDRSTRLEN];
"%s(%s): Route not in table, not advertising",
__FUNCTION__, buf1);
}
- bgp_info_unset_flag(rn, new, BGP_INFO_VALID);
+ bgp_info_unset_flag(rn, new, BGP_PATH_VALID);
}
} else {
/* Delete the NHT structure if any, if we're toggling between
*/
bgp_unlink_nexthop(new);
- bgp_info_set_flag(rn, new, BGP_INFO_VALID);
+ bgp_info_set_flag(rn, new, BGP_PATH_VALID);
}
/* Aggregate address increment. */
memset(&add, 0, sizeof(union gw_addr));
if (attrhash_cmp(ri->attr, attr_new)
&& overlay_index_equal(afi, ri, bgp_static->eth_s_id, &add)
- && !CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) {
+ && !CHECK_FLAG(ri->flags, BGP_PATH_REMOVED)) {
bgp_unlock_node(rn);
bgp_attr_unintern(&attr_new);
aspath_unintern(&attr.aspath);
return;
} else {
/* The attribute is changed. */
- bgp_info_set_flag(rn, ri, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(rn, ri, BGP_PATH_ATTR_CHANGED);
/* Rewrite BGP route information. */
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED))
bgp_info_restore(rn, ri);
else
bgp_aggregate_decrement(bgp, p, ri, afi, safi);
/* Make new BGP info. */
new = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0, bgp->peer_self,
attr_new, rn);
- SET_FLAG(new->flags, BGP_INFO_VALID);
+ SET_FLAG(new->flags, BGP_PATH_VALID);
new->extra = bgp_info_extra_new();
if (num_labels) {
new->extra->label[0] = bgp_static->label;
if (!community_cmp(ri->attr->community, comm))
return 0;
- if (!CHECK_FLAG(ri->flags, BGP_INFO_VALID))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_VALID))
return 0;
return 1;
community, aggregate->as_set,
atomic_aggregate),
rn);
- SET_FLAG(new->flags, BGP_INFO_VALID);
+ SET_FLAG(new->flags, BGP_PATH_VALID);
bgp_info_add(rn, new);
bgp_process(bgp, rn, afi, safi);
match = 0;
for (ri = rn->info; ri; ri = ri->next) {
- if (BGP_INFO_HOLDDOWN(ri))
+ if (BGP_PATH_HOLDDOWN(ri))
continue;
if (del && ri == del)
if (aggregate->summary_only) {
(bgp_info_extra_get(ri))->suppress++;
bgp_info_set_flag(rn, ri,
- BGP_INFO_ATTR_CHANGED);
+ BGP_PATH_ATTR_CHANGED);
match++;
}
match = 0;
for (ri = rn->info; ri; ri = ri->next) {
- if (BGP_INFO_HOLDDOWN(ri))
+ if (BGP_PATH_HOLDDOWN(ri))
continue;
if (ri->sub_type == BGP_ROUTE_AGGREGATE)
if (ri->extra->suppress == 0) {
bgp_info_set_flag(
- rn, ri, BGP_INFO_ATTR_CHANGED);
+ rn, ri, BGP_PATH_ATTR_CHANGED);
match++;
}
}
if (p->prefixlen == 0)
return;
- if (BGP_INFO_HOLDDOWN(ri))
+ if (BGP_PATH_HOLDDOWN(ri))
return;
child = bgp_node_get(table, p);
/* Ensure the (source route) type is updated. */
bi->type = type;
if (attrhash_cmp(bi->attr, new_attr)
- && !CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ && !CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
bgp_attr_unintern(&new_attr);
aspath_unintern(&attr.aspath);
bgp_unlock_node(bn);
} else {
/* The attribute is changed. */
bgp_info_set_flag(bn, bi,
- BGP_INFO_ATTR_CHANGED);
+ BGP_PATH_ATTR_CHANGED);
/* Rewrite BGP route information. */
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
bgp_info_restore(bn, bi);
else
bgp_aggregate_decrement(bgp, p, bi, afi,
new = info_make(type, BGP_ROUTE_REDISTRIBUTE, instance,
bgp->peer_self, new_attr, bn);
- SET_FLAG(new->flags, BGP_INFO_VALID);
+ SET_FLAG(new->flags, BGP_PATH_VALID);
bgp_aggregate_increment(bgp, p, new, afi, SAFI_UNICAST);
bgp_info_add(bn, new);
if (json_path) {
/* Route status display. */
- if (CHECK_FLAG(binfo->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_REMOVED))
json_object_boolean_true_add(json_path, "removed");
- if (CHECK_FLAG(binfo->flags, BGP_INFO_STALE))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_STALE))
json_object_boolean_true_add(json_path, "stale");
if (binfo->extra && binfo->extra->suppress)
json_object_boolean_true_add(json_path, "suppressed");
- if (CHECK_FLAG(binfo->flags, BGP_INFO_VALID)
- && !CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_VALID)
+ && !CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY))
json_object_boolean_true_add(json_path, "valid");
/* Selected */
- if (CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY))
json_object_boolean_true_add(json_path, "history");
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED))
json_object_boolean_true_add(json_path, "damped");
- if (CHECK_FLAG(binfo->flags, BGP_INFO_SELECTED))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_SELECTED))
json_object_boolean_true_add(json_path, "bestpath");
- if (CHECK_FLAG(binfo->flags, BGP_INFO_MULTIPATH))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_MULTIPATH))
json_object_boolean_true_add(json_path, "multipath");
/* Internal route. */
}
/* Route status display. */
- if (CHECK_FLAG(binfo->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_REMOVED))
vty_out(vty, "R");
- else if (CHECK_FLAG(binfo->flags, BGP_INFO_STALE))
+ else if (CHECK_FLAG(binfo->flags, BGP_PATH_STALE))
vty_out(vty, "S");
else if (binfo->extra && binfo->extra->suppress)
vty_out(vty, "s");
- else if (CHECK_FLAG(binfo->flags, BGP_INFO_VALID)
- && !CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY))
+ else if (CHECK_FLAG(binfo->flags, BGP_PATH_VALID)
+ && !CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY))
vty_out(vty, "*");
else
vty_out(vty, " ");
/* Selected */
- if (CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY))
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY))
vty_out(vty, "h");
- else if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED))
+ else if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED))
vty_out(vty, "d");
- else if (CHECK_FLAG(binfo->flags, BGP_INFO_SELECTED))
+ else if (CHECK_FLAG(binfo->flags, BGP_PATH_SELECTED))
vty_out(vty, ">");
- else if (CHECK_FLAG(binfo->flags, BGP_INFO_MULTIPATH))
+ else if (CHECK_FLAG(binfo->flags, BGP_PATH_MULTIPATH))
vty_out(vty, "=");
else
vty_out(vty, " ");
json_object *json_nexthop_global = NULL;
json_object *json_nexthop_ll = NULL;
char vrf_id_str[VRF_NAMSIZ] = {0};
- bool nexthop_self = CHECK_FLAG(binfo->flags, BGP_INFO_ANNC_NH_SELF)
- ? true
- : false;
+ bool nexthop_self =
+ CHECK_FLAG(binfo->flags, BGP_PATH_ANNC_NH_SELF) ? true : false;
bool nexthop_othervrf = false;
vrf_id_t nexthop_vrfid = VRF_DEFAULT;
const char *nexthop_vrfname = "Default";
vty_out(vty, "%s ", peer_uptime(bdi->start_time, timebuf,
BGP_UPTIME_LEN, 0, NULL));
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED)
- && !CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED)
+ && !CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY)) {
if (use_json)
bgp_damp_reuse_time_vty(vty, binfo, timebuf,
BGP_UPTIME_LEN, use_json, json);
int addpath_capable;
int has_adj;
unsigned int first_as;
- bool nexthop_self = CHECK_FLAG(binfo->flags, BGP_INFO_ANNC_NH_SELF)
- ? true
- : false;
+ bool nexthop_self =
+ CHECK_FLAG(binfo->flags, BGP_PATH_ANNC_NH_SELF) ? true : false;
if (json_paths) {
json_path = json_object_new_object();
}
}
- if (CHECK_FLAG(binfo->flags, BGP_INFO_REMOVED)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_REMOVED)) {
if (json_paths)
json_object_boolean_true_add(json_path,
"removed");
vty_out(vty, ", (removed)");
}
- if (CHECK_FLAG(binfo->flags, BGP_INFO_STALE)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_STALE)) {
if (json_paths)
json_object_boolean_true_add(json_path,
"stale");
vty_out(vty, ", (Received from a RS-client)");
}
- if (CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY)) {
if (json_paths)
json_object_boolean_true_add(
json_path, "dampeningHistoryEntry");
else
vty_out(vty, ", (history entry)");
- } else if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED)) {
+ } else if (CHECK_FLAG(binfo->flags, BGP_PATH_DAMPED)) {
if (json_paths)
json_object_boolean_true_add(
json_path, "dampeningSuppressed");
}
/* Display the IGP cost or 'inaccessible' */
- if (!CHECK_FLAG(binfo->flags, BGP_INFO_VALID)) {
+ if (!CHECK_FLAG(binfo->flags, BGP_PATH_VALID)) {
if (json_paths)
json_object_boolean_false_add(
json_nexthop_global, "accessible");
attr->tag);
}
- if (!CHECK_FLAG(binfo->flags, BGP_INFO_VALID)) {
+ if (!CHECK_FLAG(binfo->flags, BGP_PATH_VALID)) {
if (json_paths)
json_object_boolean_false_add(json_path,
"valid");
else
vty_out(vty, ", invalid");
- } else if (!CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY)) {
+ } else if (!CHECK_FLAG(binfo->flags, BGP_PATH_HISTORY)) {
if (json_paths)
json_object_boolean_true_add(json_path,
"valid");
vty_out(vty, ", atomic-aggregate");
}
- if (CHECK_FLAG(binfo->flags, BGP_INFO_MULTIPATH)
- || (CHECK_FLAG(binfo->flags, BGP_INFO_SELECTED)
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_MULTIPATH)
+ || (CHECK_FLAG(binfo->flags, BGP_PATH_SELECTED)
&& bgp_info_mpath_count(binfo))) {
if (json_paths)
json_object_boolean_true_add(json_path,
}
// Mark the bestpath(s)
- if (CHECK_FLAG(binfo->flags, BGP_INFO_DMED_SELECTED)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_DMED_SELECTED)) {
first_as = aspath_get_first_as(attr->aspath);
if (json_paths) {
}
}
- if (CHECK_FLAG(binfo->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(binfo->flags, BGP_PATH_SELECTED)) {
if (json_paths) {
if (!json_bestpath)
json_bestpath =
if ((addpath_capable && has_adj)
|| (!addpath_capable && has_adj
&& CHECK_FLAG(binfo->flags,
- BGP_INFO_SELECTED))) {
+ BGP_PATH_SELECTED))) {
if (json_path && !json_adv_to)
json_adv_to =
json_object_new_object();
}
if (type == bgp_show_type_dampend_paths
|| type == bgp_show_type_damp_neighbor) {
- if (!CHECK_FLAG(ri->flags, BGP_INFO_DAMPED)
- || CHECK_FLAG(ri->flags, BGP_INFO_HISTORY))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_DAMPED)
+ || CHECK_FLAG(ri->flags, BGP_PATH_HISTORY))
continue;
}
for (ri = rn->info; ri; ri = ri->next) {
count++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)) {
best = count;
if (ri->extra && ri->extra->suppress)
suppress = 1;
if (pathtype == BGP_PATH_SHOW_ALL
|| (pathtype == BGP_PATH_SHOW_BESTPATH
&& CHECK_FLAG(ri->flags,
- BGP_INFO_SELECTED))
+ BGP_PATH_SELECTED))
|| (pathtype == BGP_PATH_SHOW_MULTIPATH
&& (CHECK_FLAG(ri->flags,
- BGP_INFO_MULTIPATH)
+ BGP_PATH_MULTIPATH)
|| CHECK_FLAG(ri->flags,
- BGP_INFO_SELECTED))))
+ BGP_PATH_SELECTED))))
route_vty_out_detail(vty, bgp, &rm->p,
ri, AFI_IP, safi,
json_paths);
== BGP_PATH_SHOW_BESTPATH
&& CHECK_FLAG(
ri->flags,
- BGP_INFO_SELECTED))
+ BGP_PATH_SELECTED))
|| (pathtype
== BGP_PATH_SHOW_MULTIPATH
&& (CHECK_FLAG(
ri->flags,
- BGP_INFO_MULTIPATH)
+ BGP_PATH_MULTIPATH)
|| CHECK_FLAG(
ri->flags,
- BGP_INFO_SELECTED))))
+ BGP_PATH_SELECTED))))
route_vty_out_detail(
vty, bgp, &rn->p, ri,
afi, safi, json_paths);
pc->count[PCOUNT_ALL]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_DAMPED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_DAMPED))
pc->count[PCOUNT_DAMPED]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_HISTORY))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_HISTORY))
pc->count[PCOUNT_HISTORY]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_REMOVED))
pc->count[PCOUNT_REMOVED]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_STALE))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_STALE))
pc->count[PCOUNT_STALE]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_VALID))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_VALID))
pc->count[PCOUNT_VALID]++;
- if (!CHECK_FLAG(ri->flags, BGP_INFO_UNUSEABLE))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_UNUSEABLE))
pc->count[PCOUNT_PFCNT]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_COUNTED)) {
+ if (CHECK_FLAG(ri->flags, BGP_PATH_COUNTED)) {
pc->count[PCOUNT_COUNTED]++;
- if (CHECK_FLAG(ri->flags, BGP_INFO_UNUSEABLE))
+ if (CHECK_FLAG(ri->flags, BGP_PATH_UNUSEABLE))
flog_err(
EC_LIB_DEVELOPMENT,
"Attempting to count but flags say it is unusable");
} else {
- if (!CHECK_FLAG(ri->flags, BGP_INFO_UNUSEABLE))
+ if (!CHECK_FLAG(ri->flags, BGP_PATH_UNUSEABLE))
flog_err(
EC_LIB_DEVELOPMENT,
"Not counted but flags say we should");
/* BGP information status. */
uint16_t flags;
-#define BGP_INFO_IGP_CHANGED (1 << 0)
-#define BGP_INFO_DAMPED (1 << 1)
-#define BGP_INFO_HISTORY (1 << 2)
-#define BGP_INFO_SELECTED (1 << 3)
-#define BGP_INFO_VALID (1 << 4)
-#define BGP_INFO_ATTR_CHANGED (1 << 5)
-#define BGP_INFO_DMED_CHECK (1 << 6)
-#define BGP_INFO_DMED_SELECTED (1 << 7)
-#define BGP_INFO_STALE (1 << 8)
-#define BGP_INFO_REMOVED (1 << 9)
-#define BGP_INFO_COUNTED (1 << 10)
-#define BGP_INFO_MULTIPATH (1 << 11)
-#define BGP_INFO_MULTIPATH_CHG (1 << 12)
-#define BGP_INFO_RIB_ATTR_CHG (1 << 13)
-#define BGP_INFO_ANNC_NH_SELF (1 << 14)
+#define BGP_PATH_IGP_CHANGED (1 << 0)
+#define BGP_PATH_DAMPED (1 << 1)
+#define BGP_PATH_HISTORY (1 << 2)
+#define BGP_PATH_SELECTED (1 << 3)
+#define BGP_PATH_VALID (1 << 4)
+#define BGP_PATH_ATTR_CHANGED (1 << 5)
+#define BGP_PATH_DMED_CHECK (1 << 6)
+#define BGP_PATH_DMED_SELECTED (1 << 7)
+#define BGP_PATH_STALE (1 << 8)
+#define BGP_PATH_REMOVED (1 << 9)
+#define BGP_PATH_COUNTED (1 << 10)
+#define BGP_PATH_MULTIPATH (1 << 11)
+#define BGP_PATH_MULTIPATH_CHG (1 << 12)
+#define BGP_PATH_RIB_ATTR_CHG (1 << 13)
+#define BGP_PATH_ANNC_NH_SELF (1 << 14)
/* BGP route type. This can be static, RIP, OSPF, BGP etc. */
uint8_t type;
#define BGP_ATTR_NEXTHOP_AFI_IP6(attr) \
(!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) \
&& ((attr)->mp_nexthop_len == 16 || (attr)->mp_nexthop_len == 32))
-#define BGP_INFO_COUNTABLE(BI) \
- (!CHECK_FLAG((BI)->flags, BGP_INFO_HISTORY) \
- && !CHECK_FLAG((BI)->flags, BGP_INFO_REMOVED))
+#define BGP_PATH_COUNTABLE(BI) \
+ (!CHECK_FLAG((BI)->flags, BGP_PATH_HISTORY) \
+ && !CHECK_FLAG((BI)->flags, BGP_PATH_REMOVED))
/* Flags which indicate a route is unuseable in some form */
-#define BGP_INFO_UNUSEABLE \
- (BGP_INFO_HISTORY | BGP_INFO_DAMPED | BGP_INFO_REMOVED)
+#define BGP_PATH_UNUSEABLE \
+ (BGP_PATH_HISTORY | BGP_PATH_DAMPED | BGP_PATH_REMOVED)
/* Macro to check BGP information is alive or not. Sadly,
* not equivalent to just checking previous, because of the
* sense of the additional VALID flag.
*/
-#define BGP_INFO_HOLDDOWN(BI) \
- (!CHECK_FLAG((BI)->flags, BGP_INFO_VALID) \
- || CHECK_FLAG((BI)->flags, BGP_INFO_UNUSEABLE))
+#define BGP_PATH_HOLDDOWN(BI) \
+ (!CHECK_FLAG((BI)->flags, BGP_PATH_VALID) \
+ || CHECK_FLAG((BI)->flags, BGP_PATH_UNUSEABLE))
#define DISTRIBUTE_IN_NAME(F) ((F)->dlist[FILTER_IN].name)
#define DISTRIBUTE_IN(F) ((F)->dlist[FILTER_IN].alist)
if (CHECK_FLAG(peer->af_flags[afi][safi],
PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS)
- && CHECK_FLAG(ri->flags, BGP_INFO_DMED_SELECTED))
+ && CHECK_FLAG(ri->flags, BGP_PATH_DMED_SELECTED))
return 1;
return 0;
for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn))
for (ri = rn->info; ri; ri = ri->next)
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED)
|| (addpath_capable
&& bgp_addpath_tx_path(peer, afi, safi, ri))) {
if (subgroup_announce_check(rn, ri, subgrp,
for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn))
for (ri = rn->info; ri; ri = ri->next)
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED) &&
+ if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED) &&
(ri->type == ZEBRA_ROUTE_BGP
&& (ri->sub_type == BGP_ROUTE_NORMAL
bgp_attr_unintern(&old_attr);
bgp_info_set_flag(rn, ri,
- BGP_INFO_ATTR_CHANGED);
+ BGP_PATH_ATTR_CHANGED);
bgp_process(bgp, rn, afi, SAFI_UNICAST);
}
}
}
if (attrhash_cmp(bi->attr, new_attr)
- && !CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ && !CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
bgp_attr_unintern(&new_attr);
bgp_unlock_node(bn);
goto done;
} else {
/* The attribute is changed. */
- bgp_info_set_flag(bn, bi, BGP_INFO_ATTR_CHANGED);
+ bgp_info_set_flag(bn, bi, BGP_PATH_ATTR_CHANGED);
if (safi == SAFI_MPLS_VPN) {
struct bgp_node *prn = NULL;
}
/* Rewrite BGP route information. */
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
bgp_info_restore(bn, bi);
else
bgp_aggregate_decrement(bgp, p, bi, afi, safi);
new->type = type;
new->sub_type = sub_type;
new->peer = rfd->peer;
- SET_FLAG(new->flags, BGP_INFO_VALID);
+ SET_FLAG(new->flags, BGP_PATH_VALID);
new->attr = new_attr;
new->uptime = bgp_clock();
next = bi->next;
if (CHECK_FLAG(bi->flags,
- BGP_INFO_REMOVED)) {
+ BGP_PATH_REMOVED)) {
++holddown_count;
} else {
* If there is a timer waiting to delete this bi, cancel
* the timer and delete immediately
*/
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)
&& bi->extra->vnc.import.timer) {
struct thread *t =
for (bi = rn->info; bi; bi = bi->next) {
struct prefix pfx;
- if (!CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)
+ if (!CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)
&& (bi->extra && !rfapiGetUnAddrOfVpnBi(bi, &pfx))) {
return 1;
int ctrc = rfapiGetUnAddrOfVpnBi(bi, &pfx);
int nr;
- if (!CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)
+ if (!CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)
&& (bi->extra && !ctrc)) {
nr = 1;
struct prefix pfx_vn;
struct prefix *newpfx;
- if (removed && !CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (removed && !CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
#if DEBUG_RETURNED_NHL
vnc_zlog_debug_verbose(
"%s: want holddown, this route not holddown, skip",
#endif
continue;
}
- if (!removed && CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (!removed && CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
continue;
}
* Construct an rfapi nexthop list based on the routes attached to
* the specified node.
*
- * If there are any routes that do NOT have BGP_INFO_REMOVED set,
- * return those only. If there are ONLY routes with BGP_INFO_REMOVED,
+ * If there are any routes that do NOT have BGP_PATH_REMOVED set,
+ * return those only. If there are ONLY routes with BGP_PATH_REMOVED,
* then return those, and also include all the non-removed routes from the
* next less-specific node (i.e., this node's parent) at the end.
*/
for (prev = NULL, next = rn->info; next;
prev = next, next = next->next) {
- if (!bgp || (!CHECK_FLAG(info_new->flags, BGP_INFO_REMOVED)
- && CHECK_FLAG(next->flags, BGP_INFO_REMOVED))
+ if (!bgp
+ || (!CHECK_FLAG(info_new->flags, BGP_PATH_REMOVED)
+ && CHECK_FLAG(next->flags, BGP_PATH_REMOVED))
|| bgp_info_cmp_compatible(bgp, info_new, next, pfx_buf,
afi, safi)
== -1) { /* -1 if 1st is better */
/*
* Remove the route (doubly-linked)
*/
- if (CHECK_FLAG(bi->flags, BGP_INFO_VALID)
+ if (CHECK_FLAG(bi->flags, BGP_PATH_VALID)
&& VALID_INTERIOR_TYPE(bi->type))
RFAPI_MONITOR_EXTERIOR(wcb->node)->valid_interior_count--;
vpn_bi->extra->vnc.import.un_family = 0;
memset(&vpn_bi->extra->vnc.import.un, 0,
sizeof(vpn_bi->extra->vnc.import.un));
- if (CHECK_FLAG(vpn_bi->flags, BGP_INFO_VALID)) {
+ if (CHECK_FLAG(vpn_bi->flags, BGP_PATH_VALID)) {
if (rfapiGetVncTunnelUnAddr(vpn_bi->attr, NULL)) {
- UNSET_FLAG(vpn_bi->flags, BGP_INFO_VALID);
+ UNSET_FLAG(vpn_bi->flags, BGP_PATH_VALID);
if (VALID_INTERIOR_TYPE(vpn_bi->type))
RFAPI_MONITOR_EXTERIOR(vpn_rn)
->valid_interior_count--;
return 1;
}
rfapiCopyUnEncap2VPN(encap_bi, vpn_bi);
- if (!CHECK_FLAG(vpn_bi->flags, BGP_INFO_VALID)) {
- SET_FLAG(vpn_bi->flags, BGP_INFO_VALID);
+ if (!CHECK_FLAG(vpn_bi->flags, BGP_PATH_VALID)) {
+ SET_FLAG(vpn_bi->flags, BGP_PATH_VALID);
if (VALID_INTERIOR_TYPE(vpn_bi->type))
RFAPI_MONITOR_EXTERIOR(vpn_rn)
->valid_interior_count++;
uint32_t lifetime;
struct rfapi_withdraw *wcb;
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
/*
* Already on the path to being withdrawn,
* should already have a timer set up to
/*
* withdrawn routes get to hang around for a while
*/
- SET_FLAG(bi->flags, BGP_INFO_REMOVED);
+ SET_FLAG(bi->flags, BGP_PATH_REMOVED);
/* set timer to remove the route later */
lifetime = rfapiGetHolddownFromLifetime(lifetime);
&bi->extra->vnc.import.timer);
}
- /* re-sort route list (BGP_INFO_REMOVED routes are last) */
+ /* re-sort route list (BGP_PATH_REMOVED routes are last) */
if (((struct bgp_info *)rn->info)->next) {
rfapiBgpInfoDetach(rn, bi);
rfapiBgpInfoAttachSorted(rn, bi, afi, safi);
* a previous withdraw, we must cancel its
* timer.
*/
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)
&& bi->extra->vnc.import.timer) {
struct thread *t =
int un_match = 0;
next = bi->next;
- if (!CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (!CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
/*
* the address family of the cached UN address field.
*/
rfapiCopyUnEncap2VPN(info_new, m->bi);
- if (!CHECK_FLAG(m->bi->flags, BGP_INFO_VALID)) {
- SET_FLAG(m->bi->flags, BGP_INFO_VALID);
+ if (!CHECK_FLAG(m->bi->flags, BGP_PATH_VALID)) {
+ SET_FLAG(m->bi->flags, BGP_PATH_VALID);
if (VALID_INTERIOR_TYPE(m->bi->type))
RFAPI_MONITOR_EXTERIOR(m->node)
->valid_interior_count++;
if (action == FIF_ACTION_WITHDRAW) {
int washolddown =
- CHECK_FLAG(bi->flags, BGP_INFO_REMOVED);
+ CHECK_FLAG(bi->flags, BGP_PATH_REMOVED);
vnc_zlog_debug_verbose(
"%s: withdrawing at prefix %s/%d%s",
* a previous withdraw, we must cancel its
* timer.
*/
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)
&& bi->extra->vnc.import.timer) {
struct thread *t =
* processing
*/
if (CHECK_FLAG(bi->flags,
- BGP_INFO_VALID)
+ BGP_PATH_VALID)
&& VALID_INTERIOR_TYPE(bi->type))
RFAPI_MONITOR_EXTERIOR(rn)
->valid_interior_count--;
if (!rfapiGetUnAddrOfVpnBi(info_new, NULL)) {
if (VALID_INTERIOR_TYPE(info_new->type))
RFAPI_MONITOR_EXTERIOR(rn)->valid_interior_count++;
- SET_FLAG(info_new->flags, BGP_INFO_VALID);
+ SET_FLAG(info_new->flags, BGP_PATH_VALID);
}
RFAPI_UPDATE_ITABLE_COUNT(info_new, import_table, afi, 1);
vnc_import_bgp_exterior_add_route_interior(bgp, import_table, rn,
/*
* Must be holddown
*/
- if (!CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (!CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
/*
for (bi = rn->info; bi; bi = bi->next) {
if (bi->peer == peer) {
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
/* already in holddown, skip */
continue;
}
uint32_t label = 0;
if (CHECK_FLAG(bi->flags,
- BGP_INFO_REMOVED))
+ BGP_PATH_REMOVED))
continue;
if (bi->extra)
* a previous withdraw, we must cancel its
* timer.
*/
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
if (!delete_holddown)
continue;
if (bi->extra->vnc.import.timer) {
if (!bi)
return;
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED) && bi->extra
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED) && bi->extra
&& bi->extra->vnc.import.timer) {
struct thread *t = (struct thread *)bi->extra->vnc.import.timer;
r = snprintf(p, REMAIN, " [%4lu] ",
r = snprintf(p, REMAIN, " p@%p", bi->peer);
INCP;
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED)) {
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED)) {
r = snprintf(p, REMAIN, " HD=yes");
INCP;
} else {
fp(out, "%-10s ", buf_lifetime);
}
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED) && bi->extra
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED) && bi->extra
&& bi->extra->vnc.import.timer) {
uint32_t remaining;
}
if (show_expiring
- && !CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ && !CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
if (!show_expiring
- && CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ && CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
if (bi->type == ZEBRA_ROUTE_BGP_DIRECT
struct prefix_rd *prd;
/*
- * Find the bgp_info in the RIB corresponding to this
+ * Find the bgp_path in the RIB corresponding to this
* prefix and rfd
*/
for (ubi = urn->info; ubi; ubi = ubi->next) {
struct prefix unicast_nexthop;
- if (CHECK_FLAG(ubi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(ubi->flags, BGP_PATH_REMOVED))
continue;
rfapiUnicastNexthop2Prefix(afi, ubi->attr, &unicast_nexthop);
return;
}
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
return;
vncHDResolveNve.peer = bi->peer;
return;
}
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
return;
vncHDResolveNve.peer = bi->peer;
#endif
return 0;
}
- if (!CHECK_FLAG(bi_interior->flags, BGP_INFO_VALID)) {
+ if (!CHECK_FLAG(bi_interior->flags, BGP_PATH_VALID)) {
#if DEBUG_IS_USABLE_INTERIOR
- vnc_zlog_debug_verbose("%s: NO: BGP_INFO_VALID not set",
+ vnc_zlog_debug_verbose("%s: NO: BGP_PATH_VALID not set",
__func__);
#endif
return 0;
for (bi = rn->info; bi; bi = bi->next) {
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
vnc_import_bgp_add_route(bgp, &rn->p, bi);
for (bi = rn->info; bi; bi = bi->next) {
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
vnc_import_bgp_exterior_add_route(bgp_exterior, &rn->p,
for (bi = rn->info; bi; bi = bi->next) {
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
vnc_import_bgp_exterior_add_route_it(
for (bi = rn->info; bi; bi = bi->next) {
- if (CHECK_FLAG(bi->flags, BGP_INFO_REMOVED))
+ if (CHECK_FLAG(bi->flags, BGP_PATH_REMOVED))
continue;
vnc_import_bgp_exterior_del_route(bgp_exterior,
EXPECT_TRUE(bgp_info_mpath_count(new_best) == 2, test_result);
mpath = bgp_info_mpath_first(new_best);
EXPECT_TRUE(mpath == &test_mp_list_info[0], test_result);
- EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
+ EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
mpath = bgp_info_mpath_next(mpath);
EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
- EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
+ EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
EXPECT_TRUE(bgp_info_mpath_count(new_best) == 1, test_result);
mpath = bgp_info_mpath_first(new_best);
EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
- EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
- EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_INFO_MULTIPATH),
+ EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
+ EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_PATH_MULTIPATH),
test_result);
return test_result;
projects / mirror / frr.git / commitdiff