void
rpki_revalidate_all_routes(struct bgp* bgp, afi_t afi)
{
struct bgp_node* bgp_node;
struct bgp_info* bgp_info;
safi_t safi;
for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
{
for (bgp_node = bgp_table_top(bgp->rib[afi][safi]); bgp_node; bgp_node =
bgp_route_next(bgp_node))
{
if (bgp_node->info != NULL )
{
bool status_changed = false;
for (bgp_info = bgp_node->info; bgp_info;
bgp_info = bgp_info->next)
{
u_char old_status = bgp_info->rpki_validation_status;
bgp_info->rpki_validation_status = rpki_validate_prefix(
bgp_info->peer, bgp_info->attr, &bgp_node->p);
if (old_status != bgp_info->rpki_validation_status)
{
status_changed = true;
}
}
if (status_changed)
{
bgp_process(bgp, bgp_node, afi, safi);
}
}
}
}
}
/* Handler of reuse timer event. Each route in the current reuse-list
is evaluated. RFC2439 Section 4.8.7. */
static int
bgp_reuse_timer (struct thread *t)
{
struct bgp_damp_info *bdi;
struct bgp_damp_info *next;
time_t t_now, t_diff;
damp->t_reuse = NULL;
damp->t_reuse =
thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
t_now = bgp_clock ();
/* 1. save a pointer to the current zeroth queue head and zero the
list head entry. */
bdi = damp->reuse_list[damp->reuse_offset];
damp->reuse_list[damp->reuse_offset] = NULL;
/* 2. set offset = modulo reuse-list-size ( offset + 1 ), thereby
rotating the circular queue of list-heads. */
damp->reuse_offset = (damp->reuse_offset + 1) % damp->reuse_list_size;
/* 3. if ( the saved list head pointer is non-empty ) */
for (; bdi; bdi = next)
{
struct bgp *bgp = bdi->binfo->peer->bgp;
next = bdi->next;
/* Set t-diff = t-now - t-updated. */
t_diff = t_now - bdi->t_updated;
/* Set figure-of-merit = figure-of-merit * decay-array-ok [t-diff] */
bdi->penalty = bgp_damp_decay (t_diff, bdi->penalty);
/* Set t-updated = t-now. */
bdi->t_updated = t_now;
/* if (figure-of-merit < reuse). */
if (bdi->penalty < damp->reuse_limit)
{
/* Reuse the route. */
bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_DAMPED);
bdi->suppress_time = 0;
if (bdi->lastrecord == BGP_RECORD_UPDATE)
{
bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_HISTORY);
bgp_aggregate_increment (bgp, &bdi->rn->p, bdi->binfo,
bdi->afi, bdi->safi);
bgp_process (bgp, bdi->rn, bdi->afi, bdi->safi);
}
if (bdi->penalty <= damp->reuse_limit / 2.0)
bgp_damp_info_free (bdi, 1);
else
BGP_DAMP_LIST_ADD (damp, bdi);
}
else
/* Re-insert into another list (See RFC2439 Section 4.8.6). */
bgp_reuse_list_add (bdi);
}
return 0;
}
static void
bgp_scan (afi_t afi, safi_t safi)
{
struct bgp_node *rn;
struct bgp *bgp;
struct bgp_info *bi;
struct bgp_info *next;
struct peer *peer;
struct listnode *node, *nnode;
int valid;
int current;
int changed;
int metricchanged;
/* Change cache. */
if (bgp_nexthop_cache_table[afi] == cache1_table[afi])
bgp_nexthop_cache_table[afi] = cache2_table[afi];
else
bgp_nexthop_cache_table[afi] = cache1_table[afi];
/* Get default bgp. */
bgp = bgp_get_default ();
if (bgp == NULL)
return;
/* Maximum prefix check */
for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
{
if (peer->status != Established)
continue;
if (peer->afc[afi][SAFI_UNICAST])
bgp_maximum_prefix_overflow (peer, afi, SAFI_UNICAST, 1);
if (peer->afc[afi][SAFI_MULTICAST])
bgp_maximum_prefix_overflow (peer, afi, SAFI_MULTICAST, 1);
if (peer->afc[afi][SAFI_MPLS_VPN])
bgp_maximum_prefix_overflow (peer, afi, SAFI_MPLS_VPN, 1);
}
for (rn = bgp_table_top (bgp->rib[afi][SAFI_UNICAST]); rn;
rn = bgp_route_next (rn))
{
for (bi = rn->info; bi; bi = next)
{
next = bi->next;
if (bi->type == ZEBRA_ROUTE_BGP && bi->sub_type == BGP_ROUTE_NORMAL)
{
changed = 0;
metricchanged = 0;
if (bi->peer->sort == BGP_PEER_EBGP && bi->peer->ttl == 1)
valid = bgp_nexthop_onlink (afi, bi->attr);
else
valid = bgp_nexthop_lookup (afi, bi->peer, bi,
&changed, &metricchanged);
current = CHECK_FLAG (bi->flags, BGP_INFO_VALID) ? 1 : 0;
if (changed)
SET_FLAG (bi->flags, BGP_INFO_IGP_CHANGED);
else
UNSET_FLAG (bi->flags, BGP_INFO_IGP_CHANGED);
if (valid != current)
{
if (CHECK_FLAG (bi->flags, BGP_INFO_VALID))
{
bgp_aggregate_decrement (bgp, &rn->p, bi,
afi, SAFI_UNICAST);
bgp_info_unset_flag (rn, bi, BGP_INFO_VALID);
}
else
{
bgp_info_set_flag (rn, bi, BGP_INFO_VALID);
bgp_aggregate_increment (bgp, &rn->p, bi,
afi, SAFI_UNICAST);
}
}
if (CHECK_FLAG (bgp->af_flags[afi][SAFI_UNICAST],
BGP_CONFIG_DAMPENING)
&& bi->extra && bi->extra->damp_info )
if (bgp_damp_scan (bi, afi, SAFI_UNICAST))
bgp_aggregate_increment (bgp, &rn->p, bi,
afi, SAFI_UNICAST);
}
}
bgp_process (bgp, rn, afi, SAFI_UNICAST);
}
/* Flash old cache. */
if (bgp_nexthop_cache_table[afi] == cache1_table[afi])
bgp_nexthop_cache_reset (cache2_table[afi]);
else
bgp_nexthop_cache_reset (cache1_table[afi]);
if (BGP_DEBUG (events, EVENTS))
{
if (afi == AFI_IP)
zlog_debug ("scanning IPv4 Unicast routing tables");
else if (afi == AFI_IP6)
zlog_debug ("scanning IPv6 Unicast routing tables");
}
/* Reevaluate default-originate route-maps and announce/withdraw
* default route if neccesary. */
for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
{
if (peer->status == Established
&& CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE)
&& peer->default_rmap[afi][safi].name)
bgp_default_originate (peer, afi, safi, 0);
}
}