bfdd,eigrpd,isisd,ldpd: remove use of the EVENT_OFF macro

Replace use of deprecated macro with function call.

Signed-off-by: Mark Stapp <mjs@cisco.com>

diff --git a/bfdd/bfd.c b/bfdd/bfd.c
index f199970e2084b9c13ca81db79a80ec4ed6fad1c1..45fd4092c59c58b5b50f0e8a1418329ba98612fb 100644 (file)
--- a/bfdd/bfd.c
+++ b/bfdd/bfd.c
@@ -2434,13 +2434,13 @@ static int bfd_vrf_disable(struct vrf *vrf)
                zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
 
        /* Disable read/write poll triggering. */
-       EVENT_OFF(bvrf->bg_ev[0]);
-       EVENT_OFF(bvrf->bg_ev[1]);
-       EVENT_OFF(bvrf->bg_ev[2]);
-       EVENT_OFF(bvrf->bg_ev[3]);
-       EVENT_OFF(bvrf->bg_ev[4]);
-       EVENT_OFF(bvrf->bg_ev[5]);
-       EVENT_OFF(bvrf->bg_ev[6]);
+       event_cancel(&bvrf->bg_ev[0]);
+       event_cancel(&bvrf->bg_ev[1]);
+       event_cancel(&bvrf->bg_ev[2]);
+       event_cancel(&bvrf->bg_ev[3]);
+       event_cancel(&bvrf->bg_ev[4]);
+       event_cancel(&bvrf->bg_ev[5]);
+       event_cancel(&bvrf->bg_ev[6]);
 
        /* Close all descriptors. */
        socket_close(&bvrf->bg_echo);

diff --git a/bfdd/bfd_packet.c b/bfdd/bfd_packet.c
index cecced3ccc17e67035b75b6256a5b5a8339081f9..9efbbc59893d41bd7730f903aad53b1c82cc5618 100644 (file)
--- a/bfdd/bfd_packet.c
+++ b/bfdd/bfd_packet.c
@@ -738,31 +738,31 @@ ssize_t bfd_recv_ipv6(int sd, uint8_t *msgbuf, size_t msgbuflen, uint8_t *ttl,
 static void bfd_sd_reschedule(struct bfd_vrf_global *bvrf, int sd)
 {
        if (sd == bvrf->bg_shop) {
-               EVENT_OFF(bvrf->bg_ev[0]);
+               event_cancel(&bvrf->bg_ev[0]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop,
                               &bvrf->bg_ev[0]);
        } else if (sd == bvrf->bg_mhop) {
-               EVENT_OFF(bvrf->bg_ev[1]);
+               event_cancel(&bvrf->bg_ev[1]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop,
                               &bvrf->bg_ev[1]);
        } else if (sd == bvrf->bg_shop6) {
-               EVENT_OFF(bvrf->bg_ev[2]);
+               event_cancel(&bvrf->bg_ev[2]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop6,
                               &bvrf->bg_ev[2]);
        } else if (sd == bvrf->bg_mhop6) {
-               EVENT_OFF(bvrf->bg_ev[3]);
+               event_cancel(&bvrf->bg_ev[3]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop6,
                               &bvrf->bg_ev[3]);
        } else if (sd == bvrf->bg_echo) {
-               EVENT_OFF(bvrf->bg_ev[4]);
+               event_cancel(&bvrf->bg_ev[4]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echo,
                               &bvrf->bg_ev[4]);
        } else if (sd == bvrf->bg_echov6) {
-               EVENT_OFF(bvrf->bg_ev[5]);
+               event_cancel(&bvrf->bg_ev[5]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echov6,
                               &bvrf->bg_ev[5]);
        } else if (sd == bvrf->bg_initv6) {
-               EVENT_OFF(bvrf->bg_ev[6]);
+               event_cancel(&bvrf->bg_ev[6]);
                event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_initv6, &bvrf->bg_ev[6]);
        }
 }

diff --git a/bfdd/dplane.c b/bfdd/dplane.c
index 7269b319a365ff07af8c33707f7c8d72770dfcfb..641d3c98a47ccc2819e820d831e7372da0e6c804 100644 (file)
--- a/bfdd/dplane.c
+++ b/bfdd/dplane.c
@@ -307,7 +307,7 @@ static ssize_t bfd_dplane_flush(struct bfd_dplane_ctx *bdc)
        stream_pulldown(bdc->outbuf);
 
        /* Disable write ready events. */
-       EVENT_OFF(bdc->outbufev);
+       event_cancel(&bdc->outbufev);
 
        return total;
 }
@@ -677,7 +677,7 @@ static void bfd_dplane_ctx_free(struct bfd_dplane_ctx *bdc)
        /* Client mode has special treatment. */
        if (bdc->client) {
                /* Disable connection event if any. */
-               EVENT_OFF(bdc->connectev);
+               event_cancel(&bdc->connectev);
 
                /* Normal treatment on shutdown. */
                if (bglobal.bg_shutdown)
@@ -685,8 +685,8 @@ static void bfd_dplane_ctx_free(struct bfd_dplane_ctx *bdc)
 
                /* Attempt reconnection. */
                socket_close(&bdc->sock);
-               EVENT_OFF(bdc->inbufev);
-               EVENT_OFF(bdc->outbufev);
+               event_cancel(&bdc->inbufev);
+               event_cancel(&bdc->outbufev);
                event_add_timer(master, bfd_dplane_client_connect, bdc, 3,
                                &bdc->connectev);
                return;
@@ -704,8 +704,8 @@ free_resources:
        socket_close(&bdc->sock);
        stream_free(bdc->inbuf);
        stream_free(bdc->outbuf);
-       EVENT_OFF(bdc->inbufev);
-       EVENT_OFF(bdc->outbufev);
+       event_cancel(&bdc->inbufev);
+       event_cancel(&bdc->outbufev);
        XFREE(MTYPE_BFDD_DPLANE_CTX, bdc);
 }
 
@@ -957,8 +957,8 @@ static void bfd_dplane_client_connect(struct event *t)
        return;
 
 reschedule_connect:
-       EVENT_OFF(bdc->inbufev);
-       EVENT_OFF(bdc->outbufev);
+       event_cancel(&bdc->inbufev);
+       event_cancel(&bdc->outbufev);
        socket_close(&sock);
        event_add_timer(master, bfd_dplane_client_connect, bdc, 3,
                        &bdc->connectev);
@@ -1005,7 +1005,7 @@ static int bfd_dplane_finish_late(void)
                bfd_dplane_ctx_free(bdc);
 
        /* Cancel accept thread and close socket. */
-       EVENT_OFF(bglobal.bg_dplane_sockev);
+       event_cancel(&bglobal.bg_dplane_sockev);
        close(bglobal.bg_dplane_sock);
 
        return 0;

