damp->t_reuse = NULL;
damp->t_reuse =
- thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
+ thread_add_timer(bm->master, bgp_reuse_timer, NULL, DELTA_REUSE, NULL);
t_now = bgp_clock ();
bgp_damp_parameter_set (half, reuse, suppress, max);
/* Register reuse timer. */
- if (! damp->t_reuse)
- damp->t_reuse =
- thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
+ thread_add_timer(bm->master, bgp_reuse_timer, NULL, DELTA_REUSE,
+ &damp->t_reuse);
return 0;
}
secs_into_day = tm->tm_sec + 60*tm->tm_min + 60*60*tm->tm_hour;
interval = interval - secs_into_day % interval; /* always > 0 */
}
- bgp_dump->t_interval = thread_add_timer (bm->master, bgp_dump_interval_func,
- bgp_dump, interval);
+ bgp_dump->t_interval = thread_add_timer(bm->master,
+ bgp_dump_interval_func,
+ bgp_dump, interval, NULL);
}
else
{
/* One-off dump: execute immediately, don't affect any scheduled dumps */
- bgp_dump->t_interval = thread_add_event (bm->master, bgp_dump_interval_func,
- bgp_dump, 0);
+ bgp_dump->t_interval = thread_add_event(bm->master,
+ bgp_dump_interval_func,
+ bgp_dump, 0, NULL);
}
return 0;
zlog_info ("Begin maxmed onstartup mode - timer %d seconds",
bgp->v_maxmed_onstartup);
- THREAD_TIMER_ON (bm->master, bgp->t_maxmed_onstartup,
- bgp_maxmed_onstartup_timer,
- bgp, bgp->v_maxmed_onstartup);
+ thread_add_timer(bm->master, bgp_maxmed_onstartup_timer, bgp,
+ bgp->v_maxmed_onstartup, &bgp->t_maxmed_onstartup);
if (!bgp->v_maxmed_admin)
{
peer->update_delay_over = 0;
/* Start the update-delay timer */
- THREAD_TIMER_ON (bm->master, bgp->t_update_delay, bgp_update_delay_timer,
- bgp, bgp->v_update_delay);
+ thread_add_timer(bm->master, bgp_update_delay_timer, bgp,
+ bgp->v_update_delay, &bgp->t_update_delay);
if (bgp->v_establish_wait != bgp->v_update_delay)
- THREAD_TIMER_ON (bm->master, bgp->t_establish_wait, bgp_establish_wait_timer,
- bgp, bgp->v_establish_wait);
+ thread_add_timer(bm->master, bgp_establish_wait_timer, bgp,
+ bgp->v_establish_wait, &bgp->t_establish_wait);
quagga_timestamp(3, bgp->update_delay_begin_time,
sizeof(bgp->update_delay_begin_time));
#define _QUAGGA_BGP_FSM_H
/* Macro for BGP read, write and timer thread. */
-#define BGP_READ_ON(T,F,V) \
- do { \
- if (!(T) && (peer->status != Deleted)) \
- THREAD_READ_ON(bm->master,T,F,peer,V); \
+#define BGP_READ_ON(T,F,V) \
+ do { \
+ if ((peer->status != Deleted)) \
+ thread_add_read (bm->master,(F),peer,(V),&(T)); \
} while (0)
-#define BGP_READ_OFF(T) \
- do { \
- if (T) \
- THREAD_READ_OFF(T); \
+#define BGP_READ_OFF(T) \
+ do { \
+ if (T) \
+ THREAD_READ_OFF(T); \
} while (0)
-#define BGP_WRITE_ON(T,F,V) \
- do { \
- if (!(T) && (peer->status != Deleted)) \
- THREAD_WRITE_ON(bm->master,(T),(F),peer,(V)); \
+#define BGP_WRITE_ON(T,F,V) \
+ do { \
+ if ((peer)->status != Deleted) \
+ thread_add_write (bm->master,(F),(peer),(V),&(T)); \
} while (0)
-#define BGP_PEER_WRITE_ON(T,F,V, peer) \
- do { \
- if (!(T) && ((peer)->status != Deleted)) \
- THREAD_WRITE_ON(bm->master,(T),(F),(peer),(V)); \
+#define BGP_PEER_WRITE_ON(T,F,V, peer) \
+ do { \
+ if ((peer)->status != Deleted) \
+ thread_add_write (bm->master,(F),(peer),(V),&(T)); \
} while (0)
-#define BGP_WRITE_OFF(T) \
- do { \
- if (T) \
- THREAD_WRITE_OFF(T); \
+#define BGP_WRITE_OFF(T) \
+ do { \
+ if (T) \
+ THREAD_WRITE_OFF(T); \
} while (0)
-#define BGP_TIMER_ON(T,F,V) \
- do { \
- if (!(T) && (peer->status != Deleted)) \
- THREAD_TIMER_ON(bm->master,(T),(F),peer,(V)); \
+#define BGP_TIMER_ON(T,F,V) \
+ do { \
+ if ((peer->status != Deleted)) \
+ thread_add_timer (bm->master,(F),peer,(V),&(T)); \
} while (0)
-#define BGP_TIMER_OFF(T) \
- do { \
- if (T) \
- THREAD_TIMER_OFF(T); \
+#define BGP_TIMER_OFF(T) \
+ do { \
+ if (T) \
+ THREAD_TIMER_OFF(T); \
} while (0)
-#define BGP_EVENT_ADD(P,E) \
- do { \
- if ((P)->status != Deleted) \
- thread_add_event (bm->master, bgp_event, (P), (E)); \
+#define BGP_EVENT_ADD(P,E) \
+ do { \
+ if ((P)->status != Deleted) \
+ thread_add_event (bm->master, bgp_event, (P), (E), NULL); \
} while (0)
-#define BGP_EVENT_FLUSH(P) \
- do { \
- assert (peer); \
- thread_cancel_event (bm->master, (P)); \
+#define BGP_EVENT_FLUSH(P) \
+ do { \
+ assert (peer); \
+ thread_cancel_event (bm->master, (P)); \
} while (0)
#define BGP_MSEC_JITTER 10
zlog_err ("accept_sock is nevative value %d", accept_sock);
return -1;
}
- listener->thread = thread_add_read (bm->master, bgp_accept, listener, accept_sock);
+ listener->thread = thread_add_read(bm->master, bgp_accept, listener,
+ accept_sock, NULL);
/* Accept client connection. */
bgp_sock = sockunion_accept (accept_sock, &su);
listener = XMALLOC (MTYPE_BGP_LISTENER, sizeof(*listener));
listener->fd = sock;
memcpy(&listener->su, sa, salen);
- listener->thread = thread_add_read (bm->master, bgp_accept, listener, sock);
+ listener->thread = thread_add_read(bm->master, bgp_accept, listener, sock,
+ NULL);
listnode_add (bm->listen_sockets, listener);
return 0;
if (!bgp->t_rmap_def_originate_eval)
{
bgp_lock (bgp);
- THREAD_TIMER_ON(bm->master, bgp->t_rmap_def_originate_eval,
- update_group_refresh_default_originate_route_map,
- bgp, RMAP_DEFAULT_ORIGINATE_EVAL_TIMER);
+ thread_add_timer(bm->master,
+ update_group_refresh_default_originate_route_map,
+ bgp, RMAP_DEFAULT_ORIGINATE_EVAL_TIMER,
+ &bgp->t_rmap_def_originate_eval);
}
}
* multiple peers and the announcement doesn't happen in the
* vty context.
*/
- THREAD_TIMER_MSEC_ON (bm->master, paf->t_announce_route,
- bgp_announce_route_timer_expired, paf,
- (subgrp->peer_count == 1) ?
- BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS :
- BGP_ANNOUNCE_ROUTE_DELAY_MS);
+ thread_add_timer_msec(bm->master, bgp_announce_route_timer_expired, paf,
+ (subgrp->peer_count == 1) ? BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS : BGP_ANNOUNCE_ROUTE_DELAY_MS,
+ &paf->t_announce_route);
}
/*
{
bm->t_rmap_update =
thread_add_timer(bm->master, bgp_route_map_update_timer, NULL,
- bm->rmap_update_timer);
+ bm->rmap_update_timer, NULL);
/* Signal the groups that a route-map update event has started */
for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
return 0;
subgrp->t_merge_check =
- thread_add_background (bm->master,
- update_subgroup_merge_check_thread_cb,
- subgrp, 0);
+ thread_add_background(bm->master, update_subgroup_merge_check_thread_cb,
+ subgrp, 0, NULL);
SUBGRP_INCR_STAT (subgrp, merge_checks_triggered);
*/
if (!subgrp->t_coalesce)
{
- THREAD_TIMER_MSEC_ON (bm->master, subgrp->t_coalesce, subgroup_coalesce_timer,
- subgrp, subgrp->v_coalesce);
+ thread_add_timer_msec(bm->master, subgroup_coalesce_timer, subgrp,
+ subgrp->v_coalesce, &subgrp->t_coalesce);
}
}
else
{
/* TODO - The startup timer needs to be run for the whole of BGP */
- THREAD_TIMER_ON (bm->master, bgp->t_startup, bgp_startup_timer_expire,
- bgp, bgp->restart_time);
+ thread_add_timer(bm->master, bgp_startup_timer_expire, bgp,
+ bgp->restart_time, &bgp->t_startup);
}
bgp->wpkt_quanta = BGP_WRITE_PACKET_MAX;
if (lifetime > UINT32_MAX / 1001)
{
/* sub-optimal case, but will probably never happen */
- bi->extra->vnc.import.timer = thread_add_timer (bm->master,
- timer_service_func,
- wcb, lifetime);
+ bi->extra->vnc.import.timer = thread_add_timer(bm->master,
+ timer_service_func, wcb,
+ lifetime, NULL);
}
else
{
lifetime_msec = (lifetime * 1000) + jitter;
- bi->extra->vnc.import.timer = thread_add_background (bm->master,
- timer_service_func,
- wcb,
- lifetime_msec);
+ bi->extra->vnc.import.timer = thread_add_background(bm->master,
+ timer_service_func,
+ wcb, lifetime_msec,
+ NULL);
}
/* re-sort route list (BGP_INFO_REMOVED routes are last) */
rfapi_ntop (m->p.family, m->p.u.val, buf, BUFSIZ),
m->rfd->response_lifetime);
}
- m->timer = thread_add_timer (bm->master, rfapiMonitorTimerExpire, m,
- m->rfd->response_lifetime);
+ m->timer = thread_add_timer(bm->master, rfapiMonitorTimerExpire, m,
+ m->rfd->response_lifetime, NULL);
}
/*
rfapiEthAddr2Str (&m->macaddr, buf, BUFSIZ),
m->rfd->response_lifetime);
}
- m->timer = thread_add_timer (bm->master, rfapiMonitorEthTimerExpire, m,
- m->rfd->response_lifetime);
+ m->timer = thread_add_timer(bm->master, rfapiMonitorEthTimerExpire, m,
+ m->rfd->response_lifetime, NULL);
}
static int
prefix2str (&rn->p, buf_prefix, BUFSIZ);
vnc_zlog_debug_verbose ("%s: rfd %p pfx %s life %u", __func__, rfd, buf_prefix,
ri->lifetime);
- ri->timer = thread_add_timer (bm->master, rfapiRibExpireTimer,
- tcb, ri->lifetime);
+ ri->timer = thread_add_timer(bm->master, rfapiRibExpireTimer, tcb,
+ ri->lifetime, NULL);
assert (ri->timer);
}
if (!eti->timer && eti->lifetime <= INT32_MAX)
{
- eti->timer = thread_add_timer (bm->master,
- vncExportWithdrawTimer,
- eti, eti->lifetime);
+ eti->timer = thread_add_timer(bm->master, vncExportWithdrawTimer, eti,
+ eti->lifetime, NULL);
vnc_zlog_debug_verbose ("%s: set expiration timer for %u seconds",
__func__, eti->lifetime);
}
isis_circuit_prepare (struct isis_circuit *circuit)
{
#ifdef GNU_LINUX
- THREAD_READ_ON (master, circuit->t_read, isis_receive, circuit,
- circuit->fd);
+ thread_add_read(master, isis_receive, circuit, circuit->fd,
+ &circuit->t_read);
#else
- THREAD_TIMER_MSEC_ON (master, circuit->t_read, isis_receive, circuit,
- listcount (circuit->area->circuit_list) * 100);
+ thread_add_timer_msec(master, isis_receive, circuit,
+ listcount(circuit->area->circuit_list) * 100,
+ &circuit->t_read);
#endif
}
if (circuit->is_type & IS_LEVEL_1)
{
- thread_add_event (master, send_lan_l1_hello, circuit, 0);
+ thread_add_event(master, send_lan_l1_hello, circuit, 0, NULL);
circuit->u.bc.lan_neighs[0] = list_new ();
}
if (circuit->is_type & IS_LEVEL_2)
{
- thread_add_event (master, send_lan_l2_hello, circuit, 0);
+ thread_add_event(master, send_lan_l2_hello, circuit, 0, NULL);
circuit->u.bc.lan_neighs[1] = list_new ();
}
/* 8.4.1 d) */
/* dr election will commence in... */
if (circuit->is_type & IS_LEVEL_1)
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[0]);
+ thread_add_timer(master, isis_run_dr_l1, circuit,
+ 2 * circuit->hello_interval[0],
+ &circuit->u.bc.t_run_dr[0]);
if (circuit->is_type & IS_LEVEL_2)
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
+ thread_add_timer(master, isis_run_dr_l2, circuit,
+ 2 * circuit->hello_interval[1],
+ &circuit->u.bc.t_run_dr[1]);
}
else
{
* for a ptp IF
*/
circuit->u.p2p.neighbor = NULL;
- thread_add_event (master, send_p2p_hello, circuit, 0);
+ thread_add_event(master, send_p2p_hello, circuit, 0, NULL);
}
/* initializing PSNP timers */
if (circuit->is_type & IS_LEVEL_1)
- THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
+ thread_add_timer(master, send_l1_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
+ &circuit->t_send_psnp[0]);
if (circuit->is_type & IS_LEVEL_2)
- THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
+ thread_add_timer(master, send_l2_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
+ &circuit->t_send_psnp[1]);
/* unified init for circuits; ignore warnings below this level */
retv = isis_sock_init (circuit);
THREAD_TIMER_OFF (circuit->t_send_csnp[0]);
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[0]);
+ thread_add_timer(master, isis_run_dr_l1, circuit,
+ 2 * circuit->hello_interval[0],
+ &circuit->u.bc.t_run_dr[0]);
- THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter (circuit->psnp_interval[level - 1],
- PSNP_JITTER));
+ thread_add_timer(master, send_l1_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[level - 1], PSNP_JITTER),
+ &circuit->t_send_psnp[0]);
}
else
{
THREAD_TIMER_OFF (circuit->t_send_csnp[1]);
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
+ thread_add_timer(master, isis_run_dr_l2, circuit,
+ 2 * circuit->hello_interval[1],
+ &circuit->u.bc.t_run_dr[1]);
- THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter (circuit->psnp_interval[level - 1],
- PSNP_JITTER));
+ thread_add_timer(master, send_l2_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[level - 1], PSNP_JITTER),
+ &circuit->t_send_psnp[1]);
}
- thread_add_event (master, isis_event_dis_status_change, circuit, 0);
+ thread_add_event(master, isis_event_dis_status_change, circuit, 0, NULL);
return ISIS_OK;
}
/* Lets keep a pause in DR election */
circuit->u.bc.run_dr_elect[level - 1] = 0;
if (level == 1)
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[0]);
+ thread_add_timer(master, isis_run_dr_l1, circuit,
+ 2 * circuit->hello_interval[0],
+ &circuit->u.bc.t_run_dr[0]);
else
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
+ thread_add_timer(master, isis_run_dr_l2, circuit,
+ 2 * circuit->hello_interval[1],
+ &circuit->u.bc.t_run_dr[1]);
circuit->u.bc.is_dr[level - 1] = 1;
if (level == 1)
lsp_generate_pseudo (circuit, 1);
THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[0]);
+ thread_add_timer(master, isis_run_dr_l1, circuit,
+ 2 * circuit->hello_interval[0],
+ &circuit->u.bc.t_run_dr[0]);
- THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
- isis_jitter (circuit->csnp_interval[level - 1],
- CSNP_JITTER));
+ thread_add_timer(master, send_l1_csnp, circuit,
+ isis_jitter(circuit->csnp_interval[level - 1], CSNP_JITTER),
+ &circuit->t_send_csnp[0]);
}
else
lsp_generate_pseudo (circuit, 2);
THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
+ thread_add_timer(master, isis_run_dr_l2, circuit,
+ 2 * circuit->hello_interval[1],
+ &circuit->u.bc.t_run_dr[1]);
- THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
- isis_jitter (circuit->csnp_interval[level - 1],
- CSNP_JITTER));
+ thread_add_timer(master, send_l2_csnp, circuit,
+ isis_jitter(circuit->csnp_interval[level - 1], CSNP_JITTER),
+ &circuit->t_send_csnp[1]);
}
- thread_add_event (master, isis_event_dis_status_change, circuit, 0);
+ thread_add_event(master, isis_event_dis_status_change, circuit, 0, NULL);
return ISIS_OK;
}
{
if (dyn_cache == NULL)
dyn_cache = list_new ();
- THREAD_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
+ thread_add_timer(master, dyn_cache_cleanup, NULL, 120, &isis->t_dync_clean);
return;
}
XFREE (MTYPE_ISIS_DYNHN, dyn);
}
- THREAD_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
+ thread_add_timer(master, dyn_cache_cleanup, NULL, 120, &isis->t_dync_clean);
return ISIS_OK;
}
if (level == 1)
{
if (! circuit->is_passive)
- THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
+ thread_add_timer(master, send_l1_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
+ &circuit->t_send_psnp[0]);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[0]);
+ thread_add_timer(master, isis_run_dr_l1, circuit,
+ 2 * circuit->hello_interval[0],
+ &circuit->u.bc.t_run_dr[0]);
- THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
- send_lan_l1_hello, circuit,
- isis_jitter (circuit->hello_interval[0],
- IIH_JITTER));
+ thread_add_timer(master, send_lan_l1_hello, circuit,
+ isis_jitter(circuit->hello_interval[0], IIH_JITTER),
+ &circuit->u.bc.t_send_lan_hello[0]);
circuit->u.bc.lan_neighs[0] = list_new ();
}
else
{
if (! circuit->is_passive)
- THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
+ thread_add_timer(master, send_l2_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
+ &circuit->t_send_psnp[1]);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
- THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
+ thread_add_timer(master, isis_run_dr_l2, circuit,
+ 2 * circuit->hello_interval[1],
+ &circuit->u.bc.t_run_dr[1]);
- THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
- send_lan_l2_hello, circuit,
- isis_jitter (circuit->hello_interval[1],
- IIH_JITTER));
+ thread_add_timer(master, send_lan_l2_hello, circuit,
+ isis_jitter(circuit->hello_interval[1], IIH_JITTER),
+ &circuit->u.bc.t_send_lan_hello[1]);
circuit->u.bc.lan_neighs[1] = list_new ();
}
THREAD_TIMER_OFF (area->t_lsp_refresh[level - 1]);
area->lsp_regenerate_pending[level - 1] = 0;
if (level == IS_LEVEL_1)
- THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
- lsp_l1_refresh, area, refresh_time);
+ thread_add_timer(master, lsp_l1_refresh, area, refresh_time,
+ &area->t_lsp_refresh[level - 1]);
else if (level == IS_LEVEL_2)
- THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
- lsp_l2_refresh, area, refresh_time);
+ thread_add_timer(master, lsp_l2_refresh, area, refresh_time,
+ &area->t_lsp_refresh[level - 1]);
if (isis->debugs & DEBUG_UPDATE_PACKETS)
{
refresh_time = lsp_refresh_time (lsp, rem_lifetime);
if (level == IS_LEVEL_1)
- THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
- lsp_l1_refresh, area, refresh_time);
+ thread_add_timer(master, lsp_l1_refresh, area, refresh_time,
+ &area->t_lsp_refresh[level - 1]);
else if (level == IS_LEVEL_2)
- THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
- lsp_l2_refresh, area, refresh_time);
+ thread_add_timer(master, lsp_l2_refresh, area, refresh_time,
+ &area->t_lsp_refresh[level - 1]);
area->lsp_regenerate_pending[level - 1] = 0;
if (isis->debugs & DEBUG_UPDATE_PACKETS)
area->lsp_regenerate_pending[lvl - 1] = 1;
if (lvl == IS_LEVEL_1)
{
- THREAD_TIMER_MSEC_ON(master, area->t_lsp_refresh[lvl - 1],
- lsp_l1_refresh, area, timeout);
+ thread_add_timer_msec(master, lsp_l1_refresh, area, timeout,
+ &area->t_lsp_refresh[lvl - 1]);
}
else if (lvl == IS_LEVEL_2)
{
- THREAD_TIMER_MSEC_ON(master, area->t_lsp_refresh[lvl - 1],
- lsp_l2_refresh, area, timeout);
+ thread_add_timer_msec(master, lsp_l2_refresh, area, timeout,
+ &area->t_lsp_refresh[lvl - 1]);
}
}
THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
circuit->lsp_regenerate_pending[level - 1] = 0;
if (level == IS_LEVEL_1)
- THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
- lsp_l1_refresh_pseudo, circuit, refresh_time);
+ thread_add_timer(master, lsp_l1_refresh_pseudo, circuit, refresh_time,
+ &circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
else if (level == IS_LEVEL_2)
- THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
- lsp_l2_refresh_pseudo, circuit, refresh_time);
+ thread_add_timer(master, lsp_l2_refresh_pseudo, circuit, refresh_time,
+ &circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
if (isis->debugs & DEBUG_UPDATE_PACKETS)
{
refresh_time = lsp_refresh_time (lsp, rem_lifetime);
if (level == IS_LEVEL_1)
- THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
- lsp_l1_refresh_pseudo, circuit, refresh_time);
+ thread_add_timer(master, lsp_l1_refresh_pseudo, circuit, refresh_time,
+ &circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
else if (level == IS_LEVEL_2)
- THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
- lsp_l2_refresh_pseudo, circuit, refresh_time);
+ thread_add_timer(master, lsp_l2_refresh_pseudo, circuit, refresh_time,
+ &circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
if (isis->debugs & DEBUG_UPDATE_PACKETS)
{
if (lvl == IS_LEVEL_1)
{
- THREAD_TIMER_MSEC_ON(master,
- circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1],
- lsp_l1_refresh_pseudo, circuit, timeout);
+ thread_add_timer_msec(master, lsp_l1_refresh_pseudo, circuit,
+ timeout,
+ &circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
}
else if (lvl == IS_LEVEL_2)
{
- THREAD_TIMER_MSEC_ON(master,
- circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1],
- lsp_l2_refresh_pseudo, circuit, timeout);
+ thread_add_timer_msec(master, lsp_l2_refresh_pseudo, circuit,
+ timeout,
+ &circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
}
}
area = THREAD_ARG (thread);
assert (area);
area->t_tick = NULL;
- THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
+ thread_add_timer(master, lsp_tick, area, 1, &area->t_tick);
/*
* Build a list of LSPs with (any) SRMflag set
if (! listnode_lookup (circuit->lsp_queue, lsp))
{
listnode_add (circuit->lsp_queue, lsp);
- thread_add_event (master, send_lsp, circuit, 0);
+ thread_add_event(master, send_lsp, circuit, 0,
+ NULL);
}
}
}
/* lets take care of the expiry */
THREAD_TIMER_OFF (adj->t_expire);
- THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
- (long) adj->hold_time);
+ thread_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
+ &adj->t_expire);
/* 8.2.5.2 a) a match was detected */
if (area_match (circuit->area->area_addrs, tlvs.area_addrs))
case 1:
if (memcmp (circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
{
- thread_add_event (master, isis_event_dis_status_change, circuit, 0);
+ thread_add_event(master, isis_event_dis_status_change, circuit, 0,
+ NULL);
memcpy (&circuit->u.bc.l1_desig_is, hdr.lan_id,
ISIS_SYS_ID_LEN + 1);
}
case 2:
if (memcmp (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
{
- thread_add_event (master, isis_event_dis_status_change, circuit, 0);
+ thread_add_event(master, isis_event_dis_status_change, circuit, 0,
+ NULL);
memcpy (&circuit->u.bc.l2_desig_is, hdr.lan_id,
ISIS_SYS_ID_LEN + 1);
}
/* lets take care of the expiry */
THREAD_TIMER_OFF (adj->t_expire);
- THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
- (long) adj->hold_time);
+ thread_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
+ &adj->t_expire);
/*
* If the snpa for this circuit is found from LAN Neighbours TLV
retval = send_hello (circuit, 1);
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
- send_lan_l1_hello, circuit,
- isis_jitter (circuit->hello_interval[0], IIH_JITTER));
+ thread_add_timer(master, send_lan_l1_hello, circuit,
+ isis_jitter(circuit->hello_interval[0], IIH_JITTER),
+ &circuit->u.bc.t_send_lan_hello[0]);
return retval;
}
retval = send_hello (circuit, 2);
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
- send_lan_l2_hello, circuit,
- isis_jitter (circuit->hello_interval[1], IIH_JITTER));
+ thread_add_timer(master, send_lan_l2_hello, circuit,
+ isis_jitter(circuit->hello_interval[1], IIH_JITTER),
+ &circuit->u.bc.t_send_lan_hello[1]);
return retval;
}
send_hello (circuit, 1);
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->u.p2p.t_send_p2p_hello, send_p2p_hello,
- circuit, isis_jitter (circuit->hello_interval[1],
- IIH_JITTER));
+ thread_add_timer(master, send_p2p_hello, circuit,
+ isis_jitter(circuit->hello_interval[1], IIH_JITTER),
+ &circuit->u.p2p.t_send_p2p_hello);
return ISIS_OK;
}
send_csnp (circuit, 1);
}
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
- isis_jitter (circuit->csnp_interval[0], CSNP_JITTER));
+ thread_add_timer(master, send_l1_csnp, circuit,
+ isis_jitter(circuit->csnp_interval[0], CSNP_JITTER),
+ &circuit->t_send_csnp[0]);
return retval;
}
send_csnp (circuit, 2);
}
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
- isis_jitter (circuit->csnp_interval[1], CSNP_JITTER));
+ thread_add_timer(master, send_l2_csnp, circuit,
+ isis_jitter(circuit->csnp_interval[1], CSNP_JITTER),
+ &circuit->t_send_csnp[1]);
return retval;
}
send_psnp (1, circuit);
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
+ thread_add_timer(master, send_l1_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
+ &circuit->t_send_psnp[0]);
return retval;
}
send_psnp (2, circuit);
/* set next timer thread */
- THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
+ thread_add_timer(master, send_l2_psnp, circuit,
+ isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
+ &circuit->t_send_psnp[1]);
return retval;
}
if (area->spf_timer[level - 1])
return ISIS_OK;
- THREAD_TIMER_MSEC_ON(master, area->spf_timer[level-1],
- isis_run_spf_cb, isis_run_spf_arg(area, level),
- delay);
+ thread_add_timer_msec (master, isis_run_spf_cb,
+ isis_run_spf_arg(area, level),
+ delay, &area->spf_timer[level-1]);
return ISIS_OK;
}
return retval;
}
- THREAD_TIMER_ON (master, area->spf_timer[level-1],
- isis_run_spf_cb, isis_run_spf_arg(area, level),
- area->min_spf_interval[level-1] - diff);
+ thread_add_timer (master, isis_run_spf_cb, isis_run_spf_arg(area, level),
+ area->min_spf_interval[level-1] - diff,
+ &area->spf_timer[level-1]);
if (isis->debugs & DEBUG_SPF_EVENTS)
zlog_debug ("ISIS-Spf (%s) L%d SPF scheduled %d sec from now",
area->circuit_list = list_new ();
area->area_addrs = list_new ();
- THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
+ thread_add_timer(master, lsp_tick, area, 1, &area->t_tick);
flags_initialize (&area->flags);
/*
av->arg = arg;
LIST_INSERT_HEAD(&accept_queue.queue, av, entry);
- av->ev = thread_add_read(master, accept_cb, av, av->fd);
+ av->ev = thread_add_read(master, accept_cb, av, av->fd, NULL);
log_debug("%s: accepting on fd %d", __func__, fd);
{
log_debug(__func__);
accept_unarm();
- accept_queue.evt = thread_add_timer(master, accept_timeout, NULL, 1);
+ accept_queue.evt = thread_add_timer(master, accept_timeout, NULL, 1,
+ NULL);
}
void
{
struct accept_ev *av;
LIST_FOREACH(av, &accept_queue.queue, entry)
- av->ev = thread_add_read(master, accept_cb, av, av->fd);
+ av->ev = thread_add_read(master, accept_cb, av, av->fd, NULL);
}
static void
accept_cb(struct thread *thread)
{
struct accept_ev *av = THREAD_ARG(thread);
- av->ev = thread_add_read(master, accept_cb, av, av->fd);
+ av->ev = thread_add_read(master, accept_cb, av, av->fd, NULL);
av->accept_cb(thread);
return (0);
{
THREAD_TIMER_OFF(adj->inactivity_timer);
adj->inactivity_timer = thread_add_timer(master, adj_itimer, adj,
- adj->holdtime);
+ adj->holdtime, NULL);
}
void
{
THREAD_TIMER_OFF(tnbr->hello_timer);
tnbr->hello_timer = thread_add_timer(master, tnbr_hello_timer, tnbr,
- tnbr_get_hello_interval(tnbr));
+ tnbr_get_hello_interval(tnbr),
+ NULL);
}
static void
imsg_init(&c->iev.ibuf, connfd);
c->iev.handler_read = control_dispatch_imsg;
- c->iev.ev_read = thread_add_read(master, c->iev.handler_read,
- &c->iev, c->iev.ibuf.fd);
+ c->iev.ev_read = thread_add_read(master, c->iev.handler_read, &c->iev,
+ c->iev.ibuf.fd, NULL);
c->iev.handler_write = ldp_write_handler;
c->iev.ev_write = NULL;
{
THREAD_TIMER_OFF(ia->hello_timer);
ia->hello_timer = thread_add_timer(master, if_hello_timer, ia,
- if_get_hello_interval(ia));
+ if_get_hello_interval(ia), NULL);
}
static void
imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
iev_main->handler_read = lde_dispatch_parent;
iev_main->ev_read = thread_add_read(master, iev_main->handler_read,
- iev_main, iev_main->ibuf.fd);
+ iev_main, iev_main->ibuf.fd, NULL);
iev_main->handler_write = ldp_write_handler;
if ((iev_main_sync = calloc(1, sizeof(struct imsgev))) == NULL)
imsg_init(&iev_ldpe->ibuf, fd);
iev_ldpe->handler_read = lde_dispatch_imsg;
iev_ldpe->ev_read = thread_add_read(master,
- iev_ldpe->handler_read, iev_ldpe, iev_ldpe->ibuf.fd);
+ iev_ldpe->handler_read,
+ iev_ldpe,
+ iev_ldpe->ibuf.fd,
+ NULL);
iev_ldpe->handler_write = ldp_write_handler;
iev_ldpe->ev_write = NULL;
break;
{
THREAD_TIMER_OFF(gc_timer);
gc_timer = thread_add_timer(master, lde_gc_timer, NULL,
- LDE_GC_INTERVAL);
+ LDE_GC_INTERVAL, NULL);
}
void
imsg_init(&iev_ldpe->ibuf, pipe_parent2ldpe[0]);
iev_ldpe->handler_read = main_dispatch_ldpe;
iev_ldpe->ev_read = thread_add_read(master, iev_ldpe->handler_read,
- iev_ldpe, iev_ldpe->ibuf.fd);
+ iev_ldpe, iev_ldpe->ibuf.fd, NULL);
iev_ldpe->handler_write = ldp_write_handler;
imsg_init(&iev_ldpe_sync->ibuf, pipe_parent2ldpe_sync[0]);
iev_ldpe_sync->handler_read = main_dispatch_ldpe;
iev_ldpe_sync->ev_read = thread_add_read(master,
- iev_ldpe_sync->handler_read, iev_ldpe_sync, iev_ldpe_sync->ibuf.fd);
+ iev_ldpe_sync->handler_read,
+ iev_ldpe_sync,
+ iev_ldpe_sync->ibuf.fd, NULL);
iev_ldpe_sync->handler_write = ldp_write_handler;
imsg_init(&iev_lde->ibuf, pipe_parent2lde[0]);
iev_lde->handler_read = main_dispatch_lde;
iev_lde->ev_read = thread_add_read(master, iev_lde->handler_read,
- iev_lde, iev_lde->ibuf.fd);
+ iev_lde, iev_lde->ibuf.fd, NULL);
iev_lde->handler_write = ldp_write_handler;
imsg_init(&iev_lde_sync->ibuf, pipe_parent2lde_sync[0]);
iev_lde_sync->handler_read = main_dispatch_lde;
iev_lde_sync->ev_read = thread_add_read(master,
- iev_lde_sync->handler_read, iev_lde_sync, iev_lde_sync->ibuf.fd);
+ iev_lde_sync->handler_read,
+ iev_lde_sync,
+ iev_lde_sync->ibuf.fd, NULL);
iev_lde_sync->handler_write = ldp_write_handler;
if (main_imsg_send_ipc_sockets(&iev_ldpe->ibuf, &iev_lde->ibuf))
imsg_event_add(struct imsgev *iev)
{
if (iev->handler_read)
- THREAD_READ_ON(master, iev->ev_read, iev->handler_read, iev,
- iev->ibuf.fd);
+ thread_add_read(master, iev->handler_read, iev, iev->ibuf.fd,
+ &iev->ev_read);
if (iev->handler_write && iev->ibuf.w.queued)
- THREAD_WRITE_ON(master, iev->ev_write, iev->handler_write, iev,
- iev->ibuf.fd);
+ thread_add_write(master, iev->handler_write, iev,
+ iev->ibuf.fd, &iev->ev_write);
}
int
evbuf_event_add(struct evbuf *eb)
{
if (eb->wbuf.queued)
- THREAD_WRITE_ON(master, eb->ev, eb->handler, eb->arg,
- eb->wbuf.fd);
+ thread_add_write(master, eb->handler, eb->arg, eb->wbuf.fd,
+ &eb->ev);
}
void
imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
iev_main->handler_read = ldpe_dispatch_main;
iev_main->ev_read = thread_add_read(master, iev_main->handler_read,
- iev_main, iev_main->ibuf.fd);
+ iev_main, iev_main->ibuf.fd, NULL);
iev_main->handler_write = ldp_write_handler;
if ((iev_main_sync = calloc(1, sizeof(struct imsgev))) == NULL)
#ifdef __OpenBSD__
global.pfkeysock = pfkey_init();
if (sysdep.no_pfkey == 0)
- pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey,
- NULL, global.pfkeysock);
+ pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey, NULL,
+ global.pfkeysock, NULL);
#endif
/* mark sockets as closed */
imsg_init(&iev_lde->ibuf, fd);
iev_lde->handler_read = ldpe_dispatch_lde;
iev_lde->ev_read = thread_add_read(master,
- iev_lde->handler_read, iev_lde, iev_lde->ibuf.fd);
+ iev_lde->handler_read,
+ iev_lde,
+ iev_lde->ibuf.fd,
+ NULL);
iev_lde->handler_write = ldp_write_handler;
iev_lde->ev_write = NULL;
break;
{
int fd = THREAD_FD(thread);
- pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey,
- NULL, global.pfkeysock);
+ pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey, NULL,
+ global.pfkeysock, NULL);
if (pfkey_read(fd, NULL) == -1)
fatal("pfkey_read failed, exiting...");
/* discovery socket */
af_global->ldp_disc_socket = disc_socket;
af_global->disc_ev = thread_add_read(master, disc_recv_packet,
- &af_global->disc_ev, af_global->ldp_disc_socket);
+ &af_global->disc_ev,
+ af_global->ldp_disc_socket, NULL);
/* extended discovery socket */
af_global->ldp_edisc_socket = edisc_socket;
af_global->edisc_ev = thread_add_read(master, disc_recv_packet,
- &af_global->edisc_ev, af_global->ldp_edisc_socket);
+ &af_global->edisc_ev,
+ af_global->ldp_edisc_socket,
+ NULL);
/* session socket */
af_global->ldp_session_socket = session_socket;
/* send three keepalives per period */
secs = nbr->keepalive / KEEPALIVE_PER_PERIOD;
THREAD_TIMER_OFF(nbr->keepalive_timer);
- nbr->keepalive_timer = thread_add_timer(master, nbr_ktimer, nbr, secs);
+ nbr->keepalive_timer = thread_add_timer(master, nbr_ktimer, nbr, secs,
+ NULL);
}
void
{
THREAD_TIMER_OFF(nbr->keepalive_timeout);
nbr->keepalive_timeout = thread_add_timer(master, nbr_ktimeout, nbr,
- nbr->keepalive);
+ nbr->keepalive, NULL);
}
void
secs = INIT_FSM_TIMEOUT;
THREAD_TIMER_OFF(nbr->init_timeout);
- nbr->init_timeout = thread_add_timer(master, nbr_itimeout, nbr, secs);
+ nbr->init_timeout = thread_add_timer(master, nbr_itimeout, nbr, secs,
+ NULL);
}
void
}
THREAD_TIMER_OFF(nbr->initdelay_timer);
- nbr->initdelay_timer = thread_add_timer(master, nbr_idtimer, nbr, secs);
+ nbr->initdelay_timer = thread_add_timer(master, nbr_idtimer, nbr,
+ secs, NULL);
}
void
if (connect(nbr->fd, (struct sockaddr *)&remote_sa,
sockaddr_len((struct sockaddr *)&remote_sa)) == -1) {
if (errno == EINPROGRESS) {
- THREAD_WRITE_ON(master, nbr->ev_connect, nbr_connect_cb,
- nbr, nbr->fd);
+ thread_add_write(master, nbr_connect_cb, nbr, nbr->fd,
+ &nbr->ev_connect);
return (0);
}
log_warn("%s: error while connecting to %s", __func__,
struct in_addr lsr_id;
/* reschedule read */
- *threadp = thread_add_read(master, disc_recv_packet, threadp, fd);
+ *threadp = thread_add_read(master, disc_recv_packet, threadp, fd,
+ NULL);
/* setup buffer */
memset(&m, 0, sizeof(m));
uint16_t pdu_len, msg_len, msg_size, max_pdu_len;
int ret;
- tcp->rev = thread_add_read(master, session_read, nbr, fd);
+ tcp->rev = thread_add_read(master, session_read, nbr, fd, NULL);
if ((n = read(fd, tcp->rbuf->buf + tcp->rbuf->wpos,
sizeof(tcp->rbuf->buf) - tcp->rbuf->wpos)) == -1) {
if ((tcp->rbuf = calloc(1, sizeof(struct ibuf_read))) == NULL)
fatal(__func__);
- tcp->rev = thread_add_read(master, session_read, nbr, tcp->fd);
+ tcp->rev = thread_add_read(master, session_read, nbr, tcp->fd,
+ NULL);
tcp->nbr = nbr;
}
pconn->addr = *addr;
TAILQ_INSERT_TAIL(&global.pending_conns, pconn, entry);
pconn->ev_timeout = thread_add_timer(master, pending_conn_timeout,
- pconn, PENDING_CONN_TIMEOUT);
+ pconn, PENDING_CONN_TIMEOUT,
+ NULL);
return (pconn);
}
snmp_select_info (&maxfd, &fds, &timeout, &block);
if (!block)
- timeout_thr = thread_add_timer_tv (agentx_tm, agentx_timeout, NULL, &timeout);
+ timeout_thr = thread_add_timer_tv(agentx_tm, agentx_timeout, NULL,
+ &timeout, NULL);
ln = listhead (events);
thr = ln ? listgetdata (ln) : NULL;
else if (FD_ISSET (fd, &fds))
{
struct listnode *newln;
- thr = thread_add_read (agentx_tm, agentx_read, NULL, fd);
+ thr = thread_add_read(agentx_tm, agentx_read, NULL, fd, NULL);
newln = listnode_add_before (events, ln, thr);
thr->arg = newln;
}
int i;
sigm = THREAD_ARG (t);
- sigm->t = thread_add_timer (sigm->t->master, quagga_signal_timer, &sigmaster,
- QUAGGA_SIGNAL_TIMER_INTERVAL);
+ sigm->t = thread_add_timer(sigm->t->master, quagga_signal_timer, &sigmaster,
+ QUAGGA_SIGNAL_TIMER_INTERVAL, NULL);
return quagga_sigevent_process ();
}
#endif /* SIGEVENT_SCHEDULE_THREAD */
#ifdef SIGEVENT_SCHEDULE_THREAD
sigmaster.t =
- thread_add_timer (m, quagga_signal_timer, &sigmaster,
- QUAGGA_SIGNAL_TIMER_INTERVAL);
+ thread_add_timer(m, quagga_signal_timer, &sigmaster,
+ QUAGGA_SIGNAL_TIMER_INTERVAL, NULL);
#endif /* SIGEVENT_SCHEDULE_THREAD */
}
switch (event)
{
case SMUX_SCHEDULE:
- smux_connect_thread = thread_add_event (smux_master, smux_connect, NULL, 0);
+ smux_connect_thread = thread_add_event(smux_master, smux_connect, NULL,
+ 0, NULL);
break;
case SMUX_CONNECT:
- smux_connect_thread = thread_add_timer (smux_master, smux_connect, NULL, 10);
+ smux_connect_thread = thread_add_timer(smux_master, smux_connect, NULL,
+ 10, NULL);
break;
case SMUX_READ:
- smux_read_thread = thread_add_read (smux_master, smux_read, NULL, sock);
+ smux_read_thread = thread_add_read(smux_master, smux_read, NULL, sock,
+ NULL);
break;
default:
break;
{
case SPF_BACKOFF_QUIET:
backoff->state = SPF_BACKOFF_SHORT_WAIT;
- THREAD_TIMER_MSEC_ON(backoff->m, backoff->t_timetolearn,
- spf_backoff_timetolearn_elapsed, backoff,
- backoff->timetolearn);
- THREAD_TIMER_MSEC_ON(backoff->m, backoff->t_holddown,
- spf_backoff_holddown_elapsed, backoff,
- backoff->holddown);
+ thread_add_timer_msec(backoff->m, spf_backoff_timetolearn_elapsed,
+ backoff, backoff->timetolearn,
+ &backoff->t_timetolearn);
+ thread_add_timer_msec(backoff->m, spf_backoff_holddown_elapsed, backoff,
+ backoff->holddown, &backoff->t_holddown);
backoff->first_event_time = now;
rv = backoff->init_delay;
break;
case SPF_BACKOFF_SHORT_WAIT:
case SPF_BACKOFF_LONG_WAIT:
THREAD_TIMER_OFF(backoff->t_holddown);
- THREAD_TIMER_MSEC_ON(backoff->m, backoff->t_holddown,
- spf_backoff_holddown_elapsed, backoff,
- backoff->holddown);
+ thread_add_timer_msec(backoff->m, spf_backoff_holddown_elapsed, backoff,
+ backoff->holddown, &backoff->t_holddown);
if (backoff->state == SPF_BACKOFF_SHORT_WAIT)
rv = backoff->short_delay;
else
{
systemd_send_information ("WATCHDOG=1");
- thread_add_timer (systemd_master, systemd_send_watchdog, NULL, wsecs);
+ thread_add_timer(systemd_master, systemd_send_watchdog, NULL, wsecs, NULL);
return 1;
}
systemd_send_information ("READY=1");
if (wsecs != 0)
- thread_add_timer (m, systemd_send_watchdog, m, wsecs);
+ thread_add_timer(m, systemd_send_watchdog, m, wsecs, NULL);
}
num = poll (m->handler.pfds, m->handler.pfdcount + m->handler.pfdcountsnmp, timeout);
#else
struct timeval timeout;
+
if (m->selectpoll_timeout > 0) // use the user's timeout
{
timeout.tv_sec = m->selectpoll_timeout / 1000;
/* Add new read thread. */
struct thread *
funcname_thread_add_read_write (int dir, struct thread_master *m,
- int (*func) (struct thread *), void *arg, int fd,
- debugargdef)
+ int (*func) (struct thread *), void *arg, int fd, struct thread **t_ptr,
+ debugargdef)
{
struct thread *thread = NULL;
pthread_mutex_lock (&m->mtx);
{
+ if (t_ptr && *t_ptr) // thread is already scheduled; don't reschedule
+ {
+ pthread_mutex_unlock (&m->mtx);
+ return NULL;
+ }
+
#if defined (HAVE_POLL_CALL)
thread = generic_thread_add(m, func, arg, fd, dir, debugargpass);
#else
}
pthread_mutex_unlock (&thread->mtx);
}
+
+ if (t_ptr)
+ *t_ptr = thread;
}
pthread_mutex_unlock (&m->mtx);
static struct thread *
funcname_thread_add_timer_timeval (struct thread_master *m,
- int (*func) (struct thread *),
- int type,
- void *arg,
- struct timeval *time_relative,
- debugargdef)
+ int (*func) (struct thread *), int type, void *arg,
+ struct timeval *time_relative, struct thread **t_ptr, debugargdef)
{
struct thread *thread;
struct pqueue *queue;
pthread_mutex_lock (&m->mtx);
{
+ if (t_ptr && *t_ptr) // thread is already scheduled; don't reschedule
+ {
+ pthread_mutex_unlock (&m->mtx);
+ return NULL;
+ }
+
queue = ((type == THREAD_TIMER) ? m->timer : m->background);
thread = thread_get (m, type, func, arg, debugargpass);
pqueue_enqueue(thread, queue);
}
pthread_mutex_unlock (&thread->mtx);
+
+ if (t_ptr)
+ *t_ptr = thread;
}
pthread_mutex_unlock (&m->mtx);
/* Add timer event thread. */
struct thread *
funcname_thread_add_timer (struct thread_master *m,
- int (*func) (struct thread *),
- void *arg, long timer,
- debugargdef)
+ int (*func) (struct thread *), void *arg, long timer,
+ struct thread **t_ptr, debugargdef)
{
struct timeval trel;
trel.tv_sec = timer;
trel.tv_usec = 0;
- return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg,
- &trel, debugargpass);
+ return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg, &trel,
+ t_ptr, debugargpass);
}
/* Add timer event thread with "millisecond" resolution */
struct thread *
funcname_thread_add_timer_msec (struct thread_master *m,
- int (*func) (struct thread *),
- void *arg, long timer,
- debugargdef)
+ int (*func) (struct thread *), void *arg, long timer,
+ struct thread **t_ptr, debugargdef)
{
struct timeval trel;
trel.tv_sec = timer / 1000;
trel.tv_usec = 1000*(timer % 1000);
- return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER,
- arg, &trel, debugargpass);
+ return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg, &trel,
+ t_ptr, debugargpass);
}
/* Add timer event thread with "millisecond" resolution */
struct thread *
funcname_thread_add_timer_tv (struct thread_master *m,
- int (*func) (struct thread *),
- void *arg, struct timeval *tv,
- debugargdef)
+ int (*func) (struct thread *), void *arg, struct timeval *tv,
+ struct thread **t_ptr, debugargdef)
{
- return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER,
- arg, tv, debugargpass);
+ return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg, tv,
+ t_ptr, debugargpass);
}
/* Add a background thread, with an optional millisec delay */
struct thread *
funcname_thread_add_background (struct thread_master *m,
- int (*func) (struct thread *),
- void *arg, long delay,
- debugargdef)
+ int (*func) (struct thread *), void *arg, long delay,
+ struct thread **t_ptr, debugargdef)
{
struct timeval trel;
trel.tv_usec = 0;
}
- return funcname_thread_add_timer_timeval (m, func, THREAD_BACKGROUND,
- arg, &trel, debugargpass);
+ return funcname_thread_add_timer_timeval (m, func, THREAD_BACKGROUND, arg,
+ &trel, t_ptr, debugargpass);
}
/* Add simple event thread. */
struct thread *
funcname_thread_add_event (struct thread_master *m,
- int (*func) (struct thread *), void *arg, int val,
- debugargdef)
+ int (*func) (struct thread *), void *arg, int val,
+ struct thread **t_ptr, debugargdef)
{
struct thread *thread;
pthread_mutex_lock (&m->mtx);
{
+ if (t_ptr && *t_ptr) // thread is already scheduled; don't reschedule
+ {
+ pthread_mutex_unlock (&m->mtx);
+ return NULL;
+ }
+
thread = thread_get (m, THREAD_EVENT, func, arg, debugargpass);
pthread_mutex_lock (&thread->mtx);
{
thread_list_add (&m->event, thread);
}
pthread_mutex_unlock (&thread->mtx);
+
+ if (t_ptr)
+ *t_ptr = thread;
}
pthread_mutex_unlock (&m->mtx);
#define THREAD_FD(X) ((X)->u.fd)
#define THREAD_VAL(X) ((X)->u.val)
-#define THREAD_READ_ON(master,thread,func,arg,sock) \
- do { \
- if (! thread) \
- thread = thread_add_read (master, func, arg, sock); \
- } while (0)
-
-#define THREAD_WRITE_ON(master,thread,func,arg,sock) \
- do { \
- if (! thread) \
- thread = thread_add_write (master, func, arg, sock); \
- } while (0)
-
-#define THREAD_TIMER_ON(master,thread,func,arg,time) \
- do { \
- if (! thread) \
- thread = thread_add_timer (master, func, arg, time); \
- } while (0)
-
-#define THREAD_TIMER_MSEC_ON(master,thread,func,arg,time) \
- do { \
- if (! thread) \
- thread = thread_add_timer_msec (master, func, arg, time); \
- } while (0)
-
#define THREAD_OFF(thread) \
do { \
if (thread) \
#define debugargdef const char *funcname, const char *schedfrom, int fromln
-#define thread_add_read(m,f,a,v) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,#f,__FILE__,__LINE__)
-#define thread_add_write(m,f,a,v) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,#f,__FILE__,__LINE__)
-#define thread_add_timer(m,f,a,v) funcname_thread_add_timer(m,f,a,v,#f,__FILE__,__LINE__)
-#define thread_add_timer_msec(m,f,a,v) funcname_thread_add_timer_msec(m,f,a,v,#f,__FILE__,__LINE__)
-#define thread_add_timer_tv(m,f,a,v) funcname_thread_add_timer_tv(m,f,a,v,#f,__FILE__,__LINE__)
-#define thread_add_event(m,f,a,v) funcname_thread_add_event(m,f,a,v,#f,__FILE__,__LINE__)
+#define thread_add_read(m,f,a,v,t) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,t,#f,__FILE__,__LINE__)
+#define thread_add_write(m,f,a,v,t) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,t,#f,__FILE__,__LINE__)
+#define thread_add_timer(m,f,a,v,t) funcname_thread_add_timer(m,f,a,v,t,#f,__FILE__,__LINE__)
+#define thread_add_timer_msec(m,f,a,v,t) funcname_thread_add_timer_msec(m,f,a,v,t,#f,__FILE__,__LINE__)
+#define thread_add_timer_tv(m,f,a,v,t) funcname_thread_add_timer_tv(m,f,a,v,t,#f,__FILE__,__LINE__)
+#define thread_add_event(m,f,a,v,t) funcname_thread_add_event(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f,__FILE__,__LINE__)
/* The 4th arg to thread_add_background is the # of milliseconds to delay. */
-#define thread_add_background(m,f,a,v) funcname_thread_add_background(m,f,a,v,#f,__FILE__,__LINE__)
+#define thread_add_background(m,f,a,v,t) funcname_thread_add_background(m,f,a,v,t,#f,__FILE__,__LINE__)
/* Prototypes. */
extern struct thread_master *thread_master_create (void);
extern void thread_master_free_unused(struct thread_master *);
extern struct thread *funcname_thread_add_read_write (int dir, struct thread_master *,
- int (*)(struct thread *),
- void *, int, debugargdef);
+ int (*)(struct thread *), void *, int, struct thread **, debugargdef);
+
extern struct thread *funcname_thread_add_timer (struct thread_master *,
- int (*)(struct thread *),
- void *, long, debugargdef);
+ int (*)(struct thread *), void *, long, struct thread **, debugargdef);
+
extern struct thread *funcname_thread_add_timer_msec (struct thread_master *,
- int (*)(struct thread *),
- void *, long, debugargdef);
+ int (*)(struct thread *), void *, long, struct thread **, debugargdef);
+
extern struct thread *funcname_thread_add_timer_tv (struct thread_master *,
- int (*)(struct thread *),
- void *, struct timeval *,
- debugargdef);
+ int (*)(struct thread *), void *, struct timeval *, struct thread **, debugargdef);
+
extern struct thread *funcname_thread_add_event (struct thread_master *,
- int (*)(struct thread *),
- void *, int, debugargdef);
+ int (*)(struct thread *), void *, int, struct thread **, debugargdef);
+
extern struct thread *funcname_thread_add_background (struct thread_master *,
- int (*func)(struct thread *),
- void *arg,
- long milliseconds_to_delay,
- debugargdef);
+ int (*func)(struct thread *), void *arg, long milliseconds_to_delay,
+ struct thread **, debugargdef);
+
extern struct thread *funcname_thread_execute (struct thread_master *,
- int (*)(struct thread *),
- void *, int, debugargdef);
+ int (*)(struct thread *), void *, int, debugargdef);
#undef debugargdef
extern void thread_cancel (struct thread *);
switch (event)
{
case VTY_SERV:
- vty_serv_thread = thread_add_read (vty_master, vty_accept, vty, sock);
+ vty_serv_thread = thread_add_read(vty_master, vty_accept, vty, sock,
+ NULL);
vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
break;
#ifdef VTYSH
case VTYSH_SERV:
- vty_serv_thread = thread_add_read (vty_master, vtysh_accept, vty, sock);
+ vty_serv_thread = thread_add_read(vty_master, vtysh_accept, vty, sock,
+ NULL);
vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
break;
case VTYSH_READ:
- vty->t_read = thread_add_read (vty_master, vtysh_read, vty, sock);
+ vty->t_read = thread_add_read(vty_master, vtysh_read, vty, sock, NULL);
break;
case VTYSH_WRITE:
- vty->t_write = thread_add_write (vty_master, vtysh_write, vty, sock);
+ vty->t_write = thread_add_write(vty_master, vtysh_write, vty, sock,
+ NULL);
break;
#endif /* VTYSH */
case VTY_READ:
- vty->t_read = thread_add_read (vty_master, vty_read, vty, sock);
+ vty->t_read = thread_add_read(vty_master, vty_read, vty, sock, NULL);
/* Time out treatment. */
if (vty->v_timeout)
if (vty->t_timeout)
thread_cancel (vty->t_timeout);
vty->t_timeout =
- thread_add_timer (vty_master, vty_timeout, vty, vty->v_timeout);
+ thread_add_timer(vty_master, vty_timeout, vty, vty->v_timeout,
+ NULL);
}
break;
case VTY_WRITE:
- if (! vty->t_write)
- vty->t_write = thread_add_write (vty_master, vty_flush, vty, sock);
+ thread_add_write(vty_master, vty_flush, vty, sock, &vty->t_write);
break;
case VTY_TIMEOUT_RESET:
if (vty->t_timeout)
if (vty->v_timeout)
{
vty->t_timeout =
- thread_add_timer (vty_master, vty_timeout, vty, vty->v_timeout);
+ thread_add_timer(vty_master, vty_timeout, vty, vty->v_timeout,
+ NULL);
}
break;
}
slots_to_skip++;
wheel->slots_to_skip = slots_to_skip;
- THREAD_TIMER_MSEC_ON (wheel->master, wheel->timer,
- wheel_timer_thread, wheel,
- wheel->nexttime * slots_to_skip);
+ thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
+ wheel->nexttime * slots_to_skip, &wheel->timer);
return 0;
}
for (i = 0; i < slots; i++)
wheel->wheel_slot_lists[i] = list_new ();
- THREAD_TIMER_MSEC_ON (wheel->master, wheel->timer,
- wheel_timer_thread, wheel,
- wheel->nexttime);
+ thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
+ wheel->nexttime, &wheel->timer);
return wheel;
}
wheel_start (struct timer_wheel *wheel)
{
if (!wheel->timer)
- THREAD_TIMER_MSEC_ON (wheel->master, wheel->timer,
- wheel_timer_thread, wheel,
- wheel->nexttime);
+ thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
+ wheel->nexttime, &wheel->timer);
return 0;
}
&& (wq->thread == NULL)
&& (listcount (wq->items) > 0) )
{
- wq->thread = thread_add_background (wq->master, work_queue_run,
- wq, delay);
+ wq->thread = thread_add_background(wq->master, work_queue_run, wq,
+ delay, NULL);
/* set thread yield time, if needed */
if (wq->thread && wq->spec.yield != THREAD_YIELD_TIME_SLOT)
thread_set_yield_time (wq->thread, wq->spec.yield);
break;
case BUFFER_PENDING:
zclient->t_write = thread_add_write(zclient->master, zclient_flush_data,
- zclient, zclient->sock);
+ zclient, zclient->sock, NULL);
break;
case BUFFER_EMPTY:
break;
THREAD_OFF(zclient->t_write);
break;
case BUFFER_PENDING:
- THREAD_WRITE_ON(zclient->master, zclient->t_write,
- zclient_flush_data, zclient, zclient->sock);
+ thread_add_write(zclient->master, zclient_flush_data, zclient,
+ zclient->sock, &zclient->t_write);
break;
}
return 0;
switch (event)
{
case ZCLIENT_SCHEDULE:
- if (! zclient->t_connect)
- zclient->t_connect =
- thread_add_event (zclient->master, zclient_connect, zclient, 0);
+ thread_add_event(zclient->master, zclient_connect, zclient, 0,
+ &zclient->t_connect);
break;
case ZCLIENT_CONNECT:
if (zclient_debug)
zlog_debug ("zclient connect failures: %d schedule interval is now %d",
zclient->fail, zclient->fail < 3 ? 10 : 60);
- if (! zclient->t_connect)
- zclient->t_connect =
- thread_add_timer (zclient->master, zclient_connect, zclient,
- zclient->fail < 3 ? 10 : 60);
+ thread_add_timer(zclient->master, zclient_connect, zclient,
+ zclient->fail < 3 ? 10 : 60, &zclient->t_connect);
break;
case ZCLIENT_READ:
zclient->t_read =
- thread_add_read (zclient->master, zclient_read, zclient, zclient->sock);
+ thread_add_read(zclient->master, zclient_read, zclient, zclient->sock,
+ NULL);
break;
}
}
}
}
- thread_add_read(master, netlink_route_recv, 0, fd);
+ thread_add_read(master, netlink_route_recv, 0, fd, NULL);
return 0;
}
}
}
- THREAD_READ_ON(master, netlink_log_thread, netlink_log_recv, 0, netlink_log_fd);
+ thread_add_read(master, netlink_log_recv, 0, netlink_log_fd,
+ &netlink_log_thread);
return 0;
}
if (nlgroup) {
netlink_log_fd = znl_open(NETLINK_NETFILTER, 0);
netlink_log_register(netlink_log_fd, nlgroup);
- THREAD_READ_ON(master, netlink_log_thread, netlink_log_recv, 0, netlink_log_fd);
+ thread_add_read(master, netlink_log_recv, 0, netlink_log_fd,
+ &netlink_log_thread);
}
}
{
netlink_req_fd = znl_open(NETLINK_ROUTE, 0);
netlink_listen_fd = znl_open(NETLINK_ROUTE, RTMGRP_NEIGH);
- thread_add_read(master, netlink_route_recv, 0, netlink_listen_fd);
+ thread_add_read(master, netlink_route_recv, 0, netlink_listen_fd,
+ NULL);
return 0;
}
switch (c->cur.type) {
case NHRP_CACHE_INVALID:
if (!c->t_auth)
- THREAD_TIMER_MSEC_ON(master, c->t_timeout, nhrp_cache_do_free, c, 10);
+ thread_add_timer_msec(master, nhrp_cache_do_free, c,
+ 10, &c->t_timeout);
break;
default:
if (c->cur.expires)
- THREAD_TIMER_ON(master, c->t_timeout, nhrp_cache_do_timeout, c, c->cur.expires - monotime(NULL));
+ thread_add_timer(master, nhrp_cache_do_timeout, c,
+ c->cur.expires - monotime(NULL),
+ &c->t_timeout);
break;
}
}
case NOTIFY_PEER_UP:
if (nhrp_peer_check(c->new.peer, 1)) {
evmgr_notify("authorize-binding", c, nhrp_cache_authorize_binding);
- THREAD_TIMER_ON(master, c->t_auth, nhrp_cache_do_auth_timeout, c, 10);
+ thread_add_timer(master, nhrp_cache_do_auth_timeout,
+ c, 10, &c->t_auth);
}
break;
case NOTIFY_PEER_DOWN:
} else {
nhrp_peer_notify_add(c->new.peer, &c->newpeer_notifier, nhrp_cache_newpeer_notifier);
nhrp_cache_newpeer_notifier(&c->newpeer_notifier, NOTIFY_PEER_UP);
- THREAD_TIMER_ON(master, c->t_auth, nhrp_cache_do_auth_timeout, c, 60);
+ thread_add_timer(master, nhrp_cache_do_auth_timeout,
+ c, 60, &c->t_auth);
}
}
nhrp_cache_update_timers(c);
close(evmgr->fd);
evmgr->fd = -1;
if (nhrp_event_socket_path)
- THREAD_TIMER_MSEC_ON(master, evmgr->t_reconnect, evmgr_reconnect,
- evmgr, 10);
+ thread_add_timer_msec(master, evmgr_reconnect, evmgr, 10,
+ &evmgr->t_reconnect);
}
static void evmgr_recv_message(struct event_manager *evmgr, struct zbuf *zb)
while (zbuf_may_pull_until(ibuf, "\n\n", &msg))
evmgr_recv_message(evmgr, &msg);
- THREAD_READ_ON(master, evmgr->t_read, evmgr_read, evmgr, evmgr->fd);
+ thread_add_read(master, evmgr_read, evmgr, evmgr->fd, &evmgr->t_read);
return 0;
}
evmgr->t_write = NULL;
r = zbufq_write(&evmgr->obuf, evmgr->fd);
if (r > 0) {
- THREAD_WRITE_ON(master, evmgr->t_write, evmgr_write, evmgr, evmgr->fd);
+ thread_add_write(master, evmgr_write, evmgr, evmgr->fd,
+ &evmgr->t_write);
} else if (r < 0) {
evmgr_connection_error(evmgr);
}
zbuf_put(obuf, "\n", 1);
zbufq_queue(&evmgr->obuf, obuf);
if (evmgr->fd >= 0)
- THREAD_WRITE_ON(master, evmgr->t_write, evmgr_write, evmgr, evmgr->fd);
+ thread_add_write(master, evmgr_write, evmgr, evmgr->fd,
+ &evmgr->t_write);
}
static int evmgr_reconnect(struct thread *t)
zlog_warn("%s: failure connecting nhrp-event socket: %s",
__PRETTY_FUNCTION__, strerror(errno));
zbufq_reset(&evmgr->obuf);
- THREAD_TIMER_ON(master, evmgr->t_reconnect, evmgr_reconnect, evmgr, 10);
+ thread_add_timer(master, evmgr_reconnect, evmgr, 10,
+ &evmgr->t_reconnect);
return 0;
}
zlog_info("Connected to Event Manager");
evmgr->fd = fd;
- THREAD_READ_ON(master, evmgr->t_read, evmgr_read, evmgr, evmgr->fd);
+ thread_add_read(master, evmgr_read, evmgr, evmgr->fd, &evmgr->t_read);
return 0;
}
evmgr->fd = -1;
zbuf_init(&evmgr->ibuf, evmgr->ibuf_data, sizeof(evmgr->ibuf_data), 0);
zbufq_init(&evmgr->obuf);
- THREAD_TIMER_MSEC_ON(master, evmgr->t_reconnect, evmgr_reconnect, evmgr, 10);
+ thread_add_timer_msec(master, evmgr_reconnect, evmgr, 10,
+ &evmgr->t_reconnect);
}
void evmgr_set_socket(const char *socket)
/* RFC 2332 5.2.3 - Registration is recommend to be renewed
* every one third of holdtime */
- THREAD_TIMER_ON(master, r->t_register, nhrp_reg_send_req, r, holdtime / 3);
+ thread_add_timer(master, nhrp_reg_send_req, r, holdtime / 3,
+ &r->t_register);
r->proto_addr = p->dst_proto;
c = nhrp_cache_get(ifp, &p->dst_proto, 1);
r->timeout <<= 1;
if (r->timeout > 64) r->timeout = 2;
- THREAD_TIMER_MSEC_ON(master, r->t_register, nhrp_reg_send_req, r, 10);
+ thread_add_timer_msec(master, nhrp_reg_send_req, r, 10,
+ &r->t_register);
return 0;
}
debugf(NHRP_DEBUG_COMMON, "NHS: Flush timer for %s",
sockunion2str(&r->peer->vc->remote.nbma, buf, sizeof buf));
THREAD_TIMER_OFF(r->t_register);
- THREAD_TIMER_MSEC_ON(master, r->t_register, nhrp_reg_send_req, r, 10);
+ thread_add_timer_msec(master, nhrp_reg_send_req, r, 10,
+ &r->t_register);
break;
}
}
if (!nhrp_peer_check(r->peer, 2)) {
debugf(NHRP_DEBUG_COMMON, "NHS: Waiting link for %s",
sockunion2str(&r->peer->vc->remote.nbma, buf1, sizeof buf1));
- THREAD_TIMER_ON(master, r->t_register, nhrp_reg_send_req, r, 120);
+ thread_add_timer(master, nhrp_reg_send_req, r, 120,
+ &r->t_register);
return 0;
}
- THREAD_TIMER_ON(master, r->t_register, nhrp_reg_timeout, r, r->timeout);
+ thread_add_timer(master, nhrp_reg_timeout, r, r->timeout,
+ &r->t_register);
/* RFC2332 5.2.3 NHC uses it's own address as dst if NHS is unknown */
dst_proto = &nhs->proto_addr;
nhs->t_resolve = NULL;
if (n < 0) {
/* Failed, retry in a moment */
- THREAD_TIMER_ON(master, nhs->t_resolve, nhrp_nhs_resolve, nhs, 5);
+ thread_add_timer(master, nhrp_nhs_resolve, nhs, 5,
+ &nhs->t_resolve);
return;
}
- THREAD_TIMER_ON(master, nhs->t_resolve, nhrp_nhs_resolve, nhs, 2*60*60);
+ thread_add_timer(master, nhrp_nhs_resolve, nhs, 2 * 60 * 60,
+ &nhs->t_resolve);
list_for_each_entry(reg, &nhs->reglist_head, reglist_entry)
reg->mark = 1;
list_init(®->reglist_entry);
list_add_tail(®->reglist_entry, &nhs->reglist_head);
nhrp_peer_notify_add(reg->peer, ®->peer_notifier, nhrp_reg_peer_notify);
- THREAD_TIMER_MSEC_ON(master, reg->t_register, nhrp_reg_send_req, reg, 50);
+ thread_add_timer_msec(master, nhrp_reg_send_req, reg, 50,
+ ®->t_register);
}
list_for_each_entry_safe(reg, regn, &nhs->reglist_head, reglist_entry) {
.reglist_head = LIST_INITIALIZER(nhs->reglist_head),
};
list_add_tail(&nhs->nhslist_entry, &nifp->afi[afi].nhslist_head);
- THREAD_TIMER_MSEC_ON(master, nhs->t_resolve, nhrp_nhs_resolve, nhs, 1000);
+ thread_add_timer_msec(master, nhrp_nhs_resolve, nhs, 1000,
+ &nhs->t_resolve);
return NHRP_OK;
}
uint8_t addr[64];
size_t len, addrlen;
- thread_add_read(master, nhrp_packet_recvraw, 0, fd);
+ thread_add_read(master, nhrp_packet_recvraw, 0, fd, NULL);
zb = zbuf_alloc(1500);
if (!zb) return 0;
int nhrp_packet_init(void)
{
- thread_add_read(master, nhrp_packet_recvraw, 0, os_socket());
+ thread_add_read(master, nhrp_packet_recvraw, 0, os_socket(), NULL);
return 0;
}
* the up notification a bit to allow things
* settle down. This allows IKE to install
* SPDs and SAs. */
- THREAD_TIMER_MSEC_ON(
- master, p->t_fallback,
- nhrp_peer_notify_up, p, 50);
+ thread_add_timer_msec(master, nhrp_peer_notify_up, p,
+ 50, &p->t_fallback);
} else {
nhrp_peer_ref(p);
p->online = online;
p->fallback_requested = 1;
vici_request_vc(nifp->ipsec_fallback_profile,
&vc->local.nbma, &vc->remote.nbma, p->prio);
- THREAD_TIMER_ON(master, p->t_fallback, nhrp_peer_request_timeout, p, 30);
+ thread_add_timer(master, nhrp_peer_request_timeout, p, 30,
+ &p->t_fallback);
} else {
p->requested = p->fallback_requested = 0;
}
p->prio = establish > 1;
p->requested = 1;
vici_request_vc(nifp->ipsec_profile, &vc->local.nbma, &vc->remote.nbma, p->prio);
- THREAD_TIMER_ON(master, p->t_fallback, nhrp_peer_request_timeout, p,
- (nifp->ipsec_fallback_profile && !p->prio) ? 15 : 30);
+ thread_add_timer(master, nhrp_peer_request_timeout, p,
+ (nifp->ipsec_fallback_profile && !p->prio) ? 15 : 30,
+ &p->t_fallback);
return 0;
}
struct nhrp_shortcut *s = THREAD_ARG(t);
s->t_timer = NULL;
- THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, s->holding_time/3);
+ thread_add_timer(master, nhrp_shortcut_do_purge, s,
+ s->holding_time / 3, &s->t_timer);
s->expiring = 1;
nhrp_shortcut_check_use(s);
if (holding_time) {
s->expiring = 0;
s->holding_time = holding_time;
- THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_expire, s, 2*holding_time/3);
+ thread_add_timer(master, nhrp_shortcut_do_expire, s,
+ 2 * holding_time / 3, &s->t_timer);
}
}
nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid);
THREAD_OFF(s->t_timer);
- THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 1);
+ thread_add_timer(master, nhrp_shortcut_do_purge, s, 1, &s->t_timer);
if (pp->hdr->type != NHRP_PACKET_RESOLUTION_REPLY) {
if (pp->hdr->type == NHRP_PACKET_ERROR_INDICATION &&
if (s && s->type != NHRP_CACHE_INCOMPLETE) {
s->addr = *addr;
THREAD_OFF(s->t_timer);
- THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 30);
+ thread_add_timer(master, nhrp_shortcut_do_purge, s, 30,
+ &s->t_timer);
nhrp_shortcut_send_resolution_req(s);
}
}
if (force) {
/* Immediate purge on route with draw or pending shortcut */
- THREAD_TIMER_MSEC_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 5);
+ thread_add_timer_msec(master, nhrp_shortcut_do_purge, s, 5,
+ &s->t_timer);
} else {
/* Soft expire - force immediate renewal, but purge
* in few seconds to make sure stale route is not
* This allows to keep nhrp route up, and to not
* cause temporary rerouting via hubs causing latency
* jitter. */
- THREAD_TIMER_MSEC_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 3000);
+ thread_add_timer_msec(master, nhrp_shortcut_do_purge, s, 3000,
+ &s->t_timer);
s->expiring = 1;
nhrp_shortcut_check_use(s);
}
ares_process_fd(r->channel, fd, ARES_SOCKET_BAD);
if (vector_lookup(r->read_threads, fd) == THREAD_RUNNING) {
t = NULL;
- THREAD_READ_ON(master, t, resolver_cb_socket_readable, r, fd);
+ thread_add_read(master, resolver_cb_socket_readable, r, fd,
+ &t);
vector_set_index(r->read_threads, fd, t);
}
resolver_update_timeouts(r);
ares_process_fd(r->channel, ARES_SOCKET_BAD, fd);
if (vector_lookup(r->write_threads, fd) == THREAD_RUNNING) {
t = NULL;
- THREAD_WRITE_ON(master, t, resolver_cb_socket_writable, r, fd);
+ thread_add_write(master, resolver_cb_socket_writable, r, fd,
+ &t);
vector_set_index(r->write_threads, fd, t);
}
resolver_update_timeouts(r);
tv = ares_timeout(r->channel, NULL, &tvbuf);
if (tv) {
unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
- THREAD_TIMER_MSEC_ON(master, r->timeout, resolver_cb_timeout, r, timeoutms);
+ thread_add_timer_msec(master, resolver_cb_timeout, r,
+ timeoutms, &r->timeout);
}
}
if (readable) {
t = vector_lookup_ensure(r->read_threads, fd);
if (!t) {
- THREAD_READ_ON(master, t, resolver_cb_socket_readable, r, fd);
+ thread_add_read(master, resolver_cb_socket_readable,
+ r, fd, &t);
vector_set_index(r->read_threads, fd, t);
}
} else {
if (writable) {
t = vector_lookup_ensure(r->write_threads, fd);
if (!t) {
- THREAD_READ_ON(master, t, resolver_cb_socket_writable, r, fd);
+ thread_add_read(master, resolver_cb_socket_writable,
+ r, fd, &t);
vector_set_index(r->write_threads, fd, t);
}
} else {
close(vici->fd);
vici->fd = -1;
- THREAD_TIMER_ON(master, vici->t_reconnect, vici_reconnect, vici, 2);
+ thread_add_timer(master, vici_reconnect, vici, 2, &vici->t_reconnect);
}
static void vici_parse_message(
vici_recv_message(vici, &pktbuf);
} while (1);
- THREAD_READ_ON(master, vici->t_read, vici_read, vici, vici->fd);
+ thread_add_read(master, vici_read, vici, vici->fd, &vici->t_read);
return 0;
}
vici->t_write = NULL;
r = zbufq_write(&vici->obuf, vici->fd);
if (r > 0) {
- THREAD_WRITE_ON(master, vici->t_write, vici_write, vici, vici->fd);
+ thread_add_write(master, vici_write, vici, vici->fd,
+ &vici->t_write);
} else if (r < 0) {
vici_connection_error(vici);
}
}
zbufq_queue(&vici->obuf, obuf);
- THREAD_WRITE_ON(master, vici->t_write, vici_write, vici, vici->fd);
+ thread_add_write(master, vici_write, vici, vici->fd, &vici->t_write);
}
static void vici_submit_request(struct vici_conn *vici, const char *name, ...)
if (fd < 0) {
zlog_warn("%s: failure connecting VICI socket: %s",
__PRETTY_FUNCTION__, strerror(errno));
- THREAD_TIMER_ON(master, vici->t_reconnect, vici_reconnect, vici, 2);
+ thread_add_timer(master, vici_reconnect, vici, 2,
+ &vici->t_reconnect);
return 0;
}
debugf(NHRP_DEBUG_COMMON, "VICI: Connected");
vici->fd = fd;
- THREAD_READ_ON(master, vici->t_read, vici_read, vici, vici->fd);
+ thread_add_read(master, vici_read, vici, vici->fd, &vici->t_read);
/* Send event subscribtions */
//vici_register_event(vici, "child-updown");
vici->fd = -1;
zbuf_init(&vici->ibuf, vici->ibuf_data, sizeof(vici->ibuf_data), 0);
zbufq_init(&vici->obuf);
- THREAD_TIMER_MSEC_ON(master, vici->t_reconnect, vici_reconnect, vici, 10);
+ thread_add_timer_msec(master, vici_reconnect, vici, 10,
+ &vici->t_reconnect);
}
void vici_terminate(void)
if ((status == BFD_STATUS_DOWN) && (old_status == BFD_STATUS_UP))
{
THREAD_OFF (on->inactivity_timer);
- thread_add_event (master, inactivity_timer, on, 0);
+ thread_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);
- lsa->refresh = thread_add_timer (master, ospf6_lsa_refresh, lsa,
- OSPF_LS_REFRESH_TIME);
+ lsa->refresh = thread_add_timer(master, ospf6_lsa_refresh, lsa,
+ OSPF_LS_REFRESH_TIME, NULL);
if (IS_OSPF6_DEBUG_LSA_TYPE (lsa->header->type) ||
IS_OSPF6_DEBUG_ORIGINATE_TYPE (lsa->header->type))
monotime(&now);
if (! OSPF6_LSA_IS_MAXAGE (lsa))
- lsa->expire = thread_add_timer (master, ospf6_lsa_expire, lsa,
- OSPF_LSA_MAXAGE + lsa->birth.tv_sec - now.tv_sec);
+ lsa->expire = thread_add_timer(master, ospf6_lsa_expire, lsa,
+ OSPF_LSA_MAXAGE + lsa->birth.tv_sec - now.tv_sec,
+ NULL);
else
lsa->expire = NULL;
ospf6_lsdb_add (ospf6_lsa_copy (lsa), on->retrans_list);
if (on->thread_send_lsupdate == NULL)
on->thread_send_lsupdate =
- thread_add_timer (master, ospf6_lsupdate_send_neighbor,
- on, on->ospf6_if->rxmt_interval);
+ thread_add_timer(master, ospf6_lsupdate_send_neighbor, on,
+ on->ospf6_if->rxmt_interval, NULL);
retrans_added++;
}
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsupdate_list);
if (oi->thread_send_lsupdate == NULL)
oi->thread_send_lsupdate =
- thread_add_event (master, ospf6_lsupdate_send_interface, oi, 0);
+ thread_add_event(master, ospf6_lsupdate_send_interface, oi, 0, NULL);
}
else
{
{
THREAD_OFF (on->thread_send_lsupdate);
on->thread_send_lsupdate =
- thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0);
+ thread_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
+ NULL);
}
}
}
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsack_list);
if (oi->thread_send_lsack == NULL)
oi->thread_send_lsack =
- thread_add_timer (master, ospf6_lsack_send_interface, oi, 3);
+ thread_add_timer(master, ospf6_lsack_send_interface, oi, 3,
+ NULL);
}
else
{
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsack_list);
if (oi->thread_send_lsack == NULL)
oi->thread_send_lsack =
- thread_add_timer (master, ospf6_lsack_send_interface, oi, 3);
+ thread_add_timer(master, ospf6_lsack_send_interface, oi, 3,
+ NULL);
}
else
{
ospf6_lsdb_add (ospf6_lsa_copy (lsa), from->lsack_list);
if (from->thread_send_lsack == NULL)
from->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_neighbor, from, 0);
+ thread_add_event(master, ospf6_lsack_send_neighbor, from, 0, NULL);
return;
}
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsack_list);
if (oi->thread_send_lsack == NULL)
oi->thread_send_lsack =
- thread_add_timer (master, ospf6_lsack_send_interface, oi, 3);
+ thread_add_timer(master, ospf6_lsack_send_interface, oi, 3, NULL);
return;
}
ospf6_lsdb_add (ospf6_lsa_copy (lsa), from->lsack_list);
if (from->thread_send_lsack == NULL)
from->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_neighbor, from, 0);
+ thread_add_event(master, ospf6_lsack_send_neighbor, from, 0, NULL);
return;
}
ospf6_lsdb_add (ospf6_lsa_copy (new), from->lsack_list);
if (from->thread_send_lsack == NULL)
from->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_neighbor, from, 0);
+ thread_add_event(master, ospf6_lsack_send_neighbor, from, 0, NULL);
/* b) Discard */
ospf6_lsa_delete (new);
zlog_debug ("Newer instance of the self-originated LSA");
zlog_debug ("Schedule reorigination");
}
- new->refresh = thread_add_event (master, ospf6_lsa_refresh, new, 0);
+ new->refresh = thread_add_event(master, ospf6_lsa_refresh, new, 0,
+ NULL);
}
return;
}
/* BadLSReq */
- thread_add_event (master, bad_lsreq, from, 0);
+ thread_add_event(master, bad_lsreq, from, 0, NULL);
ospf6_lsa_delete (new);
return;
ospf6_lsdb_add (ospf6_lsa_copy (old), from->lsupdate_list);
if (from->thread_send_lsupdate == NULL)
from->thread_send_lsupdate =
- thread_add_event (master, ospf6_lsupdate_send_neighbor, from, 0);
+ thread_add_event(master, ospf6_lsupdate_send_neighbor, from, 0,
+ NULL);
ospf6_lsa_delete (new);
return;
}
if (if_is_operative (ifp)
&& (ospf6_interface_get_linklocal_address(oi->interface)
|| if_is_loopback(oi->interface)))
- thread_add_event (master, interface_up, oi, 0);
+ thread_add_event(master, interface_up, oi, 0, NULL);
else
- thread_add_event (master, interface_down, oi, 0);
+ thread_add_event(master, interface_down, oi, 0, NULL);
return;
}
if (on->state < OSPF6_NEIGHBOR_TWOWAY)
continue;
/* Schedule AdjOK. */
- thread_add_event (master, adj_ok, on, 0);
+ thread_add_event(master, adj_ok, on, 0, NULL);
}
}
{
zlog_info("Scheduling %s for sso retry, trial count: %d",
oi->interface->name, oi->sso_try_cnt);
- thread_add_timer (master, interface_up, oi,
- OSPF6_INTERFACE_SSO_RETRY_INT);
+ thread_add_timer(master, interface_up, oi,
+ OSPF6_INTERFACE_SSO_RETRY_INT, NULL);
}
return 0;
}
/* Schedule Hello */
if (! CHECK_FLAG (oi->flag, OSPF6_INTERFACE_PASSIVE) &&
!if_is_loopback (oi->interface))
- oi->thread_send_hello = thread_add_event (master, ospf6_hello_send, oi, 0);
+ oi->thread_send_hello = thread_add_event(master, ospf6_hello_send, oi, 0,
+ NULL);
/* decide next interface state */
if ((if_is_pointopoint (oi->interface)) ||
else
{
ospf6_interface_state_change (OSPF6_INTERFACE_WAITING, oi);
- thread_add_timer (master, wait_timer, oi, oi->dead_interval);
+ thread_add_timer(master, wait_timer, oi, oi->dead_interval, NULL);
}
return 0;
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->inactivity_timer);
- thread_add_event (master, inactivity_timer, on, 0);
+ thread_add_event(master, inactivity_timer, on, 0, NULL);
}
return CMD_SUCCESS;
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->inactivity_timer);
- thread_add_event (master, inactivity_timer, on, 0);
+ thread_add_event(master, inactivity_timer, on, 0, NULL);
}
return CMD_SUCCESS;
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->inactivity_timer);
- thread_add_event (master, inactivity_timer, on, 0);
+ thread_add_event(master, inactivity_timer, on, 0, NULL);
}
return CMD_SUCCESS;
UNSET_FLAG (oi->flag, OSPF6_INTERFACE_PASSIVE);
THREAD_OFF (oi->thread_send_hello);
oi->thread_send_hello =
- thread_add_event (master, ospf6_hello_send, oi, 0);
+ thread_add_event(master, ospf6_hello_send, oi, 0, NULL);
return CMD_SUCCESS;
}
}
/* Reset the interface */
- thread_add_event (master, interface_down, oi, 0);
- thread_add_event (master, interface_up, oi, 0);
+ thread_add_event(master, interface_down, oi, 0, NULL);
+ thread_add_event(master, interface_up, oi, 0, NULL);
return CMD_SUCCESS;
}
oi->type = type;
/* Reset the interface */
- thread_add_event (master, interface_down, oi, 0);
- thread_add_event (master, interface_up, oi, 0);
+ thread_add_event(master, interface_down, oi, 0, NULL);
+ thread_add_event(master, interface_up, oi, 0, NULL);
return CMD_SUCCESS;
}
zlog_debug ("Interface %s: clear by reset", ifp->name);
/* Reset the interface */
- thread_add_event (master, interface_down, oi, 0);
- thread_add_event (master, interface_up, oi, 0);
+ thread_add_event(master, interface_down, oi, 0, NULL);
+ thread_add_event(master, interface_up, oi, 0, NULL);
}
/* Clear interface */
#define OSPF6_ROUTER_LSA_SCHEDULE(oa) \
do { \
- if (! (oa)->thread_router_lsa \
- && CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
- (oa)->thread_router_lsa = \
- thread_add_event (master, ospf6_router_lsa_originate, oa, 0); \
+ if (CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
+ thread_add_event (master, ospf6_router_lsa_originate, oa, 0, &(oa)->thread_router_lsa); \
} while (0)
#define OSPF6_NETWORK_LSA_SCHEDULE(oi) \
do { \
- if (! (oi)->thread_network_lsa \
- && ! CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
- (oi)->thread_network_lsa = \
- thread_add_event (master, ospf6_network_lsa_originate, oi, 0); \
+ if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
+ thread_add_event (master, ospf6_network_lsa_originate, oi, 0, &(oi)->thread_network_lsa); \
} while (0)
#define OSPF6_LINK_LSA_SCHEDULE(oi) \
do { \
- if (! (oi)->thread_link_lsa \
- && ! CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
- (oi)->thread_link_lsa = \
- thread_add_event (master, ospf6_link_lsa_originate, oi, 0); \
+ if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
+ thread_add_event (master, ospf6_link_lsa_originate, oi, 0, &(oi)->thread_link_lsa); \
} while (0)
#define OSPF6_INTRA_PREFIX_LSA_SCHEDULE_STUB(oa) \
do { \
- if (! (oa)->thread_intra_prefix_lsa \
- && CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
- (oa)->thread_intra_prefix_lsa = \
- thread_add_event (master, ospf6_intra_prefix_lsa_originate_stub, \
- oa, 0); \
+ if (CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
+ thread_add_event (master, ospf6_intra_prefix_lsa_originate_stub, \
+ oa, 0, &(oa)->thread_intra_prefix_lsa); \
} while (0)
#define OSPF6_INTRA_PREFIX_LSA_SCHEDULE_TRANSIT(oi) \
do { \
- if (! (oi)->thread_intra_prefix_lsa \
- && ! CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
- (oi)->thread_intra_prefix_lsa = \
- thread_add_event (master, ospf6_intra_prefix_lsa_originate_transit, \
- oi, 0); \
+ if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
+ thread_add_event (master, ospf6_intra_prefix_lsa_originate_transit, \
+ oi, 0, &(oi)->thread_intra_prefix_lsa); \
} while (0)
#define OSPF6_NETWORK_LSA_EXECUTE(oi) \
new = ospf6_lsa_create (self->header);
new->lsdb = old->lsdb;
- new->refresh = thread_add_timer (master, ospf6_lsa_refresh, new,
- OSPF_LS_REFRESH_TIME);
+ new->refresh = thread_add_timer(master, ospf6_lsa_refresh, new,
+ OSPF_LS_REFRESH_TIME, NULL);
/* store it in the LSDB for self-originated LSAs */
ospf6_lsdb_add (ospf6_lsa_copy (new), lsdb_self);
/* Schedule interface events */
if (backupseen)
- thread_add_event (master, backup_seen, oi, 0);
+ thread_add_event (master, backup_seen, oi, 0, NULL);
if (neighborchange)
- thread_add_event (master, neighbor_change, oi, 0);
+ thread_add_event (master, neighbor_change, oi, 0, NULL);
if (neighbor_ifindex_change && on->state == OSPF6_NEIGHBOR_FULL)
OSPF6_ROUTER_LSA_SCHEDULE (oi->area);
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Master/Slave bit mismatch");
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Initialize bit mismatch");
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Option field mismatch");
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Sequence number mismatch (%#lx expected)",
(u_long) on->dbdesc_seqnum);
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
break;
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Not duplicate dbdesc in state %s",
ospf6_neighbor_state_str[on->state]);
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
default:
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("SeqNumMismatch (E-bit mismatch), discard");
ospf6_lsa_delete (his);
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
on->dbdesc_seqnum ++;
/* schedule send lsreq */
- if (on->request_list->count && (on->thread_send_lsreq == NULL))
- on->thread_send_lsreq =
- thread_add_event (master, ospf6_lsreq_send, on, 0);
+ if (on->request_list->count)
+ thread_add_event (master, ospf6_lsreq_send, on, 0, &on->thread_send_lsreq);
THREAD_OFF (on->thread_send_dbdesc);
/* More bit check */
if (! CHECK_FLAG (dbdesc->bits, OSPF6_DBDESC_MBIT) &&
! CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MBIT))
- thread_add_event (master, exchange_done, on, 0);
+ thread_add_event (master, exchange_done, on, 0, NULL);
else
on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send_newone, on, 0);
+ thread_add_event (master, ospf6_dbdesc_send_newone, on, 0, NULL);
/* save last received dbdesc */
memcpy (&on->dbdesc_last, dbdesc, sizeof (struct ospf6_dbdesc));
zlog_debug ("Duplicated dbdesc causes retransmit");
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send, on, 0);
+ thread_add_event (master, ospf6_dbdesc_send, on, 0, NULL);
return;
}
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Master/Slave bit mismatch");
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Initialize bit mismatch");
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Option field mismatch");
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Sequence number mismatch (%#lx expected)",
(u_long) on->dbdesc_seqnum + 1);
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
break;
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Duplicated dbdesc causes retransmit");
THREAD_OFF (on->thread_send_dbdesc);
- on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send, on, 0);
+ thread_add_event (master, ospf6_dbdesc_send, on, 0, &on->thread_send_dbdesc);
return;
}
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Not duplicate dbdesc in state %s",
ospf6_neighbor_state_str[on->state]);
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
default:
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("E-bit mismatch with LSA Headers");
ospf6_lsa_delete (his);
- thread_add_event (master, seqnumber_mismatch, on, 0);
+ thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
on->dbdesc_seqnum = ntohl (dbdesc->seqnum);
/* schedule send lsreq */
- if ((on->thread_send_lsreq == NULL) &&
- (on->request_list->count))
- on->thread_send_lsreq =
- thread_add_event (master, ospf6_lsreq_send, on, 0);
+ if (on->request_list->count)
+ thread_add_event (master, ospf6_lsreq_send, on, 0, &on->thread_send_lsreq);
THREAD_OFF (on->thread_send_dbdesc);
- on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send_newone, on, 0);
+ thread_add_event (master, ospf6_dbdesc_send_newone, on, 0, &on->thread_send_dbdesc);
/* save last received dbdesc */
memcpy (&on->dbdesc_last, dbdesc, sizeof (struct ospf6_dbdesc));
zlog_debug ("Can't find requested [%s Id:%s Adv:%s]",
ospf6_lstype_name (e->type), id, adv_router);
}
- thread_add_event (master, bad_lsreq, on, 0);
+ thread_add_event (master, bad_lsreq, on, 0, NULL);
return;
}
/* schedule send lsupdate */
THREAD_OFF (on->thread_send_lsupdate);
- on->thread_send_lsupdate =
- thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0);
+ thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0, &on->thread_send_lsupdate);
}
/* Verify, that the specified memory area contains exactly N valid IPv6
/* add next read thread */
sockfd = THREAD_FD (thread);
- thread_add_read (master, ospf6_receive, NULL, sockfd);
+ thread_add_read (master, ospf6_receive, NULL, sockfd, NULL);
/* initialize */
memset (&src, 0, sizeof (src));
}
/* set next thread */
- oi->thread_send_hello = thread_add_timer (master, ospf6_hello_send,
- oi, oi->hello_interval);
+ thread_add_timer (master, ospf6_hello_send, oi, oi->hello_interval, &oi->thread_send_hello);
memset (sendbuf, 0, iobuflen);
oh = (struct ospf6_header *) sendbuf;
/* set next thread if master */
if (CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MSBIT))
- on->thread_send_dbdesc =
- thread_add_timer (master, ospf6_dbdesc_send, on,
- on->ospf6_if->rxmt_interval);
+ thread_add_timer (master, ospf6_dbdesc_send, on,
+ on->ospf6_if->rxmt_interval,
+ &on->thread_send_dbdesc);
memset (sendbuf, 0, iobuflen);
oh = (struct ospf6_header *) sendbuf;
if (! CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MSBIT) && /* Slave */
! CHECK_FLAG (on->dbdesc_last.bits, OSPF6_DBDESC_MBIT) &&
! CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MBIT))
- thread_add_event (master, exchange_done, on, 0);
+ thread_add_event (master, exchange_done, on, 0, NULL);
thread_execute (master, ospf6_dbdesc_send, on, 0);
return 0;
/* schedule loading_done if request list is empty */
if (on->request_list->count == 0)
{
- thread_add_event (master, loading_done, on, 0);
+ thread_add_event (master, loading_done, on, 0, NULL);
return 0;
}
if (on->request_list->count != 0)
{
on->thread_send_lsreq =
- thread_add_timer (master, ospf6_lsreq_send, on,
- on->ospf6_if->rxmt_interval);
+ thread_add_timer (master, ospf6_lsreq_send, on,
+ on->ospf6_if->rxmt_interval, NULL);
}
return 0;
if (on->lsupdate_list->count != 0)
on->thread_send_lsupdate =
- thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0);
+ thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0, NULL);
else if (on->retrans_list->count != 0)
on->thread_send_lsupdate =
thread_add_timer (master, ospf6_lsupdate_send_neighbor, on,
- on->ospf6_if->rxmt_interval);
+ on->ospf6_if->rxmt_interval, NULL);
return 0;
}
if (oi->lsupdate_list->count > 0)
{
oi->thread_send_lsupdate =
- thread_add_event (master, ospf6_lsupdate_send_interface, oi, 0);
+ thread_add_event (master, ospf6_lsupdate_send_interface, oi, 0, NULL);
}
return 0;
/* if we run out of packet size/space here,
better to try again soon. */
THREAD_OFF (on->thread_send_lsack);
- on->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_neighbor, on, 0);
+ thread_add_event (master, ospf6_lsack_send_neighbor, on, 0, &on->thread_send_lsack);
ospf6_lsdb_lsa_unlock (lsa);
break;
on->ospf6_if, oh);
}
- if (on->thread_send_lsack == NULL && on->lsack_list->count > 0)
- {
- on->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_neighbor, on, 0);
- }
+ if (on->lsack_list->count > 0)
+ thread_add_event (master, ospf6_lsack_send_neighbor, on, 0, &on->thread_send_lsack);
return 0;
}
/* if we run out of packet size/space here,
better to try again soon. */
THREAD_OFF (oi->thread_send_lsack);
- oi->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_interface, oi, 0);
+ thread_add_event (master, ospf6_lsack_send_interface, oi, 0,
+ &oi->thread_send_lsack);
ospf6_lsdb_lsa_unlock (lsa);
break;
ospf6_send (oi->linklocal_addr, &alldrouters6, oi, oh);
}
- if (oi->thread_send_lsack == NULL && oi->lsack_list->count > 0)
- {
- oi->thread_send_lsack =
- thread_add_event (master, ospf6_lsack_send_interface, oi, 0);
- }
+ if (oi->lsack_list->count > 0)
+ thread_add_event (master, ospf6_lsack_send_interface, oi, 0, &oi->thread_send_lsack);
return 0;
}
/* reset Inactivity Timer */
THREAD_OFF (on->inactivity_timer);
- on->inactivity_timer = thread_add_timer (master, inactivity_timer, on,
- on->ospf6_if->dead_interval);
+ on->inactivity_timer = thread_add_timer(master, inactivity_timer, on,
+ on->ospf6_if->dead_interval, NULL);
if (on->state <= OSPF6_NEIGHBOR_DOWN)
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_INIT, on,
if (IS_OSPF6_DEBUG_NEIGHBOR (EVENT))
zlog_debug ("Neighbor Event %s: *2Way-Received*", on->name);
- thread_add_event (master, neighbor_change, on->ospf6_if, 0);
+ thread_add_event(master, neighbor_change, on->ospf6_if, 0, NULL);
if (! need_adjacency (on))
{
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send, on, 0);
+ thread_add_event(master, ospf6_dbdesc_send, on, 0, NULL);
return 0;
}
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_LOADING, on,
OSPF6_NEIGHBOR_EVENT_EXCHANGE_DONE);
- if (on->thread_send_lsreq == NULL)
- on->thread_send_lsreq =
- thread_add_event (master, ospf6_lsreq_send, on, 0);
+ thread_add_event(master, ospf6_lsreq_send, on, 0,
+ &on->thread_send_lsreq);
}
return 0;
(on->state == OSPF6_NEIGHBOR_EXCHANGE))
{
if (on->request_list->count == 0)
- thread_add_event (master, loading_done, on, 0);
+ thread_add_event(master, loading_done, on, 0, NULL);
else if (on->last_ls_req == NULL)
{
if (on->thread_send_lsreq != NULL)
THREAD_OFF (on->thread_send_lsreq);
on->thread_send_lsreq =
- thread_add_event (master, ospf6_lsreq_send, on, 0);
+ thread_add_event(master, ospf6_lsreq_send, on, 0, NULL);
}
}
}
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send, on, 0);
+ thread_add_event(master, ospf6_dbdesc_send, on, 0, NULL);
}
else if (on->state >= OSPF6_NEIGHBOR_EXSTART &&
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send, on, 0);
+ thread_add_event(master, ospf6_dbdesc_send, on, 0, NULL);
return 0;
}
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
on->thread_send_dbdesc =
- thread_add_event (master, ospf6_dbdesc_send, on, 0);
+ thread_add_event(master, ospf6_dbdesc_send, on, 0, NULL);
return 0;
}
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_INIT, on,
OSPF6_NEIGHBOR_EVENT_ONEWAY_RCVD);
- thread_add_event (master, neighbor_change, on->ospf6_if, 0);
+ thread_add_event(master, neighbor_change, on->ospf6_if, 0, NULL);
ospf6_lsdb_remove_all (on->summary_list);
ospf6_lsdb_remove_all (on->request_list);
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_DOWN, on,
OSPF6_NEIGHBOR_EVENT_INACTIVITY_TIMER);
- thread_add_event (master, neighbor_change, on->ospf6_if, 0);
+ thread_add_event(master, neighbor_change, on->ospf6_if, 0, NULL);
listnode_delete (on->ospf6_if->neighbor_list, on);
ospf6_neighbor_delete (on);
zlog_info ("SPF: Scheduled in %ld msec", delay);
ospf6->t_spf_calc =
- thread_add_timer_msec (master, ospf6_spf_calculation_thread, ospf6, delay);
+ thread_add_timer_msec(master, ospf6_spf_calculation_thread, ospf6, delay,
+ NULL);
}
void
ospf6_maxage_remove (struct ospf6 *o)
{
if (o && ! o->maxage_remover)
- o->maxage_remover = thread_add_timer (master, ospf6_maxage_remover, o,
- OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT);
+ o->maxage_remover = thread_add_timer(master, ospf6_maxage_remover, o,
+ OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT,
+ NULL);
}
/* start ospf6 */
/* Make ospf protocol socket. */
ospf6_serv_sock ();
- thread_add_read (master, ospf6_receive, NULL, ospf6_sock);
+ thread_add_read(master, ospf6_receive, NULL, ospf6_sock, NULL);
}
void
}
/* Reschedule read thread */
- thread_add_read (master, lsa_read, oclient, fd);
+ thread_add_read(master, lsa_read, oclient, fd, NULL);
return 0;
}
lsa_type, opaque_type, inet_ntoa (addr));
/* Schedule opaque LSA originate in 5 secs */
- thread_add_timer (master, lsa_inject, oclient, 5);
+ thread_add_timer(master, lsa_inject, oclient, 5, NULL);
/* Schedule opaque LSA update with new value */
- thread_add_timer (master, lsa_inject, oclient, 10);
+ thread_add_timer(master, lsa_inject, oclient, 10, NULL);
/* Schedule delete */
- thread_add_timer (master, lsa_delete, oclient, 30);
+ thread_add_timer(master, lsa_delete, oclient, 30, NULL);
}
static void
ospf_apiclient_sync_lsdb (oclient);
/* Schedule thread that handles asynchronous messages */
- thread_add_read (master, lsa_read, oclient, oclient->fd_async);
+ thread_add_read(master, lsa_read, oclient, oclient->fd_async, NULL);
/* Now connection is established, run loop */
while (1)
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Scheduling ABR task");
- if (ospf->t_abr_task == NULL)
- ospf->t_abr_task = thread_add_timer (master, ospf_abr_task_timer,
- ospf, OSPF_ABR_TASK_DELAY);
+ thread_add_timer(master, ospf_abr_task_timer, ospf, OSPF_ABR_TASK_DELAY,
+ &ospf->t_abr_task);
}
switch (event)
{
case OSPF_APISERVER_ACCEPT:
- (void)thread_add_read (master, ospf_apiserver_accept, apiserv, fd);
+ (void) thread_add_read(master, ospf_apiserver_accept, apiserv, fd, NULL);
break;
case OSPF_APISERVER_SYNC_READ:
apiserv->t_sync_read =
- thread_add_read (master, ospf_apiserver_read, apiserv, fd);
+ thread_add_read(master, ospf_apiserver_read, apiserv, fd, NULL);
break;
#ifdef USE_ASYNC_READ
case OSPF_APISERVER_ASYNC_READ:
apiserv->t_async_read =
- thread_add_read (master, ospf_apiserver_read, apiserv, fd);
+ thread_add_read(master, ospf_apiserver_read, apiserv, fd, NULL);
break;
#endif /* USE_ASYNC_READ */
case OSPF_APISERVER_SYNC_WRITE:
if (!apiserv->t_sync_write)
{
apiserv->t_sync_write =
- thread_add_write (master, ospf_apiserver_sync_write, apiserv, fd);
+ thread_add_write(master, ospf_apiserver_sync_write, apiserv, fd,
+ NULL);
}
break;
case OSPF_APISERVER_ASYNC_WRITE:
if (!apiserv->t_async_write)
{
apiserv->t_async_write =
- thread_add_write (master, ospf_apiserver_async_write, apiserv, fd);
+ thread_add_write(master, ospf_apiserver_async_write, apiserv, fd,
+ NULL);
}
break;
}
if (ospf == NULL)
return;
- if (! ospf->t_ase_calc)
- ospf->t_ase_calc = thread_add_timer (master, ospf_ase_calculate_timer,
- ospf, OSPF_ASE_CALC_INTERVAL);
+ thread_add_timer(master, ospf_ase_calculate_timer, ospf,
+ OSPF_ASE_CALC_INTERVAL, &ospf->t_ase_calc);
}
void
#define ISM_InterfaceDown 7
#define OSPF_ISM_EVENT_MAX 8
-#define OSPF_ISM_WRITE_ON(O) \
- do \
- { \
- if (oi->on_write_q == 0) \
- { \
- listnode_add ((O)->oi_write_q, oi); \
- oi->on_write_q = 1; \
- } \
- if ((O)->t_write == NULL) \
- (O)->t_write = \
- thread_add_write (master, ospf_write, (O), (O)->fd); \
- } while (0)
+#define OSPF_ISM_WRITE_ON(O) \
+ do \
+ { \
+ if (oi->on_write_q == 0) \
+ { \
+ listnode_add ((O)->oi_write_q, oi); \
+ oi->on_write_q = 1; \
+ } \
+ thread_add_write (master, ospf_write, (O), (O)->fd, &(O)->t_write); \
+ } while (0)
/* Macro for OSPF ISM timer turn on. */
#define OSPF_ISM_TIMER_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), oi, (V)); \
- } while (0)
+ thread_add_timer (master, (F), oi, (V), &(T))
+
#define OSPF_ISM_TIMER_MSEC_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer_msec (master, (F), oi, (V)); \
- } while (0)
+ thread_add_timer_msec (master, (F), oi, (V), &(T))
/* convenience macro to set hello timer correctly, according to
* whether fast-hello is set or not
/* Macro for OSPF schedule event. */
#define OSPF_ISM_EVENT_SCHEDULE(I,E) \
- thread_add_event (master, ospf_ism_event, (I), (E))
+ thread_add_event (master, ospf_ism_event, (I), (E), NULL)
/* Macro for OSPF execute event. */
#define OSPF_ISM_EVENT_EXECUTE(I,E) \
data->area = area;
data->lsa = ospf_lsa_lock (lsa); /* Message / Flood area */
- thread_add_event (master, ospf_lsa_action, data, 0);
+ thread_add_event(master, ospf_lsa_action, data, 0, NULL);
}
void
data->area = area;
data->lsa = ospf_lsa_lock (lsa); /* Message / Flush area */
- thread_add_event (master, ospf_lsa_action, data, 0);
+ thread_add_event(master, ospf_lsa_action, data, 0, NULL);
}
}
}
- ospf->t_lsa_refresher = thread_add_timer (master, ospf_lsa_refresh_walker,
- ospf, ospf->lsa_refresh_interval);
+ ospf->t_lsa_refresher = thread_add_timer(master, ospf_lsa_refresh_walker,
+ ospf, ospf->lsa_refresh_interval,
+ NULL);
ospf->lsa_refresher_started = monotime(NULL);
for (ALL_LIST_ELEMENTS (lsa_to_refresh, node, nnode, lsa))
#define OSPF_NSM_EVENT_MAX 14
/* Macro for OSPF NSM timer turn on. */
-#define OSPF_NSM_TIMER_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), nbr, (V)); \
- } while (0)
+#define OSPF_NSM_TIMER_ON(T,F,V) thread_add_timer (master, (F), nbr, (V), &(T))
/* Macro for OSPF NSM timer turn off. */
#define OSPF_NSM_TIMER_OFF(X) \
/* Macro for OSPF NSM schedule event. */
#define OSPF_NSM_EVENT_SCHEDULE(N,E) \
- thread_add_event (master, ospf_nsm_event, (N), (E))
+ thread_add_event (master, ospf_nsm_event, (N), (E), NULL)
/* Macro for OSPF NSM execute event. */
#define OSPF_NSM_EVENT_EXECUTE(N,E) \
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Schedule Type-9 Opaque-LSA origination in %d ms later.", delay);
oi->t_opaque_lsa_self =
- thread_add_timer_msec (master, ospf_opaque_type9_lsa_originate, oi, delay);
+ thread_add_timer_msec(master, ospf_opaque_type9_lsa_originate, oi,
+ delay, NULL);
delay += top->min_ls_interval;
}
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Schedule Type-10 Opaque-LSA origination in %d ms later.", delay);
area->t_opaque_lsa_self =
- thread_add_timer_msec (master, ospf_opaque_type10_lsa_originate,
- area, delay);
+ thread_add_timer_msec(master, ospf_opaque_type10_lsa_originate, area,
+ delay, NULL);
delay += top->min_ls_interval;
}
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Schedule Type-11 Opaque-LSA origination in %d ms later.", delay);
top->t_opaque_lsa_self =
- thread_add_timer_msec (master, ospf_opaque_type11_lsa_originate,
- top, delay);
+ thread_add_timer_msec(master, ospf_opaque_type11_lsa_originate, top,
+ delay, NULL);
delay += top->min_ls_interval;
}
* triggered by external interventions (vty session, signaling, etc).
*------------------------------------------------------------------------*/
-#define OSPF_OPAQUE_TIMER_ON(T,F,L,V) \
- if (!(T)) \
- (T) = thread_add_timer_msec (master, (F), (L), (V))
+#define OSPF_OPAQUE_TIMER_ON(T,F,L,V) thread_add_timer_msec (master, (F), (L), (V), &(T))
static struct ospf_lsa *pseudo_lsa (struct ospf_interface *oi, struct ospf_area *area, u_char lsa_type, u_char opaque_type);
static int ospf_opaque_type9_lsa_reoriginate_timer (struct thread *t);
thread_cancel (nbr->t_ls_req);
nbr->t_ls_req = NULL;
}
- nbr->t_ls_req = thread_add_event (master, ospf_ls_req_timer, nbr, 0);
+ nbr->t_ls_req = thread_add_event(master, ospf_ls_req_timer, nbr, 0, NULL);
}
/* Cyclic timer function. Fist registered in ospf_nbr_new () in
/* If packets still remain in queue, call write thread. */
if (!list_isempty (ospf->oi_write_q))
ospf->t_write =
- thread_add_write (master, ospf_write, ospf, ospf->fd);
+ thread_add_write(master, ospf_write, ospf, ospf->fd, NULL);
return 0;
}
ospf = THREAD_ARG (thread);
/* prepare for next packet. */
- ospf->t_read = thread_add_read (master, ospf_read, ospf, ospf->fd);
+ ospf->t_read = thread_add_read(master, ospf_read, ospf, ospf->fd, NULL);
stream_reset(ospf->ibuf);
if (!(ibuf = ospf_recv_packet (ospf->fd, &ifp, ospf->ibuf)))
zlog_debug ("ospf_ls_upd_send_queue: update lists not cleared,"
" %d nodes to try again, raising new event", again);
oi->t_ls_upd_event =
- thread_add_event (master, ospf_ls_upd_send_queue_event, oi, 0);
+ thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0, NULL);
}
if (IS_DEBUG_OSPF_EVENT)
for (ALL_LIST_ELEMENTS_RO (update, node, lsa))
listnode_add (rn->info, ospf_lsa_lock (lsa)); /* oi->ls_upd_queue */
- if (oi->t_ls_upd_event == NULL)
- oi->t_ls_upd_event =
- thread_add_event (master, ospf_ls_upd_send_queue_event, oi, 0);
+ thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0,
+ &oi->t_ls_upd_event);
}
static void
listnode_add (oi->ls_ack_direct.ls_ack, ospf_lsa_lock (lsa));
- if (oi->t_ls_ack_direct == NULL)
- oi->t_ls_ack_direct =
- thread_add_event (master, ospf_ls_ack_send_event, oi, 0);
+ thread_add_event(master, ospf_ls_ack_send_event, oi, 0,
+ &oi->t_ls_ack_direct);
}
/* Send Link State Acknowledgment delayed. */
zlog_info ("SPF: Scheduled in %ld msec", delay);
ospf->t_spf_calc =
- thread_add_timer_msec (master, ospf_spf_calculate_timer, ospf, delay);
+ thread_add_timer_msec(master, ospf_spf_calculate_timer, ospf, delay, NULL);
}
if (ospf->router_id.s_addr == 0)
ospf->external_origin |= (1 << DEFAULT_ROUTE);
else
- thread_add_timer (master, ospf_default_originate_timer, ospf, 1);
+ thread_add_timer(master, ospf_default_originate_timer, ospf, 1, NULL);
ospf_asbr_status_update (ospf, ++ospf->redistribute);
/* Set timer. */
ospf->t_distribute_update =
- thread_add_timer_msec (master, ospf_distribute_list_update_timer,
- (void *) type, ospf->min_ls_interval);
+ thread_add_timer_msec(master, ospf_distribute_list_update_timer,
+ (void *)type, ospf->min_ls_interval, NULL);
}
/* If access-list is updated, apply some check. */
/* Originate each redistributed external route. */
for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
if (ospf->external_origin & (1 << type))
- thread_add_event (master, ospf_external_lsa_originate_timer,
- ospf, type);
+ thread_add_event(master, ospf_external_lsa_originate_timer,
+ ospf, type, NULL);
/* Originate Deafult. */
if (ospf->external_origin & (1 << ZEBRA_ROUTE_MAX))
- thread_add_event (master, ospf_default_originate_timer, ospf, 0);
+ thread_add_event(master, ospf_default_originate_timer, ospf, 0,
+ NULL);
ospf->external_origin = 0;
}
/* Originate each redistributed external route. */
for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
- thread_add_event (master, ospf_external_lsa_originate_timer,
- ospf, type);
- thread_add_event (master, ospf_default_originate_timer, ospf, 0);
+ thread_add_event(master, ospf_external_lsa_originate_timer, ospf,
+ type, NULL);
+ thread_add_event(master, ospf_default_originate_timer, ospf, 0, NULL);
/* update router-lsa's for each area */
ospf_router_lsa_update (ospf);
new->maxage_delay = OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT;
new->maxage_lsa = route_table_init();
new->t_maxage_walker =
- thread_add_timer (master, ospf_lsa_maxage_walker,
- new, OSPF_LSA_MAXAGE_CHECK_INTERVAL);
+ thread_add_timer(master, ospf_lsa_maxage_walker, new,
+ OSPF_LSA_MAXAGE_CHECK_INTERVAL, NULL);
/* Distance table init. */
new->distance_table = route_table_init ();
new->lsa_refresh_queue.index = 0;
new->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
- new->t_lsa_refresher = thread_add_timer (master, ospf_lsa_refresh_walker,
- new, new->lsa_refresh_interval);
+ new->t_lsa_refresher = thread_add_timer(master, ospf_lsa_refresh_walker,
+ new, new->lsa_refresh_interval,
+ NULL);
new->lsa_refresher_started = monotime(NULL);
if ((new->fd = ospf_sock_init()) < 0)
OSPF_MAX_PACKET_SIZE+1);
exit(1);
}
- new->t_read = thread_add_read (master, ospf_read, new, new->fd);
+ new->t_read = thread_add_read(master, ospf_read, new, new->fd, NULL);
new->oi_write_q = list_new ();
new->write_oi_count = OSPF_WRITE_INTERFACE_COUNT_DEFAULT;
{
OSPF_TIMER_OFF (ospf->t_lsa_refresher);
ospf->t_lsa_refresher =
- thread_add_timer (master, ospf_lsa_refresh_walker, ospf, interval);
+ thread_add_timer(master, ospf_lsa_refresh_walker, ospf, interval,
+ NULL);
}
ospf->lsa_refresh_interval = interval;
{
OSPF_TIMER_OFF (ospf->t_lsa_refresher);
ospf->t_lsa_refresher =
- thread_add_timer (master, ospf_lsa_refresh_walker, ospf,
- OSPF_LSA_REFRESH_INTERVAL_DEFAULT);
+ thread_add_timer(master, ospf_lsa_refresh_walker, ospf,
+ OSPF_LSA_REFRESH_INTERVAL_DEFAULT, NULL);
}
ospf->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
#define LSA_OPTIONS_NSSA_GET(area) \
(((area)->external_routing == OSPF_AREA_NSSA) ? OSPF_OPTION_NP : 0)
-#define OSPF_TIMER_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), ospf, (V)); \
- } while (0)
-
-#define OSPF_AREA_TIMER_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), area, (V)); \
- } while (0)
-
-#define OSPF_POLL_TIMER_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), nbr_nbma, (V)); \
- } while (0)
-
-#define OSPF_POLL_TIMER_OFF(X) OSPF_TIMER_OFF((X))
-
+#define OSPF_TIMER_ON(T,F,V) thread_add_timer (master,(F),ospf,(V),&(T))
+#define OSPF_AREA_TIMER_ON(T,F,V) thread_add_timer (master, (F), area, (V), &(T))
+#define OSPF_POLL_TIMER_ON(T,F,V) thread_add_timer (master, (F), nbr_nbma, (V), &(T))
+#define OSPF_POLL_TIMER_OFF(X) OSPF_TIMER_OFF((X))
#define OSPF_TIMER_OFF(X) \
do { \
if (X) \
ch->sg_str, interval, ch->interface->name);
}
- THREAD_TIMER_ON(master, ch->t_ifassert_timer,
- on_assert_timer,
- ch, interval);
+ thread_add_timer(master, on_assert_timer, ch, interval,
+ &ch->t_ifassert_timer);
}
static void pim_assert_timer_reset(struct pim_ifchannel *ch)
}
if (holdtime != 0xFFFF) {
- THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
- on_ifjoin_expiry_timer,
- ch, holdtime);
+ thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
+ &ch->t_ifjoin_expiry_timer);
}
}
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
THREAD_OFF(ch->t_ifjoin_expiry_timer);
- THREAD_TIMER_MSEC_ON(master, ch->t_ifjoin_prune_pending_timer,
- on_ifjoin_prune_pending_timer,
- ch, jp_override_interval_msec);
- THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
- on_ifjoin_expiry_timer,
- ch, holdtime);
+ thread_add_timer_msec(master, on_ifjoin_prune_pending_timer, ch,
+ jp_override_interval_msec,
+ &ch->t_ifjoin_prune_pending_timer);
+ thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
+ &ch->t_ifjoin_expiry_timer);
pim_upstream_update_join_desired(ch->upstream);
}
break;
be taken not to use "ch" afterwards since it would be
deleted. */
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
- THREAD_TIMER_MSEC_ON(master, ch->t_ifjoin_prune_pending_timer,
- on_ifjoin_prune_pending_timer,
- ch, jp_override_interval_msec);
+ thread_add_timer_msec(master, on_ifjoin_prune_pending_timer, ch,
+ jp_override_interval_msec,
+ &ch->t_ifjoin_prune_pending_timer);
break;
case PIM_IFJOIN_PRUNE:
if (source_flags & PIM_ENCODE_RPT_BIT)
{
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
- THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
- on_ifjoin_expiry_timer,
- ch, holdtime);
+ thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
+ &ch->t_ifjoin_expiry_timer);
}
break;
case PIM_IFJOIN_PRUNE_TMP:
{
ch->ifjoin_state = PIM_IFJOIN_PRUNE;
THREAD_OFF(ch->t_ifjoin_expiry_timer);
- THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
- on_ifjoin_expiry_timer,
- ch, holdtime);
+ thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
+ &ch->t_ifjoin_expiry_timer);
}
break;
case PIM_IFJOIN_PRUNE_PENDING_TMP:
{
ch->ifjoin_state = PIM_IFJOIN_PRUNE_PENDING;
THREAD_OFF(ch->t_ifjoin_expiry_timer);
- THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
- on_ifjoin_expiry_timer,
- ch, holdtime);
+ thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
+ &ch->t_ifjoin_expiry_timer);
}
break;
}
other_querier_present_interval_msec % 1000);
}
- THREAD_TIMER_MSEC_ON(master, igmp->t_other_querier_timer,
- pim_igmp_other_querier_expire,
- igmp, other_querier_present_interval_msec);
+ thread_add_timer_msec(master, pim_igmp_other_querier_expire, igmp,
+ other_querier_present_interval_msec,
+ &igmp->t_other_querier_timer);
}
void pim_igmp_other_querier_timer_off(struct igmp_sock *igmp)
igmp->fd);
}
igmp->t_igmp_query_timer = NULL;
- THREAD_TIMER_ON(master, igmp->t_igmp_query_timer,
- pim_igmp_general_query,
- igmp, query_interval);
+ thread_add_timer(master, pim_igmp_general_query, igmp, query_interval,
+ &igmp->t_igmp_query_timer);
}
void pim_igmp_general_query_off(struct igmp_sock *igmp)
igmp->fd);
}
igmp->t_igmp_read = NULL;
- THREAD_READ_ON(master, igmp->t_igmp_read, pim_igmp_read, igmp, igmp->fd);
+ thread_add_read(master, pim_igmp_read, igmp, igmp->fd, &igmp->t_igmp_read);
}
*/
zassert(group->group_filtermode_isexcl);
- THREAD_TIMER_MSEC_ON(master, group->t_group_timer,
- igmp_group_timer,
- group, interval_msec);
+ thread_add_timer_msec(master, igmp_group_timer, group, interval_msec,
+ &group->t_group_timer);
}
struct igmp_group *
group->group_igmp_sock->interface->name);
}
- THREAD_TIMER_MSEC_ON(master, source->t_source_timer,
- igmp_source_timer,
- source, interval_msec);
+ thread_add_timer_msec(master, igmp_source_timer, source, interval_msec,
+ &source->t_source_timer);
zassert(source->t_source_timer);
/*
igmp->interface->name);
}
- THREAD_TIMER_MSEC_ON(master, group->t_group_query_retransmit_timer,
- igmp_group_retransmit,
- group, lmqi_msec);
+ thread_add_timer_msec(master, igmp_group_retransmit, group, lmqi_msec,
+ &group->t_group_query_retransmit_timer);
}
static long igmp_group_timer_remain_msec(struct igmp_group *group)
{
zassert(!qpim_mroute_socket_reader);
- THREAD_READ_ON(master, qpim_mroute_socket_reader,
- mroute_read, 0, qpim_mroute_socket_fd);
+ thread_add_read(master, mroute_read, 0, qpim_mroute_socket_fd,
+ &qpim_mroute_socket_reader);
}
static void mroute_read_off()
{
THREAD_OFF(msdp->sa_adv_timer);
if (start) {
- THREAD_TIMER_ON(msdp->master, msdp->sa_adv_timer,
- pim_msdp_sa_adv_timer_cb, NULL, PIM_MSDP_SA_ADVERTISMENT_TIME);
+ thread_add_timer(msdp->master, pim_msdp_sa_adv_timer_cb, NULL,
+ PIM_MSDP_SA_ADVERTISMENT_TIME, &msdp->sa_adv_timer);
}
}
{
THREAD_OFF(sa->sa_state_timer);
if (start) {
- THREAD_TIMER_ON(msdp->master, sa->sa_state_timer,
- pim_msdp_sa_state_timer_cb, sa, PIM_MSDP_SA_HOLD_TIME);
+ thread_add_timer(msdp->master, pim_msdp_sa_state_timer_cb, sa,
+ PIM_MSDP_SA_HOLD_TIME, &sa->sa_state_timer);
}
}
{
THREAD_OFF(mp->hold_timer);
if (start) {
- THREAD_TIMER_ON(msdp->master, mp->hold_timer,
- pim_msdp_peer_hold_timer_cb, mp, PIM_MSDP_PEER_HOLD_TIME);
+ thread_add_timer(msdp->master, pim_msdp_peer_hold_timer_cb, mp,
+ PIM_MSDP_PEER_HOLD_TIME, &mp->hold_timer);
}
}
{
THREAD_OFF(mp->ka_timer);
if (start) {
- THREAD_TIMER_ON(msdp->master, mp->ka_timer,
- pim_msdp_peer_ka_timer_cb, mp, PIM_MSDP_PEER_KA_TIME);
+ thread_add_timer(msdp->master, pim_msdp_peer_ka_timer_cb, mp,
+ PIM_MSDP_PEER_KA_TIME, &mp->ka_timer);
}
}
{
THREAD_OFF(mp->cr_timer);
if (start) {
- THREAD_TIMER_ON(msdp->master, mp->cr_timer,
- pim_msdp_peer_cr_timer_cb, mp, PIM_MSDP_PEER_CONNECT_RETRY_TIME);
+ thread_add_timer(msdp->master, pim_msdp_peer_cr_timer_cb, mp,
+ PIM_MSDP_PEER_CONNECT_RETRY_TIME, &mp->cr_timer);
}
}
struct pim_msdp_mg *mg;
};
-#define PIM_MSDP_PEER_READ_ON(mp) THREAD_READ_ON(msdp->master, mp->t_read, pim_msdp_read, mp, mp->fd);
-#define PIM_MSDP_PEER_WRITE_ON(mp) THREAD_WRITE_ON(msdp->master, mp->t_write, pim_msdp_write, mp, mp->fd);
+#define PIM_MSDP_PEER_READ_ON(mp) \
+ thread_add_read (msdp->master, pim_msdp_read, mp, mp->fd, &mp->t_read)
+
+#define PIM_MSDP_PEER_WRITE_ON(mp) \
+ thread_add_write (msdp->master, pim_msdp_write, mp, mp->fd, &mp->t_write)
#define PIM_MSDP_PEER_READ_OFF(mp) THREAD_READ_OFF(mp->t_read)
#define PIM_MSDP_PEER_WRITE_OFF(mp) THREAD_WRITE_OFF(mp->t_write)
zlog_err ("accept_sock is negative value %d", accept_sock);
return -1;
}
- listener->thread = thread_add_read(master, pim_msdp_sock_accept,
- listener, accept_sock);
+ listener->thread = thread_add_read(master, pim_msdp_sock_accept, listener,
+ accept_sock, NULL);
/* accept client connection. */
msdp_sock = sockunion_accept(accept_sock, &su);
/* add accept thread */
listener->fd = sock;
memcpy(&listener->su, &sin, socklen);
- listener->thread = thread_add_read(msdp->master, pim_msdp_sock_accept, listener, sock);
+ listener->thread = thread_add_read(msdp->master, pim_msdp_sock_accept,
+ listener, sock, NULL);
msdp->flags |= PIM_MSDPF_LISTENER;
return 0;
neigh->holdtime, src_str, neigh->interface->name);
}
- THREAD_TIMER_ON(master, neigh->t_expire_timer,
- on_neighbor_timer,
- neigh, neigh->holdtime);
+ thread_add_timer(master, on_neighbor_timer, neigh, neigh->holdtime,
+ &neigh->t_expire_timer);
}
static int
rpf.rpf_addr.u.prefix4 = neigh->source_addr;
pim_joinprune_send(&rpf, neigh->upstream_jp_agg);
- THREAD_TIMER_ON(master, neigh->jp_timer,
- on_neighbor_jp_timer,
- neigh, qpim_t_periodic);
+ thread_add_timer(master, on_neighbor_jp_timer, neigh, qpim_t_periodic,
+ &neigh->jp_timer);
return 0;
}
pim_neighbor_start_jp_timer (struct pim_neighbor *neigh)
{
THREAD_TIMER_OFF(neigh->jp_timer);
- THREAD_TIMER_ON(master, neigh->jp_timer,
- on_neighbor_jp_timer,
- neigh, qpim_t_periodic);
+ thread_add_timer(master, on_neighbor_jp_timer, neigh, qpim_t_periodic,
+ &neigh->jp_timer);
}
static struct pim_neighbor *pim_neighbor_new(struct interface *ifp,
pim_ifp->pim_sock_fd);
}
pim_ifp->t_pim_sock_read = NULL;
- THREAD_READ_ON(master, pim_ifp->t_pim_sock_read, pim_sock_read, ifp,
- pim_ifp->pim_sock_fd);
+ thread_add_read(master, pim_sock_read, ifp, pim_ifp->pim_sock_fd,
+ &pim_ifp->t_pim_sock_read);
}
static int pim_sock_open(struct interface *ifp)
pim_ifp->pim_hello_period, ifp->name);
}
THREAD_OFF(pim_ifp->t_pim_hello_timer);
- THREAD_TIMER_ON(master, pim_ifp->t_pim_hello_timer,
- on_pim_hello_send,
- ifp, pim_ifp->pim_hello_period);
+ thread_add_timer(master, on_pim_hello_send, ifp, pim_ifp->pim_hello_period,
+ &pim_ifp->t_pim_hello_timer);
}
/*
random_msec, ifp->name);
}
- THREAD_TIMER_MSEC_ON(master, pim_ifp->t_pim_hello_timer,
- on_pim_hello_send,
- ifp, random_msec);
+ thread_add_timer_msec(master, on_pim_hello_send, ifp, random_msec,
+ &pim_ifp->t_pim_hello_timer);
}
int pim_sock_add(struct interface *ifp)
static void ssmpingd_read_on(struct ssmpingd_sock *ss)
{
zassert(!ss->t_sock_read);
- THREAD_READ_ON(master, ss->t_sock_read,
- ssmpingd_sock_read, ss, ss->sock_fd);
+ thread_add_read(master, ssmpingd_sock_read, ss, ss->sock_fd,
+ &ss->t_sock_read);
}
static struct ssmpingd_sock *ssmpingd_new(struct in_addr source_addr)
else
{
THREAD_OFF (up->t_join_timer);
- THREAD_TIMER_ON(master, up->t_join_timer,
- on_join_timer,
- up, qpim_t_periodic);
+ thread_add_timer(master, on_join_timer, up, qpim_t_periodic,
+ &up->t_join_timer);
}
pim_jp_agg_upstream_verification (up, true);
}
}
THREAD_OFF(up->t_join_timer);
- THREAD_TIMER_MSEC_ON(master, up->t_join_timer,
- on_join_timer,
- up, interval_msec);
+ thread_add_timer_msec(master, on_join_timer, up, interval_msec,
+ &up->t_join_timer);
}
void pim_upstream_join_suppress(struct pim_upstream *up,
zlog_debug ("kat start on %s with no stream reference", up->sg_str);
}
THREAD_OFF (up->t_ka_timer);
- THREAD_TIMER_ON (master,
- up->t_ka_timer,
- pim_upstream_keep_alive_timer,
- up, time);
+ thread_add_timer(master, pim_upstream_keep_alive_timer, up, time,
+ &up->t_ka_timer);
/* any time keepalive is started against a SG we will have to
* re-evaluate our active source database */
pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)
{
THREAD_OFF(up->t_msdp_reg_timer);
- THREAD_TIMER_ON(master, up->t_msdp_reg_timer,
- pim_upstream_msdp_reg_timer, up, PIM_MSDP_REG_RXED_PERIOD);
+ thread_add_timer(master, pim_upstream_msdp_reg_timer, up,
+ PIM_MSDP_REG_RXED_PERIOD, &up->t_msdp_reg_timer);
pim_msdp_sa_local_update(up);
}
zlog_debug ("%s: (S,G)=%s Starting upstream register stop timer %d",
__PRETTY_FUNCTION__, up->sg_str, time);
}
- THREAD_TIMER_ON (master, up->t_rs_timer,
- pim_upstream_register_stop_timer,
- up, time);
+ thread_add_timer(master, pim_upstream_register_stop_timer, up, time,
+ &up->t_rs_timer);
}
int
qpim_rpf_cache_refresh_delay_msec);
}
- THREAD_TIMER_MSEC_ON(master, qpim_rpf_cache_refresher,
- on_rpf_cache_refresh,
- 0, qpim_rpf_cache_refresh_delay_msec);
+ thread_add_timer_msec(master, on_rpf_cache_refresh, 0,
+ qpim_rpf_cache_refresh_delay_msec,
+ &qpim_rpf_cache_refresher);
}
static void
{
zassert(!zlookup->t_connect);
- THREAD_TIMER_ON(master, zlookup->t_connect,
- zclient_lookup_connect,
- zlookup, delay);
+ thread_add_timer(master, zclient_lookup_connect, zlookup, delay,
+ &zlookup->t_connect);
zlog_notice("%s: zclient lookup connection scheduled for %d seconds",
__PRETTY_FUNCTION__, delay);
zassert(!zlookup->t_connect);
zlookup->t_connect = thread_add_event(master, zclient_lookup_connect,
- zlookup, 0);
+ zlookup, 0, NULL);
zlog_notice("%s: zclient lookup immediate connection scheduled",
__PRETTY_FUNCTION__);
zlog_debug ("turn on %s", ifp->name);
/* Add interface wake up thread. */
- if (! ri->t_wakeup)
- ri->t_wakeup = thread_add_timer (master, rip_interface_wakeup,
- ifp, 1);
+ thread_add_timer(master, rip_interface_wakeup, ifp, 1,
+ &ri->t_wakeup);
rip_connect_set (ifp, 1);
}
}
}
/* Update timeout thread. */
- peer->t_timeout = thread_add_timer (master, rip_peer_timeout, peer,
- RIP_PEER_TIMER_DEFAULT);
+ peer->t_timeout = thread_add_timer(master, rip_peer_timeout, peer,
+ RIP_PEER_TIMER_DEFAULT, NULL);
/* Last update time set. */
time (&peer->uptime);
interval = (random () % 5) + 1;
rip->t_triggered_interval =
- thread_add_timer (master, rip_triggered_interval, NULL, interval);
+ thread_add_timer(master, rip_triggered_interval, NULL, interval, NULL);
return 0;
}
switch (event)
{
case RIP_READ:
- rip->t_read = thread_add_read (master, rip_read, NULL, sock);
+ rip->t_read = thread_add_read(master, rip_read, NULL, sock, NULL);
break;
case RIP_UPDATE_EVENT:
RIP_TIMER_OFF (rip->t_update);
jitter = rip_update_jitter (rip->update_time);
rip->t_update =
- thread_add_timer (master, rip_update, NULL,
- sock ? 2 : rip->update_time + jitter);
+ thread_add_timer(master, rip_update, NULL,
+ sock ? 2 : rip->update_time + jitter, NULL);
break;
case RIP_TRIGGERED_UPDATE:
if (rip->t_triggered_interval)
rip->trigger = 1;
- else if (! rip->t_triggered_update)
- rip->t_triggered_update =
- thread_add_event (master, rip_triggered_update, NULL, 0);
+ else thread_add_event(master, rip_triggered_update, NULL, 0,
+ &rip->t_triggered_update);
break;
default:
break;
};
/* Macro for timer turn on. */
-#define RIP_TIMER_ON(T,F,V) \
- do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), rinfo, (V)); \
- } while (0)
+#define RIP_TIMER_ON(T,F,V) thread_add_timer (master, (F), rinfo, (V), &(T))
/* Macro for timer turn off. */
#define RIP_TIMER_OFF(X) THREAD_TIMER_OFF(X)
zlog_debug ("RIPng turn on %s", ifp->name);
/* Add interface wake up thread. */
- if (! ri->t_wakeup)
- ri->t_wakeup = thread_add_timer (master, ripng_interface_wakeup,
- ifp, 1);
+ thread_add_timer(master, ripng_interface_wakeup, ifp, 1,
+ &ri->t_wakeup);
ripng_connect_set (ifp, 1);
}
}
/* Update timeout thread. */
- peer->t_timeout = thread_add_timer (master, ripng_peer_timeout, peer,
- RIPNG_PEER_TIMER_DEFAULT);
+ peer->t_timeout = thread_add_timer(master, ripng_peer_timeout, peer,
+ RIPNG_PEER_TIMER_DEFAULT, NULL);
/* Last update time set. */
time (&peer->uptime);
interval = (random () % 5) + 1;
ripng->t_triggered_interval =
- thread_add_timer (master, ripng_triggered_interval, NULL, interval);
+ thread_add_timer(master, ripng_triggered_interval, NULL, interval, NULL);
return 0;
}
switch (event)
{
case RIPNG_READ:
- if (!ripng->t_read)
- ripng->t_read = thread_add_read (master, ripng_read, NULL, sock);
+ thread_add_read(master, ripng_read, NULL, sock, &ripng->t_read);
break;
case RIPNG_UPDATE_EVENT:
if (ripng->t_update)
jitter = ripng_update_jitter (ripng->update_time);
ripng->t_update =
- thread_add_timer (master, ripng_update, NULL,
- sock ? 2 : ripng->update_time + jitter);
+ thread_add_timer(master, ripng_update, NULL,
+ sock ? 2 : ripng->update_time + jitter, NULL);
break;
case RIPNG_TRIGGERED_UPDATE:
if (ripng->t_triggered_interval)
ripng->trigger = 1;
- else if (! ripng->t_triggered_update)
- ripng->t_triggered_update =
- thread_add_event (master, ripng_triggered_update, NULL, 0);
+ else thread_add_event(master, ripng_triggered_update, NULL, 0,
+ &ripng->t_triggered_update);
break;
default:
break;
};
/* RIPng timer on/off macro. */
-#define RIPNG_TIMER_ON(T,F,V) \
-do { \
- if (!(T)) \
- (T) = thread_add_timer (master, (F), rinfo, (V)); \
-} while (0)
+#define RIPNG_TIMER_ON(T,F,V) thread_add_timer (master, (F), rinfo, (V), &(T))
#define RIPNG_TIMER_OFF(T) \
do { \
int *count = THREAD_ARG(thread);
printf ("run %d of timer\n", (*count)++);
- thread_add_timer (master, test_timer, count, 5);
+ thread_add_timer(master, test_timer, count, 5, NULL);
return 0;
}
static void
test_timer_init()
{
- thread_add_timer (master, test_timer, &timer_count, 10);
+ thread_add_timer(master, test_timer, &timer_count, 10, NULL);
}
static void
ws->i++;
if (thread_should_yield(thread))
{
- thread_add_background(master, clear_something, ws, 0);
+ thread_add_background(master, clear_something, ws, 0, NULL);
return 0;
}
}
ws->vty = vty;
ws->i = ITERS_FIRST;
- thread_add_background(master, clear_something, ws, 0);
+ thread_add_background(master, clear_something, ws, 0, NULL);
return CMD_SUCCESS;
}
/* Schedule timers to expire in 0..5 seconds */
interval_msec = prng_rand(prng) % 5000;
arg = XMALLOC(MTYPE_TMP, TIMESTR_LEN + 1);
- timers[i] = thread_add_timer_msec(master, timer_func, arg, interval_msec);
+ timers[i] = thread_add_timer_msec(master, timer_func, arg,
+ interval_msec, NULL);
ret = snprintf(arg, TIMESTR_LEN + 1, "%lld.%06lld",
(long long)timers[i]->u.sands.tv_sec,
(long long)timers[i]->u.sands.tv_usec);
/* create thread structures so they won't be allocated during the
* time measurement */
for (i = 0; i < SCHEDULE_TIMERS; i++)
- timers[i] = thread_add_timer_msec(master, dummy_func, NULL, 0);
+ timers[i] = thread_add_timer_msec(master, dummy_func, NULL, 0, NULL);
for (i = 0; i < SCHEDULE_TIMERS; i++)
thread_cancel(timers[i]);
long interval_msec;
interval_msec = prng_rand(prng) % (100 * SCHEDULE_TIMERS);
- timers[i] = thread_add_timer_msec(master, dummy_func,
- NULL, interval_msec);
+ timers[i] = thread_add_timer_msec(master, dummy_func, NULL,
+ interval_msec, NULL);
}
monotime(&tv_lap);
kill(-restart->pid, (restart->kills ? SIGKILL : SIGTERM));
restart->kills++;
restart->t_kill = thread_add_timer(master, restart_kill, restart,
- gs.restart_timeout);
+ gs.restart_timeout, NULL);
return 0;
}
if ((restart->pid = run_background(cmd)) > 0) {
restart->t_kill =
thread_add_timer(master, restart_kill, restart,
- gs.restart_timeout);
+ gs.restart_timeout, NULL);
restart->what = cmdtype;
gs.numpids++;
} else
}
#define SET_READ_HANDLER(DMN) \
- (DMN)->t_read = thread_add_read(master,handle_read,(DMN),(DMN)->fd)
+ (DMN)->t_read = thread_add_read(master,handle_read,(DMN),(DMN)->fd, NULL)
#define SET_WAKEUP_DOWN(DMN) \
(DMN)->t_wakeup = thread_add_timer_msec(master,wakeup_down,(DMN), \
- FUZZY(gs.period))
+ FUZZY(gs.period), NULL)
#define SET_WAKEUP_UNRESPONSIVE(DMN) \
(DMN)->t_wakeup = thread_add_timer_msec(master,wakeup_unresponsive,(DMN), \
- FUZZY(gs.period))
+ FUZZY(gs.period), NULL)
#define SET_WAKEUP_ECHO(DMN) \
(DMN)->t_wakeup = thread_add_timer_msec(master,wakeup_send_echo,(DMN), \
- FUZZY(gs.period))
+ FUZZY(gs.period), NULL)
static int wakeup_down(struct thread *t_wakeup)
{
dmn->state = DAEMON_CONNECTING;
dmn->fd = sock;
dmn->t_write =
- thread_add_write(master, check_connect, dmn, dmn->fd);
+ thread_add_write(master, check_connect, dmn, dmn->fd,
+ NULL);
dmn->t_wakeup =
thread_add_timer(master, wakeup_connect_hanging, dmn,
- gs.timeout);
+ gs.timeout, NULL);
SET_READ_HANDLER(dmn);
return 0;
}
if (gs.t_phase_hanging)
thread_cancel(gs.t_phase_hanging);
gs.t_phase_hanging = thread_add_timer(master, phase_hanging, NULL,
- PHASE_TIMEOUT);
+ PHASE_TIMEOUT, NULL);
}
static void phase_check(void)
} else {
gettimeofday(&dmn->echo_sent, NULL);
dmn->t_wakeup =
- thread_add_timer(master, wakeup_no_answer, dmn, gs.timeout);
+ thread_add_timer(master, wakeup_no_answer, dmn,
+ gs.timeout, NULL);
}
return 0;
}
dmn->fd = -1;
dmn->t_wakeup =
thread_add_timer_msec(master, wakeup_init, dmn,
- 100 + (random() % 900));
+ 100 + (random() % 900),
+ NULL);
dmn->restart.interval = gs.min_restart_interval;
if (tail)
tail->next = dmn;
ifp->name,
timer);
- irdp->t_advertise = thread_add_timer(zebrad.master,
- irdp_send_thread,
- ifp,
- timer);
+ irdp->t_advertise = thread_add_timer(zebrad.master, irdp_send_thread, ifp,
+ timer, NULL);
}
static void
return ret;
};
- t_irdp_raw = thread_add_read (zebrad.master, irdp_read_raw, NULL, sock);
+ t_irdp_raw = thread_add_read(zebrad.master, irdp_read_raw, NULL, sock, NULL);
return sock;
}
if(irdp->flags & IF_DEBUG_MISC)
zlog_debug("IRDP: New timer for %s set to %u\n", ifp->name, timer);
- irdp->t_advertise = thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer);
+ irdp->t_advertise = thread_add_timer(zebrad.master, irdp_send_thread, ifp,
+ timer, NULL);
return 0;
}
timer = (random () % MAX_RESPONSE_DELAY) + 1;
- irdp->t_advertise = thread_add_timer(zebrad.master,
- irdp_send_thread,
- ifp,
- timer);
+ irdp->t_advertise = thread_add_timer(zebrad.master, irdp_send_thread, ifp,
+ timer, NULL);
}
void irdp_finish()
int ret, ifindex = 0;
int irdp_sock = THREAD_FD (r);
- t_irdp_raw = thread_add_read (zebrad.master, irdp_read_raw, NULL, irdp_sock);
+ t_irdp_raw = thread_add_read(zebrad.master, irdp_read_raw, NULL, irdp_sock,
+ NULL);
ret = irdp_recvmsg (irdp_sock, (u_char *) buf, IRDP_RX_BUF, &ifindex);
{
struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG (thread);
netlink_parse_info (netlink_information_fetch, &zns->netlink, zns, 5, 0);
- zns->t_netlink = thread_add_read (zebrad.master, kernel_read, zns,
- zns->netlink.sock);
+ zns->t_netlink = thread_add_read(zebrad.master, kernel_read, zns,
+ zns->netlink.sock, NULL);
return 0;
}
netlink_recvbuf (&zns->netlink, nl_rcvbufsize);
netlink_install_filter (zns->netlink.sock, zns->netlink_cmd.snl.nl_pid);
- zns->t_netlink = thread_add_read (zebrad.master, kernel_read, zns,
- zns->netlink.sock);
+ zns->t_netlink = thread_add_read(zebrad.master, kernel_read, zns,
+ zns->netlink.sock, NULL);
}
}
return 0;
}
- thread_add_read (zebrad.master, kernel_read, NULL, sock);
+ thread_add_read(zebrad.master, kernel_read, NULL, sock, NULL);
if (IS_ZEBRA_DEBUG_KERNEL)
rtmsg_debug (&buf.r.rtm);
zlog_err ("routing_socket: Can't lower privileges");
/* kernel_read needs rewrite. */
- thread_add_read (zebrad.master, kernel_read, NULL, routing_sock);
+ thread_add_read(zebrad.master, kernel_read, NULL, routing_sock, NULL);
}
/* Exported interface function. This function simply calls
if (zclient_socket_connect(zclient) < 0) {
zlog_err("Error connecting synchronous zclient!");
- THREAD_TIMER_ON(zebrad.master, zclient->t_connect,
- zclient_connect,
- zclient, CONNECTION_DELAY);
+ thread_add_timer(zebrad.master, zclient_connect, zclient,
+ CONNECTION_DELAY, &zclient->t_connect);
return -1;
}
switch (event)
{
case RTADV_START:
- if (! rtadv->ra_read)
- rtadv->ra_read = thread_add_read (zebrad.master, rtadv_read, zns, val);
- if (! rtadv->ra_timer)
- rtadv->ra_timer = thread_add_event (zebrad.master, rtadv_timer,
- zns, 0);
+ thread_add_read(zebrad.master, rtadv_read, zns, val, &rtadv->ra_read);
+ thread_add_event(zebrad.master, rtadv_timer, zns, 0, &rtadv->ra_timer);
break;
case RTADV_STOP:
if (rtadv->ra_timer)
}
break;
case RTADV_TIMER:
- if (! rtadv->ra_timer)
- rtadv->ra_timer = thread_add_timer (zebrad.master, rtadv_timer, zns,
- val);
+ thread_add_timer(zebrad.master, rtadv_timer, zns, val, &rtadv->ra_timer);
break;
case RTADV_TIMER_MSEC:
- if (! rtadv->ra_timer)
- rtadv->ra_timer = thread_add_timer_msec (zebrad.master, rtadv_timer,
- zns, val);
+ thread_add_timer_msec(zebrad.master, rtadv_timer, zns, val,
+ &rtadv->ra_timer);
break;
case RTADV_READ:
- if (! rtadv->ra_read)
- rtadv->ra_read = thread_add_read (zebrad.master, rtadv_read, zns, val);
+ thread_add_read(zebrad.master, rtadv_read, zns, val, &rtadv->ra_read);
break;
default:
break;
assert (!zfpm_g->t_read);
assert (zfpm_g->sock >= 0);
- THREAD_READ_ON (zfpm_g->master, zfpm_g->t_read, zfpm_read_cb, 0,
- zfpm_g->sock);
+ thread_add_read(zfpm_g->master, zfpm_read_cb, 0, zfpm_g->sock,
+ &zfpm_g->t_read);
}
/*
assert (!zfpm_g->t_write);
assert (zfpm_g->sock >= 0);
- THREAD_WRITE_ON (zfpm_g->master, zfpm_g->t_write, zfpm_write_cb, 0,
- zfpm_g->sock);
+ thread_add_write(zfpm_g->master, zfpm_write_cb, 0, zfpm_g->sock,
+ &zfpm_g->t_write);
}
/*
zfpm_g->stats.t_conn_up_yields++;
zfpm_rnodes_iter_pause (iter);
- zfpm_g->t_conn_up = thread_add_background (zfpm_g->master,
- zfpm_conn_up_thread_cb,
- 0, 0);
+ zfpm_g->t_conn_up = thread_add_background(zfpm_g->master,
+ zfpm_conn_up_thread_cb, 0, 0,
+ NULL);
return 0;
}
zfpm_rnodes_iter_init (&zfpm_g->t_conn_up_state.iter);
zfpm_debug ("Starting conn_up thread");
- zfpm_g->t_conn_up = thread_add_background (zfpm_g->master,
- zfpm_conn_up_thread_cb, 0, 0);
+ zfpm_g->t_conn_up = thread_add_background(zfpm_g->master,
+ zfpm_conn_up_thread_cb, 0, 0,
+ NULL);
zfpm_g->stats.t_conn_up_starts++;
}
zfpm_g->stats.t_conn_down_yields++;
zfpm_rnodes_iter_pause (iter);
- zfpm_g->t_conn_down = thread_add_background (zfpm_g->master,
- zfpm_conn_down_thread_cb,
- 0, 0);
+ zfpm_g->t_conn_down = thread_add_background(zfpm_g->master,
+ zfpm_conn_down_thread_cb, 0,
+ 0, NULL);
return 0;
}
assert (!zfpm_g->t_conn_down);
zfpm_debug ("Starting conn_down thread");
zfpm_rnodes_iter_init (&zfpm_g->t_conn_down_state.iter);
- zfpm_g->t_conn_down = thread_add_background (zfpm_g->master,
- zfpm_conn_down_thread_cb, 0, 0);
+ zfpm_g->t_conn_down = thread_add_background(zfpm_g->master,
+ zfpm_conn_down_thread_cb, 0, 0,
+ NULL);
zfpm_g->stats.t_conn_down_starts++;
zfpm_set_state (ZFPM_STATE_IDLE, detail);
delay_secs = zfpm_calc_connect_delay();
zfpm_debug ("scheduling connect in %ld seconds", delay_secs);
- THREAD_TIMER_ON (zfpm_g->master, zfpm_g->t_connect, zfpm_connect_cb, 0,
- delay_secs);
+ thread_add_timer(zfpm_g->master, zfpm_connect_cb, 0, delay_secs,
+ &zfpm_g->t_connect);
zfpm_set_state (ZFPM_STATE_ACTIVE, reason);
}
{
assert (!zfpm_g->t_stats);
- THREAD_TIMER_ON (zfpm_g->master, zfpm_g->t_stats, zfpm_stats_timer_cb, 0,
- ZFPM_STATS_IVL_SECS);
+ thread_add_timer(zfpm_g->master, zfpm_stats_timer_cb, 0,
+ ZFPM_STATS_IVL_SECS, &zfpm_g->t_stats);
}
/*
close(ptm_cb.ptm_sock);
ptm_cb.ptm_sock = -1;
zebra_ptm_reset_status(0);
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return (-1);
case BUFFER_PENDING:
- ptm_cb.t_write = thread_add_write(zebrad.master, zebra_ptm_flush_messages,
- NULL, ptm_cb.ptm_sock);
+ ptm_cb.t_write = thread_add_write(zebrad.master,
+ zebra_ptm_flush_messages, NULL,
+ ptm_cb.ptm_sock, NULL);
break;
case BUFFER_EMPTY:
break;
close(ptm_cb.ptm_sock);
ptm_cb.ptm_sock = -1;
zebra_ptm_reset_status(0);
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return -1;
case BUFFER_EMPTY:
THREAD_OFF(ptm_cb.t_write);
break;
case BUFFER_PENDING:
- THREAD_WRITE_ON(zebrad.master, ptm_cb.t_write,
- zebra_ptm_flush_messages, NULL, ptm_cb.ptm_sock);
+ thread_add_write(zebrad.master, zebra_ptm_flush_messages, NULL,
+ ptm_cb.ptm_sock, &ptm_cb.t_write);
break;
}
if (ptm_cb.ptm_sock != -1) {
if (init) {
- ptm_cb.t_read = thread_add_read (zebrad.master, zebra_ptm_sock_read,
- NULL, ptm_cb.ptm_sock);
+ ptm_cb.t_read = thread_add_read(zebrad.master, zebra_ptm_sock_read,
+ NULL, ptm_cb.ptm_sock, NULL);
zebra_bfd_peer_replay_req();
}
zebra_ptm_send_status_req();
if (ptm_cb.reconnect_time > ZEBRA_PTM_RECONNECT_TIME_MAX)
ptm_cb.reconnect_time = ZEBRA_PTM_RECONNECT_TIME_MAX;
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect, NULL,
- ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect, NULL,
+ ptm_cb.reconnect_time, NULL);
} else if (ptm_cb.reconnect_time >= ZEBRA_PTM_RECONNECT_TIME_MAX){
ptm_cb.reconnect_time = ZEBRA_PTM_RECONNECT_TIME_INITIAL;
}
close (ptm_cb.ptm_sock);
ptm_cb.ptm_sock = -1;
zebra_ptm_reset_status(0);
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return (-1);
}
}
- ptm_cb.t_read = thread_add_read (zebrad.master, zebra_ptm_sock_read,
- NULL, ptm_cb.ptm_sock);
+ ptm_cb.t_read = thread_add_read(zebrad.master, zebra_ptm_sock_read, NULL,
+ ptm_cb.ptm_sock, NULL);
return 0;
}
if (ptm_cb.ptm_sock == -1)
{
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return -1;
}
if (ptm_cb.ptm_sock == -1)
{
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return -1;
}
if (ptm_cb.ptm_sock == -1)
{
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return -1;
}
if (ptm_cb.ptm_sock == -1)
{
- ptm_cb.t_timer = thread_add_timer (zebrad.master, zebra_ptm_connect,
- NULL, ptm_cb.reconnect_time);
+ ptm_cb.t_timer = thread_add_timer(zebrad.master, zebra_ptm_connect,
+ NULL, ptm_cb.reconnect_time, NULL);
return;
}
if (zebra_rmap_update_timer && !zebra_t_rmap_update)
zebra_t_rmap_update =
thread_add_timer(zebrad.master, zebra_route_map_update_timer, NULL,
- zebra_rmap_update_timer);
+ zebra_rmap_update_timer, NULL);
}
static void
break;
case BUFFER_PENDING:
client->t_write = thread_add_write(zebrad.master, zserv_flush_data,
- client, client->sock);
+ client, client->sock, NULL);
break;
case BUFFER_EMPTY:
break;
possibility that an I/O error may have caused the client to be
deleted. */
client->t_suicide = thread_add_event(zebrad.master, zserv_delayed_close,
- client, 0);
+ client, 0, NULL);
return -1;
case BUFFER_EMPTY:
THREAD_OFF(client->t_write);
break;
case BUFFER_PENDING:
- THREAD_WRITE_ON(zebrad.master, client->t_write,
- zserv_flush_data, client, client->sock);
+ thread_add_write(zebrad.master, zserv_flush_data, client, client->sock,
+ &client->t_write);
break;
}
switch (event)
{
case ZEBRA_SERV:
- thread_add_read (zebrad.master, zebra_accept, client, sock);
+ thread_add_read(zebrad.master, zebra_accept, client, sock, NULL);
break;
case ZEBRA_READ:
client->t_read =
- thread_add_read (zebrad.master, zebra_client_read, client, sock);
+ thread_add_read(zebrad.master, zebra_client_read, client, sock, NULL);
break;
case ZEBRA_WRITE:
/**/
projects / mirror_frr.git / commitdiff