void
eigrp_nbr_state_update (struct eigrp_neighbor *nbr)
{
switch (nbr->state)
{
case EIGRP_NEIGHBOR_DOWN:
{
/*Start Hold Down Timer for neighbor*/
// THREAD_OFF(nbr->t_holddown);
// THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired,
// nbr, nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_PENDING:
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_UP:
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
}
}
}
void pim_neighbor_timer_reset(struct pim_neighbor *neigh, uint16_t holdtime)
{
neigh->holdtime = holdtime;
neighbor_timer_off(neigh);
/*
0xFFFF is request for no holdtime
*/
if (neigh->holdtime == 0xFFFF) {
return;
}
if (PIM_DEBUG_PIM_TRACE) {
char src_str[100];
pim_inet4_dump("<src?>", neigh->source_addr, src_str, sizeof(src_str));
zlog_debug("%s: starting %u sec timer for neighbor %s on %s",
__PRETTY_FUNCTION__,
neigh->holdtime, src_str, neigh->interface->name);
}
THREAD_TIMER_ON(master, neigh->t_expire_timer,
on_neighbor_timer,
neigh, neigh->holdtime);
}
void
dyn_cache_init (void)
{
dyn_cache = list_new ();
THREAD_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
return;
}
static void pim_assert_timer_set(struct pim_ifchannel *ch,
int interval)
{
struct interface *ifp;
zassert(ch);
ifp = ch->interface;
zassert(ifp);
assert_timer_off(ch);
if (PIM_DEBUG_PIM_TRACE) {
char src_str[100];
char grp_str[100];
pim_inet4_dump("<src?>", ch->source_addr, src_str, sizeof(src_str));
pim_inet4_dump("<grp?>", ch->group_addr, grp_str, sizeof(grp_str));
zlog_debug("%s: (S,G)=(%s,%s) starting %u sec timer on interface %s",
__PRETTY_FUNCTION__,
src_str, grp_str, interval, ifp->name);
}
THREAD_TIMER_ON(master, ch->t_ifassert_timer,
on_assert_timer,
ch, interval);
}
/* Schedule connection with delay. */
static void zclient_lookup_sched(struct zclient *zlookup, int delay)
{
zassert(!zlookup->t_connect);
THREAD_TIMER_ON(master, zlookup->t_connect,
zclient_lookup_connect,
zlookup, delay);
zlog_notice("%s: zclient lookup connection scheduled for %d seconds",
__PRETTY_FUNCTION__, delay);
}
void pim_igmp_general_query_on(struct igmp_sock *igmp)
{
struct pim_interface *pim_ifp;
int startup_mode;
int query_interval;
zassert(igmp);
zassert(igmp->interface);
/*
Since this socket is starting as querier,
there should not exist a timer for other-querier-present.
*/
zassert(!igmp->t_other_querier_timer);
pim_ifp = igmp->interface->info;
zassert(pim_ifp);
/*
RFC 3376: 8.6. Startup Query Interval
The Startup Query Interval is the interval between General Queries
sent by a Querier on startup. Default: 1/4 the Query Interval.
*/
startup_mode = igmp->startup_query_count > 0;
if (startup_mode) {
--igmp->startup_query_count;
/* query_interval = pim_ifp->igmp_default_query_interval >> 2; */
query_interval = PIM_IGMP_SQI(pim_ifp->igmp_default_query_interval);
}
else {
query_interval = igmp->querier_query_interval;
}
if (PIM_DEBUG_IGMP_TRACE) {
char ifaddr_str[100];
pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
zlog_debug("Querier %s scheduling %d-second (%s) TIMER event for IGMP query on fd=%d",
ifaddr_str,
query_interval,
startup_mode ? "startup" : "non-startup",
igmp->fd);
}
igmp->t_igmp_query_timer = 0;
zassert(!igmp->t_igmp_query_timer);
THREAD_TIMER_ON(master, igmp->t_igmp_query_timer,
pim_igmp_general_query,
igmp, query_interval);
}
static void hello_resched(struct interface *ifp)
{
struct pim_interface *pim_ifp;
zassert(ifp);
pim_ifp = ifp->info;
zassert(pim_ifp);
if (PIM_DEBUG_PIM_HELLO) {
zlog_debug("Rescheduling %d sec hello on interface %s",
pim_ifp->pim_hello_period, ifp->name);
}
THREAD_OFF(pim_ifp->t_pim_hello_timer);
THREAD_TIMER_ON(master, pim_ifp->t_pim_hello_timer,
on_pim_hello_send,
ifp, pim_ifp->pim_hello_period);
}
static void join_timer_start(struct pim_upstream *up)
{
if (PIM_DEBUG_PIM_EVENTS) {
char src_str[100];
char grp_str[100];
pim_inet4_dump("<src?>", up->source_addr, src_str, sizeof(src_str));
pim_inet4_dump("<grp?>", up->group_addr, grp_str, sizeof(grp_str));
zlog_debug("%s: starting %d sec timer for upstream (S,G)=(%s,%s)",
__PRETTY_FUNCTION__,
qpim_t_periodic,
src_str, grp_str);
}
zassert(!up->t_join_timer);
THREAD_TIMER_ON(master, up->t_join_timer,
on_join_timer,
up, qpim_t_periodic);
}
static int
dyn_cache_cleanup (struct thread *thread)
{
struct listnode *node, *nnode;
struct isis_dynhn *dyn;
time_t now = time (NULL);
isis->t_dync_clean = NULL;
for (ALL_LIST_ELEMENTS (dyn_cache, node, nnode, dyn))
{
if ((now - dyn->refresh) < (MAX_AGE + 120))
continue;
list_delete_node (dyn_cache, node);
XFREE (MTYPE_ISIS_DYNHN, dyn);
}
THREAD_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
return ISIS_OK;
}
static void
circuit_commence_level (struct isis_circuit *circuit, int level)
{
if (level == 1)
{
if (! circuit->is_passive)
THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
circuit, 2 * circuit->hello_interval[0]);
THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
send_lan_l1_hello, circuit,
isis_jitter (circuit->hello_interval[0],
IIH_JITTER));
circuit->u.bc.lan_neighs[0] = list_new ();
}
}
else
{
if (! circuit->is_passive)
THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
circuit, 2 * circuit->hello_interval[1]);
THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
send_lan_l2_hello, circuit,
isis_jitter (circuit->hello_interval[1],
IIH_JITTER));
circuit->u.bc.lan_neighs[1] = list_new ();
}
}
return;
}