diff --git a/bfdd/event.c b/bfdd/event.c
index f85b4335be47066a9e3a9477b9f186bd2c7bc9e6..d318067b12299169cf0439a82614a18d6cfe05e8 100644 (file)
--- a/bfdd/event.c
+++ b/bfdd/event.c
@@ -166,40 +166,40 @@ void bfd_echo_xmttimer_update(struct bfd_session *bs, uint64_t jitter)
 
 void bfd_recvtimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->recvtimer_ev);
+       event_cancel(&bs->recvtimer_ev);
 }
 
 void bfd_echo_recvtimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->echo_recvtimer_ev);
+       event_cancel(&bs->echo_recvtimer_ev);
 }
 
 void bfd_xmttimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->xmttimer_ev);
+       event_cancel(&bs->xmttimer_ev);
 }
 
 void bfd_echo_xmttimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->echo_xmttimer_ev);
+       event_cancel(&bs->echo_xmttimer_ev);
 }
 
 void sbfd_init_recvtimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->recvtimer_ev);
+       event_cancel(&bs->recvtimer_ev);
 }
 
 void sbfd_echo_recvtimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->echo_recvtimer_ev);
+       event_cancel(&bs->echo_recvtimer_ev);
 }
 
 void sbfd_init_xmttimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->xmttimer_ev);
+       event_cancel(&bs->xmttimer_ev);
 }
 
 void sbfd_echo_xmttimer_delete(struct bfd_session *bs)
 {
-       EVENT_OFF(bs->echo_xmttimer_ev);
+       event_cancel(&bs->echo_xmttimer_ev);
 }

diff --git a/eigrpd/eigrp_interface.c b/eigrpd/eigrp_interface.c
index 8bf0e130b1b3de4bf22df5201d76f779e2727347..b9159a68489cbbe5206000509093c8c5e9393e6f 100644 (file)
--- a/eigrpd/eigrp_interface.c
+++ b/eigrpd/eigrp_interface.c
@@ -338,7 +338,7 @@ int eigrp_if_down(struct eigrp_interface *ei)
                return 0;
 
        /* Shutdown packet reception and sending */
-       EVENT_OFF(ei->t_hello);
+       event_cancel(&ei->t_hello);
 
        eigrp_if_stream_unset(ei);
 

diff --git a/eigrpd/eigrp_neighbor.c b/eigrpd/eigrp_neighbor.c
index ac3cbd04b23e80d1e537bd2080e5e5f154a84c8e..2d7f6b8ba2c4c942b14b7458c2ffd0a83794f61f 100644 (file)
--- a/eigrpd/eigrp_neighbor.c
+++ b/eigrpd/eigrp_neighbor.c
@@ -177,7 +177,7 @@ void eigrp_nbr_delete(struct eigrp_neighbor *nbr)
        event_cancel_event(master, nbr);
        eigrp_fifo_free(nbr->multicast_queue);
        eigrp_fifo_free(nbr->retrans_queue);
-       EVENT_OFF(nbr->t_holddown);
+       event_cancel(&nbr->t_holddown);
 
        if (nbr->ei)
                eigrp_nbr_hash_del(&nbr->ei->nbr_hash_head, nbr);
@@ -220,7 +220,7 @@ void eigrp_nbr_state_set(struct eigrp_neighbor *nbr, uint8_t state)
 
                // hold time..
                nbr->v_holddown = EIGRP_HOLD_INTERVAL_DEFAULT;
-               EVENT_OFF(nbr->t_holddown);
+               event_cancel(&nbr->t_holddown);
 
                /* out with the old */
                if (nbr->multicast_queue)
@@ -262,7 +262,7 @@ void eigrp_nbr_state_update(struct eigrp_neighbor *nbr)
        switch (nbr->state) {
        case EIGRP_NEIGHBOR_DOWN: {
                /*Start Hold Down Timer for neighbor*/
-               //     EVENT_OFF(nbr->t_holddown);
+               //     event_cancel(&nbr->t_holddown);
                //     EVENT_TIMER_ON(master, nbr->t_holddown,
                //     holddown_timer_expired,
                //     nbr, nbr->v_holddown);
@@ -270,14 +270,14 @@ void eigrp_nbr_state_update(struct eigrp_neighbor *nbr)
        }
        case EIGRP_NEIGHBOR_PENDING: {
                /*Reset Hold Down Timer for neighbor*/
-               EVENT_OFF(nbr->t_holddown);
+               event_cancel(&nbr->t_holddown);
                event_add_timer(master, holddown_timer_expired, nbr,
                                nbr->v_holddown, &nbr->t_holddown);
                break;
        }
        case EIGRP_NEIGHBOR_UP: {
                /*Reset Hold Down Timer for neighbor*/
-               EVENT_OFF(nbr->t_holddown);
+               event_cancel(&nbr->t_holddown);
                event_add_timer(master, holddown_timer_expired, nbr,
                                nbr->v_holddown, &nbr->t_holddown);
                break;

diff --git a/eigrpd/eigrp_packet.c b/eigrpd/eigrp_packet.c
index 7560514ceca37bddb4e01d47e6165efd82f40e9d..ba0841d9f7bea2cf142a951c3711c1b1b8470b94 100644 (file)
--- a/eigrpd/eigrp_packet.c
+++ b/eigrpd/eigrp_packet.c
@@ -923,7 +923,7 @@ void eigrp_packet_free(struct eigrp_packet *ep)
        if (ep->s)
                stream_free(ep->s);
 
-       EVENT_OFF(ep->t_retrans_timer);
+       event_cancel(&ep->t_retrans_timer);
 
        XFREE(MTYPE_EIGRP_PACKET, ep);
 }

diff --git a/eigrpd/eigrpd.c b/eigrpd/eigrpd.c
index bc7c60c50108a325492e666046c9060d50498b50..998450816a990a27acbc543f2110aafda8f59499 100644 (file)
--- a/eigrpd/eigrpd.c
+++ b/eigrpd/eigrpd.c
@@ -266,8 +266,8 @@ void eigrp_finish_final(struct eigrp *eigrp)
                eigrp_if_delete_hook(ei->ifp);
        }
 
-       EVENT_OFF(eigrp->t_write);
-       EVENT_OFF(eigrp->t_read);
+       event_cancel(&eigrp->t_write);
+       event_cancel(&eigrp->t_read);
        close(eigrp->fd);
 
        eigrp_interface_hash_fini(&eigrp->eifs);

