Replace use of the macro with the cancel function.
Signed-off-by: Mark Stapp <mjs@cisco.com>
ospf6_spf_table_finish(oa->spf_table);
ospf6_route_remove_all(oa->route_table);
- EVENT_OFF(oa->thread_router_lsa);
- EVENT_OFF(oa->thread_intra_prefix_lsa);
+ event_cancel(&oa->thread_router_lsa);
+ event_cancel(&oa->thread_intra_prefix_lsa);
}
if (IS_OSPF6_DEBUG_AGGR)
zlog_debug("%s: LSA found, refresh it",
__func__);
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa, 0,
&lsa->refresh);
return;
lsa = ospf6_find_external_lsa(ospf6, &rt->prefix);
if (lsa) {
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa, 0,
&lsa->refresh);
} else {
if (IS_OSPF6_DEBUG_AGGR)
zlog_debug("%s, Restarting Aggregator delay timer.",
__func__);
- EVENT_OFF(ospf6->t_external_aggr);
+ event_cancel(&ospf6->t_external_aggr);
}
}
if (bss->state == BFD_STATUS_DOWN
&& bss->previous_state == BFD_STATUS_UP) {
- EVENT_OFF(on->inactivity_timer);
+ event_cancel(&on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
}
lsdb_self = ospf6_get_scoped_lsdb_self(lsa);
ospf6_lsdb_add(ospf6_lsa_copy(lsa), lsdb_self);
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->refresh);
event_add_timer(master, ospf6_lsa_refresh, lsa, OSPF_LS_REFRESH_TIME,
&lsa->refresh);
self = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
lsa->header->adv_router, lsdb_self);
if (self) {
- EVENT_OFF(self->expire);
- EVENT_OFF(self->refresh);
+ event_cancel(&self->expire);
+ event_cancel(&self->refresh);
ospf6_lsdb_remove(self, lsdb_self);
}
lsa->name);
lsa->external_lsa_id = old->external_lsa_id;
}
- EVENT_OFF(old->expire);
- EVENT_OFF(old->refresh);
+ event_cancel(&old->expire);
+ event_cancel(&old->refresh);
ospf6_flood_clear(old);
}
} else {
/* reschedule retransmissions to all neighbors */
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- EVENT_OFF(on->thread_send_lsupdate);
+ event_cancel(&on->thread_send_lsupdate);
event_add_event(master, ospf6_lsupdate_send_neighbor,
on, 0, &on->thread_send_lsupdate);
}
ospf6->gr_info.finishing_restart = true;
XFREE(MTYPE_TMP, ospf6->gr_info.exit_reason);
ospf6->gr_info.exit_reason = XSTRDUP(MTYPE_TMP, reason);
- EVENT_OFF(ospf6->gr_info.t_grace_period);
+ event_cancel(&ospf6->gr_info.t_grace_period);
for (ALL_LIST_ELEMENTS_RO(ospf6->area_list, onode, area)) {
struct ospf6_interface *oi;
/* Disable hello delay. */
if (oi->gr.hello_delay.t_grace_send) {
oi->gr.hello_delay.elapsed_seconds = 0;
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
event_add_event(master, ospf6_hello_send, oi, 0,
&oi->thread_send_hello);
}
}
if (OSPF6_GR_IS_ACTIVE_HELPER(restarter)) {
- EVENT_OFF(restarter->gr_helper_info.t_grace_timer);
+ event_cancel(&restarter->gr_helper_info.t_grace_timer);
if (ospf6->ospf6_helper_cfg.active_restarter_cnt > 0)
ospf6->ospf6_helper_cfg.active_restarter_cnt--;
* expiry, stop the grace timer.
*/
if (reason != OSPF6_GR_HELPER_GRACE_TIMEOUT)
- EVENT_OFF(nbr->gr_helper_info.t_grace_timer);
+ event_cancel(&nbr->gr_helper_info.t_grace_timer);
if (ospf6->ospf6_helper_cfg.active_restarter_cnt <= 0) {
zlog_err(
list_delete(&oi->neighbor_list);
- EVENT_OFF(oi->thread_send_hello);
- EVENT_OFF(oi->thread_send_lsupdate);
- EVENT_OFF(oi->thread_send_lsack);
- EVENT_OFF(oi->thread_sso);
- EVENT_OFF(oi->thread_wait_timer);
+ event_cancel(&oi->thread_send_hello);
+ event_cancel(&oi->thread_send_lsupdate);
+ event_cancel(&oi->thread_send_lsack);
+ event_cancel(&oi->thread_sso);
+ event_cancel(&oi->thread_wait_timer);
ospf6_lsdb_remove_all(oi->lsdb);
ospf6_lsdb_remove_all(oi->lsupdate_list);
ospf6_lsdb_remove_all(oi->lsupdate_list);
ospf6_lsdb_remove_all(oi->lsack_list);
- EVENT_OFF(oi->thread_send_hello);
- EVENT_OFF(oi->thread_send_lsupdate);
- EVENT_OFF(oi->thread_send_lsack);
- EVENT_OFF(oi->thread_sso);
+ event_cancel(&oi->thread_send_hello);
+ event_cancel(&oi->thread_send_lsupdate);
+ event_cancel(&oi->thread_send_lsack);
+ event_cancel(&oi->thread_sso);
- EVENT_OFF(oi->thread_network_lsa);
- EVENT_OFF(oi->thread_link_lsa);
- EVENT_OFF(oi->thread_intra_prefix_lsa);
- EVENT_OFF(oi->thread_as_extern_lsa);
- EVENT_OFF(oi->thread_wait_timer);
+ event_cancel(&oi->thread_network_lsa);
+ event_cancel(&oi->thread_link_lsa);
+ event_cancel(&oi->thread_intra_prefix_lsa);
+ event_cancel(&oi->thread_as_extern_lsa);
+ event_cancel(&oi->thread_wait_timer);
oi->gr.hello_delay.elapsed_seconds = 0;
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
}
static struct in6_addr *
oi->interface->name);
/* Stop Hellos */
- EVENT_OFF(oi->thread_send_hello);
+ event_cancel(&oi->thread_send_hello);
/* Stop trying to set socket options. */
- EVENT_OFF(oi->thread_sso);
+ event_cancel(&oi->thread_sso);
/* Cease the HELPER role for all the neighbours
* of this interface.
/* re-establish adjacencies */
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- EVENT_OFF(on->inactivity_timer);
+ event_cancel(&on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
/* re-establish adjacencies */
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- EVENT_OFF(on->inactivity_timer);
+ event_cancel(&on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
* If the thread is scheduled, send the new hello now.
*/
if (event_is_scheduled(oi->thread_send_hello)) {
- EVENT_OFF(oi->thread_send_hello);
+ event_cancel(&oi->thread_send_hello);
event_add_timer(master, ospf6_hello_send, oi, 0,
&oi->thread_send_hello);
oi->gr.hello_delay.interval = OSPF_HELLO_DELAY_DEFAULT;
oi->gr.hello_delay.elapsed_seconds = 0;
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
return CMD_SUCCESS;
}
assert(oi);
SET_FLAG(oi->flag, OSPF6_INTERFACE_PASSIVE);
- EVENT_OFF(oi->thread_send_hello);
- EVENT_OFF(oi->thread_sso);
+ event_cancel(&oi->thread_send_hello);
+ event_cancel(&oi->thread_sso);
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- EVENT_OFF(on->inactivity_timer);
+ event_cancel(&on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
assert(oi);
UNSET_FLAG(oi->flag, OSPF6_INTERFACE_PASSIVE);
- EVENT_OFF(oi->thread_send_hello);
- EVENT_OFF(oi->thread_sso);
+ event_cancel(&oi->thread_send_hello);
+ event_cancel(&oi->thread_sso);
/* don't send hellos over loopback interface */
if (!if_is_loopback(oi->interface))
#define OSPF6_NETWORK_LSA_EXECUTE(oi) \
do { \
- EVENT_OFF((oi)->thread_network_lsa); \
+ event_cancel(&(oi)->thread_network_lsa); \
event_execute(master, ospf6_network_lsa_originate, oi, 0, \
NULL); \
} while (0)
#define OSPF6_INTRA_PREFIX_LSA_EXECUTE_TRANSIT(oi) \
do { \
- EVENT_OFF((oi)->thread_intra_prefix_lsa); \
+ event_cancel(&(oi)->thread_intra_prefix_lsa); \
event_execute(master, \
ospf6_intra_prefix_lsa_originate_transit, oi, \
0, NULL); \
#define OSPF6_AS_EXTERN_LSA_EXECUTE(oi) \
do { \
- EVENT_OFF((oi)->thread_as_extern_lsa); \
+ event_cancel(&(oi)->thread_as_extern_lsa); \
event_execute(master, ospf6_orig_as_external_lsa, oi, 0, NULL);\
} while (0)
if (IS_OSPF6_DEBUG_LSA_TYPE(lsa->header->type))
zlog_debug("LSA: Premature aging: %s", lsa->name);
- EVENT_OFF(lsa->expire);
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->expire);
+ event_cancel(&lsa->refresh);
/*
* We clear the LSA from the neighbor retx lists now because it
assert(lsa->lock == 0);
/* cancel threads */
- EVENT_OFF(lsa->expire);
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->expire);
+ event_cancel(&lsa->refresh);
/* do free */
XFREE(MTYPE_OSPF6_LSA_HEADER, lsa->header);
htonl(OSPF_MAX_SEQUENCE_NUMBER + 1);
ospf6_lsa_checksum(lsa->header);
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->refresh);
event_execute(master, ospf6_lsa_refresh, lsa, 0, NULL);
} else {
if (IS_OSPF6_DEBUG_LSA_TYPE(lsa->header->type))
{
if (IS_OSPF6_DEBUG_EVENT)
zlog_debug("ospf6d config start received");
- EVENT_OFF(t_ospf6_cfg);
+ event_cancel(&t_ospf6_cfg);
event_add_timer(master, ospf6_config_finish, NULL,
OSPF6_PRE_CONFIG_MAX_WAIT_SECONDS, &t_ospf6_cfg);
}
if (IS_OSPF6_DEBUG_EVENT)
zlog_debug("ospf6d config end received");
- EVENT_OFF(t_ospf6_cfg);
+ event_cancel(&t_ospf6_cfg);
}
/* Main routine of ospf6d. Treatment of argument and starting ospf finite
event_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
/* More bit check */
if (!CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MBIT)
if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV_HDR))
zlog_debug(
"Duplicated dbdesc causes retransmit");
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
return;
if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV_HDR))
zlog_debug(
"Duplicated dbdesc causes retransmit");
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
return;
event_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send_newone, on, 0,
&on->thread_send_dbdesc);
assert(p == OSPF6_MESSAGE_END(oh));
/* schedule send lsupdate */
- EVENT_OFF(on->thread_send_lsupdate);
+ event_cancel(&on->thread_send_lsupdate);
event_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
&on->thread_send_lsupdate);
}
> ospf6_packet_max(oi)) {
/* if we run out of packet size/space here,
better to try again soon. */
- EVENT_OFF(oi->thread_send_lsack);
+ event_cancel(&oi->thread_send_lsack);
event_add_event(master, ospf6_lsack_send_interface, oi,
0, &oi->thread_send_lsack);
ospf6_lsdb_delete(on->lsupdate_list);
ospf6_lsdb_delete(on->lsack_list);
- EVENT_OFF(on->inactivity_timer);
+ event_cancel(&on->inactivity_timer);
- EVENT_OFF(on->last_dbdesc_release_timer);
+ event_cancel(&on->last_dbdesc_release_timer);
- EVENT_OFF(on->thread_send_dbdesc);
- EVENT_OFF(on->thread_send_lsreq);
- EVENT_OFF(on->thread_send_lsupdate);
- EVENT_OFF(on->thread_send_lsack);
- EVENT_OFF(on->thread_exchange_done);
- EVENT_OFF(on->thread_adj_ok);
- EVENT_OFF(on->event_loading_done);
+ event_cancel(&on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_lsreq);
+ event_cancel(&on->thread_send_lsupdate);
+ event_cancel(&on->thread_send_lsack);
+ event_cancel(&on->thread_exchange_done);
+ event_cancel(&on->thread_adj_ok);
+ event_cancel(&on->event_loading_done);
- EVENT_OFF(on->gr_helper_info.t_grace_timer);
+ event_cancel(&on->gr_helper_info.t_grace_timer);
bfd_sess_free(&on->bfd_session);
XFREE(MTYPE_OSPF6_NEIGHBOR, on);
zlog_debug("Neighbor Event %s: *HelloReceived*", on->name);
/* reset Inactivity Timer */
- EVENT_OFF(on->inactivity_timer);
+ event_cancel(&on->inactivity_timer);
event_add_timer(master, inactivity_timer, on,
on->ospf6_if->dead_interval, &on->inactivity_timer);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
}
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *ExchangeDone*", on->name);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
ospf6_lsdb_remove_all(on->dbdesc_list);
/* RFC 2328 (10.8): Release the last dbdesc after dead_interval */
if (!CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT)) {
- EVENT_OFF(on->last_dbdesc_release_timer);
+ event_cancel(&on->last_dbdesc_release_timer);
event_add_timer(master, ospf6_neighbor_last_dbdesc_release, on,
on->ospf6_if->dead_interval,
&on->last_dbdesc_release_timer);
event_add_event(master, loading_done, on, 0,
&on->event_loading_done);
else if (on->last_ls_req == NULL) {
- EVENT_OFF(on->thread_send_lsreq);
+ event_cancel(&on->thread_send_lsreq);
event_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
}
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
ospf6_neighbor_clear_ls_lists(on);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
event_add_event(master, ospf6_dbdesc_send, on, 0,
ospf6_neighbor_clear_ls_lists(on);
- EVENT_OFF(on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_dbdesc);
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
event_add_event(master, ospf6_dbdesc_send, on, 0,
ospf6_neighbor_clear_ls_lists(on);
- EVENT_OFF(on->thread_send_dbdesc);
- EVENT_OFF(on->thread_send_lsreq);
- EVENT_OFF(on->thread_send_lsupdate);
- EVENT_OFF(on->thread_send_lsack);
- EVENT_OFF(on->thread_exchange_done);
- EVENT_OFF(on->thread_adj_ok);
+ event_cancel(&on->thread_send_dbdesc);
+ event_cancel(&on->thread_send_lsreq);
+ event_cancel(&on->thread_send_lsupdate);
+ event_cancel(&on->thread_send_lsack);
+ event_cancel(&on->thread_exchange_done);
+ event_cancel(&on->thread_adj_ok);
}
void inactivity_timer(struct event *thread)
static void ospf6_if_p2xp_destroy(struct ospf6_if_p2xp_neighcfg *p2xp_cfg)
{
- EVENT_OFF(p2xp_cfg->t_unicast_hello);
+ event_cancel(&p2xp_cfg->t_unicast_hello);
ospf6_if_p2xp_neighcfgs_del(&p2xp_cfg->ospf6_if->p2xp_neighs, p2xp_cfg);
XFREE(MTYPE_OSPF6_NEIGHBOR_P2XP_CFG, p2xp_cfg);
(p2xp_cfg->ospf6_if->state != OSPF6_INTERFACE_POINTTOMULTIPOINT &&
p2xp_cfg->ospf6_if->state != OSPF6_INTERFACE_POINTTOPOINT))
/* state check covers DOWN state too */
- EVENT_OFF(p2xp_cfg->t_unicast_hello);
+ event_cancel(&p2xp_cfg->t_unicast_hello);
else
event_add_timer(master, p2xp_unicast_hello_send, p2xp_cfg,
p2xp_cfg->poll_interval,
route->path.origin.id, o->router_id,
o->lsdb);
if (old) {
- EVENT_OFF(old->refresh);
+ event_cancel(&old->refresh);
event_add_event(master, ospf6_lsa_refresh, old, 0,
&old->refresh);
} else {
lsa)) {
if (IS_OSPF6_DEBUG_NSSA)
ospf6_lsa_header_print(lsa);
- EVENT_OFF(lsa->refresh);
+ event_cancel(&lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa,
0, &lsa->refresh);
}
if (IS_OSPF6_DEBUG_SPF(PROCESS) || IS_OSPF6_DEBUG_SPF(TIME))
zlog_debug("SPF: Rescheduling in %ld msec", delay);
- EVENT_OFF(ospf6->t_spf_calc);
+ event_cancel(&ospf6->t_spf_calc);
event_add_timer_msec(master, ospf6_spf_calculation_thread, ospf6, delay,
&ospf6->t_spf_calc);
}
ospf6_route_remove_all(o->route_table);
ospf6_route_remove_all(o->brouter_table);
- EVENT_OFF(o->maxage_remover);
- EVENT_OFF(o->t_spf_calc);
- EVENT_OFF(o->t_ase_calc);
- EVENT_OFF(o->t_distribute_update);
- EVENT_OFF(o->t_ospf6_receive);
- EVENT_OFF(o->t_external_aggr);
- EVENT_OFF(o->gr_info.t_grace_period);
- EVENT_OFF(o->t_write);
- EVENT_OFF(o->t_abr_task);
+ event_cancel(&o->maxage_remover);
+ event_cancel(&o->t_spf_calc);
+ event_cancel(&o->t_ase_calc);
+ event_cancel(&o->t_distribute_update);
+ event_cancel(&o->t_ospf6_receive);
+ event_cancel(&o->t_external_aggr);
+ event_cancel(&o->gr_info.t_grace_period);
+ event_cancel(&o->t_write);
+ event_cancel(&o->t_abr_task);
}
}
struct listnode *node;
struct ospf *ospf = EVENT_ARG(thread);
- EVENT_OFF(ospf->t_abr_fr);
+ event_cancel(&ospf->t_abr_fr);
if (!IS_OSPF_ABR(ospf))
return;
struct listnode *node;
/* Cancel read and write threads. */
- EVENT_OFF(apiserv->t_sync_read);
+ event_cancel(&apiserv->t_sync_read);
#ifdef USE_ASYNC_READ
- EVENT_OFF(apiserv->t_async_read);
+ event_cancel(&apiserv->t_async_read);
#endif /* USE_ASYNC_READ */
- EVENT_OFF(apiserv->t_sync_write);
- EVENT_OFF(apiserv->t_async_write);
+ event_cancel(&apiserv->t_sync_write);
+ event_cancel(&apiserv->t_async_write);
/* Unregister all opaque types that application registered
and flush opaque LSAs if still in LSDB. */
zlog_debug(
"%s, Restarting Aggregator delay timer.",
__func__);
- EVENT_OFF(ospf->t_external_aggr);
+ event_cancel(&ospf->t_external_aggr);
}
}
struct ospf_lsa_list_entry *ls_rxmt_list_entry;
if (nbr->t_ls_rxmt)
- EVENT_OFF(nbr->t_ls_rxmt);
+ event_cancel(&nbr->t_ls_rxmt);
ls_rxmt_list_entry = ospf_lsa_list_first(&nbr->ls_rxmt_list);
if (ls_rxmt_list_entry) {
zlog_debug("GR: exiting graceful restart: %s", reason);
ospf->gr_info.restart_in_progress = false;
- EVENT_OFF(ospf->gr_info.t_grace_period);
+ event_cancel(&ospf->gr_info.t_grace_period);
for (ALL_LIST_ELEMENTS_RO(ospf->areas, onode, area)) {
struct ospf_interface *oi;
/* Disable hello delay. */
if (oi->gr.hello_delay.t_grace_send) {
oi->gr.hello_delay.elapsed_seconds = 0;
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
OSPF_ISM_TIMER_MSEC_ON(oi->t_hello,
ospf_hello_timer, 1);
}
if (OSPF_GR_IS_ACTIVE_HELPER(restarter)) {
if (restarter->gr_helper_info.t_grace_timer)
- EVENT_OFF(restarter->gr_helper_info.t_grace_timer);
+ event_cancel(&restarter->gr_helper_info.t_grace_timer);
if (ospf->active_restarter_cnt > 0)
ospf->active_restarter_cnt--;
* expiry, stop the grace timer.
*/
if (reason != OSPF_GR_HELPER_GRACE_TIMEOUT)
- EVENT_OFF(nbr->gr_helper_info.t_grace_timer);
+ event_cancel(&nbr->gr_helper_info.t_grace_timer);
/* check exit triggered due to successful completion
* of graceful restart.
/* oi->nbrs and oi->nbr_nbma should be deleted on InterfaceDown event */
/* delete all static neighbors attached to this interface */
for (ALL_LIST_ELEMENTS(oi->nbr_nbma, node, nnode, nbr_nbma)) {
- EVENT_OFF(nbr_nbma->t_poll);
+ event_cancel(&nbr_nbma->t_poll);
if (nbr_nbma->nbr) {
nbr_nbma->nbr->nbr_nbma = NULL;
if (oi->on_write_q) {
listnode_delete(ospf->oi_write_q, oi);
if (list_isempty(ospf->oi_write_q))
- EVENT_OFF(ospf->t_write);
+ event_cancel(&ospf->t_write);
oi->on_write_q = 0;
}
}
ospf_hello_send(oi);
/* Restart hello timer for this interface */
- EVENT_OFF(oi->t_hello);
+ event_cancel(&oi->t_hello);
OSPF_HELLO_TIMER_ON(oi);
}
ospf_hello_send(oi);
/* Restart the hello timer. */
- EVENT_OFF(oi->t_hello);
+ event_cancel(&oi->t_hello);
OSPF_HELLO_TIMER_ON(oi);
}
}
interface parameters must be set to initial values, and
timers are
reset also. */
- EVENT_OFF(oi->t_hello);
- EVENT_OFF(oi->t_wait);
- EVENT_OFF(oi->t_ls_ack_delayed);
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->t_hello);
+ event_cancel(&oi->t_wait);
+ event_cancel(&oi->t_ls_ack_delayed);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
break;
case ISM_Loopback:
/* In this state, the interface may be looped back and will be
unavailable for regular data traffic. */
- EVENT_OFF(oi->t_hello);
- EVENT_OFF(oi->t_wait);
- EVENT_OFF(oi->t_ls_ack_delayed);
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->t_hello);
+ event_cancel(&oi->t_wait);
+ event_cancel(&oi->t_ls_ack_delayed);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
break;
case ISM_Waiting:
/* The router is trying to determine the identity of DRouter and
OSPF_ISM_TIMER_MSEC_ON(oi->t_hello, ospf_hello_timer, 1);
OSPF_ISM_TIMER_ON(oi->t_wait, ospf_wait_timer,
OSPF_IF_PARAM(oi, v_wait));
- EVENT_OFF(oi->t_ls_ack_delayed);
+ event_cancel(&oi->t_ls_ack_delayed);
break;
case ISM_PointToPoint:
/* The interface connects to a physical Point-to-point network
neighboring router. Hello packets are also sent. */
/* send first hello immediately */
OSPF_ISM_TIMER_MSEC_ON(oi->t_hello, ospf_hello_timer, 1);
- EVENT_OFF(oi->t_wait);
+ event_cancel(&oi->t_wait);
break;
case ISM_DROther:
/* The network type of the interface is broadcast or NBMA
and the router itself is neither Designated Router nor
Backup Designated Router. */
OSPF_HELLO_TIMER_ON(oi);
- EVENT_OFF(oi->t_wait);
+ event_cancel(&oi->t_wait);
break;
case ISM_Backup:
/* The network type of the interface is broadcast os NBMA
network,
and the router is Backup Designated Router. */
OSPF_HELLO_TIMER_ON(oi);
- EVENT_OFF(oi->t_wait);
+ event_cancel(&oi->t_wait);
break;
case ISM_DR:
/* The network type of the interface is broadcast or NBMA
network,
and the router is Designated Router. */
OSPF_HELLO_TIMER_ON(oi);
- EVENT_OFF(oi->t_wait);
+ event_cancel(&oi->t_wait);
break;
}
}
if (ldp_sync_info && ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED) {
if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP)
ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_UP;
- EVENT_OFF(ldp_sync_info->t_holddown);
+ event_cancel(&ldp_sync_info->t_holddown);
ospf_if_recalculate_output_cost(ifp);
}
}
if (ldp_sync_info &&
ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED &&
ldp_sync_info->state != LDP_IGP_SYNC_STATE_NOT_REQUIRED) {
- EVENT_OFF(ldp_sync_info->t_holddown);
+ event_cancel(&ldp_sync_info->t_holddown);
ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
ospf_if_recalculate_output_cost(ifp);
}
*/
ols_debug("%s: Removed from if %s", __func__, ifp->name);
- EVENT_OFF(ldp_sync_info->t_holddown);
+ event_cancel(&ldp_sync_info->t_holddown);
ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
ospf_if_recalculate_output_cost(ifp);
UNSET_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_IF_CONFIG);
ldp_sync_info->enabled = LDP_IGP_SYNC_DEFAULT;
ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
- EVENT_OFF(ldp_sync_info->t_holddown);
+ event_cancel(&ldp_sync_info->t_holddown);
ospf_if_recalculate_output_cost(ifp);
return CMD_SUCCESS;
* without conflicting to other threads.
*/
if (ospf->t_maxage != NULL) {
- EVENT_OFF(ospf->t_maxage);
+ event_cancel(&ospf->t_maxage);
event_execute(master, ospf_maxage_lsa_remover, ospf, 0, NULL);
}
static void ospf_config_start(void)
{
- EVENT_OFF(t_ospf_cfg);
+ event_cancel(&t_ospf_cfg);
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("ospfd config start callback received.");
event_add_timer(master, ospf_config_finish, NULL,
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("ospfd config end callback received.");
- EVENT_OFF(t_ospf_cfg);
+ event_cancel(&t_ospf_cfg);
}
/* OSPFd main routine. */
}
/* Cancel all timers. */
- EVENT_OFF(nbr->t_inactivity);
- EVENT_OFF(nbr->t_db_desc);
- EVENT_OFF(nbr->t_ls_req);
- EVENT_OFF(nbr->t_ls_rxmt);
+ event_cancel(&nbr->t_inactivity);
+ event_cancel(&nbr->t_db_desc);
+ event_cancel(&nbr->t_ls_req);
+ event_cancel(&nbr->t_ls_rxmt);
/* Cancel all events. */ /* Thread lookup cost would be negligible. */
event_cancel_event(master, nbr);
bfd_sess_free(&nbr->bfd_session);
- EVENT_OFF(nbr->gr_helper_info.t_grace_timer);
+ event_cancel(&nbr->gr_helper_info.t_grace_timer);
nbr->oi = NULL;
XFREE(MTYPE_OSPF_NEIGHBOR, nbr);
nbr->nbr_nbma = nbr_nbma;
if (nbr_nbma->t_poll)
- EVENT_OFF(nbr_nbma->t_poll);
+ event_cancel(&nbr_nbma->t_poll);
nbr->state_change = nbr_nbma->state_change + 1;
}
switch (nbr->state) {
case NSM_Deleted:
case NSM_Down:
- EVENT_OFF(nbr->t_inactivity);
- EVENT_OFF(nbr->t_hello_reply);
+ event_cancel(&nbr->t_inactivity);
+ event_cancel(&nbr->t_hello_reply);
fallthrough;
case NSM_Attempt:
case NSM_Init:
case NSM_TwoWay:
- EVENT_OFF(nbr->t_db_desc);
- EVENT_OFF(nbr->t_ls_rxmt);
- EVENT_OFF(nbr->t_ls_req);
+ event_cancel(&nbr->t_db_desc);
+ event_cancel(&nbr->t_ls_rxmt);
+ event_cancel(&nbr->t_ls_req);
break;
case NSM_ExStart:
OSPF_NSM_TIMER_ON(nbr->t_db_desc, ospf_db_desc_timer,
nbr->v_db_desc);
- EVENT_OFF(nbr->t_ls_rxmt);
- EVENT_OFF(nbr->t_ls_req);
+ event_cancel(&nbr->t_ls_rxmt);
+ event_cancel(&nbr->t_ls_req);
break;
case NSM_Exchange:
if (!IS_SET_DD_MS(nbr->dd_flags))
- EVENT_OFF(nbr->t_db_desc);
+ event_cancel(&nbr->t_db_desc);
break;
case NSM_Loading:
case NSM_Full:
default:
- EVENT_OFF(nbr->t_db_desc);
+ event_cancel(&nbr->t_db_desc);
break;
}
}
static int nsm_hello_received(struct ospf_neighbor *nbr)
{
/* Start or Restart Inactivity Timer. */
- EVENT_OFF(nbr->t_inactivity);
+ event_cancel(&nbr->t_inactivity);
OSPF_NSM_TIMER_ON(nbr->t_inactivity, ospf_inactivity_timer,
nbr->v_inactivity);
if (OSPF_IF_NON_BROADCAST(nbr->oi) && nbr->nbr_nbma != NULL)
- EVENT_OFF(nbr->nbr_nbma->t_poll);
+ event_cancel(&nbr->nbr_nbma->t_poll);
/* Send proactive ARP requests */
if (nbr->state < NSM_Exchange)
static int nsm_start(struct ospf_neighbor *nbr)
{
if (nbr->nbr_nbma)
- EVENT_OFF(nbr->nbr_nbma->t_poll);
+ event_cancel(&nbr->nbr_nbma->t_poll);
- EVENT_OFF(nbr->t_inactivity);
+ event_cancel(&nbr->t_inactivity);
OSPF_NSM_TIMER_ON(nbr->t_inactivity, ospf_inactivity_timer,
nbr->v_inactivity);
void ospf_opaque_type9_lsa_term(struct ospf_interface *oi)
{
- EVENT_OFF(oi->t_opaque_lsa_self);
+ event_cancel(&oi->t_opaque_lsa_self);
if (oi->opaque_lsa_self != NULL)
list_delete(&oi->opaque_lsa_self);
oi->opaque_lsa_self = NULL;
hook_unregister(ospf_lsa_delete, ospf_opaque_lsa_delete_hook);
ospf_opaque_lsa_hooks_registered = false;
- EVENT_OFF(area->t_opaque_lsa_self);
+ event_cancel(&area->t_opaque_lsa_self);
if (area->opaque_lsa_self != NULL)
list_delete(&area->opaque_lsa_self);
return;
void ospf_opaque_type11_lsa_term(struct ospf *top)
{
- EVENT_OFF(top->t_opaque_lsa_self);
+ event_cancel(&top->t_opaque_lsa_self);
if (top->opaque_lsa_self != NULL)
list_delete(&top->opaque_lsa_self);
return;
ospf_opaque_lsa_flush_schedule(lsa);
}
- EVENT_OFF(oipt->t_opaque_lsa_self);
+ event_cancel(&oipt->t_opaque_lsa_self);
list_delete(&oipt->id_list);
if (cleanup_owner) {
/* Remove from its owner's self-originated LSA list. */
{
struct opaque_info_per_id *oipi = (struct opaque_info_per_id *)val;
- EVENT_OFF(oipi->t_opaque_lsa_self);
+ event_cancel(&oipi->t_opaque_lsa_self);
if (oipi->lsa != NULL)
ospf_lsa_unlock(&oipi->lsa);
XFREE(MTYPE_OPAQUE_INFO_PER_ID, oipi);
void ospf_ls_req_event(struct ospf_neighbor *nbr)
{
- EVENT_OFF(nbr->t_ls_req);
+ event_cancel(&nbr->t_ls_req);
event_add_event(master, ospf_ls_req_timer, nbr, 0, &nbr->t_ls_req);
}
* is actually turned off.
*/
if (list_isempty(oi->ospf->oi_write_q))
- EVENT_OFF(oi->ospf->t_write);
+ event_cancel(&oi->ospf->t_write);
} else {
/* Hook thread to write packet. */
OSPF_ISM_WRITE_ON(oi->ospf);
osr_debug("SR (%s): Stop Segment Routing", __func__);
/* Disable any re-attempt to connect to Label Manager */
- EVENT_OFF(OspfSR.t_start_lm);
+ event_cancel(&OspfSR.t_start_lm);
/* Release SRGB if active */
sr_global_block_delete();
continue;
oi->gr.hello_delay.elapsed_seconds = 0;
- EVENT_OFF(oi->gr.hello_delay.t_grace_send);
+ event_cancel(&oi->gr.hello_delay.t_grace_send);
}
return CMD_SUCCESS;
for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
SET_FLAG(area->stub_router_state,
OSPF_AREA_WAS_START_STUB_ROUTED);
- EVENT_OFF(area->t_stub_router);
+ event_cancel(&area->t_stub_router);
/* Don't trample on admin stub routed */
if (!CHECK_FLAG(area->stub_router_state,
else
ospf->maxage_delay = value;
- EVENT_OFF(ospf->t_maxage);
+ event_cancel(&ospf->t_maxage);
OSPF_TIMER_ON(ospf->t_maxage, ospf_maxage_lsa_remover,
ospf->maxage_delay);
/* Clear static neighbors */
for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
if ((nbr_nbma = rn->info)) {
- EVENT_OFF(nbr_nbma->t_poll);
+ event_cancel(&nbr_nbma->t_poll);
if (nbr_nbma->nbr) {
nbr_nbma->nbr->nbr_nbma = NULL;
}
/* Cancel all timers. */
- EVENT_OFF(ospf->t_read);
- EVENT_OFF(ospf->t_write);
- EVENT_OFF(ospf->t_spf_calc);
- EVENT_OFF(ospf->t_ase_calc);
- EVENT_OFF(ospf->t_maxage);
- EVENT_OFF(ospf->t_maxage_walker);
- EVENT_OFF(ospf->t_deferred_shutdown);
- EVENT_OFF(ospf->t_abr_task);
- EVENT_OFF(ospf->t_abr_fr);
- EVENT_OFF(ospf->t_asbr_check);
- EVENT_OFF(ospf->t_asbr_redist_update);
- EVENT_OFF(ospf->t_distribute_update);
- EVENT_OFF(ospf->t_lsa_refresher);
- EVENT_OFF(ospf->t_opaque_lsa_self);
- EVENT_OFF(ospf->t_sr_update);
- EVENT_OFF(ospf->t_default_routemap_timer);
- EVENT_OFF(ospf->t_external_aggr);
- EVENT_OFF(ospf->gr_info.t_grace_period);
+ event_cancel(&ospf->t_read);
+ event_cancel(&ospf->t_write);
+ event_cancel(&ospf->t_spf_calc);
+ event_cancel(&ospf->t_ase_calc);
+ event_cancel(&ospf->t_maxage);
+ event_cancel(&ospf->t_maxage_walker);
+ event_cancel(&ospf->t_deferred_shutdown);
+ event_cancel(&ospf->t_abr_task);
+ event_cancel(&ospf->t_abr_fr);
+ event_cancel(&ospf->t_asbr_check);
+ event_cancel(&ospf->t_asbr_redist_update);
+ event_cancel(&ospf->t_distribute_update);
+ event_cancel(&ospf->t_lsa_refresher);
+ event_cancel(&ospf->t_opaque_lsa_self);
+ event_cancel(&ospf->t_sr_update);
+ event_cancel(&ospf->t_default_routemap_timer);
+ event_cancel(&ospf->t_external_aggr);
+ event_cancel(&ospf->gr_info.t_grace_period);
route_table_finish(ospf->rt_aggr_tbl);
free(IMPORT_NAME(area));
/* Cancel timer. */
- EVENT_OFF(area->t_stub_router);
- EVENT_OFF(area->t_opaque_lsa_self);
+ event_cancel(&area->t_stub_router);
+ event_cancel(&area->t_opaque_lsa_self);
if (OSPF_IS_AREA_BACKBONE(area))
area->ospf->backbone = NULL;
}
/* remove update event */
- EVENT_OFF(oi->t_ls_upd_event);
+ event_cancel(&oi->t_ls_upd_event);
}
void ospf_if_update(struct ospf *ospf, struct interface *ifp)
- (monotime(NULL) - ospf->lsa_refresher_started);
if (time_left > interval) {
- EVENT_OFF(ospf->t_lsa_refresher);
+ event_cancel(&ospf->t_lsa_refresher);
event_add_timer(master, ospf_lsa_refresh_walker, ospf, interval,
&ospf->t_lsa_refresher);
}
- (monotime(NULL) - ospf->lsa_refresher_started);
if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT) {
- EVENT_OFF(ospf->t_lsa_refresher);
+ event_cancel(&ospf->t_lsa_refresher);
ospf->t_lsa_refresher = NULL;
event_add_timer(master, ospf_lsa_refresh_walker, ospf,
OSPF_LSA_REFRESH_INTERVAL_DEFAULT,
static void ospf_nbr_nbma_down(struct ospf_nbr_nbma *nbr_nbma)
{
- EVENT_OFF(nbr_nbma->t_poll);
+ event_cancel(&nbr_nbma->t_poll);
if (nbr_nbma->nbr) {
nbr_nbma->nbr->nbr_nbma = NULL;
if (nbr_nbma->v_poll != interval) {
nbr_nbma->v_poll = interval;
if (nbr_nbma->oi && ospf_if_is_up(nbr_nbma->oi)) {
- EVENT_OFF(nbr_nbma->t_poll);
+ event_cancel(&nbr_nbma->t_poll);
OSPF_POLL_TIMER_ON(nbr_nbma->t_poll, ospf_poll_timer,
nbr_nbma->v_poll);
}
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("%s: ospf old_vrf_id %d unlinked", __func__,
old_vrf_id);
- EVENT_OFF(ospf->t_read);
+ event_cancel(&ospf->t_read);
close(ospf->fd);
ospf->fd = -1;
}
pim_embedded_rp_delete(sg->iface->pim, &sg->sgaddr.grp);
/* t_sg_expiry is handled before this is reached */
- EVENT_OFF(sg->t_sg_query);
+ event_cancel(&sg->t_sg_query);
gm_packet_sg_subs_fini(sg->subs_negative);
gm_packet_sg_subs_fini(sg->subs_positive);
XFREE(MTYPE_GM_SG, sg);
gm_sg_timer_start(gm_ifp, sg, timers.expire_wait);
- EVENT_OFF(sg->t_sg_query);
+ event_cancel(&sg->t_sg_query);
sg->query_sbit = false;
/* Trigger the specific queries only for querier. */
if (!pim_ifp->gmp_immediate_leave &&
* another path.
*/
if (has_expired)
- EVENT_OFF(sg->t_sg_expire);
+ event_cancel(&sg->t_sg_expire);
assertf((!sg->t_sg_expire &&
!gm_packet_sg_subs_count(sg->subs_positive) &&
{
if (sg->t_sg_expire && PIM_DEBUG_GM_TRACE)
zlog_debug(log_sg(sg, "alive, cancelling expiry timer"));
- EVENT_OFF(sg->t_sg_expire);
+ event_cancel(&sg->t_sg_expire);
sg->query_sbit = true;
}
gm_ifp->n_pending--;
if (!gm_ifp->n_pending)
- EVENT_OFF(gm_ifp->t_expire);
+ event_cancel(&gm_ifp->t_expire);
}
/* people might be messing with their configs or something */
if (timercmp(&remain, &expire_wait, <=))
return;
- EVENT_OFF(sg->t_sg_expire);
+ event_cancel(&sg->t_sg_expire);
}
event_add_timer_tv(router->master, gm_t_sg_expire, sg, &expire_wait,
* parallel. But if we received nothing for the *,G query,
* the S,G query is kinda irrelevant.
*/
- EVENT_OFF(sg->t_sg_expire);
+ event_cancel(&sg->t_sg_expire);
frr_each_safe (gm_packet_sg_subs, sg->subs_positive, item)
/* this will also drop the EXCLUDE S,G lists */
if (timercmp(&remain, &timers->expire_wait, <=))
return;
- EVENT_OFF(pend->t_expire);
+ event_cancel(&pend->t_expire);
} else {
pend = XCALLOC(MTYPE_GM_GRP_PENDING, sizeof(*pend));
pend->grp = grp;
{
struct pim_interface *pim_ifp = gm_ifp->ifp->info;
- EVENT_OFF(gm_ifp->t_query);
+ event_cancel(&gm_ifp->t_query);
if (pim_addr_is_any(pim_ifp->ll_lowest))
return;
if (IPV6_ADDR_CMP(&pkt_src->sin6_addr, &pim_ifp->ll_lowest) < 0) {
unsigned int other_ms;
- EVENT_OFF(gm_ifp->t_query);
- EVENT_OFF(gm_ifp->t_other_querier);
+ event_cancel(&gm_ifp->t_query);
+ event_cancel(&gm_ifp->t_other_querier);
other_ms = timers.qrv * timers.qqic_ms + timers.max_resp_ms / 2;
event_add_timer_msec(router->master, gm_t_other_querier, gm_ifp,
pend_gsq->n_src++;
if (pend_gsq->n_src == array_size(pend_gsq->srcs)) {
- EVENT_OFF(pend_gsq->t_send);
+ event_cancel(&pend_gsq->t_send);
gm_send_specific(pend_gsq);
pend_gsq = NULL;
}
if (--pim->gm_socket_if_count)
return;
- EVENT_OFF(pim->t_gm_recv);
+ event_cancel(&pim->t_gm_recv);
close(pim->gm_socket);
pim->gm_socket = -1;
}
gm_packet_drop(pkt, false);
while ((pend_grp = gm_grp_pends_pop(gm_ifp->grp_pends))) {
- EVENT_OFF(pend_grp->t_expire);
+ event_cancel(&pend_grp->t_expire);
XFREE(MTYPE_GM_GRP_PENDING, pend_grp);
}
while ((pend_gsq = gm_gsq_pends_pop(gm_ifp->gsq_pends))) {
- EVENT_OFF(pend_gsq->t_send);
+ event_cancel(&pend_gsq->t_send);
XFREE(MTYPE_GM_GSQ_PENDING, pend_gsq);
}
while ((sg = gm_sgs_pop(gm_ifp->sgs))) {
- EVENT_OFF(sg->t_sg_expire);
+ event_cancel(&sg->t_sg_expire);
assertf(!gm_packet_sg_subs_count(sg->subs_negative), "%pSG",
&sg->sgaddr);
assertf(!gm_packet_sg_subs_count(sg->subs_positive), "%pSG",
if (PIM_DEBUG_GM_EVENTS)
zlog_debug(log_ifp("MLD stop"));
- EVENT_OFF(gm_ifp->t_query);
- EVENT_OFF(gm_ifp->t_other_querier);
- EVENT_OFF(gm_ifp->t_expire);
+ event_cancel(&gm_ifp->t_query);
+ event_cancel(&gm_ifp->t_other_querier);
+ event_cancel(&gm_ifp->t_expire);
frr_with_privs (&pimd_privs) {
struct ipv6_mreq mreq;
gm_ifp->cur_ll_lowest = pim_ifp->ll_lowest;
if (was_querier)
gm_ifp->querier = pim_ifp->ll_lowest;
- EVENT_OFF(gm_ifp->t_query);
+ event_cancel(&gm_ifp->t_query);
if (pim_addr_is_any(gm_ifp->cur_ll_lowest)) {
if (was_querier)
__func__, ch->sg_str, ch->interface->name);
}
}
- EVENT_OFF(ch->t_ifassert_timer);
+ event_cancel(&ch->t_ifassert_timer);
}
static void pim_assert_timer_set(struct pim_ifchannel *ch, int interval)
static void pim_bsm_rpinfo_free(struct bsm_rpinfo *bsrp_info)
{
- EVENT_OFF(bsrp_info->g2rp_timer);
+ event_cancel(&bsrp_info->g2rp_timer);
XFREE(MTYPE_PIM_BSRP_INFO, bsrp_info);
}
struct bsm_scope *scope;
scope = EVENT_ARG(t);
- EVENT_OFF(scope->bs_timer);
+ event_cancel(&scope->bs_timer);
if (PIM_DEBUG_BSM)
zlog_debug("%s: Bootstrap Timer expired for scope: %d",
struct bsgrp_node *bsgrp_node;
struct bsm_rpinfo *bsrp;
- EVENT_OFF(scope->t_ebsr_regen_bsm);
+ event_cancel(&scope->t_ebsr_regen_bsm);
/* Reset scope zone data */
scope->state = ACCEPT_ANY;
if (PIM_DEBUG_BSM)
zlog_debug("%s : BS timer being stopped of sz: %d", __func__,
scope->sz_id);
- EVENT_OFF(scope->bs_timer);
+ event_cancel(&scope->bs_timer);
}
static void pim_bs_timer_start(struct bsm_scope *scope, int bs_timeout)
zlog_debug("%s : Invalid scope(NULL).", __func__);
return;
}
- EVENT_OFF(scope->bs_timer);
+ event_cancel(&scope->bs_timer);
if (PIM_DEBUG_BSM)
zlog_debug(
"%s : starting bs timer for scope %d with timeout %d secs",
struct bsgrp_node *bsgrp;
struct cand_rp_group *crpgrp;
- EVENT_OFF(scope->unicast_read);
+ event_cancel(&scope->unicast_read);
close(scope->unicast_sock);
pim_bs_timer_stop(scope);
pim_addr bsrp_addr;
bsrp = EVENT_ARG(t);
- EVENT_OFF(bsrp->g2rp_timer);
+ event_cancel(&bsrp->g2rp_timer);
bsgrp_node = bsrp->bsgrp_node;
pim = bsgrp_node->scope->pim;
bsrp_addr = bsrp->rp_address;
zlog_debug("%s : Invalid brsp(NULL).", __func__);
return;
}
- EVENT_OFF(bsrp->g2rp_timer);
+ event_cancel(&bsrp->g2rp_timer);
if (PIM_DEBUG_BSM)
zlog_debug(
"%s : starting g2rp timer for grp: %pFX - rp: %pPAs with timeout %d secs(Actual Hold time : %d secs)",
__func__, &bsrp->bsgrp_node->group,
&bsrp->rp_address);
- EVENT_OFF(bsrp->g2rp_timer);
+ event_cancel(&bsrp->g2rp_timer);
}
static bool is_hold_time_zero(void *data)
break;
}
- EVENT_OFF(pim->global_scope.t_ebsr_regen_bsm);
+ event_cancel(&pim->global_scope.t_ebsr_regen_bsm);
if (pim->global_scope.state == BSR_ELECTED)
pim_crp_db_clear(&pim->global_scope);
struct rp_info *rp_info;
bool upstream_updated = false;
- EVENT_OFF(pim->global_scope.t_ebsr_regen_bsm);
+ event_cancel(&pim->global_scope.t_ebsr_regen_bsm);
if (pim->global_scope.state == BSR_ELECTED)
pim_crp_db_clear(&pim->global_scope);
{
struct event t;
- EVENT_OFF(scope->bs_timer);
+ event_cancel(&scope->bs_timer);
scope->changed_bsm_trigger = 2;
t.arg = scope;
pim_addr best_addr;
float prio_delay, addr_delay;
- EVENT_OFF(scope->bs_timer);
- EVENT_OFF(scope->t_ebsr_regen_bsm);
+ event_cancel(&scope->bs_timer);
+ event_cancel(&scope->t_ebsr_regen_bsm);
scope->state = BSR_PENDING;
best_prio = MAX(scope->cand_bsr_prio, scope->current_bsr_prio);
if (PIM_DEBUG_BSM)
zlog_debug("Candidate BSR ceasing operation");
- EVENT_OFF(scope->t_ebsr_regen_bsm);
- EVENT_OFF(scope->bs_timer);
+ event_cancel(&scope->t_ebsr_regen_bsm);
+ event_cancel(&scope->bs_timer);
pim_crp_db_clear(scope);
pim_bsm_accept_any(scope);
}
return;
}
- EVENT_OFF(scope->cand_rp_adv_timer);
+ event_cancel(&scope->cand_rp_adv_timer);
if (!scope->cand_rp_addrsel.run)
return;
zlog_debug("Candidate RP ceasing operation");
cand_addrsel_clear(&scope->cand_rp_addrsel);
- EVENT_OFF(scope->cand_rp_adv_timer);
+ event_cancel(&scope->cand_rp_adv_timer);
pim_cand_rp_adv_stop_maybe(scope);
scope->cand_rp_adv_trigger = 0;
return;
void pim_cand_addrs_changed(void)
{
- EVENT_OFF(t_cand_addrs_reapply);
+ event_cancel(&t_cand_addrs_reapply);
event_add_timer_msec(router->master, pim_cand_addrs_reapply, NULL, 1,
&t_cand_addrs_reapply);
}
static void pim_crp_free(struct pim_instance *pim, struct bsr_crp_rp *rp)
{
- EVENT_OFF(rp->t_hold);
+ event_cancel(&rp->t_hold);
pim_nht_candrp_del(pim, rp->addr);
bsr_crp_rp_groups_fini(rp->groups);
rp->seen_last = monotime(NULL);
rp->holdtime = ntohs(crp_hdr->rp_holdtime);
- EVENT_OFF(rp->t_hold);
+ event_cancel(&rp->t_hold);
event_add_timer(router->master, pim_crp_expire, rp,
ntohs(crp_hdr->rp_holdtime), &rp->t_hold);
ch->upstream = NULL;
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
- EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
- EVENT_OFF(ch->t_ifassert_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_prune_pending_timer);
+ event_cancel(&ch->t_ifassert_timer);
if (ch->parent) {
listnode_delete(ch->parent->sources, ch);
*/
void reset_ifassert_state(struct pim_ifchannel *ch)
{
- EVENT_OFF(ch->t_ifassert_timer);
+ event_cancel(&ch->t_ifassert_timer);
pim_ifassert_winner_set(ch, PIM_IFASSERT_NOINFO, PIMADDR_ANY,
router->infinite_assert_metric);
return;
}
}
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
break;
case PIM_IFJOIN_PRUNE:
if (source_flags & PIM_ENCODE_RPT_BIT) {
pim_ifchannel_ifjoin_switch(__func__, ch,
PIM_IFJOIN_NOINFO);
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
delete_on_noinfo(ch);
return;
} else
* maximum of its current value and the HoldTime from the
* triggering Join/Prune message.
*/
- EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
+ event_cancel(&ch->t_ifjoin_prune_pending_timer);
/* Check if SGRpt join Received */
if ((source_flags & PIM_ENCODE_RPT_BIT) &&
* I transitions to the NoInfo state.The ET and PPT are
* cancelled.
*/
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
pim_ifchannel_ifjoin_switch(__func__, ch,
PIM_IFJOIN_NOINFO);
return;
if (remain > holdtime)
return;
}
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
break;
case PIM_IFJOIN_PRUNE_TMP:
be taken not to use "ch" afterwards since it would be
deleted. */
- EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_prune_pending_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
event_add_timer_msec(router->master,
on_ifjoin_prune_pending_timer, ch,
jp_override_interval_msec,
/* If we called ifjoin_prune() directly instead, care should
be taken not to use "ch" afterwards since it would be
deleted. */
- EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
+ event_cancel(&ch->t_ifjoin_prune_pending_timer);
event_add_timer_msec(router->master,
on_ifjoin_prune_pending_timer, ch,
jp_override_interval_msec,
break;
case PIM_IFJOIN_PRUNE:
if (source_flags & PIM_ENCODE_RPT_BIT) {
- EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
+ event_cancel(&ch->t_ifjoin_prune_pending_timer);
/*
* While in Prune State, Receive SGRpt Prune.
* RFC 7761 Sec 4.5.3:
if (rem > holdtime)
return;
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
}
event_add_timer(router->master, on_ifjoin_expiry_timer,
case PIM_IFJOIN_PRUNE_TMP:
if (source_flags & PIM_ENCODE_RPT_BIT) {
ch->ifjoin_state = PIM_IFJOIN_PRUNE;
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
event_add_timer(router->master, on_ifjoin_expiry_timer,
ch, holdtime,
&ch->t_ifjoin_expiry_timer);
case PIM_IFJOIN_PRUNE_PENDING_TMP:
if (source_flags & PIM_ENCODE_RPT_BIT) {
ch->ifjoin_state = PIM_IFJOIN_PRUNE_PENDING;
- EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ event_cancel(&ch->t_ifjoin_expiry_timer);
event_add_timer(router->master, on_ifjoin_expiry_timer,
ch, holdtime,
&ch->t_ifjoin_expiry_timer);
break;
if (child->ifjoin_state == PIM_IFJOIN_PRUNE_PENDING_TMP)
- EVENT_OFF(child->t_ifjoin_prune_pending_timer);
- EVENT_OFF(child->t_ifjoin_expiry_timer);
+ event_cancel(&child->t_ifjoin_prune_pending_timer);
+ event_cancel(&child->t_ifjoin_expiry_timer);
PIM_IF_FLAG_UNSET_S_G_RPT(child->flags);
child->ifjoin_state = PIM_IFJOIN_NOINFO;
"Querier %s resetting TIMER event for Other-Querier-Present",
ifaddr_str);
}
- EVENT_OFF(igmp->t_other_querier_timer);
+ event_cancel(&igmp->t_other_querier_timer);
} else {
/*
We are the current querier, then stop sending general queries:
ifaddr_str, igmp->fd, igmp->interface->name);
}
}
- EVENT_OFF(igmp->t_other_querier_timer);
+ event_cancel(&igmp->t_other_querier_timer);
}
int igmp_validate_checksum(char *igmp_msg, int igmp_msg_len)
ifaddr_str, igmp->fd, igmp->interface->name);
}
}
- EVENT_OFF(igmp->t_igmp_query_timer);
+ event_cancel(&igmp->t_igmp_query_timer);
}
/* Issue IGMP general query */
igmp->interface->name);
}
}
- EVENT_OFF(igmp->t_igmp_read);
+ event_cancel(&igmp->t_igmp_read);
if (close(igmp->fd)) {
flog_err(
igmp_source_delete(src);
}
- EVENT_OFF(group->t_group_query_retransmit_timer);
+ event_cancel(&group->t_group_query_retransmit_timer);
group_timer_off(group);
igmp_group_count_decr(pim_ifp);
zlog_debug("Cancelling TIMER event for group %s on %s",
group_str, group->interface->name);
}
- EVENT_OFF(group->t_group_timer);
+ event_cancel(&group->t_group_timer);
}
void igmp_group_timer_on(struct gm_group *group, long interval_msec,
group_str, source_str, group->interface->name);
}
- EVENT_OFF(source->t_source_timer);
+ event_cancel(&source->t_source_timer);
}
static void igmp_source_timer_on(struct gm_group *group,
if (PIM_IF_FLAG_TEST_S_G_RPT(child->flags)) {
if (child->ifjoin_state
== PIM_IFJOIN_PRUNE_PENDING_TMP)
- EVENT_OFF(
+ event_cancel(&
child->t_ifjoin_prune_pending_timer);
- EVENT_OFF(child->t_ifjoin_expiry_timer);
+ event_cancel(&child->t_ifjoin_expiry_timer);
PIM_IF_FLAG_UNSET_S_G_RPT(child->flags);
child->ifjoin_state = PIM_IFJOIN_NOINFO;
delete_on_noinfo(child);
static void mroute_read_off(struct pim_instance *pim)
{
- EVENT_OFF(pim->thread);
+ event_cancel(&pim->thread);
}
int pim_mroute_socket_enable(struct pim_instance *pim)
static void pim_msdp_sa_adv_timer_setup(struct pim_instance *pim, bool start)
{
- EVENT_OFF(pim->msdp.sa_adv_timer);
+ event_cancel(&pim->msdp.sa_adv_timer);
if (start) {
event_add_timer(pim->msdp.master, pim_msdp_sa_adv_timer_cb, pim,
PIM_MSDP_SA_ADVERTISMENT_TIME,
static void pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
{
- EVENT_OFF(sa->sa_state_timer);
+ event_cancel(&sa->sa_state_timer);
if (start) {
event_add_timer(sa->pim->msdp.master,
pim_msdp_sa_state_timer_cb, sa,
static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
{
struct pim_instance *pim = mp->pim;
- EVENT_OFF(mp->hold_timer);
+ event_cancel(&mp->hold_timer);
if (start) {
event_add_timer(pim->msdp.master, pim_msdp_peer_hold_timer_cb,
mp, pim->msdp.hold_time, &mp->hold_timer);
static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
{
- EVENT_OFF(mp->ka_timer);
+ event_cancel(&mp->ka_timer);
if (start) {
event_add_timer(mp->pim->msdp.master, pim_msdp_peer_ka_timer_cb,
mp, mp->pim->msdp.keep_alive, &mp->ka_timer);
static void pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
{
- EVENT_OFF(mp->cr_timer);
+ event_cancel(&mp->cr_timer);
if (start) {
event_add_timer(mp->pim->msdp.master, pim_msdp_peer_cr_timer_cb,
mp, mp->pim->msdp.connection_retry,
void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)
{
- EVENT_OFF(up->t_msdp_reg_timer);
+ event_cancel(&up->t_msdp_reg_timer);
event_add_timer(router->master, pim_upstream_msdp_reg_timer, up, PIM_MSDP_REG_RXED_PERIOD,
&up->t_msdp_reg_timer);
{
neigh->holdtime = holdtime;
- EVENT_OFF(neigh->t_expire_timer);
+ event_cancel(&neigh->t_expire_timer);
/*
0xFFFF is request for no holdtime
static void pim_neighbor_start_jp_timer(struct pim_neighbor *neigh)
{
- EVENT_OFF(neigh->jp_timer);
+ event_cancel(&neigh->jp_timer);
event_add_timer(router->master, on_neighbor_jp_timer, neigh,
router->t_periodic, &neigh->jp_timer);
}
delete_prefix_list(neigh);
list_delete(&neigh->upstream_jp_agg);
- EVENT_OFF(neigh->jp_timer);
+ event_cancel(&neigh->jp_timer);
bfd_sess_free(&neigh->bfd_session);
zlog_notice("PIM NEIGHBOR DOWN: neighbor %pPA on interface %s: %s",
&neigh->source_addr, ifp->name, delete_message);
- EVENT_OFF(neigh->t_expire_timer);
+ event_cancel(&neigh->t_expire_timer);
pim_if_assert_on_neighbor_down(ifp, neigh->source_addr);
if (*oil_incoming_vif(c_oil) != pim_ifp->mroute_vif_index)
continue;
- EVENT_OFF(c_oil->up->t_ka_timer);
+ event_cancel(&c_oil->up->t_ka_timer);
PIM_UPSTREAM_FLAG_UNSET_SRC_NOCACHE(c_oil->up->flags);
PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(c_oil->up->flags);
pim_upstream_del(pim_ifp->pim, c_oil->up, __func__);
pim_ifp->pim_sock_fd, ifp->name);
}
}
- EVENT_OFF(pim_ifp->t_pim_sock_read);
+ event_cancel(&pim_ifp->t_pim_sock_read);
if (PIM_DEBUG_PIM_TRACE) {
if (pim_ifp->t_pim_hello_timer) {
ifp->name);
}
}
- EVENT_OFF(pim_ifp->t_pim_hello_timer);
+ event_cancel(&pim_ifp->t_pim_hello_timer);
if (PIM_DEBUG_PIM_TRACE) {
zlog_debug("Deleting PIM socket fd=%d on interface %s",
zlog_debug("Rescheduling %d sec hello on interface %s",
pim_ifp->pim_hello_period, ifp->name);
}
- EVENT_OFF(pim_ifp->t_pim_hello_timer);
+ event_cancel(&pim_ifp->t_pim_hello_timer);
event_add_timer(router->master, on_pim_hello_send, ifp,
pim_ifp->pim_hello_period, &pim_ifp->t_pim_hello_timer);
}
return;
}
- EVENT_OFF(pim_ifp->t_pim_hello_timer);
+ event_cancel(&pim_ifp->t_pim_hello_timer);
}
random_msec = triggered_hello_delay_msec;
&& (up->reg_state != PIM_REG_NOINFO)) {
pim_channel_del_oif(up->channel_oil, pim->regiface,
PIM_OIF_FLAG_PROTO_PIM, __func__);
- EVENT_OFF(up->t_rs_timer);
+ event_cancel(&up->t_rs_timer);
up->reg_state = PIM_REG_NOINFO;
PIM_UPSTREAM_FLAG_UNSET_FHR(up->flags);
}
{
assert(ss);
- EVENT_OFF(ss->t_sock_read);
+ event_cancel(&ss->t_sock_read);
if (close(ss->sock_fd)) {
zlog_warn(
static void pim_upstream_timers_stop(struct pim_upstream *up)
{
- EVENT_OFF(up->t_ka_timer);
- EVENT_OFF(up->t_rs_timer);
- EVENT_OFF(up->t_msdp_reg_timer);
- EVENT_OFF(up->t_join_timer);
+ event_cancel(&up->t_ka_timer);
+ event_cancel(&up->t_rs_timer);
+ event_cancel(&up->t_msdp_reg_timer);
+ event_cancel(&up->t_join_timer);
}
struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
{
struct pim_neighbor *nbr = NULL;
- EVENT_OFF(up->t_join_timer);
+ event_cancel(&up->t_join_timer);
if (up->rpf.source_nexthop.interface)
nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
if (nbr)
pim_jp_agg_add_group(nbr->upstream_jp_agg, up, 1, nbr);
else {
- EVENT_OFF(up->t_join_timer);
+ event_cancel(&up->t_join_timer);
event_add_timer(router->master, on_join_timer, up,
router->t_periodic, &up->t_join_timer);
}
void pim_upstream_join_timer_restart(struct pim_upstream *up,
struct pim_rpf *old)
{
- // EVENT_OFF(up->t_join_timer);
+ // event_cancel(&up->t_join_timer);
join_timer_start(up);
}
__func__, interval_msec, up->sg_str);
}
- EVENT_OFF(up->t_join_timer);
+ event_cancel(&up->t_join_timer);
event_add_timer_msec(router->master, on_join_timer, up, interval_msec,
&up->t_join_timer);
}
up->sg_str);
/* stop reg-stop timer */
- EVENT_OFF(up->t_rs_timer);
+ event_cancel(&up->t_rs_timer);
/* remove regiface from the OIL if it is there*/
pim_channel_del_oif(up->channel_oil, pim->regiface,
PIM_OIF_FLAG_PROTO_PIM, __func__);
zlog_debug("kat start on %s with no stream reference",
up->sg_str);
}
- EVENT_OFF(up->t_ka_timer);
+ event_cancel(&up->t_ka_timer);
event_add_timer(router->master, pim_upstream_keep_alive_timer, up, time,
&up->t_ka_timer);
{
uint32_t time;
- EVENT_OFF(up->t_rs_timer);
+ event_cancel(&up->t_rs_timer);
time = router->register_probe_time;
{
uint32_t time;
- EVENT_OFF(up->t_rs_timer);
+ event_cancel(&up->t_rs_timer);
uint32_t lower = (0.5 * router->register_suppress_time);
uint32_t upper = (1.5 * router->register_suppress_time);
zlog_debug("Received Register stop for %s",
vxlan_sg->sg_str);
- EVENT_OFF(vxlan_sg->null_register);
+ event_cancel(&vxlan_sg->null_register);
pim_vxlan_del_work(vxlan_sg);
}
}
/* global 1second timer used for periodic processing */
static void pim_vxlan_work_timer_setup(bool start)
{
- EVENT_OFF(vxlan_info.work_timer);
+ event_cancel(&vxlan_info.work_timer);
if (start)
event_add_timer(router->master, pim_vxlan_work_timer_cb, NULL,
PIM_VXLAN_WORK_TIME, &vxlan_info.work_timer);
* if there are no other references.
*/
if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
- EVENT_OFF(up->t_ka_timer);
+ event_cancel(&up->t_ka_timer);
up = pim_upstream_keep_alive_timer_proc(up);
} else {
/* this is really unexpected as we force vxlan
{
vxlan_sg->flags |= PIM_VXLAN_SGF_DEL_IN_PROG;
- EVENT_OFF(vxlan_sg->null_register);
+ event_cancel(&vxlan_sg->null_register);
pim_vxlan_del_work(vxlan_sg);
if (pim_vxlan_is_orig_mroute(vxlan_sg))
void zclient_lookup_free(void)
{
- EVENT_OFF(zlookup_read);
+ event_cancel(&zlookup_read);
zclient_stop(pim_zlookup);
zclient_free(pim_zlookup);
pim_zlookup = NULL;
ri->enable_interface = 0;
ri->running = 0;
- EVENT_OFF(ri->t_wakeup);
+ event_cancel(&ri->t_wakeup);
}
void rip_interfaces_clean(struct rip *rip)
ri = ifp->info;
- EVENT_OFF(ri->t_wakeup);
+ event_cancel(&ri->t_wakeup);
rip = ri->rip;
if (rip) {
}
if (rinfo) {
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
rip_info_free(rinfo);
}
void rip_peer_free(struct rip_peer *peer)
{
bfd_sess_free(&peer->bfd_session);
- EVENT_OFF(peer->t_timeout);
+ event_cancel(&peer->t_timeout);
XFREE(MTYPE_RIP_PEER, peer);
}
peer = rip_peer_lookup(rip, addr);
if (peer) {
- EVENT_OFF(peer->t_timeout);
+ event_cancel(&peer->t_timeout);
} else {
peer = rip_peer_new();
peer->rip = rip;
continue;
if (listcount(list) == 1) {
- EVENT_OFF(route_entry->t_timeout);
- EVENT_OFF(route_entry->t_garbage_collect);
+ event_cancel(&route_entry->t_timeout);
+ event_cancel(&route_entry->t_garbage_collect);
listnode_delete(list, route_entry);
if (list_isempty(list)) {
list_delete((struct list **)&route_node
rinfo = EVENT_ARG(t);
/* Off timeout timer. */
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
/* Get route_node pointer. */
rp = rinfo->rp;
if (tmp_rinfo == rinfo)
continue;
- EVENT_OFF(tmp_rinfo->t_timeout);
- EVENT_OFF(tmp_rinfo->t_garbage_collect);
+ event_cancel(&tmp_rinfo->t_timeout);
+ event_cancel(&tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
rip_info_free(tmp_rinfo);
}
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
memcpy(rinfo, rinfo_new, sizeof(struct rip_info));
if (rip_route_rte(rinfo)) {
rp = rinfo->rp;
list = (struct list *)rp->info;
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
if (listcount(list) > 1) {
/* Some other ECMP entries still exist. Just delete this entry.
*/
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
if (rip_route_rte(rinfo)
&& CHECK_FLAG(rinfo->flags, RIP_RTF_FIB))
static void rip_timeout_update(struct rip *rip, struct rip_info *rinfo)
{
if (rinfo->metric != RIP_METRIC_INFINITY) {
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
event_add_timer(master, rip_timeout, rinfo, rip->timeout_time,
&rinfo->t_timeout);
}
assert(newinfo.metric
!= RIP_METRIC_INFINITY);
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
memcpy(rinfo, &newinfo,
sizeof(struct rip_info));
rip_timeout_update(rip, rinfo);
RIP_TIMER_ON(rinfo->t_garbage_collect,
rip_garbage_collect,
rip->garbage_time);
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
rinfo->flags |= RIP_RTF_CHANGED;
if (IS_RIP_DEBUG_EVENT)
/* Triggered updates may be suppressed if a regular update is due by
the time the triggered update would be sent. */
- EVENT_OFF(rip->t_triggered_interval);
+ event_cancel(&rip->t_triggered_interval);
rip->trigger = 0;
/* Register myself. */
int interval;
/* Cancel interval timer. */
- EVENT_OFF(rip->t_triggered_interval);
+ event_cancel(&rip->t_triggered_interval);
rip->trigger = 0;
/* Logging triggered update. */
rinfo->metric = RIP_METRIC_INFINITY;
RIP_TIMER_ON(rinfo->t_garbage_collect, rip_garbage_collect,
rip->garbage_time);
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
rinfo->flags |= RIP_RTF_CHANGED;
if (IS_RIP_DEBUG_EVENT) {
event_add_read(master, rip_read, rip, sock, &rip->t_read);
break;
case RIP_UPDATE_EVENT:
- EVENT_OFF(rip->t_update);
+ event_cancel(&rip->t_update);
jitter = rip_update_jitter(rip->update_time);
event_add_timer(master, rip_update, rip,
sock ? 2 : rip->update_time + jitter,
if (tmp_rinfo == rinfo)
continue;
- EVENT_OFF(tmp_rinfo->t_timeout);
- EVENT_OFF(tmp_rinfo->t_garbage_collect);
+ event_cancel(&tmp_rinfo->t_timeout);
+ event_cancel(&tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
rip_info_free(tmp_rinfo);
}
rip_zebra_ipv4_delete(rip, rp);
for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
rip_info_free(rinfo);
}
list_delete(&list);
rip_redistribute_disable(rip);
/* Cancel RIP related timers. */
- EVENT_OFF(rip->t_update);
- EVENT_OFF(rip->t_triggered_update);
- EVENT_OFF(rip->t_triggered_interval);
+ event_cancel(&rip->t_update);
+ event_cancel(&rip->t_triggered_update);
+ event_cancel(&rip->t_triggered_interval);
/* Cancel read thread. */
- EVENT_OFF(rip->t_read);
+ event_cancel(&rip->t_read);
/* Close RIP socket. */
close(rip->sock);
ri = ifp->info;
- EVENT_OFF(ri->t_wakeup);
+ event_cancel(&ri->t_wakeup);
ripng = ri->ripng;
ri->enable_interface = 0;
ri->running = 0;
- EVENT_OFF(ri->t_wakeup);
+ event_cancel(&ri->t_wakeup);
}
}
}
if (rinfo) {
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
ripng_info_free(rinfo);
}
static void ripng_peer_free(struct ripng_peer *peer)
{
- EVENT_OFF(peer->t_timeout);
+ event_cancel(&peer->t_timeout);
XFREE(MTYPE_RIPNG_PEER, peer);
}
peer = ripng_peer_lookup(ripng, addr);
if (peer) {
- EVENT_OFF(peer->t_timeout);
+ event_cancel(&peer->t_timeout);
} else {
peer = ripng_peer_new();
peer->ripng = ripng;
rinfo = EVENT_ARG(t);
/* Off timeout timer. */
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
/* Get route_node pointer. */
rp = rinfo->rp;
/* Re-use the first entry, and delete the others. */
for (ALL_LIST_ELEMENTS(list, node, nextnode, tmp_rinfo))
if (tmp_rinfo != rinfo) {
- EVENT_OFF(tmp_rinfo->t_timeout);
- EVENT_OFF(tmp_rinfo->t_garbage_collect);
+ event_cancel(&tmp_rinfo->t_timeout);
+ event_cancel(&tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
ripng_info_free(tmp_rinfo);
}
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
memcpy(rinfo, rinfo_new, sizeof(struct ripng_info));
if (ripng_route_rte(rinfo)) {
struct agg_node *rp = rinfo->rp;
struct list *list = (struct list *)rp->info;
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
if (rinfo->metric != RIPNG_METRIC_INFINITY)
ripng_aggregate_decrement(rp, rinfo);
if (listcount(list) > 1) {
/* Some other ECMP entries still exist. Just delete this entry.
*/
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
if (ripng_route_rte(rinfo) &&
CHECK_FLAG(rinfo->flags, RIPNG_RTF_FIB))
static void ripng_timeout_update(struct ripng *ripng, struct ripng_info *rinfo)
{
if (rinfo->metric != RIPNG_METRIC_INFINITY) {
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
event_add_timer(master, ripng_timeout, rinfo,
ripng->timeout_time, &rinfo->t_timeout);
}
RIPNG_TIMER_ON(rinfo->t_garbage_collect,
ripng_garbage_collect,
ripng->garbage_time);
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
/* Aggregate count decrement. */
ripng_aggregate_decrement(rp, rinfo);
RIPNG_TIMER_ON(rinfo->t_garbage_collect,
ripng_garbage_collect,
ripng->garbage_time);
- EVENT_OFF(rinfo->t_timeout);
+ event_cancel(&rinfo->t_timeout);
/* Aggregate count decrement. */
ripng_aggregate_decrement(rp, rinfo);
/* Triggered updates may be suppressed if a regular update is due by
the time the triggered update would be sent. */
- EVENT_OFF(ripng->t_triggered_interval);
+ event_cancel(&ripng->t_triggered_interval);
ripng->trigger = 0;
/* Reset flush event. */
int interval;
/* Cancel interval timer. */
- EVENT_OFF(ripng->t_triggered_interval);
+ event_cancel(&ripng->t_triggered_interval);
ripng->trigger = 0;
/* Logging triggered update. */
event_add_read(master, ripng_read, ripng, sock, &ripng->t_read);
break;
case RIPNG_UPDATE_EVENT:
- EVENT_OFF(ripng->t_update);
+ event_cancel(&ripng->t_update);
/* Update timer jitter. */
jitter = ripng_update_jitter(ripng->update_time);
/* Drop all other entries, except the first one. */
for (ALL_LIST_ELEMENTS(list, node, nextnode, tmp_rinfo))
if (tmp_rinfo != rinfo) {
- EVENT_OFF(tmp_rinfo->t_timeout);
- EVENT_OFF(tmp_rinfo->t_garbage_collect);
+ event_cancel(&tmp_rinfo->t_timeout);
+ event_cancel(&tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
ripng_info_free(tmp_rinfo);
}
ripng_zebra_ipv6_delete(ripng, rp);
for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
- EVENT_OFF(rinfo->t_timeout);
- EVENT_OFF(rinfo->t_garbage_collect);
+ event_cancel(&rinfo->t_timeout);
+ event_cancel(&rinfo->t_garbage_collect);
ripng_info_free(rinfo);
}
list_delete(&list);
ripng_redistribute_disable(ripng);
/* Cancel the RIPng timers */
- EVENT_OFF(ripng->t_update);
- EVENT_OFF(ripng->t_triggered_update);
- EVENT_OFF(ripng->t_triggered_interval);
+ event_cancel(&ripng->t_update);
+ event_cancel(&ripng->t_triggered_update);
+ event_cancel(&ripng->t_triggered_interval);
/* Cancel the read thread */
- EVENT_OFF(ripng->t_read);
+ event_cancel(&ripng->t_read);
/* Close the RIPng socket */
if (ripng->sock >= 0) {
projects / mirror / frr.git / commitdiff