diff --git a/isisd/fabricd.c b/isisd/fabricd.c
index b229aa6717bdadbae5e3799f82dbd1783bc3a30c..5d6b08c66b8d11e43e2d797b8ff9d811b6741c19 100644 (file)
--- a/isisd/fabricd.c
+++ b/isisd/fabricd.c
@@ -225,11 +225,11 @@ struct fabricd *fabricd_new(struct isis_area *area)
 
 void fabricd_finish(struct fabricd *f)
 {
-       EVENT_OFF(f->initial_sync_timeout);
+       event_cancel(&f->initial_sync_timeout);
 
-       EVENT_OFF(f->tier_calculation_timer);
+       event_cancel(&f->tier_calculation_timer);
 
-       EVENT_OFF(f->tier_set_timer);
+       event_cancel(&f->tier_set_timer);
 
        isis_spftree_del(f->spftree);
        neighbor_lists_clear(f);
@@ -325,7 +325,7 @@ void fabricd_initial_sync_finish(struct isis_area *area)
                  f->initial_sync_circuit->interface->name);
        f->initial_sync_state = FABRICD_SYNC_COMPLETE;
        f->initial_sync_circuit = NULL;
-       EVENT_OFF(f->initial_sync_timeout);
+       event_cancel(&f->initial_sync_timeout);
 }
 
 static void fabricd_bump_tier_calculation_timer(struct fabricd *f);
@@ -420,14 +420,14 @@ static void fabricd_bump_tier_calculation_timer(struct fabricd *f)
 {
        /* Cancel timer if we already know our tier */
        if (f->tier != ISIS_TIER_UNDEFINED || f->tier_set_timer) {
-               EVENT_OFF(f->tier_calculation_timer);
+               event_cancel(&f->tier_calculation_timer);
                return;
        }
 
        /* If we need to calculate the tier, wait some
         * time for the topology to settle before running
         * the calculation */
-       EVENT_OFF(f->tier_calculation_timer);
+       event_cancel(&f->tier_calculation_timer);
 
        event_add_timer(master, fabricd_tier_calculation_cb, f,
                        2 * f->area->lsp_gen_interval[ISIS_LEVEL2 - 1],
@@ -712,7 +712,7 @@ void fabricd_trigger_csnp(struct isis_area *area, bool circuit_scoped)
                if (!circuit->t_send_csnp[1])
                        continue;
 
-               EVENT_OFF(circuit->t_send_csnp[ISIS_LEVEL2 - 1]);
+               event_cancel(&circuit->t_send_csnp[ISIS_LEVEL2 - 1]);
                event_add_timer_msec(master, send_l2_csnp, circuit,
                                     isis_jitter(f->csnp_delay, CSNP_JITTER),
                                     &circuit->t_send_csnp[ISIS_LEVEL2 - 1]);

diff --git a/isisd/isis_adjacency.c b/isisd/isis_adjacency.c
index 39ed076faba8af6962611537c4f566453535fc57..b2c0313def264c7ce5b806ea8a58bb098a0b0efa 100644 (file)
--- a/isisd/isis_adjacency.c
+++ b/isisd/isis_adjacency.c
@@ -149,7 +149,7 @@ void isis_delete_adj(void *arg)
        /* Remove self from snmp list without walking the list*/
        list_delete_node(adj->circuit->snmp_adj_list, adj->snmp_list_node);
 
-       EVENT_OFF(adj->t_expire);
+       event_cancel(&adj->t_expire);
        if (adj->adj_state != ISIS_ADJ_DOWN)
                adj->adj_state = ISIS_ADJ_DOWN;
 

diff --git a/isisd/isis_circuit.c b/isisd/isis_circuit.c
index 6fef026898ae8d2d8b4eed877dda48317af81311..22ef39f684d712c4b6d4a2f0f0bc6956544d9949 100644 (file)
--- a/isisd/isis_circuit.c
+++ b/isisd/isis_circuit.c
@@ -860,12 +860,12 @@ void isis_circuit_down(struct isis_circuit *circuit)
                memset(circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
                memset(circuit->u.bc.snpa, 0, ETH_ALEN);
 
-               EVENT_OFF(circuit->u.bc.t_send_lan_hello[0]);
-               EVENT_OFF(circuit->u.bc.t_send_lan_hello[1]);
-               EVENT_OFF(circuit->u.bc.t_run_dr[0]);
-               EVENT_OFF(circuit->u.bc.t_run_dr[1]);
-               EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[0]);
-               EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[1]);
+               event_cancel(&circuit->u.bc.t_send_lan_hello[0]);
+               event_cancel(&circuit->u.bc.t_send_lan_hello[1]);
+               event_cancel(&circuit->u.bc.t_run_dr[0]);
+               event_cancel(&circuit->u.bc.t_run_dr[1]);
+               event_cancel(&circuit->u.bc.t_refresh_pseudo_lsp[0]);
+               event_cancel(&circuit->u.bc.t_refresh_pseudo_lsp[1]);
                circuit->lsp_regenerate_pending[0] = 0;
                circuit->lsp_regenerate_pending[1] = 0;
 
@@ -875,7 +875,7 @@ void isis_circuit_down(struct isis_circuit *circuit)
        } else if (circuit->circ_type == CIRCUIT_T_P2P) {
                isis_delete_adj(circuit->u.p2p.neighbor);
                circuit->u.p2p.neighbor = NULL;
-               EVENT_OFF(circuit->u.p2p.t_send_p2p_hello);
+               event_cancel(&circuit->u.p2p.t_send_p2p_hello);
        }
 
        /*
@@ -888,11 +888,11 @@ void isis_circuit_down(struct isis_circuit *circuit)
        circuit->snmp_adj_idx_gen = 0;
 
        /* Cancel all active threads */
-       EVENT_OFF(circuit->t_send_csnp[0]);
-       EVENT_OFF(circuit->t_send_csnp[1]);
-       EVENT_OFF(circuit->t_send_psnp[0]);
-       EVENT_OFF(circuit->t_send_psnp[1]);
-       EVENT_OFF(circuit->t_read);
+       event_cancel(&circuit->t_send_csnp[0]);
+       event_cancel(&circuit->t_send_csnp[1]);
+       event_cancel(&circuit->t_send_psnp[0]);
+       event_cancel(&circuit->t_send_psnp[1]);
+       event_cancel(&circuit->t_read);
 
        if (circuit->tx_queue) {
                isis_tx_queue_free(circuit->tx_queue);
@@ -1674,7 +1674,7 @@ void isis_reset_hello_timer(struct isis_circuit *circuit)
                        send_hello(circuit, IS_LEVEL_1);
 
                        /* reset level-1 hello timer */
-                       EVENT_OFF(circuit->u.bc.t_send_lan_hello[0]);
+                       event_cancel(&circuit->u.bc.t_send_lan_hello[0]);
                        if (circuit->area && (circuit->area->is_type & IS_LEVEL_1))
                                send_hello_sched(circuit, IS_LEVEL_1,
                                                 isis_jitter(circuit->hello_interval[0],
@@ -1686,7 +1686,7 @@ void isis_reset_hello_timer(struct isis_circuit *circuit)
                        send_hello(circuit, IS_LEVEL_2);
 
                        /* reset level-2 hello timer */
-                       EVENT_OFF(circuit->u.bc.t_send_lan_hello[1]);
+                       event_cancel(&circuit->u.bc.t_send_lan_hello[1]);
                        if (circuit->area && (circuit->area->is_type & IS_LEVEL_2))
                                send_hello_sched(circuit, IS_LEVEL_2,
                                                 isis_jitter(circuit->hello_interval[1],
@@ -1697,7 +1697,7 @@ void isis_reset_hello_timer(struct isis_circuit *circuit)
                send_hello(circuit, IS_LEVEL_1);
 
                /* reset hello timer */
-               EVENT_OFF(circuit->u.p2p.t_send_p2p_hello);
+               event_cancel(&circuit->u.p2p.t_send_p2p_hello);
                send_hello_sched(circuit, 0, isis_jitter(circuit->hello_interval[0], IIH_JITTER));
        }
 }

diff --git a/isisd/isis_dr.c b/isisd/isis_dr.c
index 3b921608092699f9b44876c155767417ce084d29..c814433bb2222596d4c2dde41aa12f27a5c34702 100644 (file)
--- a/isisd/isis_dr.c
+++ b/isisd/isis_dr.c
@@ -211,8 +211,8 @@ int isis_dr_resign(struct isis_circuit *circuit, int level)
 
        circuit->u.bc.is_dr[level - 1] = 0;
        circuit->u.bc.run_dr_elect[level - 1] = 0;
-       EVENT_OFF(circuit->u.bc.t_run_dr[level - 1]);
-       EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
+       event_cancel(&circuit->u.bc.t_run_dr[level - 1]);
+       event_cancel(&circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
        circuit->lsp_regenerate_pending[level - 1] = 0;
 
        memcpy(id, circuit->isis->sysid, ISIS_SYS_ID_LEN);
@@ -236,7 +236,7 @@ int isis_dr_resign(struct isis_circuit *circuit, int level)
                                &circuit->t_send_psnp[1]);
        }
 
-       EVENT_OFF(circuit->t_send_csnp[level - 1]);
+       event_cancel(&circuit->t_send_csnp[level - 1]);
 
        event_add_timer(master, isis_run_dr, &circuit->level_arg[level - 1],
                        2 * circuit->hello_interval[level - 1],

diff --git a/isisd/isis_dynhn.c b/isisd/isis_dynhn.c
index 61c49d08a742af88b924940594941561ffba9bd8..49dce26b380c6305d4fd6ae05660fcee431566e5 100644 (file)
--- a/isisd/isis_dynhn.c
+++ b/isisd/isis_dynhn.c
@@ -44,7 +44,7 @@ void dyn_cache_finish(struct isis *isis)
        struct listnode *node, *nnode;
        struct isis_dynhn *dyn;
 
-       EVENT_OFF(isis->t_dync_clean);
+       event_cancel(&isis->t_dync_clean);
 
        for (ALL_LIST_ELEMENTS(isis->dyn_cache, node, nnode, dyn)) {
                list_delete_node(isis->dyn_cache, node);

diff --git a/isisd/isis_events.c b/isisd/isis_events.c
index 5237e99999c66fe1cf586c2b2dbcc54fe1707faf..856a5059fa8f18d51a557352b549ab1f308e9d05 100644 (file)
--- a/isisd/isis_events.c
+++ b/isisd/isis_events.c
@@ -98,13 +98,13 @@ static void circuit_resign_level(struct isis_circuit *circuit, int level)
                        circuit->area->area_tag, circuit->circuit_id,
                        circuit->interface->name, level);
 
-       EVENT_OFF(circuit->t_send_csnp[idx]);
-       EVENT_OFF(circuit->t_send_psnp[idx]);
+       event_cancel(&circuit->t_send_csnp[idx]);
+       event_cancel(&circuit->t_send_psnp[idx]);
 
        if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
-               EVENT_OFF(circuit->u.bc.t_send_lan_hello[idx]);
-               EVENT_OFF(circuit->u.bc.t_run_dr[idx]);
-               EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
+               event_cancel(&circuit->u.bc.t_send_lan_hello[idx]);
+               event_cancel(&circuit->u.bc.t_run_dr[idx]);
+               event_cancel(&circuit->u.bc.t_refresh_pseudo_lsp[idx]);
                circuit->lsp_regenerate_pending[idx] = 0;
                circuit->u.bc.run_dr_elect[idx] = 0;
                circuit->u.bc.is_dr[idx] = 0;

diff --git a/isisd/isis_ldp_sync.c b/isisd/isis_ldp_sync.c
index 99e9227ad56ec7b8d3c0a98a61b559abd24656b3..3c7fd7b5ee29b1902e139c8ec108843b13a46cde 100644 (file)
--- a/isisd/isis_ldp_sync.c
+++ b/isisd/isis_ldp_sync.c
@@ -170,7 +170,7 @@ void isis_ldp_sync_if_complete(struct isis_circuit *circuit)
                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);
 
                isis_ldp_sync_set_if_metric(circuit, true);
        }
@@ -190,7 +190,7 @@ void isis_ldp_sync_ldp_fail(struct isis_circuit *circuit)
        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;
                isis_ldp_sync_set_if_metric(circuit, true);
        }
@@ -515,7 +515,7 @@ void isis_if_ldp_sync_disable(struct isis_circuit *circuit)
        if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
                return;
 
-       EVENT_OFF(ldp_sync_info->t_holddown);
+       event_cancel(&ldp_sync_info->t_holddown);
        ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
        isis_ldp_sync_set_if_metric(circuit, true);
 }

diff --git a/isisd/isis_lfa.c b/isisd/isis_lfa.c
index e0b3a4dca10b8fa60b5b6ff70c52c65d17fd0f17..8b70ea4cf8ff444ef3729f21696df59cc6dda3b5 100644 (file)
--- a/isisd/isis_lfa.c
+++ b/isisd/isis_lfa.c
@@ -1513,7 +1513,7 @@ int isis_rlfa_activate(struct isis_spftree *spftree, struct rlfa *rlfa,
                          spftree->route_table_backup);
        spftree->lfa.protection_counters.rlfa[vertex->N.ip.priority] += 1;
 
-       EVENT_OFF(area->t_rlfa_rib_update);
+       event_cancel(&area->t_rlfa_rib_update);
        event_add_timer(master, isis_area_verify_routes_cb, area, 2,
                        &area->t_rlfa_rib_update);
 
@@ -1532,7 +1532,7 @@ void isis_rlfa_deactivate(struct isis_spftree *spftree, struct rlfa *rlfa)
        isis_route_delete(area, rn, spftree->route_table_backup);
        spftree->lfa.protection_counters.rlfa[vertex->N.ip.priority] -= 1;
 
-       EVENT_OFF(area->t_rlfa_rib_update);
+       event_cancel(&area->t_rlfa_rib_update);
        event_add_timer(master, isis_area_verify_routes_cb, area, 2,
                        &area->t_rlfa_rib_update);
 }

diff --git a/isisd/isis_lsp.c b/isisd/isis_lsp.c
index 4952c689fcfdeea67879c6aaede3111b8a8a85ea..c02d087719a1fee35f1105808689cec06c226cf5 100644 (file)
--- a/isisd/isis_lsp.c
+++ b/isisd/isis_lsp.c
@@ -1520,7 +1520,7 @@ int lsp_generate(struct isis_area *area, int level)
 
        refresh_time = lsp_refresh_time(newlsp, rem_lifetime);
 
-       EVENT_OFF(area->t_lsp_refresh[level - 1]);
+       event_cancel(&area->t_lsp_refresh[level - 1]);
        area->lsp_regenerate_pending[level - 1] = 0;
        event_add_timer(master, lsp_refresh, &area->lsp_refresh_arg[level - 1],
                        refresh_time, &area->t_lsp_refresh[level - 1]);
@@ -1729,7 +1729,7 @@ int _lsp_regenerate_schedule(struct isis_area *area, int level,
                        "ISIS (%s): Will schedule regen timer. Last run was: %lld, Now is: %lld",
                        area->area_tag, (long long)lsp->last_generated,
                        (long long)now);
-               EVENT_OFF(area->t_lsp_refresh[lvl - 1]);
+               event_cancel(&area->t_lsp_refresh[lvl - 1]);
                diff = now - lsp->last_generated;
                if (diff < area->lsp_gen_interval[lvl - 1]
                    && !(area->bfd_signalled_down)) {
@@ -1915,7 +1915,7 @@ int lsp_generate_pseudo(struct isis_circuit *circuit, int level)
        lsp_flood(lsp, NULL);
 
        refresh_time = lsp_refresh_time(lsp, rem_lifetime);
-       EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
+       event_cancel(&circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
        circuit->lsp_regenerate_pending[level - 1] = 0;
        if (level == IS_LEVEL_1)
                event_add_timer(master, lsp_l1_refresh_pseudo, circuit,
@@ -2104,7 +2104,7 @@ int lsp_regenerate_schedule_pseudo(struct isis_circuit *circuit, int level)
                        "ISIS (%s): Will schedule PSN regen timer. Last run was: %lld, Now is: %lld",
                        area->area_tag, (long long)lsp->last_generated,
                        (long long)now);
-               EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
+               event_cancel(&circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
                diff = now - lsp->last_generated;
                if (diff < circuit->area->lsp_gen_interval[lvl - 1]) {
                        timeout =

diff --git a/isisd/isis_main.c b/isisd/isis_main.c
index c36c531a171ca49e97f7682e08e6508cdbe0d8bd..a5bf7f882505be27ded9b3b7333148aab9cf9448 100644 (file)
--- a/isisd/isis_main.c
+++ b/isisd/isis_main.c
@@ -216,7 +216,7 @@ static void isis_config_end_timeout(struct event *t)
 
 static void isis_config_start(void)
 {
-       EVENT_OFF(t_isis_cfg);
+       event_cancel(&t_isis_cfg);
        event_add_timer(im->master, isis_config_end_timeout, NULL,
                        ISIS_PRE_CONFIG_MAX_WAIT_SECONDS, &t_isis_cfg);
 }
@@ -229,7 +229,7 @@ static void isis_config_end(void)
        if (!event_is_scheduled(t_isis_cfg))
                return;
 
-       EVENT_OFF(t_isis_cfg);
+       event_cancel(&t_isis_cfg);
        isis_config_finish(t_isis_cfg);
 }
 

diff --git a/isisd/isis_pdu.c b/isisd/isis_pdu.c
index c2ada459eb1c5341322ab6666b6e2ca1c4aae06c..78628cb74a564aa8d4eed9469c9765f80ab09f55 100644 (file)
--- a/isisd/isis_pdu.c
+++ b/isisd/isis_pdu.c
@@ -265,7 +265,7 @@ static int process_p2p_hello(struct iih_info *iih)
                                      adj);
 
        /* lets take care of the expiry */
-       EVENT_OFF(adj->t_expire);
+       event_cancel(&adj->t_expire);
        event_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
                        &adj->t_expire);
 
@@ -528,7 +528,7 @@ static int process_lan_hello(struct iih_info *iih)
                                      adj);
 
        /* lets take care of the expiry */
-       EVENT_OFF(adj->t_expire);
+       event_cancel(&adj->t_expire);
        event_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
                        &adj->t_expire);
 
@@ -2116,7 +2116,7 @@ static void _send_hello_sched(struct isis_circuit *circuit,
                if (event_timer_remain_msec(*threadp) < (unsigned long)delay)
                        return;
 
-               EVENT_OFF(*threadp);
+               event_cancel(&*threadp);
        }
 
        event_add_timer_msec(master, send_hello_cb,

diff --git a/isisd/isis_spf.c b/isisd/isis_spf.c
index 5960fef7553b3bee953f847b4501ed4e4df83291..a0b10e5ecab160ee199abe80463bba40fdddbb78 100644 (file)
--- a/isisd/isis_spf.c
+++ b/isisd/isis_spf.c
@@ -2178,7 +2178,7 @@ int _isis_spf_schedule(struct isis_area *area, int level,
                        area->area_tag, level, diff, func, file, line);
        }
 
-       EVENT_OFF(area->t_rlfa_rib_update);
+       event_cancel(&area->t_rlfa_rib_update);
        if (area->spf_delay_ietf[level - 1]) {
                /* Need to call schedule function also if spf delay is running
                 * to

diff --git a/isisd/isis_sr.c b/isisd/isis_sr.c
index fd6a44504c26f1a9e64830755b1f1e37777c8163..46b6294a90b66e47d72201ba7f3938c977b83c0b 100644 (file)
--- a/isisd/isis_sr.c
+++ b/isisd/isis_sr.c
@@ -1274,7 +1274,7 @@ void isis_sr_stop(struct isis_area *area)
                 area->area_tag);
 
        /* Disable any re-attempt to connect to Label Manager */
-       EVENT_OFF(srdb->t_start_lm);
+       event_cancel(&srdb->t_start_lm);
 
        /* Uninstall all local Adjacency-SIDs. */
        for (ALL_LIST_ELEMENTS(area->srdb.adj_sids, node, nnode, sra))

diff --git a/isisd/isis_tx_queue.c b/isisd/isis_tx_queue.c
index caf97f11749c9315b6b5e33753e4af0c959c44cf..24301fc07e939b8885d67c2286db080bba390216 100644 (file)
--- a/isisd/isis_tx_queue.c
+++ b/isisd/isis_tx_queue.c
@@ -79,7 +79,7 @@ static void tx_queue_element_free(void *element)
 {
        struct isis_tx_queue_entry *e = element;
 
-       EVENT_OFF(e->retry);
+       event_cancel(&e->retry);
 
        XFREE(MTYPE_TX_QUEUE_ENTRY, e);
 }
@@ -147,7 +147,7 @@ void _isis_tx_queue_add(struct isis_tx_queue *queue,
 
        e->type = type;
 
-       EVENT_OFF(e->retry);
+       event_cancel(&e->retry);
        event_add_event(master, tx_queue_send_event, e, 0, &e->retry);
 
        e->is_retry = false;
@@ -169,7 +169,7 @@ void _isis_tx_queue_del(struct isis_tx_queue *queue, struct isis_lsp *lsp,
                           func, file, line);
        }
 
-       EVENT_OFF(e->retry);
+       event_cancel(&e->retry);
 
        hash_release(queue->hash, e);
        XFREE(MTYPE_TX_QUEUE_ENTRY, e);

diff --git a/isisd/isisd.c b/isisd/isisd.c
index 2260ba664fcf7f38e005fea7d9458708bcc4c6cb..288256946bb4b33ef4c92ac252d1ea1a433c74b5 100644 (file)
--- a/isisd/isisd.c
+++ b/isisd/isisd.c
@@ -582,10 +582,10 @@ void isis_area_destroy(struct isis_area *area)
 
        if (area->spf_timer[0])
                isis_spf_timer_free(EVENT_ARG(area->spf_timer[0]));
-       EVENT_OFF(area->spf_timer[0]);
+       event_cancel(&area->spf_timer[0]);
        if (area->spf_timer[1])
                isis_spf_timer_free(EVENT_ARG(area->spf_timer[1]));
-       EVENT_OFF(area->spf_timer[1]);
+       event_cancel(&area->spf_timer[1]);
 
        spf_backoff_free(area->spf_delay_ietf[0]);
        spf_backoff_free(area->spf_delay_ietf[1]);
@@ -614,10 +614,10 @@ void isis_area_destroy(struct isis_area *area)
        isis_lfa_tiebreakers_clear(area, ISIS_LEVEL1);
        isis_lfa_tiebreakers_clear(area, ISIS_LEVEL2);
 
-       EVENT_OFF(area->t_tick);
-       EVENT_OFF(area->t_lsp_refresh[0]);
-       EVENT_OFF(area->t_lsp_refresh[1]);
-       EVENT_OFF(area->t_rlfa_rib_update);
+       event_cancel(&area->t_tick);
+       event_cancel(&area->t_lsp_refresh[0]);
+       event_cancel(&area->t_lsp_refresh[1]);
+       event_cancel(&area->t_rlfa_rib_update);
 
        event_cancel_event(master, area);
 
@@ -3210,12 +3210,12 @@ static void area_resign_level(struct isis_area *area, int level)
        if (area->spf_timer[level - 1])
                isis_spf_timer_free(EVENT_ARG(area->spf_timer[level - 1]));
 
-       EVENT_OFF(area->spf_timer[level - 1]);
+       event_cancel(&area->spf_timer[level - 1]);
 
        sched_debug(
                "ISIS (%s): Resigned from L%d - canceling LSP regeneration timer.",
                area->area_tag, level);
-       EVENT_OFF(area->t_lsp_refresh[level - 1]);
+       event_cancel(&area->t_lsp_refresh[level - 1]);
        area->lsp_regenerate_pending[level - 1] = 0;
 }
 
@@ -3304,7 +3304,7 @@ void isis_area_overload_bit_set(struct isis_area *area, bool overload_bit)
                } else {
                        /* Cancel overload on startup timer if it's running */
                        if (area->t_overload_on_startup_timer) {
-                               EVENT_OFF(area->t_overload_on_startup_timer);
+                               event_cancel(&area->t_overload_on_startup_timer);
                                area->t_overload_on_startup_timer = NULL;
                        }
                }

diff --git a/ldpd/accept.c b/ldpd/accept.c
index 8e881e78aecd6f6e216bd8560268a90899787627..3b767311f5a491bac0ecacac5bbc2a42657f602a 100644 (file)
--- a/ldpd/accept.c
+++ b/ldpd/accept.c
@@ -61,7 +61,7 @@ accept_del(int fd)
        LIST_FOREACH(av, &accept_queue.queue, entry)
                if (av->fd == fd) {
                        log_debug("%s: %d removed from queue", __func__, fd);
-                       EVENT_OFF(av->ev);
+                       event_cancel(&av->ev);
                        LIST_REMOVE(av, entry);
                        free(av);
                        return;
@@ -81,7 +81,7 @@ accept_unpause(void)
 {
        if (accept_queue.evt != NULL) {
                log_debug(__func__);
-               EVENT_OFF(accept_queue.evt);
+               event_cancel(&accept_queue.evt);
                accept_arm();
        }
 }
@@ -100,7 +100,7 @@ accept_unarm(void)
 {
        struct accept_ev        *av;
        LIST_FOREACH(av, &accept_queue.queue, entry)
-               EVENT_OFF(av->ev);
+               event_cancel(&av->ev);
 }
 
 static void accept_cb(struct event *thread)

diff --git a/ldpd/adjacency.c b/ldpd/adjacency.c
index 0108af80444e705742f983bc1355da6fcb1af419..fbc501b9415341504e9283d73b458aaa63708b21 100644 (file)
--- a/ldpd/adjacency.c
+++ b/ldpd/adjacency.c
@@ -185,7 +185,7 @@ static void adj_itimer(struct event *thread)
 void
 adj_start_itimer(struct adj *adj)
 {
-       EVENT_OFF(adj->inactivity_timer);
+       event_cancel(&adj->inactivity_timer);
        adj->inactivity_timer = NULL;
        event_add_timer(master, adj_itimer, adj, adj->holdtime,
                        &adj->inactivity_timer);
@@ -194,7 +194,7 @@ adj_start_itimer(struct adj *adj)
 void
 adj_stop_itimer(struct adj *adj)
 {
-       EVENT_OFF(adj->inactivity_timer);
+       event_cancel(&adj->inactivity_timer);
 }
 
 /* targeted neighbors */
@@ -343,7 +343,7 @@ static void tnbr_hello_timer(struct event *thread)
 static void
 tnbr_start_hello_timer(struct tnbr *tnbr)
 {
-       EVENT_OFF(tnbr->hello_timer);
+       event_cancel(&tnbr->hello_timer);
        tnbr->hello_timer = NULL;
        event_add_timer(master, tnbr_hello_timer, tnbr,
                        tnbr_get_hello_interval(tnbr), &tnbr->hello_timer);
@@ -352,7 +352,7 @@ tnbr_start_hello_timer(struct tnbr *tnbr)
 static void
 tnbr_stop_hello_timer(struct tnbr *tnbr)
 {
-       EVENT_OFF(tnbr->hello_timer);
+       event_cancel(&tnbr->hello_timer);
 }
 
 struct ctl_adj *

diff --git a/ldpd/control.c b/ldpd/control.c
index a08ce4cc1a619a651846761f5937c5c8190a4277..e1ac527d8ca7da525997ec66d632ff78ee5202aa 100644 (file)
--- a/ldpd/control.c
+++ b/ldpd/control.c
@@ -169,8 +169,8 @@ control_close(int fd)
        msgbuf_clear(&c->iev.ibuf.w);
        TAILQ_REMOVE(&ctl_conns, c, entry);
 
-       EVENT_OFF(c->iev.ev_read);
-       EVENT_OFF(c->iev.ev_write);
+       event_cancel(&c->iev.ev_read);
+       event_cancel(&c->iev.ev_write);
        close(c->iev.ibuf.fd);
        accept_unpause();
        free(c);

diff --git a/ldpd/interface.c b/ldpd/interface.c
index f0e70cbacce171813b176a848c0f53e241f8654c..61dcbbb3912b9b13ab99304fb2d595aaf4994eee 100644 (file)
--- a/ldpd/interface.c
+++ b/ldpd/interface.c
@@ -454,7 +454,7 @@ static void if_hello_timer(struct event *thread)
 static void
 if_start_hello_timer(struct iface_af *ia)
 {
-       EVENT_OFF(ia->hello_timer);
+       event_cancel(&ia->hello_timer);
        event_add_timer(master, if_hello_timer, ia, if_get_hello_interval(ia),
                        &ia->hello_timer);
 }
@@ -462,7 +462,7 @@ if_start_hello_timer(struct iface_af *ia)
 static void
 if_stop_hello_timer(struct iface_af *ia)
 {
-       EVENT_OFF(ia->hello_timer);
+       event_cancel(&ia->hello_timer);
 }
 
 struct ctl_iface *
@@ -728,7 +728,7 @@ static void start_wait_for_ldp_sync_timer(struct iface *iface)
        if (iface->ldp_sync.wait_for_sync_timer)
                return;
 
-       EVENT_OFF(iface->ldp_sync.wait_for_sync_timer);
+       event_cancel(&iface->ldp_sync.wait_for_sync_timer);
        event_add_timer(master, iface_wait_for_ldp_sync_timer, iface,
                        if_get_wait_for_sync_interval(),
                        &iface->ldp_sync.wait_for_sync_timer);
@@ -736,7 +736,7 @@ static void start_wait_for_ldp_sync_timer(struct iface *iface)
 
 static void stop_wait_for_ldp_sync_timer(struct iface *iface)
 {
-       EVENT_OFF(iface->ldp_sync.wait_for_sync_timer);
+       event_cancel(&iface->ldp_sync.wait_for_sync_timer);
 }
 
 static int

diff --git a/ldpd/lde.c b/ldpd/lde.c
index 562133ce916c38918bbba39c63bb25dc1ccd0ae9..3736f1a12ee9c7737050cf49f61f7d01cce6b85a 100644 (file)
--- a/ldpd/lde.c
+++ b/ldpd/lde.c
@@ -399,8 +399,8 @@ static void lde_dispatch_imsg(struct event *thread)
                imsg_event_add(iev);
        else {
                /* this pipe is dead, so remove the event handlers and exit */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                lde_shutdown();
        }
 }
@@ -677,8 +677,8 @@ static void lde_dispatch_parent(struct event *thread)
                imsg_event_add(iev);
        else {
                /* this pipe is dead, so remove the event handlers and exit */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                lde_shutdown();
        }
 }

diff --git a/ldpd/lde_lib.c b/ldpd/lde_lib.c
index 04bff9015856d6bfb87697f8e9f8b9f5c286d31b..e1b233aa22a1b09b83ae6755568b85dc5df73c3a 100644 (file)
--- a/ldpd/lde_lib.c
+++ b/ldpd/lde_lib.c
@@ -1044,12 +1044,12 @@ void lde_gc_timer(struct event *thread)
 void
 lde_gc_start_timer(void)
 {
-       EVENT_OFF(gc_timer);
+       event_cancel(&gc_timer);
        event_add_timer(master, lde_gc_timer, NULL, LDE_GC_INTERVAL, &gc_timer);
 }
 
 void
 lde_gc_stop_timer(void)
 {
-       EVENT_OFF(gc_timer);
+       event_cancel(&gc_timer);
 }

diff --git a/ldpd/ldpd.c b/ldpd/ldpd.c
index 94f9ada6da9a0a62118935bcc3f83bc2b989dd6c..3b14a5b2e99948fa3f7f802dd5a990133202ef61 100644 (file)
--- a/ldpd/ldpd.c
+++ b/ldpd/ldpd.c
@@ -622,8 +622,8 @@ static void main_dispatch_ldpe(struct event *thread)
                imsg_event_add(iev);
        else {
                /* this pipe is dead, so remove the event handlers and exit */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                ldpe_pid = 0;
 
                if (lde_pid == 0)
@@ -728,8 +728,8 @@ static void main_dispatch_lde(struct event *thread)
                imsg_event_add(iev);
        else {
                /* this pipe is dead, so remove the event handlers and exit */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                lde_pid = 0;
                if (ldpe_pid == 0)
                        ldpd_shutdown();
@@ -751,8 +751,8 @@ void ldp_write_handler(struct event *thread)
                fatal("msgbuf_write");
        if (n == 0) {
                /* this pipe is dead, so remove the event handlers */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                return;
        }
 
@@ -841,7 +841,7 @@ void evbuf_init(struct evbuf *eb, int fd, void (*handler)(struct event *),
 void
 evbuf_clear(struct evbuf *eb)
 {
-       EVENT_OFF(eb->ev);
+       event_cancel(&eb->ev);
        msgbuf_clear(&eb->wbuf);
        eb->wbuf.fd = -1;
 }

diff --git a/ldpd/ldpe.c b/ldpd/ldpe.c
index 987a4e0415350867e9b37c0c30d739621b050322..e1665c4c298cab365ad0016d922bf5e544e50f0c 100644 (file)
--- a/ldpd/ldpe.c
+++ b/ldpd/ldpe.c
@@ -203,7 +203,7 @@ static FRR_NORETURN void ldpe_shutdown(void)
 
 #ifdef __OpenBSD__
        if (sysdep.no_pfkey == 0) {
-               EVENT_OFF(pfkey_ev);
+               event_cancel(&pfkey_ev);
                close(global.pfkeysock);
        }
 #endif
@@ -604,8 +604,8 @@ static void ldpe_dispatch_main(struct event *thread)
                imsg_event_add(iev);
        else {
                /* this pipe is dead, so remove the event handlers and exit */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                ldpe_shutdown();
        }
 }
@@ -737,8 +737,8 @@ static void ldpe_dispatch_lde(struct event *thread)
                imsg_event_add(iev);
        else {
                /* this pipe is dead, so remove the event handlers and exit */
-               EVENT_OFF(iev->ev_read);
-               EVENT_OFF(iev->ev_write);
+               event_cancel(&iev->ev_read);
+               event_cancel(&iev->ev_write);
                ldpe_shutdown();
        }
 }
@@ -788,14 +788,14 @@ ldpe_close_sockets(int af)
        af_global = ldp_af_global_get(&global, af);
 
        /* discovery socket */
-       EVENT_OFF(af_global->disc_ev);
+       event_cancel(&af_global->disc_ev);
        if (af_global->ldp_disc_socket != -1) {
                close(af_global->ldp_disc_socket);
                af_global->ldp_disc_socket = -1;
        }
 
        /* extended discovery socket */
-       EVENT_OFF(af_global->edisc_ev);
+       event_cancel(&af_global->edisc_ev);
        if (af_global->ldp_edisc_socket != -1) {
                close(af_global->ldp_edisc_socket);
                af_global->ldp_edisc_socket = -1;

diff --git a/ldpd/neighbor.c b/ldpd/neighbor.c
index 2596c794811670c976cb4e6fc9d16781e52cde92..86878e79809b64d14ccc17690b9adf4d8a7865ab 100644 (file)
--- a/ldpd/neighbor.c
+++ b/ldpd/neighbor.c
@@ -293,7 +293,7 @@ nbr_del(struct nbr *nbr)
        nbr->auth.method = AUTH_NONE;
 
        if (nbr_pending_connect(nbr))
-               EVENT_OFF(nbr->ev_connect);
+               event_cancel(&nbr->ev_connect);
        nbr_stop_ktimer(nbr);
        nbr_stop_ktimeout(nbr);
        nbr_stop_itimeout(nbr);
@@ -420,7 +420,7 @@ nbr_start_ktimer(struct nbr *nbr)
 
        /* send three keepalives per period */
        secs = nbr->keepalive / KEEPALIVE_PER_PERIOD;
-       EVENT_OFF(nbr->keepalive_timer);
+       event_cancel(&nbr->keepalive_timer);
        nbr->keepalive_timer = NULL;
        event_add_timer(master, nbr_ktimer, nbr, secs, &nbr->keepalive_timer);
 }
@@ -428,7 +428,7 @@ nbr_start_ktimer(struct nbr *nbr)
 void
 nbr_stop_ktimer(struct nbr *nbr)
 {
-       EVENT_OFF(nbr->keepalive_timer);
+       event_cancel(&nbr->keepalive_timer);
 }
 
 /* Keepalive timeout: if the nbr hasn't sent keepalive */
@@ -447,7 +447,7 @@ static void nbr_ktimeout(struct event *thread)
 static void
 nbr_start_ktimeout(struct nbr *nbr)
 {
-       EVENT_OFF(nbr->keepalive_timeout);
+       event_cancel(&nbr->keepalive_timeout);
        nbr->keepalive_timeout = NULL;
        event_add_timer(master, nbr_ktimeout, nbr, nbr->keepalive,
                        &nbr->keepalive_timeout);
@@ -456,7 +456,7 @@ nbr_start_ktimeout(struct nbr *nbr)
 void
 nbr_stop_ktimeout(struct nbr *nbr)
 {
-       EVENT_OFF(nbr->keepalive_timeout);
+       event_cancel(&nbr->keepalive_timeout);
 }
 
 /* Session initialization timeout: if nbr got stuck in the initialization FSM */
@@ -476,7 +476,7 @@ nbr_start_itimeout(struct nbr *nbr)
        int              secs;
 
        secs = INIT_FSM_TIMEOUT;
-       EVENT_OFF(nbr->init_timeout);
+       event_cancel(&nbr->init_timeout);
        nbr->init_timeout = NULL;
        event_add_timer(master, nbr_itimeout, nbr, secs, &nbr->init_timeout);
 }
@@ -484,7 +484,7 @@ nbr_start_itimeout(struct nbr *nbr)
 void
 nbr_stop_itimeout(struct nbr *nbr)
 {
-       EVENT_OFF(nbr->init_timeout);
+       event_cancel(&nbr->init_timeout);
 }
 
 /* Init delay timer: timer to retry to iniziatize session */
@@ -513,7 +513,7 @@ nbr_start_idtimer(struct nbr *nbr)
                nbr->idtimer_cnt++;
        }
 
-       EVENT_OFF(nbr->initdelay_timer);
+       event_cancel(&nbr->initdelay_timer);
        nbr->initdelay_timer = NULL;
        event_add_timer(master, nbr_idtimer, nbr, secs, &nbr->initdelay_timer);
 }
@@ -521,7 +521,7 @@ nbr_start_idtimer(struct nbr *nbr)
 void
 nbr_stop_idtimer(struct nbr *nbr)
 {
-       EVENT_OFF(nbr->initdelay_timer);
+       event_cancel(&nbr->initdelay_timer);
 }
 
 int

diff --git a/ldpd/packet.c b/ldpd/packet.c
index d2d9305e714c168f16a1d9d5d8ab92eec182db84..42d526aa0b8be1dc14ff9c8d3592df553e274eb4 100644 (file)
--- a/ldpd/packet.c
+++ b/ldpd/packet.c
@@ -627,7 +627,7 @@ session_shutdown(struct nbr *nbr, uint32_t status, uint32_t msg_id,
        switch (nbr->state) {
        case NBR_STA_PRESENT:
                if (nbr_pending_connect(nbr))
-                       EVENT_OFF(nbr->ev_connect);
+                       event_cancel(&nbr->ev_connect);
                break;
        case NBR_STA_INITIAL:
        case NBR_STA_OPENREC:
@@ -731,7 +731,7 @@ tcp_close(struct tcp_conn *tcp)
        evbuf_clear(&tcp->wbuf);
 
        if (tcp->nbr) {
-               EVENT_OFF(tcp->rev);
+               event_cancel(&tcp->rev);
                free(tcp->rbuf);
                tcp->nbr->tcp = NULL;
        }
@@ -763,7 +763,7 @@ pending_conn_new(int fd, int af, union ldpd_addr *addr)
 void
 pending_conn_del(struct pending_conn *pconn)
 {
-       EVENT_OFF(pconn->ev_timeout);
+       event_cancel(&pconn->ev_timeout);
        TAILQ_REMOVE(&global.pending_conns, pconn, entry);
        free(pconn);
 }