DEFINE_MGROUP(BABELD, "babeld");
DEFINE_MTYPE_STATIC(BABELD, BABEL, "Babel Structure");
-static int babel_init_routing_process(struct thread *thread);
+static void babel_init_routing_process(struct thread *thread);
static void babel_get_myid(void);
static void babel_initial_noise(void);
-static int babel_read_protocol (struct thread *thread);
-static int babel_main_loop(struct thread *thread);
+static void babel_read_protocol(struct thread *thread);
+static void babel_main_loop(struct thread *thread);
static void babel_set_timer(struct timeval *timeout);
static void babel_fill_with_next_timeout(struct timeval *tv);
static void
}
/* thread reading entries form others babel daemons */
-static int
-babel_read_protocol (struct thread *thread)
+static void babel_read_protocol(struct thread *thread)
{
int rc;
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
/* re-add thread */
thread_add_read(master, &babel_read_protocol, NULL, protocol_socket, &babel_routing_process->t_read);
- return 0;
}
/* Zebra will give some information, especially about interfaces. This function
must be call with a litte timeout wich may give zebra the time to do his job,
making these inits have sense. */
-static int
-babel_init_routing_process(struct thread *thread)
+static void babel_init_routing_process(struct thread *thread)
{
myseqno = (frr_weak_random() & 0xFFFF);
babel_get_myid();
debugf(BABEL_DEBUG_COMMON, "My ID is : %s.", format_eui64(myid));
babel_initial_noise();
babel_main_loop(thread);/* this function self-add to the t_update thread */
- return 0;
}
/* fill "myid" with an unique id (only if myid != {0}). */
}
/* Function used with timeout. */
-static int
-babel_main_loop(struct thread *thread)
+static void babel_main_loop(struct thread *thread)
{
struct timeval tv;
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
/* it happens often to have less than 1 ms, it's bad. */
timeval_add_msec(&tv, &tv, 300);
babel_set_timer(&tv);
- return 0;
- }
+ return;
+ }
gettime(&babel_now);
}
assert(0); /* this line should never be reach */
- return 0;
}
static void
return bfd_key_lookup(key);
}
-int bfd_xmt_cb(struct thread *t)
+void bfd_xmt_cb(struct thread *t)
{
struct bfd_session *bs = THREAD_ARG(t);
ptm_bfd_xmt_TO(bs, 0);
-
- return 0;
}
-int bfd_echo_xmt_cb(struct thread *t)
+void bfd_echo_xmt_cb(struct thread *t)
{
struct bfd_session *bs = THREAD_ARG(t);
if (bs->echo_xmt_TO > 0)
ptm_bfd_echo_xmt_TO(bs);
-
- return 0;
}
/* Was ptm_bfd_detect_TO() */
-int bfd_recvtimer_cb(struct thread *t)
+void bfd_recvtimer_cb(struct thread *t)
{
struct bfd_session *bs = THREAD_ARG(t);
ptm_bfd_sess_dn(bs, BD_CONTROL_EXPIRED);
break;
}
-
- return 0;
}
/* Was ptm_bfd_echo_detect_TO() */
-int bfd_echo_recvtimer_cb(struct thread *t)
+void bfd_echo_recvtimer_cb(struct thread *t)
{
struct bfd_session *bs = THREAD_ARG(t);
ptm_bfd_sess_dn(bs, BD_ECHO_FAILED);
break;
}
-
- return 0;
}
struct bfd_session *bfd_session_new(void)
void control_shutdown(void);
int control_notify(struct bfd_session *bs, uint8_t notify_state);
int control_notify_config(const char *op, struct bfd_session *bs);
-int control_accept(struct thread *t);
+void control_accept(struct thread *t);
/*
void ptm_bfd_snd(struct bfd_session *bfd, int fbit);
void ptm_bfd_echo_snd(struct bfd_session *bfd);
-int bfd_recv_cb(struct thread *t);
+void bfd_recv_cb(struct thread *t);
/*
/* Export callback functions for `event.c`. */
extern struct thread_master *master;
-int bfd_recvtimer_cb(struct thread *t);
-int bfd_echo_recvtimer_cb(struct thread *t);
-int bfd_xmt_cb(struct thread *t);
-int bfd_echo_xmt_cb(struct thread *t);
+void bfd_recvtimer_cb(struct thread *t);
+void bfd_echo_recvtimer_cb(struct thread *t);
+void bfd_xmt_cb(struct thread *t);
+void bfd_echo_xmt_cb(struct thread *t);
extern struct in6_addr zero_addr;
mhop ? "yes" : "no", peerstr, localstr, portstr, vrfstr);
}
-int bfd_recv_cb(struct thread *t)
+void bfd_recv_cb(struct thread *t)
{
int sd = THREAD_FD(t);
struct bfd_session *bfd;
/* Handle echo packets. */
if (sd == bvrf->bg_echo || sd == bvrf->bg_echov6) {
ptm_bfd_process_echo_pkt(bvrf, sd);
- return 0;
+ return;
}
/* Sanitize input/output. */
if (mlen < BFD_PKT_LEN) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"too small (%ld bytes)", mlen);
- return 0;
+ return;
}
/* Validate single hop packet TTL. */
if ((!is_mhop) && (ttl != BFD_TTL_VAL)) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"invalid TTL: %d expected %d", ttl, BFD_TTL_VAL);
- return 0;
+ return;
}
/*
if (BFD_GETVER(cp->diag) != BFD_VERSION) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"bad version %d", BFD_GETVER(cp->diag));
- return 0;
+ return;
}
if (cp->detect_mult == 0) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"detect multiplier set to zero");
- return 0;
+ return;
}
if ((cp->len < BFD_PKT_LEN) || (cp->len > mlen)) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid, "too small");
- return 0;
+ return;
}
if (cp->discrs.my_discr == 0) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"'my discriminator' is zero");
- return 0;
+ return;
}
/* Find the session that this packet belongs. */
if (bfd == NULL) {
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"no session found");
- return 0;
+ return;
}
/*
cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
"exceeded max hop count (expected %d, got %d)",
bfd->mh_ttl, ttl);
- return 0;
+ return;
}
} else if (bfd->local_address.sa_sin.sin_family == AF_UNSPEC) {
bfd->local_address = local;
/* Send the control packet with the final bit immediately. */
ptm_bfd_snd(bfd, 1);
}
-
- return 0;
}
/*
struct bfd_control_socket *control_new(int sd);
static void control_free(struct bfd_control_socket *bcs);
static void control_reset_buf(struct bfd_control_buffer *bcb);
-static int control_read(struct thread *t);
-static int control_write(struct thread *t);
+static void control_read(struct thread *t);
+static void control_write(struct thread *t);
static void control_handle_request_add(struct bfd_control_socket *bcs,
struct bfd_control_msg *bcm);
}
}
-int control_accept(struct thread *t)
+void control_accept(struct thread *t)
{
int csock, sd = THREAD_FD(t);
csock = accept(sd, NULL, 0);
if (csock == -1) {
zlog_warn("%s: accept: %s", __func__, strerror(errno));
- return 0;
+ return;
}
control_new(csock);
thread_add_read(master, control_accept, NULL, sd, &bglobal.bg_csockev);
-
- return 0;
}
bcb->bcb_left = 0;
}
-static int control_read(struct thread *t)
+static void control_read(struct thread *t)
{
struct bfd_control_socket *bcs = THREAD_ARG(t);
struct bfd_control_buffer *bcb = &bcs->bcs_bin;
bread = read(sd, &bcm, sizeof(bcm));
if (bread == 0) {
control_free(bcs);
- return 0;
+ return;
}
if (bread < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
zlog_warn("%s: read: %s", __func__, strerror(errno));
control_free(bcs);
- return 0;
+ return;
}
/* Validate header fields. */
zlog_debug("%s: client closed due small message length: %d",
__func__, bcm.bcm_length);
control_free(bcs);
- return 0;
+ return;
}
if (bcm.bcm_ver != BMV_VERSION_1) {
zlog_debug("%s: client closed due bad version: %d", __func__,
bcm.bcm_ver);
control_free(bcs);
- return 0;
+ return;
}
/* Prepare the buffer to load the message. */
zlog_warn("%s: not enough memory for message size: %zu",
__func__, bcb->bcb_left);
control_free(bcs);
- return 0;
+ return;
}
memcpy(bcb->bcb_buf, &bcm, sizeof(bcm));
bread = read(sd, &bcb->bcb_buf[bcb->bcb_pos], bcb->bcb_left);
if (bread == 0) {
control_free(bcs);
- return 0;
+ return;
}
if (bread < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
zlog_warn("%s: read: %s", __func__, strerror(errno));
control_free(bcs);
- return 0;
+ return;
}
bcb->bcb_pos += bread;
schedule_next_read:
bcs->bcs_ev = NULL;
thread_add_read(master, control_read, bcs, sd, &bcs->bcs_ev);
-
- return 0;
}
-static int control_write(struct thread *t)
+static void control_write(struct thread *t)
{
struct bfd_control_socket *bcs = THREAD_ARG(t);
struct bfd_control_buffer *bcb = bcs->bcs_bout;
bwrite = write(sd, &bcb->bcb_buf[bcb->bcb_pos], bcb->bcb_left);
if (bwrite == 0) {
control_free(bcs);
- return 0;
+ return;
}
if (bwrite < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
bcs->bcs_outev = NULL;
thread_add_write(master, control_write, bcs,
bcs->bcs_sd, &bcs->bcs_outev);
- return 0;
+ return;
}
zlog_warn("%s: write: %s", __func__, strerror(errno));
control_free(bcs);
- return 0;
+ return;
}
bcb->bcb_pos += bwrite;
bcs->bcs_outev = NULL;
thread_add_write(master, control_write, bcs, bcs->bcs_sd,
&bcs->bcs_outev);
- return 0;
+ return;
}
control_queue_dequeue(bcs);
-
- return 0;
}
*/
typedef void (*bfd_dplane_expect_cb)(struct bfddp_message *msg, void *arg);
-static int bfd_dplane_client_connect(struct thread *t);
+static void bfd_dplane_client_connect(struct thread *t);
static bool bfd_dplane_client_connecting(struct bfd_dplane_ctx *bdc);
static void bfd_dplane_ctx_free(struct bfd_dplane_ctx *bdc);
static int _bfd_dplane_add_session(struct bfd_dplane_ctx *bdc,
return total;
}
-static int bfd_dplane_write(struct thread *t)
+static void bfd_dplane_write(struct thread *t)
{
struct bfd_dplane_ctx *bdc = THREAD_ARG(t);
/* Handle connection stage. */
if (bdc->connecting && bfd_dplane_client_connecting(bdc))
- return 0;
+ return;
bfd_dplane_flush(bdc);
-
- return 0;
}
static void
return 0;
}
-static int bfd_dplane_read(struct thread *t)
+static void bfd_dplane_read(struct thread *t)
{
struct bfd_dplane_ctx *bdc = THREAD_ARG(t);
int rv;
rv = bfd_dplane_expect(bdc, 0, bfd_dplane_handle_message, NULL);
if (rv == -1)
- return 0;
+ return;
stream_pulldown(bdc->inbuf);
thread_add_read(master, bfd_dplane_read, bdc, bdc->sock, &bdc->inbufev);
- return 0;
}
static void _bfd_session_register_dplane(struct hash_bucket *hb, void *arg)
/*
* Data plane listening socket.
*/
-static int bfd_dplane_accept(struct thread *t)
+static void bfd_dplane_accept(struct thread *t)
{
struct bfd_global *bg = THREAD_ARG(t);
struct bfd_dplane_ctx *bdc;
reschedule_and_return:
thread_add_read(master, bfd_dplane_accept, bg, bg->bg_dplane_sock,
&bglobal.bg_dplane_sockev);
- return 0;
}
/*
}
}
-static int bfd_dplane_client_connect(struct thread *t)
+static void bfd_dplane_client_connect(struct thread *t)
{
struct bfd_dplane_ctx *bdc = THREAD_ARG(t);
int rv, sock;
_bfd_dplane_client_bootstrap(bdc);
}
- return 0;
-
reschedule_connect:
THREAD_OFF(bdc->inbufev);
THREAD_OFF(bdc->outbufev);
socket_close(&sock);
thread_add_timer(master, bfd_dplane_client_connect, bdc, 3,
&bdc->connectev);
- return 0;
}
static void bfd_dplane_client_init(const struct sockaddr *sa, socklen_t salen)
(*cnt)++;
}
-static int bmp_stats(struct thread *thread)
+static void bmp_stats(struct thread *thread)
{
struct bmp_targets *bt = THREAD_ARG(thread);
struct stream *s;
bmp_send_all(bt->bmpbgp, s);
}
- return 0;
}
/* read from the BMP socket to detect session termination */
-static int bmp_read(struct thread *t)
+static void bmp_read(struct thread *t)
{
struct bmp *bmp = THREAD_ARG(t);
char buf[1024];
} else if (n == 0) {
/* the TCP session was terminated by the far end */
bmp_wrerr(bmp, NULL, true);
- return 0;
+ return;
} else if (!(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)) {
/* the TCP session experienced a fatal error, likely a timeout */
bmp_wrerr(bmp, NULL, false);
- return -1;
+ return;
}
thread_add_read(bm->master, bmp_read, bmp, bmp->socket, &bmp->t_read);
-
- return 0;
}
static struct bmp *bmp_open(struct bmp_targets *bt, int bmp_sock)
}
/* Accept BMP connection. */
-static int bmp_accept(struct thread *thread)
+static void bmp_accept(struct thread *thread)
{
union sockunion su;
struct bmp_listener *bl = THREAD_ARG(thread);
bmp_sock = sockunion_accept(bl->sock, &su);
if (bmp_sock < 0) {
zlog_info("bmp: accept_sock failed: %s", safe_strerror(errno));
- return -1;
+ return;
}
bmp_open(bl->targets, bmp_sock);
- return 0;
}
static void bmp_close(struct bmp *bmp)
bmp_active_connect(ba);
}
-static int bmp_active_thread(struct thread *t)
+static void bmp_active_thread(struct thread *t)
{
struct bmp_active *ba = THREAD_ARG(t);
socklen_t slen;
vrf_id = ba->targets->bgp->vrf_id;
resolver_resolve(&ba->resq, AF_UNSPEC, vrf_id, ba->hostname,
bmp_active_resolved);
- return 0;
+ return;
}
slen = sizeof(status);
ba->bmp->active = ba;
ba->socket = -1;
ba->curretry = ba->minretry;
- return 0;
+ return;
out_next:
close(ba->socket);
ba->socket = -1;
ba->addrpos++;
bmp_active_connect(ba);
- return 0;
}
static void bmp_active_disconnected(struct bmp_active *ba)
/* Handler of conditional advertisement timer event.
* Each route in the condition-map is evaluated.
*/
-static int bgp_conditional_adv_timer(struct thread *t)
+static void bgp_conditional_adv_timer(struct thread *t)
{
afi_t afi;
safi_t safi;
}
peer->advmap_table_change = false;
}
- return 0;
}
void bgp_conditional_adv_enable(struct peer *peer, afi_t afi, safi_t safi)
/* Handler of reuse timer event. Each route in the current reuse-list
is evaluated. RFC2439 Section 4.8.7. */
-static int bgp_reuse_timer(struct thread *t)
+static void bgp_reuse_timer(struct thread *t)
{
struct bgp_damp_info *bdi;
struct bgp_damp_info *next;
* 4.8.6). */
bgp_reuse_list_add(bdi, bdc);
}
-
- return 0;
}
/* A route becomes unreachable (RFC2439 Section 4.8.2). */
};
static int bgp_dump_unset(struct bgp_dump *bgp_dump);
-static int bgp_dump_interval_func(struct thread *);
+static void bgp_dump_interval_func(struct thread *);
/* BGP packet dump output buffer. */
struct stream *bgp_dump_obuf;
return seq;
}
-static int bgp_dump_interval_func(struct thread *t)
+static void bgp_dump_interval_func(struct thread *t)
{
struct bgp_dump *bgp_dump;
bgp_dump = THREAD_ARG(t);
/* if interval is set reschedule */
if (bgp_dump->interval > 0)
bgp_dump_interval_add(bgp_dump, bgp_dump->interval);
-
- return 0;
}
/* Dump common information. */
bool is_local);
esi_t zero_esi_buf, *zero_esi = &zero_esi_buf;
-static int bgp_evpn_run_consistency_checks(struct thread *t);
+static void bgp_evpn_run_consistency_checks(struct thread *t);
static void bgp_evpn_path_nh_info_free(struct bgp_path_evpn_nh_info *nh_info);
static void bgp_evpn_path_nh_unlink(struct bgp_path_evpn_nh_info *nh_info);
return proc_cnt;
}
-static int bgp_evpn_run_consistency_checks(struct thread *t)
+static void bgp_evpn_run_consistency_checks(struct thread *t)
{
int proc_cnt = 0;
int es_cnt = 0;
thread_add_timer(bm->master, bgp_evpn_run_consistency_checks, NULL,
BGP_EVPN_CONS_CHECK_INTERVAL,
&bgp_mh_info->t_cons_check);
-
- return 0;
}
/*****************************************************************************
function. */
/* BGP event function. */
-int bgp_event(struct thread *);
+void bgp_event(struct thread *);
/* BGP thread functions. */
-static int bgp_start_timer(struct thread *);
-static int bgp_connect_timer(struct thread *);
-static int bgp_holdtime_timer(struct thread *);
-static int bgp_delayopen_timer(struct thread *);
+static void bgp_start_timer(struct thread *);
+static void bgp_connect_timer(struct thread *);
+static void bgp_holdtime_timer(struct thread *);
+static void bgp_delayopen_timer(struct thread *);
/* BGP FSM functions. */
static int bgp_start(struct peer *);
/* BGP start timer. This function set BGP_Start event to thread value
and process event. */
-static int bgp_start_timer(struct thread *thread)
+static void bgp_start_timer(struct thread *thread)
{
struct peer *peer;
THREAD_VAL(thread) = BGP_Start;
bgp_event(thread); /* bgp_event unlocks peer */
-
- return 0;
}
/* BGP connect retry timer. */
-static int bgp_connect_timer(struct thread *thread)
+static void bgp_connect_timer(struct thread *thread)
{
struct peer *peer;
- int ret;
peer = THREAD_ARG(thread);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (connect timer expire)", peer->host);
- if (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)) {
+ if (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER))
bgp_stop(peer);
- ret = -1;
- } else {
+ else {
THREAD_VAL(thread) = ConnectRetry_timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */
- ret = 0;
}
-
- return ret;
}
/* BGP holdtime timer. */
-static int bgp_holdtime_timer(struct thread *thread)
+static void bgp_holdtime_timer(struct thread *thread)
{
atomic_size_t inq_count;
struct peer *peer;
*/
inq_count = atomic_load_explicit(&peer->ibuf->count,
memory_order_relaxed);
- if (inq_count) {
+ if (inq_count)
BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
peer->v_holdtime);
- return 0;
- }
-
THREAD_VAL(thread) = Hold_Timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */
-
- return 0;
}
-int bgp_routeadv_timer(struct thread *thread)
+void bgp_routeadv_timer(struct thread *thread)
{
struct peer *peer;
/* MRAI timer will be started again when FIFO is built, no need to
* do it here.
*/
- return 0;
}
/* RFC 4271 DelayOpenTimer */
-int bgp_delayopen_timer(struct thread *thread)
+void bgp_delayopen_timer(struct thread *thread)
{
struct peer *peer;
THREAD_VAL(thread) = DelayOpen_timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */
-
- return 0;
}
/* BGP Peer Down Cause */
bgp_timer_set(peer);
}
-static int bgp_llgr_stale_timer_expire(struct thread *thread)
+static void bgp_llgr_stale_timer_expire(struct thread *thread)
{
struct peer_af *paf;
struct peer *peer;
bgp_clear_stale_route(peer, afi, safi);
bgp_graceful_restart_timer_off(peer);
-
- return 0;
}
static void bgp_set_llgr_stale(struct peer *peer, afi_t afi, safi_t safi)
}
}
-static int bgp_graceful_restart_timer_expire(struct thread *thread)
+static void bgp_graceful_restart_timer_expire(struct thread *thread)
{
struct peer *peer, *tmp_peer;
struct listnode *node, *nnode;
}
bgp_graceful_restart_timer_off(peer);
-
- return 0;
}
-static int bgp_graceful_stale_timer_expire(struct thread *thread)
+static void bgp_graceful_stale_timer_expire(struct thread *thread)
{
struct peer *peer;
afi_t afi;
FOREACH_AFI_SAFI_NSF (afi, safi)
if (peer->nsf[afi][safi])
bgp_clear_stale_route(peer, afi, safi);
-
- return 0;
}
/* Selection deferral timer processing function */
-static int bgp_graceful_deferral_timer_expire(struct thread *thread)
+static void bgp_graceful_deferral_timer_expire(struct thread *thread)
{
struct afi_safi_info *info;
afi_t afi;
XFREE(MTYPE_TMP, info);
/* Best path selection */
- return bgp_best_path_select_defer(bgp, afi, safi);
+ bgp_best_path_select_defer(bgp, afi, safi);
}
static bool bgp_update_delay_applicable(struct bgp *bgp)
}
/* The maxmed onstartup timer expiry callback. */
-static int bgp_maxmed_onstartup_timer(struct thread *thread)
+static void bgp_maxmed_onstartup_timer(struct thread *thread)
{
struct bgp *bgp;
bgp->maxmed_onstartup_over = 1;
bgp_maxmed_update(bgp);
-
- return 0;
}
static void bgp_maxmed_onstartup_begin(struct bgp *bgp)
}
/* The update delay timer expiry callback. */
-static int bgp_update_delay_timer(struct thread *thread)
+static void bgp_update_delay_timer(struct thread *thread)
{
struct bgp *bgp;
bgp = THREAD_ARG(thread);
THREAD_OFF(bgp->t_update_delay);
bgp_update_delay_end(bgp);
-
- return 0;
}
/* The establish wait timer expiry callback. */
-static int bgp_establish_wait_timer(struct thread *thread)
+static void bgp_establish_wait_timer(struct thread *thread)
{
struct bgp *bgp;
bgp = THREAD_ARG(thread);
THREAD_OFF(bgp->t_establish_wait);
bgp_check_update_delay(bgp);
-
- return 0;
}
/* Steps to begin the update delay:
* when the connection is established. A read event is triggered when the
* connection is closed. Thus we need to cancel whichever one did not occur.
*/
-static int bgp_connect_check(struct thread *thread)
+static void bgp_connect_check(struct thread *thread)
{
int status;
socklen_t slen;
zlog_err("can't get sockopt for nonblocking connect: %d(%s)",
errno, safe_strerror(errno));
BGP_EVENT_ADD(peer, TCP_fatal_error);
- return -1;
+ return;
}
/* When status is 0 then TCP connection is established. */
BGP_EVENT_ADD(peer, TCP_connection_open_w_delay);
else
BGP_EVENT_ADD(peer, TCP_connection_open);
- return 1;
+ return;
} else {
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [Event] Connect failed %d(%s)",
peer->host, status, safe_strerror(status));
BGP_EVENT_ADD(peer, TCP_connection_open_failed);
- return 0;
+ return;
}
}
};
/* Execute event process. */
-int bgp_event(struct thread *thread)
+void bgp_event(struct thread *thread)
{
enum bgp_fsm_events event;
struct peer *peer;
- int ret;
peer = THREAD_ARG(thread);
event = THREAD_VAL(thread);
- ret = bgp_event_update(peer, event);
-
- return (ret);
+ bgp_event_update(peer, event);
}
int bgp_event_update(struct peer *peer, enum bgp_fsm_events event)
* Update FSM for peer based on whether we have valid nexthops or not.
*/
extern void bgp_fsm_nht_update(struct peer *peer, bool has_valid_nexthops);
-extern int bgp_event(struct thread *);
+extern void bgp_event(struct thread *);
extern int bgp_event_update(struct peer *, enum bgp_fsm_events event);
extern int bgp_stop(struct peer *peer);
extern void bgp_timer_set(struct peer *);
-extern int bgp_routeadv_timer(struct thread *);
+extern void bgp_routeadv_timer(struct thread *);
extern void bgp_fsm_change_status(struct peer *peer, int status);
extern const char *const peer_down_str[];
extern void bgp_update_delay_end(struct bgp *);
/* forward declarations */
static uint16_t bgp_write(struct peer *);
static uint16_t bgp_read(struct peer *peer, int *code_p);
-static int bgp_process_writes(struct thread *);
-static int bgp_process_reads(struct thread *);
+static void bgp_process_writes(struct thread *);
+static void bgp_process_reads(struct thread *);
static bool validate_header(struct peer *);
/* generic i/o status codes */
/*
* Called from I/O pthread when a file descriptor has become ready for writing.
*/
-static int bgp_process_writes(struct thread *thread)
+static void bgp_process_writes(struct thread *thread)
{
static struct peer *peer;
peer = THREAD_ARG(thread);
bool fatal = false;
if (peer->fd < 0)
- return -1;
+ return;
struct frr_pthread *fpt = bgp_pth_io;
BGP_UPDATE_GROUP_TIMER_ON(&peer->t_generate_updgrp_packets,
bgp_generate_updgrp_packets);
}
-
- return 0;
}
/*
* We read as much data as possible, process as many packets as we can and
* place them on peer->ibuf for secondary processing by the main thread.
*/
-static int bgp_process_reads(struct thread *thread)
+static void bgp_process_reads(struct thread *thread)
{
/* clang-format off */
static struct peer *peer; // peer to read from
peer = THREAD_ARG(thread);
if (peer->fd < 0 || bm->terminating)
- return -1;
+ return;
struct frr_pthread *fpt = bgp_pth_io;
thread_add_event(bm->master, bgp_process_packet,
peer, 0, &peer->t_process_packet);
}
-
- return 0;
}
/*
}
/* Accept bgp connection. */
-static int bgp_accept(struct thread *thread)
+static void bgp_accept(struct thread *thread)
{
int bgp_sock;
int accept_sock;
flog_err_sys(EC_LIB_SOCKET,
"[Error] BGP accept socket fd is negative: %d",
accept_sock);
- return -1;
+ return;
}
thread_add_read(bm->master, bgp_accept, listener, accept_sock,
"[Error] BGP socket accept failed (%s); retrying",
safe_strerror(save_errno));
}
- return -1;
+ return;
}
set_nonblocking(bgp_sock);
"[Event] Could not get instance for incoming conn from %s",
inet_sutop(&su, buf));
close(bgp_sock);
- return -1;
+ return;
}
bgp_socket_set_buffer_size(bgp_sock);
TCP_connection_open);
}
- return 0;
+ return;
}
}
VRF_LOGNAME(vrf_lookup_by_id(bgp->vrf_id)));
}
close(bgp_sock);
- return -1;
+ return;
}
if (CHECK_FLAG(peer1->flags, PEER_FLAG_SHUTDOWN)
inet_sutop(&su, buf), bgp->name_pretty, bgp->as,
VRF_LOGNAME(vrf_lookup_by_id(bgp->vrf_id)));
close(bgp_sock);
- return -1;
+ return;
}
/*
"[Event] Closing incoming conn for %s (%p) state %d",
peer1->host, peer1, peer1->status);
close(bgp_sock);
- return -1;
+ return;
}
/* Check that at least one AF is activated for the peer. */
"%s - incoming conn rejected - no AF activated for peer",
peer1->host);
close(bgp_sock);
- return -1;
+ return;
}
/* Do not try to reconnect if the peer reached maximum
"[Event] Incoming BGP connection rejected from %s due to maximum-prefix or shutdown",
peer1->host);
close(bgp_sock);
- return -1;
+ return;
}
if (bgp_debug_neighbor_events(peer1))
* massage the event system to make things happy
*/
bgp_nht_interface_events(peer);
-
- return 0;
}
/* BGP socket bind. */
static void unregister_zebra_rnh(struct bgp_nexthop_cache *bnc,
int is_bgp_static_route);
static int make_prefix(int afi, struct bgp_path_info *pi, struct prefix *p);
-static int bgp_nht_ifp_initial(struct thread *thread);
+static void bgp_nht_ifp_initial(struct thread *thread);
static int bgp_isvalid_nexthop(struct bgp_nexthop_cache *bnc)
{
bgp_nht_ifp_handle(ifp, false);
}
-static int bgp_nht_ifp_initial(struct thread *thread)
+static void bgp_nht_ifp_initial(struct thread *thread)
{
ifindex_t ifindex = THREAD_VAL(thread);
struct bgp *bgp = THREAD_ARG(thread);
struct interface *ifp = if_lookup_by_index(ifindex, bgp->vrf_id);
if (!ifp)
- return 0;
+ return;
if (BGP_DEBUG(nht, NHT))
zlog_debug(
bgp_nht_ifp_up(ifp);
else
bgp_nht_ifp_down(ifp);
-
- return 0;
}
/*
* update group a peer belongs to, encode this information into packets, and
* enqueue the packets onto the peer's output buffer.
*/
-int bgp_generate_updgrp_packets(struct thread *thread)
+void bgp_generate_updgrp_packets(struct thread *thread)
{
struct peer *peer = THREAD_ARG(thread);
* update-delay processing).
*/
if (!peer_established(peer))
- return 0;
+ return;
if ((peer->bgp->main_peers_update_hold)
|| bgp_update_delay_active(peer->bgp))
- return 0;
+ return;
if (peer->t_routeadv)
- return 0;
+ return;
do {
enum bgp_af_index index;
bgp_writes_on(peer);
bgp_write_proceed_actions(peer);
-
- return 0;
}
/*
return Receive_KEEPALIVE_message;
}
-static int bgp_refresh_stalepath_timer_expire(struct thread *thread)
+static void bgp_refresh_stalepath_timer_expire(struct thread *thread)
{
struct peer_af *paf;
peer->host, afi2str(afi), safi2str(safi));
bgp_timer_set(peer);
-
- return 0;
}
/**
* @param thread
* @return 0
*/
-int bgp_process_packet(struct thread *thread)
+void bgp_process_packet(struct thread *thread)
{
/* Yes first of all get peer pointer. */
struct peer *peer; // peer
/* Guard against scheduled events that occur after peer deletion. */
if (peer->status == Deleted || peer->status == Clearing)
- return 0;
+ return;
unsigned int processed = 0;
}
if (peer->curr == NULL) // no packets to process, hmm...
- return 0;
+ return;
/* skip the marker and copy the packet length */
stream_forward_getp(peer->curr, BGP_MARKER_SIZE);
&peer->t_process_packet);
}
}
-
- return 0;
}
/* Send EOR when routes are processed by selection deferral timer */
* having the io pthread try to enqueue fsm events or mess with the peer
* struct.
*/
-int bgp_packet_process_error(struct thread *thread)
+void bgp_packet_process_error(struct thread *thread)
{
struct peer *peer;
int code;
}
bgp_event_update(peer, code);
-
- return 0;
}
extern int bgp_packet_set_marker(struct stream *s, uint8_t type);
extern void bgp_packet_set_size(struct stream *s);
-extern int bgp_generate_updgrp_packets(struct thread *);
-extern int bgp_process_packet(struct thread *);
+extern void bgp_generate_updgrp_packets(struct thread *);
+extern void bgp_process_packet(struct thread *);
extern void bgp_send_delayed_eor(struct bgp *bgp);
/* Task callback to handle socket error encountered in the io pthread */
-int bgp_packet_process_error(struct thread *thread);
+void bgp_packet_process_error(struct thread *thread);
#endif /* _QUAGGA_BGP_PACKET_H */
return true;
}
-static int bgp_route_select_timer_expire(struct thread *thread)
+static void bgp_route_select_timer_expire(struct thread *thread)
{
struct afi_safi_info *info;
afi_t afi;
XFREE(MTYPE_TMP, info);
/* Best path selection */
- return bgp_best_path_select_defer(bgp, afi, safi);
+ bgp_best_path_select_defer(bgp, afi, safi);
}
void bgp_best_selection(struct bgp *bgp, struct bgp_dest *dest,
work_queue_add(bgp->process_queue, pqnode);
}
-static int bgp_maximum_prefix_restart_timer(struct thread *thread)
+static void bgp_maximum_prefix_restart_timer(struct thread *thread)
{
struct peer *peer;
if ((peer_clear(peer, NULL) < 0) && bgp_debug_neighbor_events(peer))
zlog_debug("%s: %s peer_clear failed", __func__, peer->host);
-
- return 0;
}
static uint32_t bgp_filtered_routes_count(struct peer *peer, afi_t afi,
* Callback that is invoked when the route announcement timer for a
* peer_af expires.
*/
-static int bgp_announce_route_timer_expired(struct thread *t)
+static void bgp_announce_route_timer_expired(struct thread *t)
{
struct peer_af *paf;
struct peer *peer;
peer = paf->peer;
if (!peer_established(peer))
- return 0;
+ return;
if (!peer->afc_nego[paf->afi][paf->safi])
- return 0;
+ return;
peer_af_announce_route(paf, 1);
/* Notify BGP conditional advertisement scanner percess */
peer->advmap_config_change[paf->afi][paf->safi] = true;
-
- return 0;
}
/*
* Without splitting the full job into several part,
* vtysh waits for the job to finish before responding to a BGP command
*/
-static int bgp_soft_reconfig_table_task(struct thread *thread)
+static void bgp_soft_reconfig_table_task(struct thread *thread)
{
uint32_t iter, max_iter;
int ret;
&table->soft_reconfig_peers);
bgp_soft_reconfig_table_flag(
table, false);
- return 0;
+ return;
}
}
}
table->soft_reconfig_init = false;
thread_add_event(bm->master, bgp_soft_reconfig_table_task,
table, 0, &table->soft_reconfig_thread);
- return 0;
+ return;
}
/* we're done, clean up the background iteration context info and
schedule route annoucement
}
list_delete(&table->soft_reconfig_peers);
-
- return 0;
}
}
}
-static int bgp_table_stats_walker(struct thread *t)
+static void bgp_table_stats_walker(struct thread *t)
{
struct bgp_dest *dest, *ndest;
struct bgp_dest *top;
unsigned int space = 0;
if (!(top = bgp_table_top(ts->table)))
- return 0;
+ return;
switch (ts->table->afi) {
case AFI_IP:
space = EVPN_ROUTE_PREFIXLEN;
break;
default:
- return 0;
+ return;
}
ts->counts[BGP_STATS_MAXBITLEN] = space;
bgp_table_stats_rn(dest, top, ts, space);
}
}
-
- return 0;
}
static void bgp_table_stats_all(struct vty *vty, afi_t afi, safi_t safi,
}
}
-static int bgp_peer_count_walker(struct thread *t)
+static void bgp_peer_count_walker(struct thread *t)
{
struct bgp_dest *rn, *rm;
const struct bgp_table *table;
} else
for (rn = bgp_table_top(pc->table); rn; rn = bgp_route_next(rn))
bgp_peer_count_proc(rn, pc);
-
- return 0;
}
static int bgp_peer_counts(struct vty *vty, struct peer *peer, afi_t afi,
vpn_policy_routemap_event(rmap_name);
}
-int bgp_route_map_update_timer(struct thread *thread)
+void bgp_route_map_update_timer(struct thread *thread)
{
bm->t_rmap_update = NULL;
route_map_walk_update_list(bgp_route_map_process_update_cb);
-
- return 0;
}
static void bgp_route_map_mark_update(const char *rmap_name)
return prefix;
}
-static int bgpd_sync_callback(struct thread *thread)
+static void bgpd_sync_callback(struct thread *thread)
{
struct bgp *bgp;
struct listnode *node;
atomic_store_explicit(&rtr_update_overflow, 0,
memory_order_seq_cst);
revalidate_all_routes();
- return 0;
+ return;
}
retval = read(socket, &rec, sizeof(struct pfx_record));
if (retval != sizeof(struct pfx_record)) {
RPKI_DEBUG("Could not read from socket");
- return retval;
+ return;
}
/* RTR-Server crashed/terminated, let's handle and switch
*/
if (rec.socket && rec.socket->state == RTR_ERROR_FATAL) {
reset(true);
- return 0;
+ return;
}
prefix = pfx_record_to_prefix(&rec);
}
prefix_free(&prefix);
- return 0;
}
static void revalidate_bgp_node(struct bgp_dest *bgp_dest, afi_t afi,
/*
* update_subgroup_merge_check_thread_cb
*/
-static int update_subgroup_merge_check_thread_cb(struct thread *thread)
+static void update_subgroup_merge_check_thread_cb(struct thread *thread)
{
struct update_subgroup *subgrp;
subgrp->t_merge_check = NULL;
update_subgroup_check_merge(subgrp, "triggered merge check");
- return 0;
}
/*
return UPDWALK_CONTINUE;
}
-int update_group_refresh_default_originate_route_map(struct thread *thread)
+void update_group_refresh_default_originate_route_map(struct thread *thread)
{
struct bgp *bgp;
char reason[] = "refresh default-originate route-map";
reason);
thread_cancel(&bgp->t_rmap_def_originate_eval);
bgp_unlock(bgp);
-
- return 0;
}
/*
updgrp_walkcb cb, void *ctx);
extern void update_group_walk(struct bgp *bgp, updgrp_walkcb cb, void *ctx);
extern void update_group_periodic_merge(struct bgp *bgp);
-extern int
+extern void
update_group_refresh_default_originate_route_map(struct thread *thread);
extern void update_group_start_advtimer(struct bgp *bgp);
update_group_af_walk(bgp, afi, safi, updgrp_show_adj_walkcb, &ctx);
}
-static int subgroup_coalesce_timer(struct thread *thread)
+static void subgroup_coalesce_timer(struct thread *thread)
{
struct update_subgroup *subgrp;
struct bgp *bgp;
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
}
}
-
- return 0;
}
static int update_group_announce_walkcb(struct update_group *updgrp, void *arg)
static uint32_t bgp_tm_min, bgp_tm_max, bgp_tm_chunk_size;
struct bgp *bgp_tm_bgp;
-static int bgp_zebra_tm_connect(struct thread *t)
+static void bgp_zebra_tm_connect(struct thread *t)
{
struct zclient *zclient;
int delay = 10, ret = 0;
}
thread_add_timer(bm->master, bgp_zebra_tm_connect, zclient, delay,
&bgp_tm_thread_connect);
- return 0;
}
bool bgp_zebra_tm_chunk_obtained(void)
return 0;
}
-static int bgp_startup_timer_expire(struct thread *thread)
+static void bgp_startup_timer_expire(struct thread *thread)
{
struct bgp *bgp;
bgp = THREAD_ARG(thread);
bgp->t_startup = NULL;
-
- return 0;
}
/*
extern void peer_tx_shutdown_message_set(struct peer *, const char *msg);
extern void peer_tx_shutdown_message_unset(struct peer *);
-extern int bgp_route_map_update_timer(struct thread *thread);
+extern void bgp_route_map_update_timer(struct thread *thread);
extern void bgp_route_map_terminate(void);
extern int peer_cmp(struct peer *p1, struct peer *p2);
* quagga lib/thread.h says this must return int even though
* it doesn't do anything with the return value
*/
-static int rfapiWithdrawTimerVPN(struct thread *t)
+static void rfapiWithdrawTimerVPN(struct thread *t)
{
struct rfapi_withdraw *wcb = t->arg;
struct bgp_path_info *bpi = wcb->info;
vnc_zlog_debug_verbose(
"%s: NULL BGP pointer, assume shutdown race condition!!!",
__func__);
- return 0;
+ return;
}
if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS)) {
vnc_zlog_debug_verbose(
"%s: BGP delete in progress, assume shutdown race condition!!!",
__func__);
- return 0;
+ return;
}
assert(wcb->node);
assert(bpi);
RFAPI_CHECK_REFCOUNT(wcb->node, SAFI_MPLS_VPN, 1 + wcb->lockoffset);
agg_unlock_node(wcb->node); /* decr ref count */
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
- return 0;
}
/*
return 0;
}
-static int rfapiWithdrawTimerEncap(struct thread *t)
+static void rfapiWithdrawTimerEncap(struct thread *t)
{
struct rfapi_withdraw *wcb = t->arg;
struct bgp_path_info *bpi = wcb->info;
agg_unlock_node(wcb->node); /* decr ref count */
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
skiplist_free(vpn_node_sl);
- return 0;
}
rfapiBiStartWithdrawTimer(struct rfapi_import_table *import_table,
struct agg_node *rn, struct bgp_path_info *bpi,
afi_t afi, safi_t safi,
- int (*timer_service_func)(struct thread *))
+ void (*timer_service_func)(struct thread *))
{
uint32_t lifetime;
struct rfapi_withdraw *wcb;
struct agg_node *rn;
struct bgp_path_info *bpi;
struct agg_table *rt;
- int (*timer_service_func)(struct thread *);
+ void (*timer_service_func)(struct thread *);
assert(afi == AFI_IP || afi == AFI_IP6);
extern int rfapiHasNonRemovedRoutes(struct agg_node *rn);
-extern int rfapiProcessDeferredClose(struct thread *t);
-
extern int rfapiGetUnAddrOfVpnBi(struct bgp_path_info *bpi, struct prefix *p);
extern void rfapiNexthop2Prefix(struct attr *attr, struct prefix *p);
bgp->rfapi_cfg->flags &= ~BGP_VNC_CONFIG_RESPONSE_REMOVAL_DISABLE;
}
-static int rfapiMonitorTimerExpire(struct thread *t)
+static void rfapiMonitorTimerExpire(struct thread *t)
{
struct rfapi_monitor_vpn *m = t->arg;
/* delete the monitor */
rfapiMonitorDel(bgp_get_default(), m->rfd, &m->p);
-
- return 0;
}
static void rfapiMonitorTimerRestart(struct rfapi_monitor_vpn *m)
}
}
-static int rfapiMonitorEthTimerExpire(struct thread *t)
+static void rfapiMonitorEthTimerExpire(struct thread *t)
{
struct rfapi_monitor_eth *m = t->arg;
rfapiMonitorEthDel(bgp_get_default(), m->rfd, &m->macaddr,
m->logical_net_id);
- return 0;
}
static void rfapiMonitorEthTimerRestart(struct rfapi_monitor_eth *m)
/*
* remove route from rib
*/
-static int rfapiRibExpireTimer(struct thread *t)
+static void rfapiRibExpireTimer(struct thread *t)
{
struct rfapi_rib_tcb *tcb = t->arg;
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
RFAPI_RIB_CHECK_COUNTS(1, 0);
-
- return 0;
}
static void rfapiRibStartTimer(struct rfapi_descriptor *rfd,
bgp_attr_unintern(&iattr);
}
-static int vncExportWithdrawTimer(struct thread *t)
+static void vncExportWithdrawTimer(struct thread *t)
{
struct vnc_export_info *eti = t->arg;
const struct prefix *p = agg_node_get_prefix(eti->node);
* Free the eti
*/
vnc_eti_delete(eti);
-
- return 0;
}
/*
*
* @param[in] thread current execution thread timer is associated with
*
- * @return int always returns 0
+ * @return void
*
* @par
* Called when 10sec waiting time expire and
* executes Graceful restart for whole process
*/
-int eigrp_distribute_timer_process(struct thread *thread)
+void eigrp_distribute_timer_process(struct thread *thread)
{
struct eigrp *eigrp;
/* execute GR for whole process */
eigrp_update_send_process_GR(eigrp, EIGRP_GR_FILTER, NULL);
-
- return 0;
}
/*
*
* @param[in] thread current execution thread timer is associated with
*
- * @return int always returns 0
+ * @return void
*
* @par
* Called when 10sec waiting time expire and
* executes Graceful restart for interface
*/
-int eigrp_distribute_timer_interface(struct thread *thread)
+void eigrp_distribute_timer_interface(struct thread *thread)
{
struct eigrp_interface *ei;
/* execute GR for interface */
eigrp_update_send_interface_GR(ei, EIGRP_GR_FILTER, NULL);
-
- return 0;
}
extern void eigrp_distribute_update_interface(struct interface *ifp);
extern void eigrp_distribute_update_all(struct prefix_list *plist);
extern void eigrp_distribute_update_all_wrapper(struct access_list *alist);
-extern int eigrp_distribute_timer_process(struct thread *thread);
-extern int eigrp_distribute_timer_interface(struct thread *thread);
+extern void eigrp_distribute_timer_process(struct thread *thread);
+extern void eigrp_distribute_timer_interface(struct thread *thread);
#endif /* EIGRPD_EIGRP_FILTER_H_ */
*
* @param[in] thread current execution thread timer is associated with
*
- * @return int always returns 0
+ * @return void
*
* @par
* Called once per "hello" time interval, default 5 seconds
* Sends hello packet via multicast for all interfaces eigrp
* is configured for
*/
-int eigrp_hello_timer(struct thread *thread)
+void eigrp_hello_timer(struct thread *thread)
{
struct eigrp_interface *ei;
/* Hello timer set. */
thread_add_timer(master, eigrp_hello_timer, ei, ei->params.v_hello,
&ei->t_hello);
-
- return 0;
}
/**
XFREE(MTYPE_EIGRP_NEIGHBOR, nbr);
}
-int holddown_timer_expired(struct thread *thread)
+void holddown_timer_expired(struct thread *thread)
{
struct eigrp_neighbor *nbr = THREAD_ARG(thread);
struct eigrp *eigrp = nbr->ei->eigrp;
ifindex2ifname(nbr->ei->ifp->ifindex, eigrp->vrf_id));
nbr->state = EIGRP_NEIGHBOR_DOWN;
eigrp_nbr_delete(nbr);
-
- return 0;
}
uint8_t eigrp_nbr_state_get(struct eigrp_neighbor *nbr)
extern struct eigrp_neighbor *eigrp_nbr_new(struct eigrp_interface *ei);
extern void eigrp_nbr_delete(struct eigrp_neighbor *neigh);
-extern int holddown_timer_expired(struct thread *thread);
+extern void holddown_timer_expired(struct thread *thread);
extern int eigrp_neighborship_check(struct eigrp_neighbor *neigh,
struct TLV_Parameter_Type *tlv);
extern int eigrp_network_set(struct eigrp *eigrp, struct prefix *p);
extern int eigrp_network_unset(struct eigrp *eigrp, struct prefix *p);
-extern int eigrp_hello_timer(struct thread *);
+extern void eigrp_hello_timer(struct thread *thread);
extern void eigrp_if_update(struct interface *);
extern int eigrp_if_add_allspfrouters(struct eigrp *, struct prefix *,
unsigned int);
return 1;
}
-int eigrp_write(struct thread *thread)
+void eigrp_write(struct thread *thread)
{
struct eigrp *eigrp = THREAD_ARG(thread);
struct eigrp_header *eigrph;
thread_add_write(master, eigrp_write, eigrp, eigrp->fd,
&eigrp->t_write);
}
-
- return 0;
}
/* Starting point of packet process function. */
-int eigrp_read(struct thread *thread)
+void eigrp_read(struct thread *thread)
{
int ret;
struct stream *ibuf;
if (!(ibuf = eigrp_recv_packet(eigrp, eigrp->fd, &ifp, eigrp->ibuf))) {
/* This raw packet is known to be at least as big as its IP
* header. */
- return -1;
+ return;
}
/* Note that there should not be alignment problems with this assignment
eigrp->vrf_id);
if (c == NULL)
- return 0;
+ return;
ifp = c->ifp;
}
must remain very accurate in doing this.
*/
if (!ei)
- return 0;
+ return;
/* Self-originated packet should be discarded silently. */
if (eigrp_if_lookup_by_local_addr(eigrp, NULL, iph->ip_src)
zlog_debug(
"eigrp_read[%pI4]: Dropping self-originated packet",
&srcaddr);
- return 0;
+ return;
}
/* Advance from IP header to EIGRP header (iph->ip_hl has been verified
"ignoring packet from router %u sent to %pI4, wrong AS Number received: %u",
ntohs(eigrph->vrid), &iph->ip_dst,
ntohs(eigrph->ASNumber));
- return 0;
+ return;
}
/* If incoming interface is passive one, ignore it. */
if (iph->ip_dst.s_addr == htonl(EIGRP_MULTICAST_ADDRESS)) {
eigrp_if_set_multicast(ei);
}
- return 0;
+ return;
}
/* else it must be a local eigrp interface, check it was received on
zlog_warn(
"Packet from [%pI4] received on wrong link %s",
&iph->ip_src, ifp->name);
- return 0;
+ return;
}
/* Verify more EIGRP header fields. */
zlog_debug(
"eigrp_read[%pI4]: Header check failed, dropping.",
&iph->ip_src);
- return ret;
+ return;
}
/* calcualte the eigrp packet length, and move the pounter to the
IF_NAME(ei), opcode);
break;
}
-
- return 0;
}
static struct stream *eigrp_recv_packet(struct eigrp *eigrp,
return 0;
}
-int eigrp_unack_packet_retrans(struct thread *thread)
+void eigrp_unack_packet_retrans(struct thread *thread)
{
struct eigrp_neighbor *nbr;
nbr = (struct eigrp_neighbor *)THREAD_ARG(thread);
eigrp_fifo_push(nbr->ei->obuf, duplicate);
ep->retrans_counter++;
- if (ep->retrans_counter == EIGRP_PACKET_RETRANS_MAX)
- return eigrp_retrans_count_exceeded(ep, nbr);
+ if (ep->retrans_counter == EIGRP_PACKET_RETRANS_MAX) {
+ eigrp_retrans_count_exceeded(ep, nbr);
+ return;
+ }
/*Start retransmission timer*/
thread_add_timer(master, eigrp_unack_packet_retrans, nbr,
thread_add_write(master, eigrp_write, nbr->ei->eigrp,
nbr->ei->eigrp->fd, &nbr->ei->eigrp->t_write);
}
-
- return 0;
}
-int eigrp_unack_multicast_packet_retrans(struct thread *thread)
+void eigrp_unack_multicast_packet_retrans(struct thread *thread)
{
struct eigrp_neighbor *nbr;
nbr = (struct eigrp_neighbor *)THREAD_ARG(thread);
eigrp_fifo_push(nbr->ei->obuf, duplicate);
ep->retrans_counter++;
- if (ep->retrans_counter == EIGRP_PACKET_RETRANS_MAX)
- return eigrp_retrans_count_exceeded(ep, nbr);
+ if (ep->retrans_counter == EIGRP_PACKET_RETRANS_MAX) {
+ eigrp_retrans_count_exceeded(ep, nbr);
+ return;
+ }
/*Start retransmission timer*/
thread_add_timer(master, eigrp_unack_multicast_packet_retrans,
thread_add_write(master, eigrp_write, nbr->ei->eigrp,
nbr->ei->eigrp->fd, &nbr->ei->eigrp->t_write);
}
-
- return 0;
}
/* Get packet from tail of fifo. */
#define _ZEBRA_EIGRP_PACKET_H
/*Prototypes*/
-extern int eigrp_read(struct thread *);
-extern int eigrp_write(struct thread *);
+extern void eigrp_read(struct thread *thread);
+extern void eigrp_write(struct thread *thread);
extern struct eigrp_packet *eigrp_packet_new(size_t size,
struct eigrp_neighbor *nbr);
extern uint16_t eigrp_add_authTLV_SHA256_to_stream(struct stream *s,
struct eigrp_interface *ei);
-extern int eigrp_unack_packet_retrans(struct thread *thread);
-extern int eigrp_unack_multicast_packet_retrans(struct thread *thread);
+extern void eigrp_unack_packet_retrans(struct thread *thread);
+extern void eigrp_unack_multicast_packet_retrans(struct thread *thread);
/*
* untill there is reason to have their own header, these externs are found in
extern void eigrp_hello_receive(struct eigrp *eigrp, struct ip *iph,
struct eigrp_header *eigrph, struct stream *s,
struct eigrp_interface *ei, int size);
-extern int eigrp_hello_timer(struct thread *thread);
+extern void eigrp_hello_timer(struct thread *thread);
/*
* These externs are found in eigrp_update.c
struct eigrp_interface *exception);
extern void eigrp_update_send_init(struct eigrp_neighbor *nbr);
extern void eigrp_update_send_EOT(struct eigrp_neighbor *nbr);
-extern int eigrp_update_send_GR_thread(struct thread *thread);
+extern void eigrp_update_send_GR_thread(struct thread *thread);
extern void eigrp_update_send_GR(struct eigrp_neighbor *nbr,
enum GR_type gr_type, struct vty *vty);
extern void eigrp_update_send_interface_GR(struct eigrp_interface *ei,
*
* Uses nbr_gr_packet_type and t_nbr_send_gr from neighbor.
*/
-int eigrp_update_send_GR_thread(struct thread *thread)
+void eigrp_update_send_GR_thread(struct thread *thread)
{
struct eigrp_neighbor *nbr;
if (nbr->retrans_queue->count > 0) {
thread_add_timer_msec(master, eigrp_update_send_GR_thread, nbr,
10, &nbr->t_nbr_send_gr);
- return 0;
+ return;
}
/* send GR EIGRP packet chunk */
if (nbr->nbr_gr_packet_type != EIGRP_PACKET_PART_LAST) {
thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
}
-
- return 0;
}
/**
hash_free(f->neighbors_neighbors);
}
-static int fabricd_initial_sync_timeout(struct thread *thread)
+static void fabricd_initial_sync_timeout(struct thread *thread)
{
struct fabricd *f = THREAD_ARG(thread);
f->initial_sync_circuit->interface->name);
f->initial_sync_state = FABRICD_SYNC_PENDING;
f->initial_sync_circuit = NULL;
- return 0;
}
void fabricd_initial_sync_hello(struct isis_circuit *circuit)
return tier;
}
-static int fabricd_tier_set_timer(struct thread *thread)
+static void fabricd_tier_set_timer(struct thread *thread)
{
struct fabricd *f = THREAD_ARG(thread);
fabricd_set_tier(f, f->tier_pending);
- return 0;
}
-static int fabricd_tier_calculation_cb(struct thread *thread)
+static void fabricd_tier_calculation_cb(struct thread *thread)
{
struct fabricd *f = THREAD_ARG(thread);
uint8_t tier = ISIS_TIER_UNDEFINED;
tier = fabricd_calculate_fabric_tier(f->area);
if (tier == ISIS_TIER_UNDEFINED)
- return 0;
+ return;
zlog_info("OpenFabric: Got tier %hhu from algorithm. Arming timer.",
tier);
f->area->lsp_gen_interval[ISIS_LEVEL2 - 1],
&f->tier_set_timer);
- return 0;
}
static void fabricd_bump_tier_calculation_timer(struct fabricd *f)
}
}
-int isis_adj_expire(struct thread *thread)
+void isis_adj_expire(struct thread *thread)
{
struct isis_adjacency *adj;
/* trigger the adj expire event */
isis_adj_state_change(&adj, ISIS_ADJ_DOWN, "holding time expired");
-
- return 0;
}
/*
enum isis_adj_state state, const char *reason);
void isis_adj_print(struct isis_adjacency *adj);
const char *isis_adj_yang_state(enum isis_adj_state state);
-int isis_adj_expire(struct thread *thread);
+void isis_adj_expire(struct thread *thread);
void isis_adj_print_vty(struct isis_adjacency *adj, struct vty *vty,
char detail);
void isis_adj_build_neigh_list(struct list *adjdb, struct list *list);
void isis_adj_build_up_list(struct list *adjdb, struct list *list);
int isis_adj_usage2levels(enum isis_adj_usage usage);
-int isis_bfd_startup_timer(struct thread *thread);
+void isis_bfd_startup_timer(struct thread *thread);
const char *isis_adj_name(const struct isis_adjacency *adj);
#endif /* ISIS_ADJACENCY_H */
return NULL; /* not reached */
}
-int isis_run_dr(struct thread *thread)
+void isis_run_dr(struct thread *thread)
{
struct isis_circuit_arg *arg = THREAD_ARG(thread);
zlog_warn("%s: scheduled for non broadcast circuit from %s:%d",
__func__, thread->xref->xref.file,
thread->xref->xref.line);
- return ISIS_WARNING;
+ return;
}
if (circuit->u.bc.run_dr_elect[level - 1])
circuit->u.bc.t_run_dr[level - 1] = NULL;
circuit->u.bc.run_dr_elect[level - 1] = 1;
-
- return ISIS_OK;
}
static int isis_check_dr_change(struct isis_adjacency *adj, int level)
#ifndef _ZEBRA_ISIS_DR_H
#define _ZEBRA_ISIS_DR_H
-int isis_run_dr(struct thread *thread);
+void isis_run_dr(struct thread *thread);
int isis_dr_elect(struct isis_circuit *circuit, int level);
int isis_dr_resign(struct isis_circuit *circuit, int level);
int isis_dr_commence(struct isis_circuit *circuit, int level);
DEFINE_MTYPE_STATIC(ISISD, ISIS_DYNHN, "ISIS dyn hostname");
-static int dyn_cache_cleanup(struct thread *);
+static void dyn_cache_cleanup(struct thread *);
void dyn_cache_init(struct isis *isis)
{
list_delete(&isis->dyn_cache);
}
-static int dyn_cache_cleanup(struct thread *thread)
+static void dyn_cache_cleanup(struct thread *thread)
{
struct listnode *node, *nnode;
struct isis_dynhn *dyn;
thread_add_timer(master, dyn_cache_cleanup, isis, 120,
&isis->t_dync_clean);
-
- return ISIS_OK;
}
struct isis_dynhn *dynhn_find_by_id(struct isis *isis, const uint8_t *id)
/* events supporting code */
-int isis_event_dis_status_change(struct thread *thread)
+void isis_event_dis_status_change(struct thread *thread)
{
struct isis_circuit *circuit;
/* invalid arguments */
if (!circuit || !circuit->area)
- return 0;
+ return;
if (IS_DEBUG_EVENTS)
zlog_debug("ISIS-Evt (%s) DIS status change",
circuit->area->area_tag);
/* LSP generation again */
lsp_regenerate_schedule(circuit->area, IS_LEVEL_1 | IS_LEVEL_2, 0);
-
- return 0;
}
void isis_event_auth_failure(char *area_tag, const char *error_string,
/*
* Events related to adjacencies
*/
-int isis_event_dis_status_change(struct thread *thread);
+void isis_event_dis_status_change(struct thread *thread);
/*
* Error events
/*
* LDP-SYNC holddown timer routines
*/
-static int isis_ldp_sync_holddown_timer(struct thread *thread)
+static void isis_ldp_sync_holddown_timer(struct thread *thread)
{
struct isis_circuit *circuit;
struct ldp_sync_info *ldp_sync_info;
*/
circuit = THREAD_ARG(thread);
if (circuit->ldp_sync_info == NULL)
- return 0;
+ return;
ldp_sync_info = circuit->ldp_sync_info;
circuit->interface->name);
isis_ldp_sync_set_if_metric(circuit, true);
- return 0;
}
void isis_ldp_sync_holddown_timer_add(struct isis_circuit *circuit)
return rlfa_tree_find(&spftree->lfa.remote.rlfas, &s);
}
-static int isis_area_verify_routes_cb(struct thread *thread)
+static void isis_area_verify_routes_cb(struct thread *thread)
{
struct isis_area *area = THREAD_ARG(thread);
zlog_debug("ISIS-LFA: updating RLFAs in the RIB");
isis_area_verify_routes(area);
-
- return 0;
}
static mpls_label_t rlfa_nexthop_label(struct isis_spftree *spftree,
DEFINE_MTYPE_STATIC(ISISD, ISIS_LSP, "ISIS LSP");
-static int lsp_refresh(struct thread *thread);
-static int lsp_l1_refresh_pseudo(struct thread *thread);
-static int lsp_l2_refresh_pseudo(struct thread *thread);
+static void lsp_refresh(struct thread *thread);
+static void lsp_l1_refresh_pseudo(struct thread *thread);
+static void lsp_l2_refresh_pseudo(struct thread *thread);
static void lsp_destroy(struct isis_lsp *lsp);
/*
* Something has changed or periodic refresh -> regenerate LSP
*/
-static int lsp_refresh(struct thread *thread)
+static void lsp_refresh(struct thread *thread)
{
struct lsp_refresh_arg *arg = THREAD_ARG(thread);
area->lsp_regenerate_pending[level - 1] = 0;
if ((area->is_type & level) == 0)
- return ISIS_ERROR;
+ return;
/*
* Throttle regeneration of LSPs (but not when BFD signalled a 'down'
area->area_tag, level);
_lsp_regenerate_schedule(area, level, 0, false,
__func__, __FILE__, __LINE__);
- return 0;
+ return;
}
sched_debug(
"ISIS (%s): LSP L%d refresh timer expired. Refreshing LSP...",
area->area_tag, level);
- return lsp_regenerate(area, level);
+ lsp_regenerate(area, level);
}
int _lsp_regenerate_schedule(struct isis_area *area, int level,
/*
* Something has changed or periodic refresh -> regenerate pseudo LSP
*/
-static int lsp_l1_refresh_pseudo(struct thread *thread)
+static void lsp_l1_refresh_pseudo(struct thread *thread)
{
struct isis_circuit *circuit;
uint8_t id[ISIS_SYS_ID_LEN + 2];
LSP_PSEUDO_ID(id) = circuit->circuit_id;
LSP_FRAGMENT(id) = 0;
lsp_purge_pseudo(id, circuit, IS_LEVEL_1);
- return ISIS_ERROR;
+ return;
}
- return lsp_regenerate_pseudo(circuit, IS_LEVEL_1);
+ lsp_regenerate_pseudo(circuit, IS_LEVEL_1);
}
-static int lsp_l2_refresh_pseudo(struct thread *thread)
+static void lsp_l2_refresh_pseudo(struct thread *thread)
{
struct isis_circuit *circuit;
uint8_t id[ISIS_SYS_ID_LEN + 2];
LSP_PSEUDO_ID(id) = circuit->circuit_id;
LSP_FRAGMENT(id) = 0;
lsp_purge_pseudo(id, circuit, IS_LEVEL_2);
- return ISIS_ERROR;
+ return;
}
- return lsp_regenerate_pseudo(circuit, IS_LEVEL_2);
+ lsp_regenerate_pseudo(circuit, IS_LEVEL_2);
}
int lsp_regenerate_schedule_pseudo(struct isis_circuit *circuit, int level)
* Walk through LSPs for an area
* - set remaining lifetime
*/
-int lsp_tick(struct thread *thread)
+void lsp_tick(struct thread *thread)
{
struct isis_area *area;
struct isis_lsp *lsp;
&& !isis_tx_queue_len(fabricd_init_c->tx_queue)) {
fabricd_initial_sync_finish(area);
}
-
- return ISIS_OK;
}
void lsp_purge_pseudo(uint8_t *id, struct isis_circuit *circuit, int level)
void lsp_db_init(struct lspdb_head *head);
void lsp_db_fini(struct lspdb_head *head);
-int lsp_tick(struct thread *thread);
+void lsp_tick(struct thread *thread);
int lsp_generate(struct isis_area *area, int level);
#define lsp_regenerate_schedule(area, level, all_pseudo) \
return retval;
}
-int isis_receive(struct thread *thread)
+void isis_receive(struct thread *thread)
{
struct isis_circuit *circuit;
uint8_t ssnpa[ETH_ALEN];
- int retval;
/*
* Get the circuit
isis_circuit_stream(circuit, &circuit->rcv_stream);
+#if ISIS_METHOD != ISIS_METHOD_BPF
+ int retval;
+
retval = circuit->rx(circuit, ssnpa);
-#if ISIS_METHOD != ISIS_METHOD_BPF
if (retval == ISIS_OK)
- retval = isis_handle_pdu(circuit, ssnpa);
-#endif //ISIS_METHOD != ISIS_METHOD_BPF
+ isis_handle_pdu(circuit, ssnpa);
+#else // ISIS_METHOD != ISIS_METHOD_BPF
+ circuit->rx(circuit, ssnpa);
+#endif
/*
* prepare for next packet.
*/
if (!circuit->is_passive)
isis_circuit_prepare(circuit);
-
- return retval;
}
/*
return retval;
}
-static int send_hello_cb(struct thread *thread)
+static void send_hello_cb(struct thread *thread)
{
struct isis_circuit_arg *arg = THREAD_ARG(thread);
assert(arg);
send_hello(circuit, 1);
send_hello_sched(circuit, ISIS_LEVEL1,
1000 * circuit->hello_interval[1]);
- return ISIS_OK;
+ return;
}
if (circuit->circ_type != CIRCUIT_T_BROADCAST) {
zlog_warn("ISIS-Hello (%s): Trying to send hello on unknown circuit type %d",
circuit->area->area_tag, circuit->circ_type);
- return ISIS_WARNING;
+ return;
}
circuit->u.bc.t_send_lan_hello[level - 1] = NULL;
if (!(circuit->is_type & level)) {
zlog_warn("ISIS-Hello (%s): Trying to send L%d IIH in L%d-only circuit",
circuit->area->area_tag, level, 3 - level);
- return ISIS_WARNING;
+ return;
}
if (circuit->u.bc.run_dr_elect[level - 1])
isis_dr_elect(circuit, level);
- int rv = send_hello(circuit, level);
+ send_hello(circuit, level);
/* set next timer thread */
send_hello_sched(circuit, level, 1000 * circuit->hello_interval[level - 1]);
- return rv;
}
static void _send_hello_sched(struct isis_circuit *circuit,
return ISIS_OK;
}
-int send_l1_csnp(struct thread *thread)
+void send_l1_csnp(struct thread *thread)
{
struct isis_circuit *circuit;
thread_add_timer(master, send_l1_csnp, circuit,
isis_jitter(circuit->csnp_interval[0], CSNP_JITTER),
&circuit->t_send_csnp[0]);
-
- return ISIS_OK;
}
-int send_l2_csnp(struct thread *thread)
+void send_l2_csnp(struct thread *thread)
{
struct isis_circuit *circuit;
thread_add_timer(master, send_l2_csnp, circuit,
isis_jitter(circuit->csnp_interval[1], CSNP_JITTER),
&circuit->t_send_csnp[1]);
-
- return ISIS_OK;
}
/*
return ISIS_OK;
}
-int send_l1_psnp(struct thread *thread)
+void send_l1_psnp(struct thread *thread)
{
struct isis_circuit *circuit;
thread_add_timer(master, send_l1_psnp, circuit,
isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
&circuit->t_send_psnp[0]);
-
- return ISIS_OK;
}
/*
* 7.3.15.4 action on expiration of partial SNP interval
* level 2
*/
-int send_l2_psnp(struct thread *thread)
+void send_l2_psnp(struct thread *thread)
{
struct isis_circuit *circuit;
thread_add_timer(master, send_l2_psnp, circuit,
isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
&circuit->t_send_psnp[1]);
-
- return ISIS_OK;
}
/*
/*
* Function for receiving IS-IS PDUs
*/
-int isis_receive(struct thread *thread);
+void isis_receive(struct thread *thread);
/*
* calling arguments for snp_process ()
*/
void send_hello_sched(struct isis_circuit *circuit, int level, long delay);
int send_csnp(struct isis_circuit *circuit, int level);
-int send_l1_csnp(struct thread *thread);
-int send_l2_csnp(struct thread *thread);
-int send_l1_psnp(struct thread *thread);
-int send_l2_psnp(struct thread *thread);
+void send_l1_csnp(struct thread *thread);
+void send_l2_csnp(struct thread *thread);
+void send_l1_psnp(struct thread *thread);
+void send_l2_psnp(struct thread *thread);
void send_lsp(struct isis_circuit *circuit,
struct isis_lsp *lsp, enum isis_tx_type tx_type);
void fill_fixed_hdr(uint8_t pdu_type, struct stream *stream);
tree->route_table_backup->cleanup = isis_route_node_cleanup;
}
-static int isis_run_spf_cb(struct thread *thread)
+static void isis_run_spf_cb(struct thread *thread)
{
struct isis_spf_run *run = THREAD_ARG(thread);
struct isis_area *area = run->area;
if (IS_DEBUG_SPF_EVENTS)
zlog_warn("ISIS-SPF (%s) area does not share level",
area->area_tag);
- return ISIS_WARNING;
+ return;
}
isis_area_delete_backup_adj_sids(area, level);
UNSET_FLAG(circuit->flags, ISIS_CIRCUIT_FLAPPED_AFTER_SPF);
fabricd_run_spf(area);
-
- return 0;
}
static struct isis_spf_run *isis_run_spf_arg(struct isis_area *area, int level)
*
* @return 1 on success
*/
-static int sr_start_label_manager(struct thread *start)
+static void sr_start_label_manager(struct thread *start)
{
struct isis_area *area;
/* re-attempt to start SR & Label Manager connection */
isis_sr_start(area);
-
- return 1;
}
/**
return hash_lookup(queue->hash, &e);
}
-static int tx_queue_send_event(struct thread *thread)
+static void tx_queue_send_event(struct thread *thread)
{
struct isis_tx_queue_entry *e = THREAD_ARG(thread);
struct isis_tx_queue *queue = e->queue;
queue->send_event(queue->circuit, e->lsp, e->type);
/* Don't access e here anymore, send_event might have destroyed it */
-
- return 0;
}
void _isis_tx_queue_add(struct isis_tx_queue *queue,
struct accept_ev {
LIST_ENTRY(accept_ev) entry;
struct thread *ev;
- int (*accept_cb)(struct thread *);
+ void (*accept_cb)(struct thread *);
void *arg;
int fd;
};
static void accept_arm(void);
static void accept_unarm(void);
-static int accept_cb(struct thread *);
-static int accept_timeout(struct thread *);
+static void accept_cb(struct thread *);
+static void accept_timeout(struct thread *);
void
accept_init(void)
LIST_INIT(&accept_queue.queue);
}
-int
-accept_add(int fd, int (*cb)(struct thread *), void *arg)
+int accept_add(int fd, void (*cb)(struct thread *), void *arg)
{
struct accept_ev *av;
thread_cancel(&av->ev);
}
-static int
-accept_cb(struct thread *thread)
+static void accept_cb(struct thread *thread)
{
struct accept_ev *av = THREAD_ARG(thread);
thread_add_read(master, accept_cb, av, av->fd, &av->ev);
av->accept_cb(thread);
-
- return (0);
}
-static int
-accept_timeout(struct thread *thread)
+static void accept_timeout(struct thread *thread)
{
accept_queue.evt = NULL;
log_debug(__func__);
accept_arm();
-
- return (0);
}
#include "log.h"
static __inline int adj_compare(const struct adj *, const struct adj *);
-static int adj_itimer(struct thread *);
+static void adj_itimer(struct thread *);
static __inline int tnbr_compare(const struct tnbr *, const struct tnbr *);
static void tnbr_del(struct ldpd_conf *, struct tnbr *);
static void tnbr_start(struct tnbr *);
static void tnbr_stop(struct tnbr *);
-static int tnbr_hello_timer(struct thread *);
+static void tnbr_hello_timer(struct thread *);
static void tnbr_start_hello_timer(struct tnbr *);
static void tnbr_stop_hello_timer(struct tnbr *);
/* adjacency timers */
/* ARGSUSED */
-static int
-adj_itimer(struct thread *thread)
+static void adj_itimer(struct thread *thread)
{
struct adj *adj = THREAD_ARG(thread);
adj->source.target->rlfa_count == 0) {
/* remove dynamic targeted neighbor */
tnbr_del(leconf, adj->source.target);
- return (0);
+ return;
}
}
adj_del(adj, S_HOLDTIME_EXP);
-
- return (0);
}
void
/* target neighbors timers */
/* ARGSUSED */
-static int
-tnbr_hello_timer(struct thread *thread)
+static void tnbr_hello_timer(struct thread *thread)
{
struct tnbr *tnbr = THREAD_ARG(thread);
tnbr->hello_timer = NULL;
send_hello(HELLO_TARGETED, NULL, tnbr);
tnbr_start_hello_timer(tnbr);
-
- return (0);
}
static void
#define CONTROL_BACKLOG 5
-static int control_accept(struct thread *);
+static void control_accept(struct thread *);
static struct ctl_conn *control_connbyfd(int);
static struct ctl_conn *control_connbypid(pid_t);
static void control_close(int);
-static int control_dispatch_imsg(struct thread *);
+static void control_dispatch_imsg(struct thread *);
struct ctl_conns ctl_conns;
}
/* ARGSUSED */
-static int
-control_accept(struct thread *thread)
+static void control_accept(struct thread *thread)
{
int connfd;
socklen_t len;
else if (errno != EWOULDBLOCK && errno != EINTR &&
errno != ECONNABORTED)
log_warn("%s: accept", __func__);
- return (0);
+ return;
}
sock_set_nonblock(connfd);
if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
log_warn(__func__);
close(connfd);
- return (0);
+ return;
}
imsg_init(&c->iev.ibuf, connfd);
c->iev.ev_write = NULL;
TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
-
- return (0);
}
static struct ctl_conn *
}
/* ARGSUSED */
-static int
-control_dispatch_imsg(struct thread *thread)
+static void control_dispatch_imsg(struct thread *thread)
{
int fd = THREAD_FD(thread);
struct ctl_conn *c;
if ((c = control_connbyfd(fd)) == NULL) {
log_warnx("%s: fd %d: not found", __func__, fd);
- return (0);
+ return;
}
c->iev.ev_read = NULL;
if (((n = imsg_read(&c->iev.ibuf)) == -1 && errno != EAGAIN) ||
n == 0) {
control_close(fd);
- return (0);
+ return;
}
for (;;) {
if ((n = imsg_get(&c->iev.ibuf, &imsg)) == -1) {
control_close(fd);
- return (0);
+ return;
}
if (n == 0)
}
imsg_event_add(&c->iev);
-
- return (0);
}
int
static int if_start(struct iface *, int);
static int if_reset(struct iface *, int);
static void if_update_af(struct iface_af *);
-static int if_hello_timer(struct thread *);
+static void if_hello_timer(struct thread *thread);
static void if_start_hello_timer(struct iface_af *);
static void if_stop_hello_timer(struct iface_af *);
static int if_join_ipv4_group(struct iface *, struct in_addr *);
static int ldp_sync_fsm_init(struct iface *iface, int state);
static int ldp_sync_act_iface_start_sync(struct iface *iface);
-static int iface_wait_for_ldp_sync_timer(struct thread *thread);
+static void iface_wait_for_ldp_sync_timer(struct thread *thread);
static void start_wait_for_ldp_sync_timer(struct iface *iface);
static void stop_wait_for_ldp_sync_timer(struct iface *iface);
static int ldp_sync_act_ldp_start_sync(struct iface *iface);
/* timers */
/* ARGSUSED */
-static int
-if_hello_timer(struct thread *thread)
+static void if_hello_timer(struct thread *thread)
{
struct iface_af *ia = THREAD_ARG(thread);
ia->hello_timer = NULL;
send_hello(HELLO_LINK, ia, NULL);
if_start_hello_timer(ia);
-
- return (0);
}
static void
return (0);
}
-static int
-iface_wait_for_ldp_sync_timer(struct thread *thread)
+static void iface_wait_for_ldp_sync_timer(struct thread *thread)
{
struct iface *iface = THREAD_ARG(thread);
ldp_sync_fsm(iface, LDP_SYNC_EVT_LDP_SYNC_COMPLETE);
-
- return (0);
}
static void start_wait_for_ldp_sync_timer(struct iface *iface)
#include "libfrr.h"
static void lde_shutdown(void);
-static int lde_dispatch_imsg(struct thread *);
-static int lde_dispatch_parent(struct thread *);
+static void lde_dispatch_imsg(struct thread *thread);
+static void lde_dispatch_parent(struct thread *thread);
static __inline int lde_nbr_compare(const struct lde_nbr *,
const struct lde_nbr *);
static struct lde_nbr *lde_nbr_new(uint32_t, struct lde_nbr *);
}
/* ARGSUSED */
-static int
-lde_dispatch_imsg(struct thread *thread)
+static void lde_dispatch_imsg(struct thread *thread)
{
struct imsgev *iev = THREAD_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
thread_cancel(&iev->ev_write);
lde_shutdown();
}
-
- return (0);
}
/* ARGSUSED */
-static int
-lde_dispatch_parent(struct thread *thread)
+static void lde_dispatch_parent(struct thread *thread)
{
static struct ldpd_conf *nconf;
struct iface *iface, *niface;
thread_cancel(&iev->ev_write);
lde_shutdown();
}
-
- return (0);
}
int
/*
* Event callback used to retry the label-manager sync zapi session.
*/
-static int zclient_sync_retry(struct thread *thread)
+static void zclient_sync_retry(struct thread *thread)
{
zclient_sync_init();
-
- return 0;
}
/*
void lde_check_withdraw_wcard(struct map *, struct lde_nbr *);
int lde_wildcard_apply(struct map *, struct fec *,
struct lde_map *);
-int lde_gc_timer(struct thread *);
+void lde_gc_timer(struct thread *thread);
void lde_gc_start_timer(void);
void lde_gc_stop_timer(void);
/* gabage collector timer: timer to remove dead entries from the LIB */
/* ARGSUSED */
-int
-lde_gc_timer(struct thread *thread)
+void lde_gc_timer(struct thread *thread)
{
struct fec *fec, *safe;
struct fec_node *fn;
log_debug("%s: %u entries removed", __func__, count);
lde_gc_start_timer();
-
- return (0);
}
void
static void ldpd_shutdown(void);
static pid_t start_child(enum ldpd_process, char *, int, int);
-static int main_dispatch_ldpe(struct thread *);
-static int main_dispatch_lde(struct thread *);
+static void main_dispatch_ldpe(struct thread *thread);
+static void main_dispatch_lde(struct thread *thread);
static int main_imsg_send_ipc_sockets(struct imsgbuf *,
struct imsgbuf *);
static void main_imsg_send_net_sockets(int);
.n_yang_modules = array_size(ldpd_yang_modules),
);
-static int ldp_config_fork_apply(struct thread *t)
+static void ldp_config_fork_apply(struct thread *t)
{
/*
* So the frr_config_fork() function schedules
* after the read in of the config.
*/
ldp_config_apply(NULL, vty_conf);
-
- return 0;
}
int
/* imsg handling */
/* ARGSUSED */
-static int
-main_dispatch_ldpe(struct thread *thread)
+static void main_dispatch_ldpe(struct thread *thread)
{
struct imsgev *iev = THREAD_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
else
kill(lde_pid, SIGTERM);
}
-
- return (0);
}
/* ARGSUSED */
-static int
-main_dispatch_lde(struct thread *thread)
+static void main_dispatch_lde(struct thread *thread)
{
struct imsgev *iev = THREAD_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
else
kill(ldpe_pid, SIGTERM);
}
-
- return (0);
}
/* ARGSUSED */
-int
-ldp_write_handler(struct thread *thread)
+void ldp_write_handler(struct thread *thread)
{
struct imsgev *iev = THREAD_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
/* this pipe is dead, so remove the event handlers */
thread_cancel(&iev->ev_read);
thread_cancel(&iev->ev_write);
- return (0);
+ return;
}
imsg_event_add(iev);
-
- return (0);
}
void
&eb->ev);
}
-void
-evbuf_init(struct evbuf *eb, int fd, int (*handler)(struct thread *),
- void *arg)
+void evbuf_init(struct evbuf *eb, int fd, void (*handler)(struct thread *),
+ void *arg)
{
msgbuf_init(&eb->wbuf);
eb->wbuf.fd = fd;
struct evbuf {
struct msgbuf wbuf;
struct thread *ev;
- int (*handler)(struct thread *);
+ void (*handler)(struct thread *);
void *arg;
};
struct imsgev {
struct imsgbuf ibuf;
- int (*handler_write)(struct thread *);
+ void (*handler_write)(struct thread *);
struct thread *ev_write;
- int (*handler_read)(struct thread *);
+ void (*handler_read)(struct thread *);
struct thread *ev_read;
};
socklen_t sockaddr_len(struct sockaddr *);
/* ldpd.c */
-int ldp_write_handler(struct thread *);
+void ldp_write_handler(struct thread *thread);
void main_imsg_compose_ldpe(int, pid_t, void *, uint16_t);
void main_imsg_compose_lde(int, pid_t, void *, uint16_t);
int main_imsg_compose_both(enum imsg_type, void *,
pid_t, int, void *, uint16_t);
void evbuf_enqueue(struct evbuf *, struct ibuf *);
void evbuf_event_add(struct evbuf *);
-void evbuf_init(struct evbuf *, int,
- int (*)(struct thread *), void *);
+void evbuf_init(struct evbuf *, int, void (*)(struct thread *), void *);
void evbuf_clear(struct evbuf *);
int ldp_acl_request(struct imsgev *, char *, int,
union ldpd_addr *, uint8_t);
#include "libfrr.h"
static void ldpe_shutdown(void);
-static int ldpe_dispatch_main(struct thread *);
-static int ldpe_dispatch_lde(struct thread *);
+static void ldpe_dispatch_main(struct thread *thread);
+static void ldpe_dispatch_lde(struct thread *thread);
#ifdef __OpenBSD__
-static int ldpe_dispatch_pfkey(struct thread *);
+static void ldpe_dispatch_pfkey(struct thread *thread);
#endif
static void ldpe_setup_sockets(int, int, int, int);
static void ldpe_close_sockets(int);
}
/* ARGSUSED */
-static int
-ldpe_dispatch_main(struct thread *thread)
+static void ldpe_dispatch_main(struct thread *thread)
{
static struct ldpd_conf *nconf;
struct iface *niface;
thread_cancel(&iev->ev_write);
ldpe_shutdown();
}
-
- return (0);
}
/* ARGSUSED */
-static int
-ldpe_dispatch_lde(struct thread *thread)
+static void ldpe_dispatch_lde(struct thread *thread)
{
struct imsgev *iev = THREAD_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
thread_cancel(&iev->ev_write);
ldpe_shutdown();
}
-
- return (0);
}
#ifdef __OpenBSD__
/* ARGSUSED */
-static int
-ldpe_dispatch_pfkey(struct thread *thread)
+static void ldpe_dispatch_pfkey(struct thread *thread)
{
int fd = THREAD_FD(thread);
if (pfkey_read(fd, NULL) == -1)
fatal("pfkey_read failed, exiting...");
-
- return (0);
}
#endif /* __OpenBSD__ */
/* accept.c */
void accept_init(void);
-int accept_add(int, int (*)(struct thread *), void *);
+int accept_add(int, void (*)(struct thread *), void *);
void accept_del(int);
void accept_pause(void);
void accept_unpause(void);
int gen_msg_hdr(struct ibuf *, uint16_t, uint16_t);
int send_packet(int, int, union ldpd_addr *,
struct iface_af *, void *, size_t);
-int disc_recv_packet(struct thread *);
-int session_accept(struct thread *);
+void disc_recv_packet(struct thread *thread);
+void session_accept(struct thread *thread);
void session_accept_nbr(struct nbr *, int);
void session_shutdown(struct nbr *, uint32_t, uint32_t,
uint32_t);
static __inline int nbr_pid_compare(const struct nbr *,
const struct nbr *);
static void nbr_update_peerid(struct nbr *);
-static int nbr_ktimer(struct thread *);
+static void nbr_ktimer(struct thread *thread);
static void nbr_start_ktimer(struct nbr *);
-static int nbr_ktimeout(struct thread *);
+static void nbr_ktimeout(struct thread *thread);
static void nbr_start_ktimeout(struct nbr *);
-static int nbr_itimeout(struct thread *);
+static void nbr_itimeout(struct thread *thread);
static void nbr_start_itimeout(struct nbr *);
-static int nbr_idtimer(struct thread *);
+static void nbr_idtimer(struct thread *thread);
static int nbr_act_session_operational(struct nbr *);
static void nbr_send_labelmappings(struct nbr *);
static __inline int nbr_params_compare(const struct nbr_params *,
/* Keepalive timer: timer to send keepalive message to neighbors */
-static int
-nbr_ktimer(struct thread *thread)
+static void nbr_ktimer(struct thread *thread)
{
struct nbr *nbr = THREAD_ARG(thread);
nbr->keepalive_timer = NULL;
send_keepalive(nbr);
nbr_start_ktimer(nbr);
-
- return (0);
}
static void
/* Keepalive timeout: if the nbr hasn't sent keepalive */
-static int
-nbr_ktimeout(struct thread *thread)
+static void nbr_ktimeout(struct thread *thread)
{
struct nbr *nbr = THREAD_ARG(thread);
log_debug("%s: lsr-id %pI4", __func__, &nbr->id);
session_shutdown(nbr, S_KEEPALIVE_TMR, 0, 0);
-
- return (0);
}
static void
/* Session initialization timeout: if nbr got stuck in the initialization FSM */
-static int
-nbr_itimeout(struct thread *thread)
+static void nbr_itimeout(struct thread *thread)
{
struct nbr *nbr = THREAD_ARG(thread);
log_debug("%s: lsr-id %pI4", __func__, &nbr->id);
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
-
- return (0);
}
static void
/* Init delay timer: timer to retry to iniziatize session */
-static int
-nbr_idtimer(struct thread *thread)
+static void nbr_idtimer(struct thread *thread)
{
struct nbr *nbr = THREAD_ARG(thread);
log_debug("%s: lsr-id %pI4", __func__, &nbr->id);
nbr_establish_connection(nbr);
-
- return (0);
}
void
return (nbr->ev_connect != NULL);
}
-static int
-nbr_connect_cb(struct thread *thread)
+static void nbr_connect_cb(struct thread *thread)
{
struct nbr *nbr = THREAD_ARG(thread);
int error;
len = sizeof(error);
if (getsockopt(nbr->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
log_warn("%s: getsockopt SOL_SOCKET SO_ERROR", __func__);
- return (0);
+ return;
}
if (error) {
errno = error;
log_debug("%s: error while connecting to %s: %s", __func__,
log_addr(nbr->af, &nbr->raddr), strerror(errno));
- return (0);
+ return;
}
nbr_fsm(nbr, NBR_EVT_CONNECT_UP);
-
- return (0);
}
int
static struct iface *disc_find_iface(unsigned int, int,
union ldpd_addr *);
-static int session_read(struct thread *);
-static int session_write(struct thread *);
+static void session_read(struct thread *thread);
+static void session_write(struct thread *thread);
static ssize_t session_get_pdu(struct ibuf_read *, char **);
static void tcp_close(struct tcp_conn *);
static struct pending_conn *pending_conn_new(int, int, union ldpd_addr *);
-static int pending_conn_timeout(struct thread *);
+static void pending_conn_timeout(struct thread *thread);
int
gen_ldp_hdr(struct ibuf *buf, uint16_t size)
}
/* Discovery functions */
-int
-disc_recv_packet(struct thread *thread)
+void disc_recv_packet(struct thread *thread)
{
int fd = THREAD_FD(thread);
struct thread **threadp = THREAD_ARG(thread);
if (errno != EAGAIN && errno != EINTR)
log_debug("%s: read error: %s", __func__,
strerror(errno));
- return (0);
+ return;
}
sa2addr((struct sockaddr *)&from, &af, &src, NULL);
if (bad_addr(af, &src)) {
log_debug("%s: invalid source address: %s", __func__,
log_addr(af, &src));
- return (0);
+ return;
}
ifindex = getsockopt_ifindex(af, &m);
if (multicast) {
iface = disc_find_iface(ifindex, af, &src);
if (iface == NULL)
- return (0);
+ return;
}
/* check packet size */
if (len < (LDP_HDR_SIZE + LDP_MSG_SIZE) || len > LDP_MAX_LEN) {
log_debug("%s: bad packet size, source %s", __func__,
log_addr(af, &src));
- return (0);
+ return;
}
/* LDP header sanity checks */
if (ntohs(ldp_hdr.version) != LDP_VERSION) {
log_debug("%s: invalid LDP version %d, source %s", __func__,
ntohs(ldp_hdr.version), log_addr(af, &src));
- return (0);
+ return;
}
if (ntohs(ldp_hdr.lspace_id) != 0) {
log_debug("%s: invalid label space %u, source %s", __func__,
ntohs(ldp_hdr.lspace_id), log_addr(af, &src));
- return (0);
+ return;
}
/* check "PDU Length" field */
pdu_len = ntohs(ldp_hdr.length);
(pdu_len > (len - LDP_HDR_DEAD_LEN))) {
log_debug("%s: invalid LDP packet length %u, source %s",
__func__, ntohs(ldp_hdr.length), log_addr(af, &src));
- return (0);
+ return;
}
buf += LDP_HDR_SIZE;
len -= LDP_HDR_SIZE;
if (msg_len < LDP_MSG_LEN || ((msg_len + LDP_MSG_DEAD_LEN) > pdu_len)) {
log_debug("%s: invalid LDP message length %u, source %s",
__func__, ntohs(msg.length), log_addr(af, &src));
- return (0);
+ return;
}
buf += LDP_MSG_SIZE;
len -= LDP_MSG_SIZE;
log_debug("%s: unknown LDP packet type, source %s", __func__,
log_addr(af, &src));
}
-
- return (0);
}
static struct iface *
return (iface);
}
-int
-session_accept(struct thread *thread)
+void session_accept(struct thread *thread)
{
int fd = THREAD_FD(thread);
struct sockaddr_storage src;
errno != ECONNABORTED)
log_debug("%s: accept error: %s", __func__,
strerror(errno));
- return (0);
+ return;
}
sock_set_nonblock(newfd);
close(newfd);
else
pending_conn_new(newfd, af, &addr);
- return (0);
+ return;
}
/* protection against buggy implementations */
if (nbr_session_active_role(nbr)) {
close(newfd);
- return (0);
+ return;
}
if (nbr->state != NBR_STA_PRESENT) {
log_debug("%s: lsr-id %pI4: rejecting additional transport connection", __func__, &nbr->id);
close(newfd);
- return (0);
+ return;
}
session_accept_nbr(nbr, newfd);
-
- return (0);
}
void
nbr_fsm(nbr, NBR_EVT_MATCH_ADJ);
}
-static int
-session_read(struct thread *thread)
+static void session_read(struct thread *thread)
{
int fd = THREAD_FD(thread);
struct nbr *nbr = THREAD_ARG(thread);
if (errno != EINTR && errno != EAGAIN) {
log_warn("%s: read error", __func__);
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
- return (0);
+ return;
}
/* retry read */
- return (0);
+ return;
}
if (n == 0) {
/* connection closed */
log_debug("%s: connection closed by remote end", __func__);
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
- return (0);
+ return;
}
tcp->rbuf->wpos += n;
if (ntohs(ldp_hdr->version) != LDP_VERSION) {
session_shutdown(nbr, S_BAD_PROTO_VER, 0, 0);
free(buf);
- return (0);
+ return;
}
pdu_len = ntohs(ldp_hdr->length);
pdu_len > max_pdu_len) {
session_shutdown(nbr, S_BAD_PDU_LEN, 0, 0);
free(buf);
- return (0);
+ return;
}
pdu_len -= LDP_HDR_PDU_LEN;
if (ldp_hdr->lsr_id != nbr->id.s_addr ||
ldp_hdr->lspace_id != 0) {
session_shutdown(nbr, S_BAD_LDP_ID, 0, 0);
free(buf);
- return (0);
+ return;
}
pdu += LDP_HDR_SIZE;
len -= LDP_HDR_SIZE;
session_shutdown(nbr, S_BAD_MSG_LEN, msg->id,
msg->type);
free(buf);
- return (0);
+ return;
}
msg_size = msg_len + LDP_MSG_DEAD_LEN;
pdu_len -= msg_size;
session_shutdown(nbr, S_SHUTDOWN,
msg->id, msg->type);
free(buf);
- return (0);
+ return;
}
break;
case MSG_TYPE_KEEPALIVE:
session_shutdown(nbr, S_SHUTDOWN,
msg->id, msg->type);
free(buf);
- return (0);
+ return;
}
break;
case MSG_TYPE_NOTIFICATION:
session_shutdown(nbr, S_SHUTDOWN,
msg->id, msg->type);
free(buf);
- return (0);
+ return;
}
break;
}
if (ret == -1) {
/* parser failed, giving up */
free(buf);
- return (0);
+ return;
}
/* no errors - update per neighbor message counters */
buf = NULL;
if (len != 0) {
session_shutdown(nbr, S_BAD_PDU_LEN, 0, 0);
- return (0);
+ return;
}
}
* allocated - but let's get rid of the SA warning.
*/
free(buf);
- return (0);
}
-static int
-session_write(struct thread *thread)
+static void session_write(struct thread *thread)
{
struct tcp_conn *tcp = THREAD_ARG(thread);
struct nbr *nbr = tcp->nbr;
* close the socket.
*/
tcp_close(tcp);
- return (0);
+ return;
}
evbuf_event_add(&tcp->wbuf);
-
- return (0);
}
void
return (NULL);
}
-static int
-pending_conn_timeout(struct thread *thread)
+static void pending_conn_timeout(struct thread *thread)
{
struct pending_conn *pconn = THREAD_ARG(thread);
struct tcp_conn *tcp;
msgbuf_write(&tcp->wbuf.wbuf);
pending_conn_del(pconn);
-
- return (0);
}
static void agentx_events_update(void);
-static int agentx_timeout(struct thread *t)
+static void agentx_timeout(struct thread *t)
{
timeout_thr = NULL;
run_alarms();
netsnmp_check_outstanding_agent_requests();
agentx_events_update();
- return 0;
}
-static int agentx_read(struct thread *t)
+static void agentx_read(struct thread *t)
{
fd_set fds;
int flags, new_flags = 0;
if (-1 == flags) {
flog_err(EC_LIB_SYSTEM_CALL, "Failed to get FD settings fcntl: %s(%d)",
strerror(errno), errno);
- return -1;
+ return;
}
if (flags & O_NONBLOCK)
netsnmp_check_outstanding_agent_requests();
agentx_events_update();
- return 0;
}
static void agentx_events_update(void)
return true;
}
-static int _bfd_sess_send(struct thread *t)
+static void _bfd_sess_send(struct thread *t)
{
struct bfd_session_params *bsp = THREAD_ARG(t);
int rv;
/* Validate configuration before trying to send bogus data. */
if (!_bfd_sess_valid(bsp))
- return 0;
+ return;
if (bsp->lastev == BSE_INSTALL) {
bsp->args.command = bsp->installed ? ZEBRA_BFD_DEST_UPDATE
/* If not installed and asked for uninstall, do nothing. */
if (!bsp->installed && bsp->args.command == ZEBRA_BFD_DEST_DEREGISTER)
- return 0;
+ return;
rv = zclient_bfd_command(bsglobal.zc, &bsp->args);
/* Command was sent successfully. */
bsp->lastev == BSE_INSTALL ? "installed"
: "uninstalled");
}
-
- return 0;
}
static void _bfd_sess_remove(struct bfd_session_params *bsp)
*/
/* dummy task for sleeper pipe */
-static int fpt_dummy(struct thread *thread)
+static void fpt_dummy(struct thread *thread)
{
- return 0;
}
/* poison pill task to end event loop */
-static int fpt_finish(struct thread *thread)
+static void fpt_finish(struct thread *thread)
{
struct frr_pthread *fpt = THREAD_ARG(thread);
atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
- return 0;
}
/* stop function, called from other threads to halt this one */
}
}
-static int frrzmq_read_msg(struct thread *t)
+static void frrzmq_read_msg(struct thread *t)
{
struct frrzmq_cb **cbp = THREAD_ARG(t);
struct frrzmq_cb *cb;
size_t moresz;
if (!cbp)
- return 1;
+ return;
cb = (*cbp);
if (!cb || !cb->zmqsock)
- return 1;
+ return;
while (1) {
zmq_pollitem_t polli = {.socket = cb->zmqsock,
if (cb->write.cancelled && !cb->write.thread)
XFREE(MTYPE_ZEROMQ_CB, *cbp);
- return 0;
+ return;
}
continue;
}
if (cb->write.cancelled && !cb->write.thread)
XFREE(MTYPE_ZEROMQ_CB, *cbp);
- return 0;
+ return;
}
/* cb_part may have read additional parts of the
thread_add_read(t->master, frrzmq_read_msg, cbp,
cb->fd, &cb->read.thread);
- return 0;
+ return;
out_err:
flog_err(EC_LIB_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
errno);
if (cb->read.cb_error)
cb->read.cb_error(cb->read.arg, cb->zmqsock);
- return 1;
}
int _frrzmq_thread_add_read(const struct xref_threadsched *xref,
return 0;
}
-static int frrzmq_write_msg(struct thread *t)
+static void frrzmq_write_msg(struct thread *t)
{
struct frrzmq_cb **cbp = THREAD_ARG(t);
struct frrzmq_cb *cb;
int ret;
if (!cbp)
- return 1;
+ return;
cb = (*cbp);
if (!cb || !cb->zmqsock)
- return 1;
+ return;
while (1) {
zmq_pollitem_t polli = {.socket = cb->zmqsock,
if (cb->read.cancelled && !cb->read.thread)
XFREE(MTYPE_ZEROMQ_CB, *cbp);
- return 0;
+ return;
}
continue;
}
thread_add_write(t->master, frrzmq_write_msg, cbp,
cb->fd, &cb->write.thread);
- return 0;
+ return;
out_err:
flog_err(EC_LIB_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
errno);
if (cb->write.cb_error)
cb->write.cb_error(cb->write.arg, cb->zmqsock);
- return 1;
}
int _frrzmq_thread_add_write(const struct xref_threadsched *xref,
* to read the config in after thread execution starts, so that
* we can match this behavior.
*/
-static int frr_config_read_in(struct thread *t)
+static void frr_config_read_in(struct thread *t)
{
hook_call(frr_config_pre, master);
}
hook_call(frr_config_post, master);
-
- return 0;
}
void frr_config_fork(void)
static struct thread *daemon_ctl_thread = NULL;
-static int frr_daemon_ctl(struct thread *t)
+static void frr_daemon_ctl(struct thread *t)
{
char buf[1];
ssize_t nr;
if (nr < 0 && (errno == EINTR || errno == EAGAIN))
goto out;
if (nr <= 0)
- return 0;
+ return;
switch (buf[0]) {
case 'S': /* SIGTSTP */
out:
thread_add_read(master, frr_daemon_ctl, NULL, daemon_ctl_sock,
&daemon_ctl_thread);
- return 0;
}
void frr_detach(void)
return ret;
}
-static int nb_cli_confirmed_commit_timeout(struct thread *thread)
+static void nb_cli_confirmed_commit_timeout(struct thread *thread)
{
struct vty *vty = THREAD_ARG(thread);
nb_cli_confirmed_commit_rollback(vty);
nb_cli_confirmed_commit_clean(vty);
-
- return 0;
}
static int nb_cli_commit(struct vty *vty, bool force,
return ITER_RECURSE;
}
-static int frr_confd_cdb_read_cb_prepare(int fd, int *subp, int reslen)
+static void frr_confd_cdb_read_cb_prepare(int fd, int *subp, int reslen)
{
struct nb_context context = {};
struct nb_config *candidate;
0, "Couldn't apply configuration changes")
!= CONFD_OK) {
flog_err_confd("cdb_sub_abort_trans");
- return -1;
+ return;
}
- return 0;
+ return;
}
/*
errmsg)
!= CONFD_OK) {
flog_err_confd("cdb_sub_abort_trans");
- return -1;
+ return;
}
} else {
/* Acknowledge the notification. */
if (cdb_sync_subscription_socket(fd, CDB_DONE_PRIORITY)
!= CONFD_OK) {
flog_err_confd("cdb_sync_subscription_socket");
- return -1;
+ return;
}
/* No configuration changes. */
if (!transaction)
nb_config_free(candidate);
}
-
- return 0;
}
-static int frr_confd_cdb_read_cb_commit(int fd, int *subp, int reslen)
+static void frr_confd_cdb_read_cb_commit(int fd, int *subp, int reslen)
{
/*
* No need to process the configuration changes again as we're already
/* Acknowledge the notification. */
if (cdb_sync_subscription_socket(fd, CDB_DONE_PRIORITY) != CONFD_OK) {
flog_err_confd("cdb_sync_subscription_socket");
- return -1;
+ return;
}
-
- return 0;
}
static int frr_confd_cdb_read_cb_abort(int fd, int *subp, int reslen)
return 0;
}
-static int frr_confd_cdb_read_cb(struct thread *thread)
+static void frr_confd_cdb_read_cb(struct thread *thread)
{
int fd = THREAD_FD(thread);
enum cdb_sub_notification cdb_ev;
if (cdb_read_subscription_socket2(fd, &cdb_ev, &flags, &subp, &reslen)
!= CONFD_OK) {
flog_err_confd("cdb_read_subscription_socket2");
- return -1;
+ return;
}
switch (cdb_ev) {
case CDB_SUB_PREPARE:
- return frr_confd_cdb_read_cb_prepare(fd, subp, reslen);
+ frr_confd_cdb_read_cb_prepare(fd, subp, reslen);
+ break;
case CDB_SUB_COMMIT:
- return frr_confd_cdb_read_cb_commit(fd, subp, reslen);
+ frr_confd_cdb_read_cb_commit(fd, subp, reslen);
+ break;
case CDB_SUB_ABORT:
- return frr_confd_cdb_read_cb_abort(fd, subp, reslen);
+ frr_confd_cdb_read_cb_abort(fd, subp, reslen);
+ break;
default:
flog_err_confd("unknown CDB event");
- return -1;
+ break;
}
}
return 0;
}
-static int frr_confd_dp_ctl_read(struct thread *thread)
+static void frr_confd_dp_ctl_read(struct thread *thread)
{
struct confd_daemon_ctx *dctx = THREAD_ARG(thread);
int fd = THREAD_FD(thread);
thread_add_read(master, frr_confd_dp_ctl_read, dctx, fd, &t_dp_ctl);
frr_confd_dp_read(dctx, fd);
-
- return 0;
}
-static int frr_confd_dp_worker_read(struct thread *thread)
+static void frr_confd_dp_worker_read(struct thread *thread)
{
struct confd_daemon_ctx *dctx = THREAD_ARG(thread);
int fd = THREAD_FD(thread);
thread_add_read(master, frr_confd_dp_worker_read, dctx, fd, &t_dp_worker);
frr_confd_dp_read(dctx, fd);
-
- return 0;
}
static int frr_confd_subscribe_state(const struct lysc_node *snode, void *arg)
}
- static int c_callback(struct thread *thread)
+ static void c_callback(struct thread *thread)
{
auto _tag = static_cast<NewRpcState<Q, S> *>(thread->arg);
/*
pthread_cond_signal(&_tag->cond);
pthread_mutex_unlock(&_tag->cmux);
- return 0;
+ return;
}
NewRpcState<Q, S> *orig;
* fork. This is done by scheduling this init function as an event task, since
* the event loop doesn't run until after fork.
*/
-static int frr_grpc_module_very_late_init(struct thread *thread)
+static void frr_grpc_module_very_late_init(struct thread *thread)
{
const char *args = THIS_MODULE->load_args;
uint port = GRPC_DEFAULT_PORT;
if (frr_grpc_init(port) < 0)
goto error;
- return 0;
+ return;
error:
flog_err(EC_LIB_GRPC_INIT, "failed to initialize the gRPC module");
- return -1;
}
static int frr_grpc_module_late_init(struct thread_master *tm)
static sr_conn_ctx_t *connection;
static struct nb_transaction *transaction;
-static int frr_sr_read_cb(struct thread *thread);
+static void frr_sr_read_cb(struct thread *thread);
static int frr_sr_finish(void);
/* Convert FRR YANG data value to sysrepo YANG data value. */
return NB_OK;
}
-static int frr_sr_read_cb(struct thread *thread)
+static void frr_sr_read_cb(struct thread *thread)
{
struct yang_module *module = THREAD_ARG(thread);
int fd = THREAD_FD(thread);
if (ret != SR_ERR_OK) {
flog_err(EC_LIB_LIBSYSREPO, "%s: sr_fd_event_process(): %s",
__func__, sr_strerror(ret));
- return -1;
+ return;
}
thread_add_read(master, frr_sr_read_cb, module, fd, &module->sr_thread);
-
- return 0;
}
static void frr_sr_subscribe_config(struct yang_module *module)
DEFINE_MTYPE_STATIC(LIB, PULLWR_HEAD, "pull-driven write controller");
DEFINE_MTYPE_STATIC(LIB, PULLWR_BUF, "pull-driven write buffer");
-static int pullwr_run(struct thread *t);
+static void pullwr_run(struct thread *t);
struct pullwr *_pullwr_new(struct thread_master *tm, int fd,
void *arg,
pullwr_bump(pullwr);
}
-static int pullwr_run(struct thread *t)
+static void pullwr_run(struct thread *t)
{
struct pullwr *pullwr = THREAD_ARG(t);
struct iovec iov[2];
* into idle, i.e. no calling thread_add_write()
*/
pullwr_resize(pullwr, 0);
- return 0;
+ return;
}
niov = pullwr_iov(pullwr, iov);
if (errno == EAGAIN || errno == EWOULDBLOCK)
break;
pullwr->err(pullwr->arg, pullwr, false);
- return 0;
+ return;
}
if (nwr == 0) {
pullwr->err(pullwr->arg, pullwr, true);
- return 0;
+ return;
}
pullwr->total_written += nwr;
*/
if (!maxspun)
pullwr_resize(pullwr, 0);
- return 0;
}
void pullwr_stats(struct pullwr *pullwr, uint64_t *total_written,
static void resolver_update_timeouts(struct resolver_state *r);
-static int resolver_cb_timeout(struct thread *t)
+static void resolver_cb_timeout(struct thread *t)
{
struct resolver_state *r = THREAD_ARG(t);
ares_process(r->channel, NULL, NULL);
resolver_update_timeouts(r);
-
- return 0;
}
-static int resolver_cb_socket_readable(struct thread *t)
+static void resolver_cb_socket_readable(struct thread *t)
{
struct resolver_fd *resfd = THREAD_ARG(t);
struct resolver_state *r = resfd->state;
*/
ares_process_fd(r->channel, resfd->fd, ARES_SOCKET_BAD);
resolver_update_timeouts(r);
-
- return 0;
}
-static int resolver_cb_socket_writable(struct thread *t)
+static void resolver_cb_socket_writable(struct thread *t)
{
struct resolver_fd *resfd = THREAD_ARG(t);
struct resolver_state *r = resfd->state;
*/
ares_process_fd(r->channel, ARES_SOCKET_BAD, resfd->fd);
resolver_update_timeouts(r);
-
- return 0;
}
static void resolver_update_timeouts(struct resolver_state *r)
callback(query, NULL, i, &addr[0]);
}
-static int resolver_cb_literal(struct thread *t)
+static void resolver_cb_literal(struct thread *t)
{
struct resolver_query *query = THREAD_ARG(t);
void (*callback)(struct resolver_query *, const char *, int,
query->callback = NULL;
callback(query, ARES_SUCCESS, 1, &query->literal_addr);
- return 0;
}
void resolver_resolve(struct resolver_query *query, int af, vrf_id_t vrf_id,
#ifdef SIGEVENT_SCHEDULE_THREAD
/* timer thread to check signals. shouldn't be needed */
-int frr_signal_timer(struct thread *t)
+void frr_signal_timer(struct thread *t)
{
struct frr_sigevent_master_t *sigm;
sigm->t = NULL;
thread_add_timer(sigm->t->master, frr_signal_timer, &sigmaster,
FRR_SIGNAL_TIMER_INTERVAL, &sigm->t);
- return frr_sigevent_process();
+ frr_sigevent_process();
}
#endif /* SIGEVENT_SCHEDULE_THREAD */
XFREE(MTYPE_SPF_BACKOFF, backoff);
}
-static int spf_backoff_timetolearn_elapsed(struct thread *thread)
+static void spf_backoff_timetolearn_elapsed(struct thread *thread)
{
struct spf_backoff *backoff = THREAD_ARG(thread);
backoff->state = SPF_BACKOFF_LONG_WAIT;
backoff_debug("SPF Back-off(%s) TIMETOLEARN elapsed, move to state %s",
backoff->name, spf_backoff_state2str(backoff->state));
- return 0;
}
-static int spf_backoff_holddown_elapsed(struct thread *thread)
+static void spf_backoff_holddown_elapsed(struct thread *thread)
{
struct spf_backoff *backoff = THREAD_ARG(thread);
backoff->state = SPF_BACKOFF_QUIET;
backoff_debug("SPF Back-off(%s) HOLDDOWN elapsed, move to state %s",
backoff->name, spf_backoff_state2str(backoff->state));
- return 0;
}
long spf_backoff_schedule(struct spf_backoff *backoff)
static struct thread_master *systemd_master = NULL;
-static int systemd_send_watchdog(struct thread *t)
+static void systemd_send_watchdog(struct thread *t)
{
systemd_send_information("WATCHDOG=1");
assert(watchdog_msec > 0);
thread_add_timer_msec(systemd_master, systemd_send_watchdog, NULL,
watchdog_msec, NULL);
- return 1;
}
void systemd_send_started(struct thread_master *m)
/* Get new thread. */
static struct thread *thread_get(struct thread_master *m, uint8_t type,
- int (*func)(struct thread *), void *arg,
+ void (*func)(struct thread *), void *arg,
const struct xref_threadsched *xref)
{
struct thread *thread = thread_list_pop(&m->unuse);
/* Add new read thread. */
void _thread_add_read_write(const struct xref_threadsched *xref,
struct thread_master *m,
- int (*func)(struct thread *), void *arg, int fd,
+ void (*func)(struct thread *), void *arg, int fd,
struct thread **t_ptr)
{
int dir = xref->thread_type;
static void _thread_add_timer_timeval(const struct xref_threadsched *xref,
struct thread_master *m,
- int (*func)(struct thread *), void *arg,
+ void (*func)(struct thread *), void *arg,
struct timeval *time_relative,
struct thread **t_ptr)
{
/* Add timer event thread. */
void _thread_add_timer(const struct xref_threadsched *xref,
- struct thread_master *m, int (*func)(struct thread *),
+ struct thread_master *m, void (*func)(struct thread *),
void *arg, long timer, struct thread **t_ptr)
{
struct timeval trel;
/* Add timer event thread with "millisecond" resolution */
void _thread_add_timer_msec(const struct xref_threadsched *xref,
struct thread_master *m,
- int (*func)(struct thread *), void *arg, long timer,
- struct thread **t_ptr)
+ void (*func)(struct thread *), void *arg,
+ long timer, struct thread **t_ptr)
{
struct timeval trel;
/* Add timer event thread with "timeval" resolution */
void _thread_add_timer_tv(const struct xref_threadsched *xref,
- struct thread_master *m, int (*func)(struct thread *),
- void *arg, struct timeval *tv, struct thread **t_ptr)
+ struct thread_master *m,
+ void (*func)(struct thread *), void *arg,
+ struct timeval *tv, struct thread **t_ptr)
{
_thread_add_timer_timeval(xref, m, func, arg, tv, t_ptr);
}
/* Add simple event thread. */
void _thread_add_event(const struct xref_threadsched *xref,
- struct thread_master *m, int (*func)(struct thread *),
+ struct thread_master *m, void (*func)(struct thread *),
void *arg, int val, struct thread **t_ptr)
{
struct thread *thread = NULL;
/* Execute thread */
void _thread_execute(const struct xref_threadsched *xref,
- struct thread_master *m, int (*func)(struct thread *),
+ struct thread_master *m, void (*func)(struct thread *),
void *arg, int val)
{
struct thread *thread;
struct thread_timer_list_item timeritem;
struct thread **ref; /* external reference (if given) */
struct thread_master *master; /* pointer to the struct thread_master */
- int (*func)(struct thread *); /* event function */
+ void (*func)(struct thread *); /* event function */
void *arg; /* event argument */
union {
int val; /* second argument of the event. */
#endif
struct cpu_thread_history {
- int (*func)(struct thread *);
+ void (*func)(struct thread *);
atomic_size_t total_cpu_warn;
atomic_size_t total_wall_warn;
atomic_size_t total_starv_warn;
extern void _thread_add_read_write(const struct xref_threadsched *xref,
struct thread_master *master,
- int (*fn)(struct thread *), void *arg,
+ void (*fn)(struct thread *), void *arg,
int fd, struct thread **tref);
extern void _thread_add_timer(const struct xref_threadsched *xref,
struct thread_master *master,
- int (*fn)(struct thread *), void *arg, long t,
+ void (*fn)(struct thread *), void *arg, long t,
struct thread **tref);
extern void _thread_add_timer_msec(const struct xref_threadsched *xref,
struct thread_master *master,
- int (*fn)(struct thread *), void *arg,
+ void (*fn)(struct thread *), void *arg,
long t, struct thread **tref);
extern void _thread_add_timer_tv(const struct xref_threadsched *xref,
struct thread_master *master,
- int (*fn)(struct thread *), void *arg,
+ void (*fn)(struct thread *), void *arg,
struct timeval *tv, struct thread **tref);
extern void _thread_add_event(const struct xref_threadsched *xref,
struct thread_master *master,
- int (*fn)(struct thread *), void *arg, int val,
+ void (*fn)(struct thread *), void *arg, int val,
struct thread **tref);
extern void _thread_execute(const struct xref_threadsched *xref,
struct thread_master *master,
- int (*fn)(struct thread *), void *arg, int val);
+ void (*fn)(struct thread *), void *arg, int val);
extern void thread_cancel(struct thread **event);
extern void thread_cancel_async(struct thread_master *, struct thread **,
}
/* Read data via vty socket. */
-static int vty_read(struct thread *thread)
+static void vty_read(struct thread *thread)
{
int i;
int nbytes;
if (nbytes < 0) {
if (ERRNO_IO_RETRY(errno)) {
vty_event(VTY_READ, vty);
- return 0;
+ return;
}
vty->monitor = 0; /* disable monitoring to avoid
infinite recursion */
vty_event(VTY_WRITE, vty);
vty_event(VTY_READ, vty);
}
- return 0;
}
/* Flush buffer to the vty. */
-static int vty_flush(struct thread *thread)
+static void vty_flush(struct thread *thread)
{
int erase;
buffer_status_t flushrc;
buffer_reset(vty->lbuf);
buffer_reset(vty->obuf);
vty_close(vty);
- return 0;
+ return;
case BUFFER_EMPTY:
if (vty->status == VTY_CLOSE)
vty_close(vty);
vty_event(VTY_WRITE, vty);
break;
}
-
- return 0;
}
/* Allocate new vty struct. */
}
/* Accept connection from the network. */
-static int vty_accept(struct thread *thread)
+static void vty_accept(struct thread *thread)
{
struct vty_serv *vtyserv = THREAD_ARG(thread);
int vty_sock;
if (vty_sock < 0) {
flog_err(EC_LIB_SOCKET, "can't accept vty socket : %s",
safe_strerror(errno));
- return -1;
+ return;
}
set_nonblocking(vty_sock);
set_cloexec(vty_sock);
close(vty_sock);
zlog_info("Vty unable to convert prefix from sockunion %pSU",
&su);
- return -1;
+ return;
}
/* VTY's accesslist apply. */
&& (access_list_apply(acl, &p) == FILTER_DENY)) {
zlog_info("Vty connection refused from %pSU", &su);
close(vty_sock);
- return 0;
+ return;
}
}
&& (access_list_apply(acl, &p) == FILTER_DENY)) {
zlog_info("Vty connection refused from %pSU", &su);
close(vty_sock);
- return 0;
+ return;
}
}
zlog_info("Vty connection from %pSU", &su);
vty_create(vty_sock, &su);
-
- return 0;
}
static void vty_serv_sock_addrinfo(const char *hostname, unsigned short port)
/* #define VTYSH_DEBUG 1 */
-static int vtysh_accept(struct thread *thread)
+static void vtysh_accept(struct thread *thread)
{
struct vty_serv *vtyserv = THREAD_ARG(thread);
int accept_sock = vtyserv->sock;
if (sock < 0) {
flog_err(EC_LIB_SOCKET, "can't accept vty socket : %s",
safe_strerror(errno));
- return -1;
+ return;
}
if (set_nonblocking(sock) < 0) {
"vtysh_accept: could not set vty socket %d to non-blocking, %s, closing",
sock, safe_strerror(errno));
close(sock);
- return -1;
+ return;
}
set_cloexec(sock);
vtys_add_tail(vtysh_sessions, vty);
vty_event(VTYSH_READ, vty);
-
- return 0;
}
static int vtysh_flush(struct vty *vty)
return 0;
}
-static int vtysh_read(struct thread *thread)
+static void vtysh_read(struct thread *thread)
{
int ret;
int sock;
if (nbytes < 0) {
if (ERRNO_IO_RETRY(errno)) {
vty_event(VTYSH_READ, vty);
- return 0;
+ return;
}
vty->monitor = 0; /* disable monitoring to avoid
infinite recursion */
#ifdef VTYSH_DEBUG
printf("close vtysh\n");
#endif /* VTYSH_DEBUG */
- return 0;
+ return;
}
#ifdef VTYSH_DEBUG
if (!vty->t_write && (vtysh_flush(vty) < 0))
/* Try to flush results; exit if a write
* error occurs. */
- return 0;
+ return;
}
}
}
vty_close(vty);
else
vty_event(VTYSH_READ, vty);
-
- return 0;
}
-static int vtysh_write(struct thread *thread)
+static void vtysh_write(struct thread *thread)
{
struct vty *vty = THREAD_ARG(thread);
vtysh_flush(vty);
- return 0;
}
#endif /* VTYSH */
}
/* When time out occur output message then close connection. */
-static int vty_timeout(struct thread *thread)
+static void vty_timeout(struct thread *thread)
{
struct vty *vty;
/* Close connection. */
vty->status = VTY_CLOSE;
vty_close(vty);
-
- return 0;
}
/* Read up configuration file from file_name. */
static int debug_timer_wheel = 0;
-static int wheel_timer_thread(struct thread *t);
+static void wheel_timer_thread(struct thread *t);
-static int wheel_timer_thread_helper(struct thread *t)
+static void wheel_timer_thread_helper(struct thread *t)
{
struct listnode *node, *nextnode;
unsigned long long curr_slot;
wheel->slots_to_skip = slots_to_skip;
thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
wheel->nexttime * slots_to_skip, &wheel->timer);
-
- return 0;
}
-static int wheel_timer_thread(struct thread *t)
+static void wheel_timer_thread(struct thread *t)
{
struct timer_wheel *wheel;
wheel = THREAD_ARG(t);
thread_execute(wheel->master, wheel_timer_thread_helper, wheel, 0);
-
- return 0;
}
struct timer_wheel *wheel_init(struct thread_master *master, int period,
* will reschedule itself if required,
* otherwise work_queue_item_add
*/
-int work_queue_run(struct thread *thread)
+void work_queue_run(struct thread *thread)
{
struct work_queue *wq;
struct work_queue_item *item, *titem;
} else if (wq->spec.completion_func)
wq->spec.completion_func(wq);
-
- return 0;
}
bool work_queue_is_scheduled(struct work_queue *);
/* Helpers, exported for thread.c and command.c */
-extern int work_queue_run(struct thread *);
+extern void work_queue_run(struct thread *);
extern void workqueue_cmd_init(void);
return ZCLIENT_SEND_FAILURE;
}
-static int zclient_flush_data(struct thread *thread)
+static void zclient_flush_data(struct thread *thread)
{
struct zclient *zclient = THREAD_ARG(thread);
zclient->t_write = NULL;
if (zclient->sock < 0)
- return -1;
+ return;
switch (buffer_flush_available(zclient->wb, zclient->sock)) {
case BUFFER_ERROR:
flog_err(
EC_LIB_ZAPI_SOCKET,
"%s: buffer_flush_available failed on zclient fd %d, closing",
__func__, zclient->sock);
- return zclient_failed(zclient);
+ zclient_failed(zclient);
+ return;
case BUFFER_PENDING:
zclient->t_write = NULL;
thread_add_write(zclient->master, zclient_flush_data, zclient,
(*zclient->zebra_buffer_write_ready)();
break;
}
- return 0;
}
/*
/* This function is a wrapper function for calling zclient_start from
timer or event thread. */
-static int zclient_connect(struct thread *t)
+static void zclient_connect(struct thread *t)
{
struct zclient *zclient;
if (zclient_debug)
zlog_debug("zclient_connect is called");
- return zclient_start(zclient);
+ zclient_start(zclient);
}
enum zclient_send_status zclient_send_rnh(struct zclient *zclient, int command,
};
/* Zebra client message read function. */
-static int zclient_read(struct thread *thread)
+static void zclient_read(struct thread *thread)
{
size_t already;
uint16_t length, command;
zlog_debug(
"zclient connection closed socket [%d].",
zclient->sock);
- return zclient_failed(zclient);
+ zclient_failed(zclient);
+ return;
}
if (nbyte != (ssize_t)(ZEBRA_HEADER_SIZE - already)) {
zclient_event(ZCLIENT_READ, zclient);
- return 0;
+ return;
}
already = ZEBRA_HEADER_SIZE;
}
EC_LIB_ZAPI_MISSMATCH,
"%s: socket %d version mismatch, marker %d, version %d",
__func__, zclient->sock, marker, version);
- return zclient_failed(zclient);
+ zclient_failed(zclient);
+ return;
}
if (length < ZEBRA_HEADER_SIZE) {
flog_err(EC_LIB_ZAPI_MISSMATCH,
"%s: socket %d message length %u is less than %d ",
__func__, zclient->sock, length, ZEBRA_HEADER_SIZE);
- return zclient_failed(zclient);
+ zclient_failed(zclient);
+ return;
}
/* Length check. */
zlog_debug(
"zclient connection closed socket [%d].",
zclient->sock);
- return zclient_failed(zclient);
+ zclient_failed(zclient);
+ return;
}
if (nbyte != (ssize_t)(length - already)) {
/* Try again later. */
zclient_event(ZCLIENT_READ, zclient);
- return 0;
+ return;
}
}
if (zclient->sock < 0)
/* Connection was closed during packet processing. */
- return -1;
+ return;
/* Register read thread. */
stream_reset(zclient->ibuf);
zclient_event(ZCLIENT_READ, zclient);
-
- return 0;
}
void zclient_redistribute(int command, struct zclient *zclient, afi_t afi,
rcu_free(MTYPE_LOG_5424, oldt, zt.rcu_head);
}
-static int zlog_5424_reconnect(struct thread *t)
+static void zlog_5424_reconnect(struct thread *t)
{
struct zlog_cfg_5424 *zcf = THREAD_ARG(t);
int fd = THREAD_FD(t);
/* logger is sending us something?!?! */
thread_add_read(t->master, zlog_5424_reconnect, zcf, fd,
&zcf->t_reconnect);
- return 0;
+ return;
}
if (ret == 0)
frr_with_mutex (&zcf->cfg_mtx) {
zlog_5424_cycle(zcf, fd);
}
- return 0;
}
static int zlog_5424_unix(struct sockaddr_un *suna, int sock_type)
nhrp_peer_send_indication(ifp, htons(pkthdr->hw_protocol), &pktpl);
}
-static int netlink_log_recv(struct thread *t)
+static void netlink_log_recv(struct thread *t)
{
uint8_t buf[ZNL_BUFFER_SIZE];
int fd = THREAD_FD(t);
thread_add_read(master, netlink_log_recv, 0, netlink_log_fd,
&netlink_log_thread);
-
- return 0;
}
void netlink_set_nflog_group(int nlgroup)
create ? nhrp_cache_alloc : NULL);
}
-static int nhrp_cache_do_free(struct thread *t)
+static void nhrp_cache_do_free(struct thread *t)
{
struct nhrp_cache *c = THREAD_ARG(t);
c->t_timeout = NULL;
nhrp_cache_free(c);
- return 0;
}
-static int nhrp_cache_do_timeout(struct thread *t)
+static void nhrp_cache_do_timeout(struct thread *t)
{
struct nhrp_cache *c = THREAD_ARG(t);
if (c->cur.type != NHRP_CACHE_INVALID)
nhrp_cache_update_binding(c, c->cur.type, -1, NULL, 0, NULL,
NULL);
- return 0;
}
static void nhrp_cache_update_route(struct nhrp_cache *c)
nhrp_cache_update_timers(c);
}
-static int nhrp_cache_do_auth_timeout(struct thread *t)
+static void nhrp_cache_do_auth_timeout(struct thread *t)
{
struct nhrp_cache *c = THREAD_ARG(t);
c->t_auth = NULL;
nhrp_cache_authorize_binding(&c->eventid, (void *)"timeout");
- return 0;
}
static void nhrp_cache_newpeer_notifier(struct notifier_block *n,
uint8_t ibuf_data[4 * 1024];
};
-static int evmgr_reconnect(struct thread *t);
+static void evmgr_reconnect(struct thread *t);
static void evmgr_connection_error(struct event_manager *evmgr)
{
}
}
-static int evmgr_read(struct thread *t)
+static void evmgr_read(struct thread *t)
{
struct event_manager *evmgr = THREAD_ARG(t);
struct zbuf *ibuf = &evmgr->ibuf;
if (zbuf_read(ibuf, evmgr->fd, (size_t)-1) < 0) {
evmgr_connection_error(evmgr);
- return 0;
+ return;
}
/* Process all messages in buffer */
evmgr_recv_message(evmgr, &msg);
thread_add_read(master, evmgr_read, evmgr, evmgr->fd, &evmgr->t_read);
- return 0;
}
-static int evmgr_write(struct thread *t)
+static void evmgr_write(struct thread *t)
{
struct event_manager *evmgr = THREAD_ARG(t);
int r;
} else if (r < 0) {
evmgr_connection_error(evmgr);
}
-
- return 0;
}
static void evmgr_hexdump(struct zbuf *zb, const uint8_t *val, size_t vallen)
&evmgr->t_write);
}
-static int evmgr_reconnect(struct thread *t)
+static void evmgr_reconnect(struct thread *t)
{
struct event_manager *evmgr = THREAD_ARG(t);
int fd;
if (evmgr->fd >= 0 || !nhrp_event_socket_path)
- return 0;
+ return;
fd = sock_open_unix(nhrp_event_socket_path);
if (fd < 0) {
zbufq_reset(&evmgr->obuf);
thread_add_timer(master, evmgr_reconnect, evmgr, 10,
&evmgr->t_reconnect);
- return 0;
+ return;
}
zlog_info("Connected to Event Manager");
evmgr->fd = fd;
thread_add_read(master, evmgr_read, evmgr, evmgr->fd, &evmgr->t_read);
-
- return 0;
}
static struct event_manager evmgr_connection;
}
}
-static int netlink_mcast_log_recv(struct thread *t)
+static void netlink_mcast_log_recv(struct thread *t)
{
uint8_t buf[65535]; /* Max OSPF Packet size */
int fd = THREAD_FD(t);
thread_add_read(master, netlink_mcast_log_recv, 0, netlink_mcast_log_fd,
&netlink_mcast_log_thread);
-
- return 0;
}
static void netlink_mcast_log_register(int fd, int group)
DEFINE_MTYPE_STATIC(NHRPD, NHRP_NHS, "NHRP next hop server");
DEFINE_MTYPE_STATIC(NHRPD, NHRP_REGISTRATION, "NHRP registration entries");
-static int nhrp_nhs_resolve(struct thread *t);
-static int nhrp_reg_send_req(struct thread *t);
+static void nhrp_nhs_resolve(struct thread *t);
+static void nhrp_reg_send_req(struct thread *t);
static void nhrp_reg_reply(struct nhrp_reqid *reqid, void *arg)
{
&cie_nbma_nhs);
}
-static int nhrp_reg_timeout(struct thread *t)
+static void nhrp_reg_timeout(struct thread *t)
{
struct nhrp_registration *r = THREAD_ARG(t);
struct nhrp_cache *c;
r->timeout = 2;
}
thread_add_timer_msec(master, nhrp_reg_send_req, r, 10, &r->t_register);
-
- return 0;
}
static void nhrp_reg_peer_notify(struct notifier_block *n, unsigned long cmd)
}
}
-static int nhrp_reg_send_req(struct thread *t)
+static void nhrp_reg_send_req(struct thread *t)
{
struct nhrp_registration *r = THREAD_ARG(t);
struct nhrp_nhs *nhs = r->nhs;
&r->peer->vc->remote.nbma);
thread_add_timer(master, nhrp_reg_send_req, r, 120,
&r->t_register);
- return 0;
+ return;
}
thread_add_timer(master, nhrp_reg_timeout, r, r->timeout,
/* No protocol address configured for tunnel interface */
if (sockunion_family(&if_ad->addr) == AF_UNSPEC)
- return 0;
+ return;
zb = zbuf_alloc(1400);
hdr = nhrp_packet_push(zb, NHRP_PACKET_REGISTRATION_REQUEST,
nhrp_packet_complete(zb, hdr);
nhrp_peer_send(r->peer, zb);
zbuf_free(zb);
-
- return 0;
}
static void nhrp_reg_delete(struct nhrp_registration *r)
nhrp_reg_delete(reg);
}
-static int nhrp_nhs_resolve(struct thread *t)
+static void nhrp_nhs_resolve(struct thread *t)
{
struct nhrp_nhs *nhs = THREAD_ARG(t);
resolver_resolve(&nhs->dns_resolve, AF_INET, VRF_DEFAULT,
nhs->nbma_fqdn, nhrp_nhs_resolve_cb);
-
- return 0;
}
int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
return -1;
}
-static int nhrp_packet_recvraw(struct thread *t)
+static void nhrp_packet_recvraw(struct thread *t)
{
int fd = THREAD_FD(t), ifindex;
struct zbuf *zb;
zb = zbuf_alloc(1500);
if (!zb)
- return 0;
+ return;
len = zbuf_size(zb);
addrlen = sizeof(addr);
nhrp_peer_recv(p, zb);
nhrp_peer_unref(p);
- return 0;
+ return;
err:
zbuf_free(zb);
- return 0;
}
int nhrp_packet_init(void)
XFREE(MTYPE_NHRP_PEER, p);
}
-static int nhrp_peer_notify_up(struct thread *t)
+static void nhrp_peer_notify_up(struct thread *t)
{
struct nhrp_peer *p = THREAD_ARG(t);
struct nhrp_vc *vc = p->vc;
notifier_call(&p->notifier_list, NOTIFY_PEER_UP);
nhrp_peer_unref(p);
}
-
- return 0;
}
static void __nhrp_peer_check(struct nhrp_peer *p)
}
}
-static int nhrp_peer_request_timeout(struct thread *t)
+static void nhrp_peer_request_timeout(struct thread *t)
{
struct nhrp_peer *p = THREAD_ARG(t);
struct nhrp_vc *vc = p->vc;
if (p->online)
- return 0;
+ return;
if (nifp->ipsec_fallback_profile && !p->prio
&& !p->fallback_requested) {
} else {
p->requested = p->fallback_requested = 0;
}
-
- return 0;
}
-static int nhrp_peer_defer_vici_request(struct thread *t)
+static void nhrp_peer_defer_vici_request(struct thread *t)
{
struct nhrp_peer *p = THREAD_ARG(t);
struct nhrp_vc *vc = p->vc;
(nifp->ipsec_fallback_profile && !p->prio) ? 15 : 30,
&p->t_fallback);
}
- return 0;
}
int nhrp_peer_check(struct nhrp_peer *p, int establish)
static struct route_table *shortcut_rib[AFI_MAX];
-static int nhrp_shortcut_do_purge(struct thread *t);
+static void nhrp_shortcut_do_purge(struct thread *t);
static void nhrp_shortcut_delete(struct nhrp_shortcut *s);
static void nhrp_shortcut_send_resolution_req(struct nhrp_shortcut *s);
}
}
-static int nhrp_shortcut_do_expire(struct thread *t)
+static void nhrp_shortcut_do_expire(struct thread *t)
{
struct nhrp_shortcut *s = THREAD_ARG(t);
&s->t_timer);
s->expiring = 1;
nhrp_shortcut_check_use(s);
-
- return 0;
}
static void nhrp_shortcut_cache_notify(struct notifier_block *n,
}
}
-static int nhrp_shortcut_do_purge(struct thread *t)
+static void nhrp_shortcut_do_purge(struct thread *t)
{
struct nhrp_shortcut *s = THREAD_ARG(t);
s->t_timer = NULL;
nhrp_shortcut_delete(s);
- return 0;
}
static struct nhrp_shortcut *nhrp_shortcut_get(struct prefix *p)
int nsections;
};
-static int vici_reconnect(struct thread *t);
+static void vici_reconnect(struct thread *t);
static void vici_submit_request(struct vici_conn *vici, const char *name, ...);
static void vici_zbuf_puts(struct zbuf *obuf, const char *str)
}
}
-static int vici_read(struct thread *t)
+static void vici_read(struct thread *t)
{
struct vici_conn *vici = THREAD_ARG(t);
struct zbuf *ibuf = &vici->ibuf;
if (zbuf_read(ibuf, vici->fd, (size_t)-1) < 0) {
vici_connection_error(vici);
- return 0;
+ return;
}
/* Process all messages in buffer */
} while (1);
thread_add_read(master, vici_read, vici, vici->fd, &vici->t_read);
- return 0;
}
-static int vici_write(struct thread *t)
+static void vici_write(struct thread *t)
{
struct vici_conn *vici = THREAD_ARG(t);
int r;
} else if (r < 0) {
vici_connection_error(vici);
}
-
- return 0;
}
static void vici_submit(struct vici_conn *vici, struct zbuf *obuf)
return buff;
}
-static int vici_reconnect(struct thread *t)
+static void vici_reconnect(struct thread *t)
{
struct vici_conn *vici = THREAD_ARG(t);
int fd;
char *file_path;
if (vici->fd >= 0)
- return 0;
+ return;
fd = sock_open_unix(VICI_SOCKET);
if (fd < 0) {
strerror(errno));
thread_add_timer(master, vici_reconnect, vici, 2,
&vici->t_reconnect);
- return 0;
+ return;
}
debugf(NHRP_DEBUG_COMMON, "VICI: Connected");
vici_register_event(vici, "child-state-destroying");
vici_register_event(vici, "list-sa");
vici_submit_request(vici, "list-sas", VICI_END);
-
- return 0;
}
static struct vici_conn vici_connection;
return lsa;
}
-int ospf6_orig_as_external_lsa(struct thread *thread)
+void ospf6_orig_as_external_lsa(struct thread *thread)
{
struct ospf6_interface *oi;
struct ospf6_lsa *lsa;
oi = (struct ospf6_interface *)THREAD_ARG(thread);
if (oi->state == OSPF6_INTERFACE_DOWN)
- return 0;
+ return;
if (IS_AREA_NSSA(oi->area) || IS_AREA_STUB(oi->area))
- return 0;
+ return;
type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
adv_router = oi->area->ospf6->router_id;
ospf6_flood_interface(NULL, lsa, oi);
}
-
- return 0;
}
static route_tag_t ospf6_as_external_lsa_get_tag(struct ospf6_lsa *lsa)
ROUTEMAP(red) = NULL;
}
-static int ospf6_asbr_routemap_update_timer(struct thread *thread)
+static void ospf6_asbr_routemap_update_timer(struct thread *thread)
{
struct ospf6 *ospf6 = THREAD_ARG(thread);
struct ospf6_redist *red;
UNSET_FLAG(red->flag, OSPF6_IS_RMAP_CHANGED);
}
-
- return 0;
}
void ospf6_asbr_distribute_list_update(struct ospf6 *ospf6,
}
}
-static int ospf6_asbr_summary_process(struct thread *thread)
+static void ospf6_asbr_summary_process(struct thread *thread)
{
struct ospf6 *ospf6 = THREAD_ARG(thread);
int operation = 0;
default:
break;
}
-
- return OSPF6_SUCCESS;
}
static void
}
/* Handling of grace period expiry. */
-static int ospf6_gr_grace_period_expired(struct thread *thread)
+static void ospf6_gr_grace_period_expired(struct thread *thread)
{
struct ospf6 *ospf6 = THREAD_ARG(thread);
ospf6->gr_info.t_grace_period = NULL;
ospf6_gr_restart_exit(ospf6, "grace period has expired");
-
- return 0;
}
/*
* Returns:
* Nothing
*/
-static int ospf6_handle_grace_timer_expiry(struct thread *thread)
+static void ospf6_handle_grace_timer_expiry(struct thread *thread)
{
struct ospf6_neighbor *nbr = THREAD_ARG(thread);
ospf6_gr_helper_exit(nbr, OSPF6_GR_HELPER_GRACE_TIMEOUT);
- return OSPF6_SUCCESS;
}
/*
#endif /* __FreeBSD__ */
/* Interface State Machine */
-int interface_up(struct thread *thread)
+void interface_up(struct thread *thread)
{
struct ospf6_interface *oi;
struct ospf6 *ospf6;
if (!if_is_operative(oi->interface)) {
zlog_warn("Interface %s is down, can't execute [InterfaceUp]",
oi->interface->name);
- return 0;
+ return;
}
/* check interface has a link-local address */
zlog_warn(
"Interface %s has no link local address, can't execute [InterfaceUp]",
oi->interface->name);
- return 0;
+ return;
}
/* Recompute cost */
if (IS_OSPF6_DEBUG_INTERFACE)
zlog_debug("Interface %s already enabled",
oi->interface->name);
- return 0;
+ return;
}
/* If no area assigned, return */
zlog_warn(
"%s: Not scheduling Hello for %s as there is no area assigned yet",
__func__, oi->interface->name);
- return 0;
+ return;
}
#ifdef __FreeBSD__
thread_add_timer(master, interface_up, oi,
OSPF6_INTERFACE_SSO_RETRY_INT,
&oi->thread_sso);
- return 0;
+ return;
}
#endif /* __FreeBSD__ */
OSPF6_INTERFACE_SSO_RETRY_INT,
&oi->thread_sso);
}
- return 0;
+ return;
}
oi->sso_try_cnt = 0; /* Reset on success */
thread_add_timer(master, wait_timer, oi, oi->dead_interval,
&oi->thread_wait_timer);
}
-
- return 0;
}
-int wait_timer(struct thread *thread)
+void wait_timer(struct thread *thread)
{
struct ospf6_interface *oi;
if (oi->state == OSPF6_INTERFACE_WAITING)
ospf6_interface_state_change(dr_election(oi), oi);
-
- return 0;
}
-int backup_seen(struct thread *thread)
+void backup_seen(struct thread *thread)
{
struct ospf6_interface *oi;
if (oi->state == OSPF6_INTERFACE_WAITING)
ospf6_interface_state_change(dr_election(oi), oi);
-
- return 0;
}
-int neighbor_change(struct thread *thread)
+void neighbor_change(struct thread *thread)
{
struct ospf6_interface *oi;
|| oi->state == OSPF6_INTERFACE_BDR
|| oi->state == OSPF6_INTERFACE_DR)
ospf6_interface_state_change(dr_election(oi), oi);
-
- return 0;
}
-int interface_down(struct thread *thread)
+void interface_down(struct thread *thread)
{
struct ospf6_interface *oi;
struct listnode *node, *nnode;
oi->bdrouter = oi->prev_bdrouter = htonl(0);
if (oi->area == NULL)
- return 0;
+ return;
ospf6 = oi->area->ospf6;
/* Leave AllSPFRouters */
}
ospf6_interface_state_change(OSPF6_INTERFACE_DOWN, oi);
-
- return 0;
}
ospf6_interface_get_global_address(struct interface *ifp);
/* interface event */
-extern int interface_up(struct thread *thread);
-extern int interface_down(struct thread *thread);
-extern int wait_timer(struct thread *thread);
-extern int backup_seen(struct thread *thread);
-extern int neighbor_change(struct thread *thread);
+extern void interface_up(struct thread *thread);
+extern void interface_down(struct thread *thread);
+extern void wait_timer(struct thread *thread);
+extern void backup_seen(struct thread *thread);
+extern void neighbor_change(struct thread *thread);
extern void ospf6_interface_init(void);
extern void ospf6_interface_clear(struct interface *ifp);
return OSPF6_NOT_STUB_ROUTER;
}
-int ospf6_router_lsa_originate(struct thread *thread)
+void ospf6_router_lsa_originate(struct thread *thread)
{
struct ospf6_area *oa;
if (IS_DEBUG_OSPF6_GR)
zlog_debug(
"Graceful Restart in progress, don't originate LSA");
- return 0;
+ return;
}
if (IS_OSPF6_DEBUG_ORIGINATE(ROUTER))
+ sizeof(struct ospf6_router_lsa)) {
zlog_warn(
"Size limit setting for Router-LSA too short");
- return 0;
+ return;
}
/* Fill LSA Header */
if (count && !link_state_id)
ospf6_spf_schedule(oa->ospf6,
OSPF6_SPF_FLAGS_ROUTER_LSA_ORIGINATED);
-
- return 0;
}
/*******************************/
return 0;
}
-int ospf6_network_lsa_originate(struct thread *thread)
+void ospf6_network_lsa_originate(struct thread *thread)
{
struct ospf6_interface *oi;
if (IS_DEBUG_OSPF6_GR)
zlog_debug(
"Graceful Restart in progress, don't originate LSA");
- return 0;
+ return;
}
old = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_NETWORK),
oi->area->ospf6,
OSPF6_SPF_FLAGS_NETWORK_LSA_ORIGINATED);
}
- return 0;
+ return;
}
if (IS_OSPF6_DEBUG_ORIGINATE(NETWORK))
zlog_debug("Interface stub, ignore");
if (old)
ospf6_lsa_purge(old);
- return 0;
+ return;
}
/* prepare buffer */
/* Originate */
ospf6_lsa_originate_area(lsa, oi->area);
-
- return 0;
}
return 0;
}
-int ospf6_link_lsa_originate(struct thread *thread)
+void ospf6_link_lsa_originate(struct thread *thread)
{
struct ospf6_interface *oi;
if (IS_DEBUG_OSPF6_GR)
zlog_debug(
"Graceful Restart in progress, don't originate LSA");
- return 0;
+ return;
}
if (CHECK_FLAG(oi->flag, OSPF6_INTERFACE_DISABLE)) {
if (old)
ospf6_lsa_purge(old);
- return 0;
+ return;
}
if (IS_OSPF6_DEBUG_ORIGINATE(LINK))
oi->interface->name);
if (old)
ospf6_lsa_purge(old);
- return 0;
+ return;
}
/* prepare buffer */
/* Originate */
ospf6_lsa_originate_interface(lsa, oi);
-
- return 0;
}
return 0;
}
-int ospf6_intra_prefix_lsa_originate_stub(struct thread *thread)
+void ospf6_intra_prefix_lsa_originate_stub(struct thread *thread)
{
struct ospf6_area *oa;
if (IS_DEBUG_OSPF6_GR)
zlog_debug(
"Graceful Restart in progress, don't originate LSA");
- return 0;
+ return;
}
/* find previous LSA */
oa->lsdb);
}
}
- return 0;
+ return;
}
if (IS_OSPF6_DEBUG_ORIGINATE(INTRA_PREFIX))
}
}
ospf6_route_table_delete(route_advertise);
- return 0;
+ return;
}
/* Neighbor change to FULL, if INTRA-AREA-PREFIX LSA
if (IS_OSPF6_DEBUG_ORIGINATE(INTRA_PREFIX))
zlog_debug(
"Quit to Advertise Intra-Prefix: no route to advertise");
- return 0;
+ return;
}
intra_prefix_lsa->prefix_num = htons(prefix_num);
/* Originate */
ospf6_lsa_originate_area(lsa, oa);
-
- return 0;
}
-int ospf6_intra_prefix_lsa_originate_transit(struct thread *thread)
+void ospf6_intra_prefix_lsa_originate_transit(struct thread *thread)
{
struct ospf6_interface *oi;
if (IS_DEBUG_OSPF6_GR)
zlog_debug(
"Graceful Restart in progress, don't originate LSA");
- return 0;
+ return;
}
/* find previous LSA */
if (CHECK_FLAG(oi->flag, OSPF6_INTERFACE_DISABLE)) {
if (old)
ospf6_lsa_purge(old);
- return 0;
+ return;
}
if (IS_OSPF6_DEBUG_ORIGINATE(INTRA_PREFIX))
zlog_debug(" Interface is not DR");
if (old)
ospf6_lsa_purge(old);
- return 0;
+ return;
}
full_count = 0;
zlog_debug(" Interface is stub");
if (old)
ospf6_lsa_purge(old);
- return 0;
+ return;
}
/* connected prefix to advertise */
if (IS_OSPF6_DEBUG_ORIGINATE(INTRA_PREFIX))
zlog_debug(
"Quit to Advertise Intra-Prefix: no route to advertise");
- return 0;
+ return;
}
intra_prefix_lsa->prefix_num = htons(prefix_num);
/* Originate */
ospf6_lsa_originate_area(lsa, oi->area);
-
- return 0;
}
static void ospf6_intra_prefix_update_route_origin(struct ospf6_route *oa_route,
struct ospf6_lsa *lsa);
extern int ospf6_router_is_stub_router(struct ospf6_lsa *lsa);
-extern int ospf6_router_lsa_originate(struct thread *thread);
-extern int ospf6_network_lsa_originate(struct thread *thread);
-extern int ospf6_link_lsa_originate(struct thread *thread);
-extern int ospf6_intra_prefix_lsa_originate_transit(struct thread *thread);
-extern int ospf6_intra_prefix_lsa_originate_stub(struct thread *thread);
+extern void ospf6_router_lsa_originate(struct thread *thread);
+extern void ospf6_network_lsa_originate(struct thread *thread);
+extern void ospf6_link_lsa_originate(struct thread *thread);
+extern void ospf6_intra_prefix_lsa_originate_transit(struct thread *thread);
+extern void ospf6_intra_prefix_lsa_originate_stub(struct thread *thread);
extern void ospf6_intra_prefix_lsa_add(struct ospf6_lsa *lsa);
extern void ospf6_intra_prefix_lsa_remove(struct ospf6_lsa *lsa);
-extern int ospf6_orig_as_external_lsa(struct thread *thread);
+extern void ospf6_orig_as_external_lsa(struct thread *thread);
extern void ospf6_intra_route_calculation(struct ospf6_area *oa);
extern void ospf6_intra_brouter_calculation(struct ospf6_area *oa);
extern void ospf6_intra_prefix_route_ecmp_path(struct ospf6_area *oa,
/* ospf6 lsa expiry */
-int ospf6_lsa_expire(struct thread *thread)
+void ospf6_lsa_expire(struct thread *thread)
{
struct ospf6_lsa *lsa;
struct ospf6 *ospf6;
}
if (CHECK_FLAG(lsa->flag, OSPF6_LSA_HEADERONLY))
- return 0; /* dbexchange will do something ... */
+ return; /* dbexchange will do something ... */
ospf6 = ospf6_get_by_lsdb(lsa);
assert(ospf6);
/* schedule maxage remover */
ospf6_maxage_remove(ospf6);
-
- return 0;
}
-int ospf6_lsa_refresh(struct thread *thread)
+void ospf6_lsa_refresh(struct thread *thread)
{
struct ospf6_lsa *old, *self, *new;
struct ospf6_lsdb *lsdb_self;
zlog_debug("Refresh: could not find self LSA, flush %s",
old->name);
ospf6_lsa_premature_aging(old);
- return 0;
+ return;
}
/* Reset age, increment LS sequence number. */
ospf6_install_lsa(new);
ospf6_flood(NULL, new);
-
- return 0;
}
void ospf6_flush_self_originated_lsas_now(struct ospf6 *ospf6)
extern struct ospf6_lsa *ospf6_lsa_lock(struct ospf6_lsa *lsa);
extern struct ospf6_lsa *ospf6_lsa_unlock(struct ospf6_lsa *lsa);
-extern int ospf6_lsa_expire(struct thread *thread);
-extern int ospf6_lsa_refresh(struct thread *thread);
+extern void ospf6_lsa_expire(struct thread *thread);
+extern void ospf6_lsa_refresh(struct thread *thread);
extern unsigned short ospf6_lsa_checksum(struct ospf6_lsa_header *lsah);
extern int ospf6_lsa_checksum_valid(struct ospf6_lsa_header *lsah);
return OSPF6_READ_CONTINUE;
}
-int ospf6_receive(struct thread *thread)
+void ospf6_receive(struct thread *thread)
{
int sockfd;
struct ospf6 *ospf6;
count++;
switch (ospf6_read_helper(sockfd, ospf6)) {
case OSPF6_READ_ERROR:
- return 0;
+ return;
case OSPF6_READ_CONTINUE:
break;
}
}
-
- return 0;
}
static void ospf6_fill_hdr_checksum(struct ospf6_interface *oi,
return length;
}
-static int ospf6_write(struct thread *thread)
+static void ospf6_write(struct thread *thread)
{
struct ospf6 *ospf6 = THREAD_ARG(thread);
struct ospf6_interface *oi;
if (ospf6->fd < 0) {
zlog_warn("ospf6_write failed to send, fd %d", ospf6->fd);
- return -1;
+ return;
}
node = listhead(ospf6->oi_write_q);
if (!list_isempty(ospf6->oi_write_q))
thread_add_write(master, ospf6_write, ospf6, ospf6->fd,
&ospf6->t_write);
-
- return 0;
}
-int ospf6_hello_send(struct thread *thread)
+void ospf6_hello_send(struct thread *thread)
{
struct ospf6_interface *oi;
struct ospf6_packet *op;
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_HELLO, SEND_HDR))
zlog_debug("Unable to send Hello on down interface %s",
oi->interface->name);
- return 0;
+ return;
}
op = ospf6_packet_new(oi->ifmtu);
if (length == OSPF6_HEADER_SIZE) {
/* Hello overshooting MTU */
ospf6_packet_free(op);
- return 0;
+ return;
}
/* Fill OSPF header. */
&oi->thread_send_hello);
OSPF6_MESSAGE_WRITE_ON(oi);
-
- return 0;
}
static uint16_t ospf6_make_dbdesc(struct ospf6_neighbor *on, struct stream *s)
return length;
}
-int ospf6_dbdesc_send(struct thread *thread)
+void ospf6_dbdesc_send(struct thread *thread)
{
struct ospf6_neighbor *on;
uint16_t length = OSPF6_HEADER_SIZE;
zlog_debug(
"Quit to send DbDesc to neighbor %s state %s",
on->name, ospf6_neighbor_state_str[on->state]);
- return 0;
+ return;
}
/* set next thread if master */
ospf6_packet_add(on->ospf6_if, op);
OSPF6_MESSAGE_WRITE_ON(on->ospf6_if);
-
- return 0;
}
-int ospf6_dbdesc_send_newone(struct thread *thread)
+void ospf6_dbdesc_send_newone(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
&on->thread_exchange_done);
thread_execute(master, ospf6_dbdesc_send, on, 0);
- return 0;
}
static uint16_t ospf6_make_lsreq(struct ospf6_neighbor *on, struct stream *s)
return length;
}
-int ospf6_lsreq_send(struct thread *thread)
+void ospf6_lsreq_send(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_packet *op;
zlog_debug("Quit to send LSReq to neighbor %s state %s",
on->name,
ospf6_neighbor_state_str[on->state]);
- return 0;
+ return;
}
/* schedule loading_done if request list is empty */
if (on->request_list->count == 0) {
thread_add_event(master, loading_done, on, 0, NULL);
- return 0;
+ return;
}
op = ospf6_packet_new(on->ospf6_if->ifmtu);
if (length == OSPF6_HEADER_SIZE) {
/* Hello overshooting MTU */
ospf6_packet_free(op);
- return 0;
+ return;
}
/* Fill OSPF header. */
on->ospf6_if->rxmt_interval,
&on->thread_send_lsreq);
}
-
- return 0;
}
static void ospf6_send_lsupdate(struct ospf6_neighbor *on,
return length;
}
-int ospf6_lsupdate_send_neighbor(struct thread *thread)
+void ospf6_lsupdate_send_neighbor(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_packet *op;
SEND_HDR))
zlog_debug("Quit to send (neighbor state %s)",
ospf6_neighbor_state_str[on->state]);
- return 0;
+ return;
}
/* first do lsupdate_list */
on->ospf6_if->rxmt_interval,
&on->thread_send_lsupdate);
}
- return 0;
}
int ospf6_lsupdate_send_neighbor_now(struct ospf6_neighbor *on,
return length;
}
-int ospf6_lsupdate_send_interface(struct thread *thread)
+void ospf6_lsupdate_send_interface(struct thread *thread)
{
struct ospf6_interface *oi;
struct ospf6_packet *op;
"Quit to send LSUpdate to interface %s state %s",
oi->interface->name,
ospf6_interface_state_str[oi->state]);
- return 0;
+ return;
}
/* if we have nothing to send, return */
if (oi->lsupdate_list->count == 0)
- return 0;
+ return;
op = ospf6_packet_new(oi->ifmtu);
ospf6_make_header(OSPF6_MESSAGE_TYPE_LSUPDATE, oi, op->s);
thread_add_event(master, ospf6_lsupdate_send_interface, oi, 0,
&oi->thread_send_lsupdate);
}
-
- return 0;
}
-int ospf6_lsack_send_neighbor(struct thread *thread)
+void ospf6_lsack_send_neighbor(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_packet *op;
zlog_debug("Quit to send LSAck to neighbor %s state %s",
on->name,
ospf6_neighbor_state_str[on->state]);
- return 0;
+ return;
}
/* if we have nothing to send, return */
if (on->lsack_list->count == 0)
- return 0;
+ return;
op = ospf6_packet_new(on->ospf6_if->ifmtu);
ospf6_make_header(OSPF6_MESSAGE_TYPE_LSACK, on->ospf6_if, op->s);
if (length == OSPF6_HEADER_SIZE) {
ospf6_packet_free(op);
- return 0;
+ return;
}
/* Fill OSPF header. */
if (on->lsack_list->count > 0)
thread_add_event(master, ospf6_lsack_send_neighbor, on, 0,
&on->thread_send_lsack);
-
- return 0;
}
static uint16_t ospf6_make_lsack_interface(struct ospf6_interface *oi,
return length;
}
-int ospf6_lsack_send_interface(struct thread *thread)
+void ospf6_lsack_send_interface(struct thread *thread)
{
struct ospf6_interface *oi;
struct ospf6_packet *op;
"Quit to send LSAck to interface %s state %s",
oi->interface->name,
ospf6_interface_state_str[oi->state]);
- return 0;
+ return;
}
/* if we have nothing to send, return */
if (oi->lsack_list->count == 0)
- return 0;
+ return;
op = ospf6_packet_new(oi->ifmtu);
ospf6_make_header(OSPF6_MESSAGE_TYPE_LSACK, oi, op->s);
if (length == OSPF6_HEADER_SIZE) {
ospf6_packet_free(op);
- return 0;
+ return;
}
/* Fill OSPF header. */
ospf6_fill_header(oi, op->s, length);
if (oi->lsack_list->count > 0)
thread_add_event(master, ospf6_lsack_send_interface, oi, 0,
&oi->thread_send_lsack);
-
- return 0;
}
/* Commands */
extern int ospf6_iobuf_size(unsigned int size);
extern void ospf6_message_terminate(void);
-extern int ospf6_receive(struct thread *thread);
-
-extern int ospf6_hello_send(struct thread *thread);
-extern int ospf6_dbdesc_send(struct thread *thread);
-extern int ospf6_dbdesc_send_newone(struct thread *thread);
-extern int ospf6_lsreq_send(struct thread *thread);
-extern int ospf6_lsupdate_send_interface(struct thread *thread);
-extern int ospf6_lsupdate_send_neighbor(struct thread *thread);
-extern int ospf6_lsack_send_interface(struct thread *thread);
-extern int ospf6_lsack_send_neighbor(struct thread *thread);
+extern void ospf6_receive(struct thread *thread);
+
+extern void ospf6_hello_send(struct thread *thread);
+extern void ospf6_dbdesc_send(struct thread *thread);
+extern void ospf6_dbdesc_send_newone(struct thread *thread);
+extern void ospf6_lsreq_send(struct thread *thread);
+extern void ospf6_lsupdate_send_interface(struct thread *thread);
+extern void ospf6_lsupdate_send_neighbor(struct thread *thread);
+extern void ospf6_lsack_send_interface(struct thread *thread);
+extern void ospf6_lsack_send_neighbor(struct thread *thread);
extern int config_write_ospf6_debug_message(struct vty *);
extern void install_element_ospf6_debug_message(void);
return 0;
}
-int hello_received(struct thread *thread)
+void hello_received(struct thread *thread)
{
struct ospf6_neighbor *on;
if (on->state <= OSPF6_NEIGHBOR_DOWN)
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_INIT, on,
OSPF6_NEIGHBOR_EVENT_HELLO_RCVD);
-
- return 0;
}
-int twoway_received(struct thread *thread)
+void twoway_received(struct thread *thread)
{
struct ospf6_neighbor *on;
assert(on);
if (on->state > OSPF6_NEIGHBOR_INIT)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *2Way-Received*", on->name);
if (!need_adjacency(on)) {
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_TWOWAY, on,
OSPF6_NEIGHBOR_EVENT_TWOWAY_RCVD);
- return 0;
+ return;
}
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_EXSTART, on,
THREAD_OFF(on->thread_send_dbdesc);
thread_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
-
- return 0;
}
-int negotiation_done(struct thread *thread)
+void negotiation_done(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
assert(on);
if (on->state != OSPF6_NEIGHBOR_EXSTART)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *NegotiationDone*", on->name);
UNSET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_EXCHANGE, on,
OSPF6_NEIGHBOR_EVENT_NEGOTIATION_DONE);
-
- return 0;
}
-static int ospf6_neighbor_last_dbdesc_release(struct thread *thread)
+static void ospf6_neighbor_last_dbdesc_release(struct thread *thread)
{
struct ospf6_neighbor *on = THREAD_ARG(thread);
assert(on);
memset(&on->dbdesc_last, 0, sizeof(struct ospf6_dbdesc));
-
- return 0;
}
-int exchange_done(struct thread *thread)
+void exchange_done(struct thread *thread)
{
struct ospf6_neighbor *on;
assert(on);
if (on->state != OSPF6_NEIGHBOR_EXCHANGE)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *ExchangeDone*", on->name);
thread_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
}
-
- return 0;
}
/* Check loading state. */
}
}
-int loading_done(struct thread *thread)
+void loading_done(struct thread *thread)
{
struct ospf6_neighbor *on;
assert(on);
if (on->state != OSPF6_NEIGHBOR_LOADING)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *LoadingDone*", on->name);
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_FULL, on,
OSPF6_NEIGHBOR_EVENT_LOADING_DONE);
-
- return 0;
}
-int adj_ok(struct thread *thread)
+void adj_ok(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
ospf6_lsdb_remove(lsa, on->retrans_list);
}
}
-
- return 0;
}
-int seqnumber_mismatch(struct thread *thread)
+void seqnumber_mismatch(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
assert(on);
if (on->state < OSPF6_NEIGHBOR_EXCHANGE)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *SeqNumberMismatch*", on->name);
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
-
- return 0;
}
-int bad_lsreq(struct thread *thread)
+void bad_lsreq(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
assert(on);
if (on->state < OSPF6_NEIGHBOR_EXCHANGE)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *BadLSReq*", on->name);
thread_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
- return 0;
}
-int oneway_received(struct thread *thread)
+void oneway_received(struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
assert(on);
if (on->state < OSPF6_NEIGHBOR_TWOWAY)
- return 0;
+ return;
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *1Way-Received*", on->name);
THREAD_OFF(on->thread_send_lsack);
THREAD_OFF(on->thread_exchange_done);
THREAD_OFF(on->thread_adj_ok);
-
- return 0;
}
-int inactivity_timer(struct thread *thread)
+void inactivity_timer(struct thread *thread)
{
struct ospf6_neighbor *on;
on->ospf6_if->dead_interval,
&on->inactivity_timer);
}
-
- return 0;
}
void ospf6_neighbor_delete(struct ospf6_neighbor *on);
/* Neighbor event */
-extern int hello_received(struct thread *thread);
-extern int twoway_received(struct thread *thread);
-extern int negotiation_done(struct thread *thread);
-extern int exchange_done(struct thread *thread);
-extern int loading_done(struct thread *thread);
-extern int adj_ok(struct thread *thread);
-extern int seqnumber_mismatch(struct thread *thread);
-extern int bad_lsreq(struct thread *thread);
-extern int oneway_received(struct thread *thread);
-extern int inactivity_timer(struct thread *thread);
+extern void hello_received(struct thread *thread);
+extern void twoway_received(struct thread *thread);
+extern void negotiation_done(struct thread *thread);
+extern void exchange_done(struct thread *thread);
+extern void loading_done(struct thread *thread);
+extern void adj_ok(struct thread *thread);
+extern void seqnumber_mismatch(struct thread *thread);
+extern void bad_lsreq(struct thread *thread);
+extern void oneway_received(struct thread *thread);
+extern void inactivity_timer(struct thread *thread);
extern void ospf6_check_nbr_loading(struct ospf6_neighbor *on);
extern void ospf6_neighbor_init(void);
}
/* This function performs ABR related processing */
-static int ospf6_abr_task_timer(struct thread *thread)
+static void ospf6_abr_task_timer(struct thread *thread)
{
struct ospf6 *ospf6 = THREAD_ARG(thread);
ospf6_abr_task(ospf6);
/* if nssa-abr, then scan Type-7 LSDB */
ospf6_abr_nssa_task(ospf6);
-
- return 0;
}
void ospf6_schedule_abr_task(struct ospf6 *ospf6)
zlog_debug("%s", buffer);
}
-static int ospf6_spf_calculation_thread(struct thread *t)
+static void ospf6_spf_calculation_thread(struct thread *t)
{
struct ospf6_area *oa;
struct ospf6 *ospf6;
ospf6->last_spf_reason = ospf6->spf_reason;
ospf6_reset_spf_reason(ospf6);
- return 0;
}
/* Add schedule for SPF calculation. To avoid frequenst SPF calc, we
return 0;
}
-static int ospf6_ase_calculate_timer(struct thread *t)
+static void ospf6_ase_calculate_timer(struct thread *t)
{
struct ospf6 *ospf6;
struct ospf6_lsa *lsa;
ospf6_zebra_gr_disable(ospf6);
ospf6->gr_info.finishing_restart = false;
}
-
- return 0;
}
void ospf6_ase_calculate_timer_add(struct ospf6 *ospf6)
om6->master = master;
}
-static int ospf6_maxage_remover(struct thread *thread)
+static void ospf6_maxage_remover(struct thread *thread)
{
struct ospf6 *o = (struct ospf6 *)THREAD_ARG(thread);
struct ospf6_area *oa;
continue;
ospf6_maxage_remove(o);
- return 0;
+ return;
}
}
}
if (reschedule) {
ospf6_maxage_remove(o);
}
-
- return 0;
}
void ospf6_maxage_remove(struct ospf6 *o)
* ---------------------------------------------------------
*/
-static int lsa_delete(struct thread *t)
+static void lsa_delete(struct thread *t)
{
struct ospf_apiclient *oclient;
struct in_addr area_id;
rc = inet_aton(args[6], &area_id);
if (rc <= 0) {
printf("Address Specified: %s is invalid\n", args[6]);
- return rc;
+ return;
}
printf("Deleting LSA... ");
atoi(args[3]), /* opaque type */
atoi(args[4])); /* opaque ID */
printf("done, return code is = %d\n", rc);
- return rc;
}
-static int lsa_inject(struct thread *t)
+static void lsa_inject(struct thread *t)
{
struct ospf_apiclient *cl;
struct in_addr ifaddr;
rc = inet_aton(args[5], &ifaddr);
if (rc <= 0) {
printf("Ifaddr specified %s is invalid\n", args[5]);
- return rc;
+ return;
}
rc = inet_aton(args[6], &area_id);
if (rc <= 0) {
printf("Area ID specified %s is invalid\n", args[6]);
- return rc;
+ return;
}
lsa_type = atoi(args[2]);
opaque_type = atoi(args[3]);
printf("done, return code is %d\n", rc);
counter++;
-
- return 0;
}
/* This thread handles asynchronous messages coming in from the OSPF
API server */
-static int lsa_read(struct thread *thread)
+static void lsa_read(struct thread *thread)
{
struct ospf_apiclient *oclient;
int fd;
/* Reschedule read thread */
thread_add_read(master, lsa_read, oclient, fd, NULL);
-
- return 0;
}
/* ---------------------------------------------------------
zlog_debug("ospf_abr_task(): Stop");
}
-static int ospf_abr_task_timer(struct thread *thread)
+static void ospf_abr_task_timer(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
ospf_abr_task(ospf);
ospf_abr_nssa_task(ospf); /* if nssa-abr, then scan Type-7 LSDB */
-
- return 0;
}
void ospf_schedule_abr_task(struct ospf *ospf)
XFREE(MTYPE_OSPF_APISERVER, apiserv);
}
-int ospf_apiserver_read(struct thread *thread)
+void ospf_apiserver_read(struct thread *thread)
{
struct ospf_apiserver *apiserv;
struct msg *msg;
int fd;
- int rc = -1;
enum event event;
apiserv = THREAD_ARG(thread);
else {
zlog_warn("ospf_apiserver_read: Unknown fd(%d)", fd);
ospf_apiserver_free(apiserv);
- goto out;
+ return;
}
/* Read message from fd. */
/* Perform cleanup. */
ospf_apiserver_free(apiserv);
- goto out;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
msg_print(msg);
/* Dispatch to corresponding message handler. */
- rc = ospf_apiserver_handle_msg(apiserv, msg);
+ ospf_apiserver_handle_msg(apiserv, msg);
/* Prepare for next message, add read thread. */
ospf_apiserver_event(event, fd, apiserv);
msg_free(msg);
-
-out:
- return rc;
}
-int ospf_apiserver_sync_write(struct thread *thread)
+void ospf_apiserver_sync_write(struct thread *thread)
{
struct ospf_apiserver *apiserv;
struct msg *msg;
if (!msg) {
zlog_warn(
"API: ospf_apiserver_sync_write: No message in Sync-FIFO?");
- return 0;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
/* Perform cleanup and disconnect with peer */
ospf_apiserver_free(apiserv);
}
-
- return rc;
}
-int ospf_apiserver_async_write(struct thread *thread)
+void ospf_apiserver_async_write(struct thread *thread)
{
struct ospf_apiserver *apiserv;
struct msg *msg;
if (!msg) {
zlog_warn(
"API: ospf_apiserver_async_write: No message in Async-FIFO?");
- return 0;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
/* Perform cleanup and disconnect with peer */
ospf_apiserver_free(apiserv);
}
-
- return rc;
}
/* Accept connection request from external applications. For each
accepted connection allocate own connection instance. */
-int ospf_apiserver_accept(struct thread *thread)
+void ospf_apiserver_accept(struct thread *thread)
{
int accept_sock;
int new_sync_sock;
if (new_sync_sock < 0) {
zlog_warn("ospf_apiserver_accept: accept: %s",
safe_strerror(errno));
- return -1;
+ return;
}
/* Get port address and port number of peer to make reverse connection.
zlog_warn("ospf_apiserver_accept: getpeername: %s",
safe_strerror(errno));
close(new_sync_sock);
- return -1;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
&peer_async.sin_addr,
ntohs(peer_async.sin_port));
close(new_sync_sock);
- return -1;
+ return;
}
new_async_sock = socket(AF_INET, SOCK_STREAM, 0);
zlog_warn("ospf_apiserver_accept: socket: %s",
safe_strerror(errno));
close(new_sync_sock);
- return -1;
+ return;
}
ret = connect(new_async_sock, (struct sockaddr *)&peer_async,
safe_strerror(errno));
close(new_sync_sock);
close(new_async_sock);
- return -1;
+ return;
}
#ifdef USE_ASYNC_READ
safe_strerror(errno));
close(new_sync_sock);
close(new_async_sock);
- return -1;
+ return;
}
#endif /* USE_ASYNC_READ */
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("API: New apiserv(%p), total#(%d)", (void *)apiserv,
apiserver_list->count);
-
- return 0;
}
extern void ospf_apiserver_event(enum event event, int fd,
struct ospf_apiserver *apiserv);
extern int ospf_apiserver_serv_sock_family(unsigned short port, int family);
-extern int ospf_apiserver_accept(struct thread *thread);
-extern int ospf_apiserver_read(struct thread *thread);
-extern int ospf_apiserver_sync_write(struct thread *thread);
-extern int ospf_apiserver_async_write(struct thread *thread);
+extern void ospf_apiserver_accept(struct thread *thread);
+extern void ospf_apiserver_read(struct thread *thread);
+extern void ospf_apiserver_sync_write(struct thread *thread);
+extern void ospf_apiserver_async_write(struct thread *thread);
extern int ospf_apiserver_send_reply(struct ospf_apiserver *apiserv,
uint32_t seqnr, uint8_t rc);
/* If there's redistribution configured, we need to refresh external
* LSAs in order to install Type-7 and flood to all NSSA Areas
*/
-static int ospf_asbr_nssa_redist_update_timer(struct thread *thread)
+static void ospf_asbr_nssa_redist_update_timer(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
int type;
}
ospf_external_lsa_refresh_default(ospf);
-
- return 0;
}
void ospf_schedule_asbr_nssa_redist_update(struct ospf *ospf)
}
}
-static int ospf_asbr_external_aggr_process(struct thread *thread)
+static void ospf_asbr_external_aggr_process(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
int operation = 0;
default:
break;
}
-
- return OSPF_SUCCESS;
}
static void ospf_external_aggr_timer(struct ospf *ospf,
struct ospf_external_aggr_rt *aggr,
return 0;
}
-static int ospf_ase_calculate_timer(struct thread *t)
+static void ospf_ase_calculate_timer(struct thread *t)
{
struct ospf *ospf;
struct ospf_lsa *lsa;
ospf_zebra_gr_disable(ospf);
ospf->gr_info.finishing_restart = false;
}
-
- return 0;
}
void ospf_ase_calculate_schedule(struct ospf *ospf)
}
/* Handling of grace period expiry. */
-static int ospf_gr_grace_period_expired(struct thread *thread)
+static void ospf_gr_grace_period_expired(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
ospf->gr_info.t_grace_period = NULL;
ospf_gr_restart_exit(ospf, "grace period has expired");
-
- return 0;
}
/*
* Returns:
* Nothing
*/
-static int ospf_handle_grace_timer_expiry(struct thread *thread)
+static void ospf_handle_grace_timer_expiry(struct thread *thread)
{
struct ospf_neighbor *nbr = THREAD_ARG(thread);
nbr->gr_helper_info.t_grace_timer = NULL;
ospf_gr_helper_exit(nbr, OSPF_GR_HELPER_GRACE_TIMEOUT);
- return OSPF_GR_SUCCESS;
}
/*
}
-int ospf_hello_timer(struct thread *thread)
+void ospf_hello_timer(struct thread *thread)
{
struct ospf_interface *oi;
/* Hello timer set. */
OSPF_HELLO_TIMER_ON(oi);
-
- return 0;
}
-static int ospf_wait_timer(struct thread *thread)
+static void ospf_wait_timer(struct thread *thread)
{
struct ospf_interface *oi;
zlog_debug("ISM[%s]: Timer (Wait timer expire)", IF_NAME(oi));
OSPF_ISM_EVENT_SCHEDULE(oi, ISM_WaitTimer);
-
- return 0;
}
/* Hook function called after ospf ISM event is occurred. And vty's
}
/* Execute ISM event process. */
-int ospf_ism_event(struct thread *thread)
+void ospf_ism_event(struct thread *thread)
{
int event;
int next_state;
/* Make sure timer is set. */
ism_timer_set(oi);
-
- return 0;
}
thread_execute(master, ospf_ism_event, (I), (E))
/* Prototypes. */
-extern int ospf_ism_event(struct thread *);
+extern void ospf_ism_event(struct thread *thread);
extern void ism_change_status(struct ospf_interface *, int);
-extern int ospf_hello_timer(struct thread *thread);
+extern void ospf_hello_timer(struct thread *thread);
extern int ospf_dr_election(struct ospf_interface *oi);
DECLARE_HOOK(ospf_ism_change,
/*
* LDP-SYNC holddown timer routines
*/
-static int ospf_ldp_sync_holddown_timer(struct thread *thread)
+static void ospf_ldp_sync_holddown_timer(struct thread *thread)
{
struct interface *ifp;
struct ospf_if_params *params;
ospf_if_recalculate_output_cost(ifp);
}
- return 0;
}
void ospf_ldp_sync_holddown_timer_add(struct interface *ifp)
stream_putw_at(*s, putp, cnt);
}
-static int ospf_stub_router_timer(struct thread *t)
+static void ospf_stub_router_timer(struct thread *t)
{
struct ospf_area *area = THREAD_ARG(t);
* clobber an administratively set stub-router state though.
*/
if (CHECK_FLAG(area->stub_router_state, OSPF_AREA_ADMIN_STUB_ROUTED))
- return 0;
+ return;
UNSET_FLAG(area->stub_router_state, OSPF_AREA_IS_STUB_ROUTED);
ospf_router_lsa_update_area(area);
-
- return 0;
}
static void ospf_stub_router_check(struct ospf_area *area)
}
-static int ospf_maxage_lsa_remover(struct thread *thread)
+static void ospf_maxage_lsa_remover(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
struct ospf_lsa *lsa, *old;
ospf_maxage_lsa_remover, 0);
route_unlock_node(
rn); /* route_top/route_next */
- return 0;
+ return;
}
/* Remove LSA from the LSDB */
if (reschedule)
OSPF_TIMER_ON(ospf->t_maxage, ospf_maxage_lsa_remover,
ospf->maxage_delay);
-
- return 0;
}
/* This function checks whether an LSA with initial sequence number should be
}
/* Periodical check of MaxAge LSA. */
-int ospf_lsa_maxage_walker(struct thread *thread)
+void ospf_lsa_maxage_walker(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
struct route_node *rn;
OSPF_TIMER_ON(ospf->t_maxage_walker, ospf_lsa_maxage_walker,
OSPF_LSA_MAXAGE_CHECK_INTERVAL);
- return 0;
}
struct ospf_lsa *ospf_lsa_lookup_by_prefix(struct ospf_lsdb *lsdb, uint8_t type,
struct ospf_lsa *lsa;
};
-static int ospf_lsa_action(struct thread *t)
+static void ospf_lsa_action(struct thread *t)
{
struct lsa_action *data;
ospf_lsa_unlock(&data->lsa); /* Message */
XFREE(MTYPE_OSPF_MESSAGE, data);
- return 0;
}
void ospf_schedule_lsa_flood_area(struct ospf_area *area, struct ospf_lsa *lsa)
}
}
-int ospf_lsa_refresh_walker(struct thread *t)
+void ospf_lsa_refresh_walker(struct thread *t)
{
struct list *refresh_list;
struct listnode *node, *nnode;
if (IS_DEBUG_OSPF(lsa, LSA_REFRESH))
zlog_debug("LSA[Refresh]: ospf_lsa_refresh_walker(): end");
-
- return 0;
}
/* Flush the LSAs for the specific area */
extern void ospf_lsa_maxage(struct ospf *, struct ospf_lsa *);
extern uint32_t get_metric(uint8_t *);
-extern int ospf_lsa_maxage_walker(struct thread *);
+extern void ospf_lsa_maxage_walker(struct thread *thread);
extern struct ospf_lsa *ospf_lsa_refresh(struct ospf *, struct ospf_lsa *);
extern void ospf_external_lsa_refresh_default(struct ospf *);
extern void ospf_refresher_register_lsa(struct ospf *, struct ospf_lsa *);
extern void ospf_refresher_unregister_lsa(struct ospf *, struct ospf_lsa *);
-extern int ospf_lsa_refresh_walker(struct thread *);
+extern void ospf_lsa_refresh_walker(struct thread *thread);
extern void ospf_lsa_maxage_delete(struct ospf *, struct ospf_lsa *);
static void nsm_clear_adj(struct ospf_neighbor *);
/* OSPF NSM Timer functions. */
-static int ospf_inactivity_timer(struct thread *thread)
+static void ospf_inactivity_timer(struct thread *thread)
{
struct ospf_neighbor *nbr;
OSPF_NSM_TIMER_ON(nbr->t_inactivity, ospf_inactivity_timer,
nbr->v_inactivity);
}
-
- return 0;
}
-static int ospf_db_desc_timer(struct thread *thread)
+static void ospf_db_desc_timer(struct thread *thread)
{
struct ospf_neighbor *nbr;
/* DD Retransmit timer set. */
OSPF_NSM_TIMER_ON(nbr->t_db_desc, ospf_db_desc_timer, nbr->v_db_desc);
-
- return 0;
}
/* Hook function called after ospf NSM event is occurred.
}
/* Execute NSM event process. */
-int ospf_nsm_event(struct thread *thread)
+void ospf_nsm_event(struct thread *thread)
{
int event;
int next_state;
*/
if (nbr->state == NSM_Deleted)
ospf_nbr_delete(nbr);
-
- return 0;
}
/* Check loading state. */
thread_execute(master, ospf_nsm_event, (N), (E))
/* Prototypes. */
-extern int ospf_nsm_event(struct thread *);
+extern void ospf_nsm_event(struct thread *);
extern void ospf_check_nbr_loading(struct ospf_neighbor *);
extern int ospf_db_summary_isempty(struct ospf_neighbor *);
extern int ospf_db_summary_count(struct ospf_neighbor *);
* Followings are Opaque-LSA origination/refresh management functions.
*------------------------------------------------------------------------*/
-static int ospf_opaque_type9_lsa_originate(struct thread *t);
-static int ospf_opaque_type10_lsa_originate(struct thread *t);
-static int ospf_opaque_type11_lsa_originate(struct thread *t);
+static void ospf_opaque_type9_lsa_originate(struct thread *t);
+static void ospf_opaque_type10_lsa_originate(struct thread *t);
+static void ospf_opaque_type11_lsa_originate(struct thread *t);
static void ospf_opaque_lsa_reoriginate_resume(struct list *listtop, void *arg);
void ospf_opaque_lsa_originate_schedule(struct ospf_interface *oi, int *delay0)
*delay0 = delay;
}
-static int ospf_opaque_type9_lsa_originate(struct thread *t)
+static void ospf_opaque_type9_lsa_originate(struct thread *t)
{
struct ospf_interface *oi;
- int rc;
oi = THREAD_ARG(t);
oi->t_opaque_lsa_self = NULL;
zlog_debug("Timer[Type9-LSA]: Originate Opaque-LSAs for OI %s",
IF_NAME(oi));
- rc = opaque_lsa_originate_callback(ospf_opaque_type9_funclist, oi);
-
- return rc;
+ opaque_lsa_originate_callback(ospf_opaque_type9_funclist, oi);
}
-static int ospf_opaque_type10_lsa_originate(struct thread *t)
+static void ospf_opaque_type10_lsa_originate(struct thread *t)
{
struct ospf_area *area;
- int rc;
area = THREAD_ARG(t);
area->t_opaque_lsa_self = NULL;
"Timer[Type10-LSA]: Originate Opaque-LSAs for Area %pI4",
&area->area_id);
- rc = opaque_lsa_originate_callback(ospf_opaque_type10_funclist, area);
-
- return rc;
+ opaque_lsa_originate_callback(ospf_opaque_type10_funclist, area);
}
-static int ospf_opaque_type11_lsa_originate(struct thread *t)
+static void ospf_opaque_type11_lsa_originate(struct thread *t)
{
struct ospf *top;
- int rc;
top = THREAD_ARG(t);
top->t_opaque_lsa_self = NULL;
zlog_debug(
"Timer[Type11-LSA]: Originate AS-External Opaque-LSAs");
- rc = opaque_lsa_originate_callback(ospf_opaque_type11_funclist, top);
-
- return rc;
+ opaque_lsa_originate_callback(ospf_opaque_type11_funclist, top);
}
static void ospf_opaque_lsa_reoriginate_resume(struct list *listtop, void *arg)
static struct ospf_lsa *pseudo_lsa(struct ospf_interface *oi,
struct ospf_area *area, uint8_t lsa_type,
uint8_t opaque_type);
-static int ospf_opaque_type9_lsa_reoriginate_timer(struct thread *t);
-static int ospf_opaque_type10_lsa_reoriginate_timer(struct thread *t);
-static int ospf_opaque_type11_lsa_reoriginate_timer(struct thread *t);
-static int ospf_opaque_lsa_refresh_timer(struct thread *t);
+static void ospf_opaque_type9_lsa_reoriginate_timer(struct thread *t);
+static void ospf_opaque_type10_lsa_reoriginate_timer(struct thread *t);
+static void ospf_opaque_type11_lsa_reoriginate_timer(struct thread *t);
+static void ospf_opaque_lsa_refresh_timer(struct thread *t);
void ospf_opaque_lsa_reoriginate_schedule(void *lsa_type_dependent,
uint8_t lsa_type, uint8_t opaque_type)
struct ospf_lsa *lsa;
struct opaque_info_per_type *oipt;
- int (*func)(struct thread * t) = NULL;
+ void (*func)(struct thread * t) = NULL;
int delay;
switch (lsa_type) {
return &lsa;
}
-static int ospf_opaque_type9_lsa_reoriginate_timer(struct thread *t)
+static void ospf_opaque_type9_lsa_reoriginate_timer(struct thread *t)
{
struct opaque_info_per_type *oipt;
struct ospf_opaque_functab *functab;
struct ospf *top;
struct ospf_interface *oi;
- int rc = -1;
oipt = THREAD_ARG(t);
flog_warn(
EC_OSPF_LSA,
"ospf_opaque_type9_lsa_reoriginate_timer: No associated function?");
- goto out;
+ return;
}
oi = (struct ospf_interface *)oipt->owner;
flog_warn(
EC_OSPF_LSA,
"ospf_opaque_type9_lsa_reoriginate_timer: Something wrong?");
- goto out;
+ return;
}
if (!CHECK_FLAG(top->config, OSPF_OPAQUE_CAPABLE)
oipt->opaque_type);
oipt->status = PROC_SUSPEND;
- rc = 0;
- goto out;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
"Timer[Type9-LSA]: Re-originate Opaque-LSAs (opaque-type=%u) for OI (%s)",
oipt->opaque_type, IF_NAME(oi));
- rc = (*functab->lsa_originator)(oi);
-out:
- return rc;
+ (*functab->lsa_originator)(oi);
}
-static int ospf_opaque_type10_lsa_reoriginate_timer(struct thread *t)
+static void ospf_opaque_type10_lsa_reoriginate_timer(struct thread *t)
{
struct opaque_info_per_type *oipt;
struct ospf_opaque_functab *functab;
struct ospf *top;
struct ospf_area *area;
struct ospf_interface *oi;
- int n, rc = -1;
+ int n;
oipt = THREAD_ARG(t);
flog_warn(
EC_OSPF_LSA,
"ospf_opaque_type10_lsa_reoriginate_timer: No associated function?");
- goto out;
+ return;
}
area = (struct ospf_area *)oipt->owner;
flog_warn(
EC_OSPF_LSA,
"ospf_opaque_type10_lsa_reoriginate_timer: Something wrong?");
- goto out;
+ return;
}
/* There must be at least one "opaque-capable, full-state" neighbor. */
oipt->opaque_type);
oipt->status = PROC_SUSPEND;
- rc = 0;
- goto out;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
"Timer[Type10-LSA]: Re-originate Opaque-LSAs (opaque-type=%u) for Area %pI4",
oipt->opaque_type, &area->area_id);
- rc = (*functab->lsa_originator)(area);
-out:
- return rc;
+ (*functab->lsa_originator)(area);
}
-static int ospf_opaque_type11_lsa_reoriginate_timer(struct thread *t)
+static void ospf_opaque_type11_lsa_reoriginate_timer(struct thread *t)
{
struct opaque_info_per_type *oipt;
struct ospf_opaque_functab *functab;
struct ospf *top;
- int rc = -1;
oipt = THREAD_ARG(t);
flog_warn(
EC_OSPF_LSA,
"ospf_opaque_type11_lsa_reoriginate_timer: No associated function?");
- goto out;
+ return;
}
if ((top = (struct ospf *)oipt->owner) == NULL) {
flog_warn(
EC_OSPF_LSA,
"ospf_opaque_type11_lsa_reoriginate_timer: Something wrong?");
- goto out;
+ return;
}
if (!CHECK_FLAG(top->config, OSPF_OPAQUE_CAPABLE)) {
oipt->opaque_type);
oipt->status = PROC_SUSPEND;
- rc = 0;
- goto out;
+ return;
}
if (IS_DEBUG_OSPF_EVENT)
"Timer[Type11-LSA]: Re-originate Opaque-LSAs (opaque-type=%u).",
oipt->opaque_type);
- rc = (*functab->lsa_originator)(top);
-out:
- return rc;
+ (*functab->lsa_originator)(top);
}
void ospf_opaque_lsa_refresh_schedule(struct ospf_lsa *lsa0)
return;
}
-static int ospf_opaque_lsa_refresh_timer(struct thread *t)
+static void ospf_opaque_lsa_refresh_timer(struct thread *t)
{
struct opaque_info_per_id *oipi;
struct ospf_opaque_functab *functab;
if ((functab = oipi->opqctl_type->functab) != NULL)
if (functab->lsa_refresher != NULL)
(*functab->lsa_refresher)(lsa);
-
- return 0;
}
void ospf_opaque_lsa_flush_schedule(struct ospf_lsa *lsa0)
}
-static int ospf_ls_req_timer(struct thread *thread)
+static void ospf_ls_req_timer(struct thread *thread)
{
struct ospf_neighbor *nbr;
/* Set Link State Request retransmission timer. */
OSPF_NSM_TIMER_ON(nbr->t_ls_req, ospf_ls_req_timer, nbr->v_ls_req);
-
- return 0;
}
void ospf_ls_req_event(struct ospf_neighbor *nbr)
/* Cyclic timer function. Fist registered in ospf_nbr_new () in
ospf_neighbor.c */
-int ospf_ls_upd_timer(struct thread *thread)
+void ospf_ls_upd_timer(struct thread *thread)
{
struct ospf_neighbor *nbr;
/* Set LS Update retransmission timer. */
OSPF_NSM_TIMER_ON(nbr->t_ls_upd, ospf_ls_upd_timer, nbr->v_ls_upd);
-
- return 0;
}
-int ospf_ls_ack_timer(struct thread *thread)
+void ospf_ls_ack_timer(struct thread *thread)
{
struct ospf_interface *oi;
/* Set LS Ack timer. */
OSPF_ISM_TIMER_ON(oi->t_ls_ack, ospf_ls_ack_timer, oi->v_ls_ack);
-
- return 0;
}
#ifdef WANT_OSPF_WRITE_FRAGMENT
}
#endif /* WANT_OSPF_WRITE_FRAGMENT */
-static int ospf_write(struct thread *thread)
+static void ospf_write(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
struct ospf_interface *oi;
zlog_debug(
"ospf_write failed to send, fd %d, instance %u",
ospf->fd, ospf->oi_running);
- return -1;
+ return;
}
node = listhead(ospf->oi_write_q);
if (!list_isempty(ospf->oi_write_q))
thread_add_write(master, ospf_write, ospf, ospf->fd,
&ospf->t_write);
-
- return 0;
}
/* OSPF Hello message read -- RFC2328 Section 10.5. */
}
/* Starting point of packet process function. */
-int ospf_read(struct thread *thread)
+void ospf_read(struct thread *thread)
{
struct ospf *ospf;
int32_t count = 0;
ret = ospf_read_helper(ospf);
switch (ret) {
case OSPF_READ_ERROR:
- return -1;
+ return;
case OSPF_READ_CONTINUE:
break;
}
}
-
- return 0;
}
/* Make OSPF header. */
ospf_hello_send_sub(oi, nbr_nbma->addr.s_addr);
}
-int ospf_poll_timer(struct thread *thread)
+void ospf_poll_timer(struct thread *thread)
{
struct ospf_nbr_nbma *nbr_nbma;
if (nbr_nbma->v_poll > 0)
OSPF_POLL_TIMER_ON(nbr_nbma->t_poll, ospf_poll_timer,
nbr_nbma->v_poll);
-
- return 0;
}
-int ospf_hello_reply_timer(struct thread *thread)
+void ospf_hello_reply_timer(struct thread *thread)
{
struct ospf_neighbor *nbr;
IF_NAME(nbr->oi), &nbr->router_id);
ospf_hello_send_sub(nbr->oi, nbr->address.u.prefix4.s_addr);
-
- return 0;
}
/* Send OSPF Hello. */
}
}
-static int ospf_ls_upd_send_queue_event(struct thread *thread)
+static void ospf_ls_upd_send_queue_event(struct thread *thread)
{
struct ospf_interface *oi = THREAD_ARG(thread);
struct route_node *rn;
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("ospf_ls_upd_send_queue stop");
-
- return 0;
}
void ospf_ls_upd_send(struct ospf_neighbor *nbr, struct list *update, int flag,
OSPF_ISM_WRITE_ON(oi->ospf);
}
-static int ospf_ls_ack_send_event(struct thread *thread)
+static void ospf_ls_ack_send_event(struct thread *thread)
{
struct ospf_interface *oi = THREAD_ARG(thread);
while (listcount(oi->ls_ack_direct.ls_ack))
ospf_ls_ack_send_list(oi, oi->ls_ack_direct.ls_ack,
oi->ls_ack_direct.dst);
-
- return 0;
}
void ospf_ls_ack_send(struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
extern void ospf_fifo_flush(struct ospf_fifo *);
extern void ospf_fifo_free(struct ospf_fifo *);
-extern int ospf_read(struct thread *);
+extern void ospf_read(struct thread *thread);
extern void ospf_hello_send(struct ospf_interface *);
extern void ospf_db_desc_send(struct ospf_neighbor *);
extern void ospf_db_desc_resend(struct ospf_neighbor *);
extern void ospf_ls_retransmit(struct ospf_interface *, struct ospf_lsa *);
extern void ospf_ls_req_event(struct ospf_neighbor *);
-extern int ospf_ls_upd_timer(struct thread *);
-extern int ospf_ls_ack_timer(struct thread *);
-extern int ospf_poll_timer(struct thread *);
-extern int ospf_hello_reply_timer(struct thread *);
+extern void ospf_ls_upd_timer(struct thread *thread);
+extern void ospf_ls_ack_timer(struct thread *thread);
+extern void ospf_poll_timer(struct thread *thread);
+extern void ospf_hello_reply_timer(struct thread *thread);
extern const struct message ospf_packet_type_str[];
extern const size_t ospf_packet_type_str_max;
}
/* Worker for SPF calculation scheduler. */
-static int ospf_spf_calculate_schedule_worker(struct thread *thread)
+static void ospf_spf_calculate_schedule_worker(struct thread *thread)
{
struct ospf *ospf = THREAD_ARG(thread);
struct route_table *new_table, *new_rtrs;
}
ospf_clear_spf_reason_flags();
-
- return 0;
}
/*
*
* @return 1 on success
*/
-static int sr_start_label_manager(struct thread *start)
+static void sr_start_label_manager(struct thread *start)
{
struct ospf *ospf;
/* re-attempt to start SR & Label Manager connection */
ospf_sr_start(ospf);
-
- return 1;
}
/* Segment Routing starter function */
* Function to originate or flush default after applying
* route-map on all ei.
*/
-static int ospf_external_lsa_default_routemap_timer(struct thread *thread)
+static void ospf_external_lsa_default_routemap_timer(struct thread *thread)
{
struct list *ext_list;
struct ospf *ospf = THREAD_ARG(thread);
/* Nothing to be done here. */
if (IS_DEBUG_OSPF_DEFAULT_INFO)
zlog_debug("Default originate info not present");
- return 0;
+ return;
}
/* For all the ei apply route-map */
ospf_external_lsa_refresh(ospf, lsa, default_ei, true, false);
else if (!ret && lsa)
ospf_external_lsa_flush(ospf, DEFAULT_ROUTE, &default_ei->p, 0);
-
- return 1;
}
}
/* distribute-list update timer. */
-static int ospf_distribute_list_update_timer(struct thread *thread)
+static void ospf_distribute_list_update_timer(struct thread *thread)
{
struct route_node *rn;
struct external_info *ei;
struct ospf *ospf = THREAD_ARG(thread);
if (ospf == NULL)
- return 0;
+ return;
ospf->t_distribute_update = NULL;
}
if (default_refresh)
ospf_external_lsa_refresh_default(ospf);
-
- return 0;
}
/* Update distribute-list and set timer to apply access-list. */
}
/* Timer thread for G-R */
-static int ospf_deferred_shutdown_timer(struct thread *t)
+static void ospf_deferred_shutdown_timer(struct thread *t)
{
struct ospf *ospf = THREAD_ARG(t);
ospf_deferred_shutdown_finish(ospf);
-
- return 0;
}
/* Check whether deferred-shutdown must be scheduled, otherwise call
/* Internal Functions Called From Main Thread */
static int pcep_ctrl_halt_cb(struct frr_pthread *fpt, void **res);
-static int pcep_refine_path_event_cb(struct thread *thread);
+static void pcep_refine_path_event_cb(struct thread *thread);
/* Internal Functions Called From Controller Thread */
-static int pcep_thread_finish_event_handler(struct thread *thread);
+static void pcep_thread_finish_event_handler(struct thread *thread);
/* Controller Thread Timer Handler */
static int schedule_thread_timer(struct ctrl_state *ctrl_state, int pcc_id,
enum pcep_ctrl_timer_type timer_type,
enum pcep_ctrl_timeout_type timeout_type, uint32_t delay, void *payload,
struct thread **thread, pcep_ctrl_thread_callback timer_cb);
-static int pcep_thread_timer_handler(struct thread *thread);
+static void pcep_thread_timer_handler(struct thread *thread);
/* Controller Thread Socket read/write Handler */
static int schedule_thread_socket(struct ctrl_state *ctrl_state, int pcc_id,
enum pcep_ctrl_event_type type,
uint32_t sub_type, void *payload,
pcep_ctrl_thread_callback event_cb);
-static int pcep_thread_event_handler(struct thread *thread);
+static void pcep_thread_event_handler(struct thread *thread);
static int pcep_thread_event_update_pcc_options(struct ctrl_state *ctrl_state,
struct pcc_opts *opts);
static int pcep_thread_event_update_pce_options(struct ctrl_state *ctrl_state,
/* Main Thread Event Handler */
static int send_to_main(struct ctrl_state *ctrl_state, int pcc_id,
enum pcep_main_event_type type, void *payload);
-static int pcep_main_event_handler(struct thread *thread);
+static void pcep_main_event_handler(struct thread *thread);
/* Helper functions */
static void set_ctrl_state(struct frr_pthread *fpt,
return 0;
}
-int pcep_refine_path_event_cb(struct thread *thread)
+void pcep_refine_path_event_cb(struct thread *thread)
{
struct pcep_refine_path_event_data *data = THREAD_ARG(thread);
assert(data != NULL);
path_pcep_refine_path(path);
- return send_to_thread(ctrl_state, pcc_id, EV_PATH_REFINED, 0, data);
+ send_to_thread(ctrl_state, pcc_id, EV_PATH_REFINED, 0, data);
}
/* ------------ Internal Functions Called From Controller Thread ------------ */
-int pcep_thread_finish_event_handler(struct thread *thread)
+void pcep_thread_finish_event_handler(struct thread *thread)
{
int i;
struct frr_pthread *fpt = THREAD_ARG(thread);
fpt->data = NULL;
atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
- return 0;
}
/* ------------ Controller Thread Timer Handler ------------ */
thread, pcep_thread_timer_handler);
}
-int pcep_thread_timer_handler(struct thread *thread)
+void pcep_thread_timer_handler(struct thread *thread)
{
/* data unpacking */
struct pcep_ctrl_timer_data *data = THREAD_ARG(thread);
void *param = data->payload;
XFREE(MTYPE_PCEP, data);
- int ret = 0;
struct pcc_state *pcc_state = NULL;
switch (timer_type) {
case TM_RECONNECT_PCC:
pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
if (!pcc_state)
- return ret;
+ return;
pcep_pcc_reconnect(ctrl_state, pcc_state);
break;
case TM_TIMEOUT:
pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
if (!pcc_state)
- return ret;
+ return;
pcep_pcc_timeout_handler(ctrl_state, pcc_state, timeout_type,
param);
break;
case TM_CALCULATE_BEST_PCE:
/* Previous best disconnect so new best should be synced */
- ret = pcep_pcc_timer_update_best_pce(ctrl_state, pcc_id);
+ pcep_pcc_timer_update_best_pce(ctrl_state, pcc_id);
break;
case TM_SESSION_TIMEOUT_PCC:
pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
"Unknown controller timer triggered: %u", timer_type);
break;
}
-
- return ret;
}
-int pcep_thread_pcep_event(struct thread *thread)
+void pcep_thread_pcep_event(struct thread *thread)
{
struct pcep_ctrl_event_data *data = THREAD_ARG(thread);
assert(data != NULL);
}
}
destroy_pcep_event(event);
-
- return 0;
}
/* ------------ Controller Thread Socket Functions ------------ */
return 0;
}
-int pcep_thread_event_handler(struct thread *thread)
+void pcep_thread_event_handler(struct thread *thread)
{
/* data unpacking */
struct pcep_ctrl_event_data *data = THREAD_ARG(thread);
void *payload = data->payload;
XFREE(MTYPE_PCEP, data);
- int ret = 0;
-
/* Possible sub-type values */
enum pcep_pathd_event_type path_event_type = PCEP_PATH_UNDEFINED;
case EV_UPDATE_PCC_OPTS:
assert(payload != NULL);
pcc_opts = (struct pcc_opts *)payload;
- ret = pcep_thread_event_update_pcc_options(ctrl_state,
- pcc_opts);
+ pcep_thread_event_update_pcc_options(ctrl_state, pcc_opts);
break;
case EV_UPDATE_PCE_OPTS:
assert(payload != NULL);
pce_opts = (struct pce_opts *)payload;
- ret = pcep_thread_event_update_pce_options(ctrl_state, pcc_id,
- pce_opts);
+ pcep_thread_event_update_pce_options(ctrl_state, pcc_id,
+ pce_opts);
break;
case EV_REMOVE_PCC:
pce_opts = (struct pce_opts *)payload;
- ret = pcep_thread_event_remove_pcc(ctrl_state, pce_opts);
- if (ret == 0) {
- ret = pcep_pcc_multi_pce_remove_pcc(ctrl_state,
- ctrl_state->pcc);
- }
+ if (pcep_thread_event_remove_pcc(ctrl_state, pce_opts) == 0)
+ pcep_pcc_multi_pce_remove_pcc(ctrl_state,
+ ctrl_state->pcc);
break;
case EV_PATHD_EVENT:
assert(payload != NULL);
path_event_type = (enum pcep_pathd_event_type)sub_type;
path = (struct path *)payload;
- ret = pcep_thread_event_pathd_event(ctrl_state, path_event_type,
- path);
+ pcep_thread_event_pathd_event(ctrl_state, path_event_type,
+ path);
break;
case EV_SYNC_PATH:
assert(payload != NULL);
pcep_thread_event_sync_path(ctrl_state, pcc_id, path);
break;
case EV_SYNC_DONE:
- ret = pcep_thread_event_sync_done(ctrl_state, pcc_id);
+ pcep_thread_event_sync_done(ctrl_state, pcc_id);
break;
case EV_RESET_PCC_SESSION:
pcc_state = pcep_pcc_get_pcc_by_name(ctrl_state->pcc,
(const char *)payload);
if (pcc_state) {
pcep_pcc_disable(ctrl_state, pcc_state);
- ret = pcep_pcc_enable(ctrl_state, pcc_state);
+ pcep_pcc_enable(ctrl_state, pcc_state);
} else {
flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
"Cannot reset state for PCE: %s",
type);
break;
}
-
- return ret;
}
int pcep_thread_event_update_pcc_options(struct ctrl_state *ctrl_state,
return 0;
}
-int pcep_main_event_handler(struct thread *thread)
+void pcep_main_event_handler(struct thread *thread)
{
/* data unpacking */
struct pcep_main_event_data *data = THREAD_ARG(thread);
void *payload = data->payload;
XFREE(MTYPE_PCEP, data);
- return handler(type, pcc_id, payload);
+ handler(type, pcc_id, payload);
}
void *payload;
};
-typedef int (*pcep_ctrl_thread_callback)(struct thread *);
+typedef void (*pcep_ctrl_thread_callback)(struct thread *);
/* PCC connection information, populated in a thread-safe
* manner with pcep_ctrl_get_pcc_info() */
int pcep_thread_send_ctrl_event(void *fpt, void *payload,
pcep_ctrl_thread_callback cb);
-int pcep_thread_pcep_event(struct thread *thread);
+void pcep_thread_pcep_event(struct thread *thread);
int pcep_thread_pcc_count(struct ctrl_state *ctrl_state);
/* Called by the PCC to refine a path in the main thread */
int pcep_thread_refine_path(struct ctrl_state *ctrl_state, int pcc_id,
void *payload);
static int pcep_lib_pceplib_socket_write_cb(void *fpt, void **thread, int fd,
void *payload);
-static int pcep_lib_socket_read_ready(struct thread *thread);
-static int pcep_lib_socket_write_ready(struct thread *thread);
+static void pcep_lib_socket_read_ready(struct thread *thread);
+static void pcep_lib_socket_write_ready(struct thread *thread);
/* pceplib pcep_event callbacks */
static void pcep_lib_pceplib_event_cb(void *fpt, pcep_event *event);
/* Callbacks called by path_pcep_controller when a socket is ready to read/write
*/
-int pcep_lib_socket_write_ready(struct thread *thread)
+void pcep_lib_socket_write_ready(struct thread *thread)
{
struct pcep_ctrl_socket_data *data = THREAD_ARG(thread);
assert(data != NULL);
- int retval = pceplib_external_socket_write(data->fd, data->payload);
+ pceplib_external_socket_write(data->fd, data->payload);
XFREE(MTYPE_PCEP, data);
-
- return retval;
}
-int pcep_lib_socket_read_ready(struct thread *thread)
+void pcep_lib_socket_read_ready(struct thread *thread)
{
struct pcep_ctrl_socket_data *data = THREAD_ARG(thread);
assert(data != NULL);
- int retval = pceplib_external_socket_read(data->fd, data->payload);
+ pceplib_external_socket_read(data->fd, data->payload);
XFREE(MTYPE_PCEP, data);
-
- return retval;
}
/* Callback passed to pceplib when a pcep_event is ready */
static uint32_t path_ted_start_importing_igp(const char *daemon_str);
static uint32_t path_ted_stop_importing_igp(void);
static enum zclient_send_status path_ted_link_state_sync(void);
-static int path_ted_timer_handler_sync(struct thread *thread);
-static int path_ted_timer_handler_refresh(struct thread *thread);
+static void path_ted_timer_handler_sync(struct thread *thread);
+static void path_ted_timer_handler_refresh(struct thread *thread);
static int path_ted_cli_debug_config_write(struct vty *vty);
static int path_ted_cli_debug_set_all(uint32_t flags, bool set);
*
* @return status
*/
-int path_ted_timer_handler_sync(struct thread *thread)
+void path_ted_timer_handler_sync(struct thread *thread)
{
/* data unpacking */
struct ted_state *data = THREAD_ARG(thread);
assert(data != NULL);
/* Retry the sync */
- return path_ted_link_state_sync();
+ path_ted_link_state_sync();
}
/**
*
* @return status
*/
-int path_ted_timer_handler_refresh(struct thread *thread)
+void path_ted_timer_handler_refresh(struct thread *thread)
{
if (!path_ted_is_initialized())
- return MPLS_LABEL_NONE;
+ return;
PATH_TED_DEBUG("%s: PATHD-TED: Refresh sid from current TED", __func__);
/* data unpacking */
assert(data != NULL);
srte_policy_update_ted_sid();
- return 0;
}
/**
(candidate));
static void trigger_pathd_candidate_created(struct srte_candidate *candidate);
-static int trigger_pathd_candidate_created_timer(struct thread *thread);
+static void trigger_pathd_candidate_created_timer(struct thread *thread);
static void trigger_pathd_candidate_updated(struct srte_candidate *candidate);
-static int trigger_pathd_candidate_updated_timer(struct thread *thread);
+static void trigger_pathd_candidate_updated_timer(struct thread *thread);
static void trigger_pathd_candidate_removed(struct srte_candidate *candidate);
static const char *
srte_candidate_metric_name(enum srte_candidate_metric_type type);
(void *)candidate, HOOK_DELAY, &candidate->hook_timer);
}
-int trigger_pathd_candidate_created_timer(struct thread *thread)
+void trigger_pathd_candidate_created_timer(struct thread *thread)
{
struct srte_candidate *candidate = THREAD_ARG(thread);
candidate->hook_timer = NULL;
- return hook_call(pathd_candidate_created, candidate);
+ hook_call(pathd_candidate_created, candidate);
}
void trigger_pathd_candidate_updated(struct srte_candidate *candidate)
(void *)candidate, HOOK_DELAY, &candidate->hook_timer);
}
-int trigger_pathd_candidate_updated_timer(struct thread *thread)
+void trigger_pathd_candidate_updated_timer(struct thread *thread)
{
struct srte_candidate *candidate = THREAD_ARG(thread);
candidate->hook_timer = NULL;
- return hook_call(pathd_candidate_updated, candidate);
+ hook_call(pathd_candidate_updated, candidate);
}
void trigger_pathd_candidate_removed(struct srte_candidate *candidate)
return pim_assert_do(ch, metric);
}
-static int on_assert_timer(struct thread *t)
+static void on_assert_timer(struct thread *t)
{
struct pim_ifchannel *ch;
struct interface *ifp;
ifp->name);
}
}
-
- return 0;
}
static void assert_timer_off(struct pim_ifchannel *ch)
return bsgrp;
}
-static int pim_on_bs_timer(struct thread *t)
+static void pim_on_bs_timer(struct thread *t)
{
struct route_node *rn;
struct bsm_scope *scope;
pim_bsm_rpinfos_free(bsgrp_node->partial_bsrp_list);
bsgrp_node->pend_rp_cnt = 0;
}
- return 0;
}
static void pim_bs_timer_stop(struct bsm_scope *scope)
return true;
}
-static int pim_on_g2rp_timer(struct thread *t)
+static void pim_on_g2rp_timer(struct thread *t)
{
struct bsm_rpinfo *bsrp;
struct bsm_rpinfo *bsrp_node;
if (!rn) {
zlog_warn("%s: Route node doesn't exist", __func__);
- return 0;
+ return;
}
rp_info = (struct rp_info *)rn->info;
if (!rp_info) {
route_unlock_node(rn);
- return 0;
+ return;
}
if (rp_info->rp_src != RP_SRC_STATIC) {
&bsgrp_node->group);
pim_free_bsgrp_data(bsgrp_node);
}
-
- return 0;
}
static void pim_g2rp_timer_start(struct bsm_rpinfo *bsrp, int hold_time)
delete_on_noinfo(ch);
}
-static int on_ifjoin_expiry_timer(struct thread *t)
+static void on_ifjoin_expiry_timer(struct thread *t)
{
struct pim_ifchannel *ch;
ifjoin_to_noinfo(ch);
/* ch may have been deleted */
-
- return 0;
}
-static int on_ifjoin_prune_pending_timer(struct thread *t)
+static void on_ifjoin_prune_pending_timer(struct thread *t)
{
struct pim_ifchannel *ch;
int send_prune_echo; /* boolean */
}
/* from here ch may have been deleted */
}
-
- return 0;
}
static void check_recv_upstream(int is_join, struct interface *recv_ifp,
#include "pim_zebra.h"
static void group_timer_off(struct gm_group *group);
-static int pim_igmp_general_query(struct thread *t);
+static void pim_igmp_general_query(struct thread *t);
/* This socket is used for TXing IGMP packets only, IGMP RX happens
* in pim_mroute_msg()
return NULL;
}
-static int pim_igmp_other_querier_expire(struct thread *t)
+static void pim_igmp_other_querier_expire(struct thread *t)
{
struct gm_sock *igmp;
Query, Set Gen. Query. timer)
*/
pim_igmp_general_query(t);
-
- return 0;
}
void pim_igmp_other_querier_timer_on(struct gm_sock *igmp)
}
/* Issue IGMP general query */
-static int pim_igmp_general_query(struct thread *t)
+static void pim_igmp_general_query(struct thread *t)
{
struct gm_sock *igmp;
struct in_addr dst_addr;
igmp->querier_query_interval);
pim_igmp_general_query_on(igmp);
-
- return 0;
}
static void sock_close(struct gm_sock *igmp)
static void igmp_read_on(struct gm_sock *igmp);
-static int pim_igmp_read(struct thread *t)
+static void pim_igmp_read(struct thread *t)
{
uint8_t buf[10000];
struct gm_sock *igmp = (struct gm_sock *)THREAD_ARG(t);
done:
igmp_read_on(igmp);
- return 0;
}
static void igmp_read_on(struct gm_sock *igmp)
source records. Source records whose timers are zero (from the
previous EXCLUDE mode) are deleted.
*/
-static int igmp_group_timer(struct thread *t)
+static void igmp_group_timer(struct thread *t)
{
struct gm_group *group;
if (listcount(group->group_source_list) < 1) {
igmp_group_delete_empty_include(group);
}
-
- return 0;
}
static void group_timer_off(struct gm_group *group)
igmp_group_timer_on(group, group_membership_interval_msec, ifp->name);
}
-static int igmp_source_timer(struct thread *t)
+static void igmp_source_timer(struct thread *t)
{
struct gm_source *source;
struct gm_group *group;
igmp_group_delete_empty_include(group);
}
}
-
- return 0;
}
static void source_timer_off(struct gm_group *group, struct gm_source *source)
return num_retransmit_sources_left;
}
-static int igmp_group_retransmit(struct thread *t)
+static void igmp_group_retransmit(struct thread *t)
{
struct gm_group *group;
int num_retransmit_sources_left;
|| (group->group_specific_query_retransmit_count > 0)) {
group_retransmit_timer_on(group);
}
-
- return 0;
}
/*
return 0;
}
-static int pim_mlag_register_handler(struct thread *thread)
+static void pim_mlag_register_handler(struct thread *thread)
{
uint32_t bit_mask = 0;
if (!zclient)
- return -1;
+ return;
SET_FLAG(bit_mask, (1 << MLAG_STATUS_UPDATE));
SET_FLAG(bit_mask, (1 << MLAG_MROUTE_ADD));
__func__, bit_mask);
zclient_send_mlag_register(zclient, bit_mask);
- return 0;
}
void pim_mlag_register(void)
NULL);
}
-static int pim_mlag_deregister_handler(struct thread *thread)
+static void pim_mlag_deregister_handler(struct thread *thread)
{
if (!zclient)
- return -1;
+ return;
if (PIM_DEBUG_MLAG)
zlog_debug("%s: Posting Client De-Register to MLAG from PIM",
__func__);
router->connected_to_mlag = false;
zclient_send_mlag_deregister(zclient);
- return 0;
}
void pim_mlag_deregister(void)
return 0;
}
-static int mroute_read(struct thread *t)
+static void mroute_read(struct thread *t)
{
struct pim_instance *pim;
static long long count;
char buf[10000];
- int result = 0;
int cont = 1;
int rd;
ifindex_t ifindex;
goto done;
}
- result = pim_mroute_msg(pim, buf, rd, ifindex);
+ pim_mroute_msg(pim, buf, rd, ifindex);
count++;
if (count % router->packet_process == 0)
/* Keep reading */
done:
mroute_read_on(pim);
-
- return result;
}
static void mroute_read_on(struct pim_instance *pim)
}
/* RFC-3618:Sec-5.1 - global active source advertisement timer */
-static int pim_msdp_sa_adv_timer_cb(struct thread *t)
+static void pim_msdp_sa_adv_timer_cb(struct thread *t)
{
struct pim_instance *pim = THREAD_ARG(t);
pim_msdp_sa_adv_timer_setup(pim, true /* start */);
pim_msdp_pkt_sa_tx(pim);
- return 0;
}
+
static void pim_msdp_sa_adv_timer_setup(struct pim_instance *pim, bool start)
{
THREAD_OFF(pim->msdp.sa_adv_timer);
}
/* RFC-3618:Sec-5.3 - SA cache state timer */
-static int pim_msdp_sa_state_timer_cb(struct thread *t)
+static void pim_msdp_sa_state_timer_cb(struct thread *t)
{
struct pim_msdp_sa *sa;
}
pim_msdp_sa_deref(sa, PIM_MSDP_SAF_PEER);
- return 0;
}
+
static void pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
{
THREAD_OFF(sa->sa_state_timer);
}
/* RFC-3618:Sec-5.4 - peer hold timer */
-static int pim_msdp_peer_hold_timer_cb(struct thread *t)
+static void pim_msdp_peer_hold_timer_cb(struct thread *t)
{
struct pim_msdp_peer *mp;
}
if (mp->state != PIM_MSDP_ESTABLISHED) {
- return 0;
+ return;
}
if (PIM_DEBUG_MSDP_EVENTS) {
pim_msdp_peer_state_chg_log(mp);
}
pim_msdp_peer_reset_tcp_conn(mp, "ht-expired");
- return 0;
}
static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
/* RFC-3618:Sec-5.5 - peer keepalive timer */
-static int pim_msdp_peer_ka_timer_cb(struct thread *t)
+static void pim_msdp_peer_ka_timer_cb(struct thread *t)
{
struct pim_msdp_peer *mp;
pim_msdp_pkt_ka_tx(mp);
pim_msdp_peer_ka_timer_setup(mp, true /* start */);
- return 0;
}
+
static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
{
THREAD_OFF(mp->ka_timer);
}
/* RFC-3618:Sec-5.6 - connection retry on active peer */
-static int pim_msdp_peer_cr_timer_cb(struct thread *t)
+static void pim_msdp_peer_cr_timer_cb(struct thread *t)
{
struct pim_msdp_peer *mp;
}
if (mp->state != PIM_MSDP_CONNECTING || PIM_MSDP_PEER_IS_LISTENER(mp)) {
- return 0;
+ return;
}
pim_msdp_peer_active_connect(mp);
- return 0;
}
+
static void pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
{
THREAD_OFF(mp->cr_timer);
void pim_msdp_peer_pkt_rxed(struct pim_msdp_peer *mp);
void pim_msdp_peer_stop_tcp_conn(struct pim_msdp_peer *mp, bool chg_state);
void pim_msdp_peer_reset_tcp_conn(struct pim_msdp_peer *mp, const char *rc_str);
-int pim_msdp_write(struct thread *thread);
+void pim_msdp_write(struct thread *thread);
int pim_msdp_config_write(struct pim_instance *pim, struct vty *vty,
const char *spaces);
bool pim_msdp_peer_config_write(struct vty *vty, struct pim_instance *pim,
}
}
-int pim_msdp_write(struct thread *thread)
+void pim_msdp_write(struct thread *thread)
{
struct pim_msdp_peer *mp;
struct stream *s;
zlog_debug("MSDP peer %s pim_msdp_write", mp->key_str);
}
if (mp->fd < 0) {
- return -1;
+ return;
}
/* check if TCP connection is established */
if (mp->state != PIM_MSDP_ESTABLISHED) {
pim_msdp_connect_check(mp);
- return 0;
+ return;
}
s = stream_fifo_head(mp->obuf);
if (!s) {
pim_msdp_write_proceed_actions(mp);
- return 0;
+ return;
}
sockopt_cork(mp->fd, 1);
}
pim_msdp_peer_reset_tcp_conn(mp, "pkt-tx-failed");
- return 0;
+ return;
}
if (num != writenum) {
zlog_debug("MSDP peer %s pim_msdp_write wrote %d packets",
mp->key_str, work_cnt);
}
-
- return 0;
}
static void pim_msdp_pkt_send(struct pim_msdp_peer *mp, struct stream *s)
return 0;
}
-int pim_msdp_read(struct thread *thread)
+void pim_msdp_read(struct thread *thread)
{
struct pim_msdp_peer *mp;
int rc;
}
if (mp->fd < 0) {
- return -1;
+ return;
}
/* check if TCP connection is established */
if (mp->state != PIM_MSDP_ESTABLISHED) {
pim_msdp_connect_check(mp);
- return 0;
+ return;
}
PIM_MSDP_PEER_READ_ON(mp);
if (stream_get_endp(mp->ibuf) < PIM_MSDP_HEADER_SIZE) {
/* start by reading the TLV header */
rc = pim_msdp_read_packet(mp);
- if (rc < 0) {
- goto pim_msdp_read_end;
- }
+ if (rc < 0)
+ return;
/* Find TLV type and len */
stream_getc(mp->ibuf);
len = stream_getw(mp->ibuf);
if (len < PIM_MSDP_HEADER_SIZE) {
pim_msdp_pkt_rxed_with_fatal_error(mp);
- goto pim_msdp_read_end;
+ return;
}
/* read complete TLV */
mp->packet_size = len;
}
rc = pim_msdp_read_packet(mp);
- if (rc < 0) {
- goto pim_msdp_read_end;
- }
+ if (rc < 0)
+ return;
pim_msdp_pkt_rx(mp);
/* reset input buffers and get ready for the next packet */
mp->packet_size = 0;
stream_reset(mp->ibuf);
-
-pim_msdp_read_end:
- return 0;
}
#define PIM_MSDP_PKT_TYPE_STRLEN 16
void pim_msdp_pkt_ka_tx(struct pim_msdp_peer *mp);
-int pim_msdp_read(struct thread *thread);
+void pim_msdp_read(struct thread *thread);
void pim_msdp_pkt_sa_tx(struct pim_instance *pim);
void pim_msdp_pkt_sa_tx_one(struct pim_msdp_sa *sa);
void pim_msdp_pkt_sa_tx_to_one_peer(struct pim_msdp_peer *mp);
}
/* passive peer socket accept */
-static int pim_msdp_sock_accept(struct thread *thread)
+static void pim_msdp_sock_accept(struct thread *thread)
{
union sockunion su;
struct pim_instance *pim = THREAD_ARG(thread);
if (accept_sock < 0) {
flog_err(EC_LIB_DEVELOPMENT, "accept_sock is negative value %d",
accept_sock);
- return -1;
+ return;
}
pim->msdp.listener.thread = NULL;
thread_add_read(router->master, pim_msdp_sock_accept, pim, accept_sock,
if (msdp_sock < 0) {
flog_err_sys(EC_LIB_SOCKET, "pim_msdp_sock_accept failed (%s)",
safe_strerror(errno));
- return -1;
+ return;
}
/* see if have peer config for this */
"msdp peer connection refused from %pSU", &su);
}
close(msdp_sock);
- return -1;
+ return;
}
if (PIM_DEBUG_MSDP_INTERNAL) {
set_nonblocking(mp->fd);
pim_msdp_update_sock_send_buffer_size(mp->fd);
pim_msdp_peer_established(mp);
- return 0;
}
/* global listener for the MSDP well know TCP port */
}
}
-static int on_neighbor_timer(struct thread *t)
+static void on_neighbor_timer(struct thread *t)
{
struct pim_neighbor *neigh;
struct interface *ifp;
router's own DR Priority changes.
*/
pim_if_dr_election(ifp); // neighbor times out
-
- return 0;
}
void pim_neighbor_timer_reset(struct pim_neighbor *neigh, uint16_t holdtime)
neigh->holdtime, &neigh->t_expire_timer);
}
-static int on_neighbor_jp_timer(struct thread *t)
+static void on_neighbor_jp_timer(struct thread *t)
{
struct pim_neighbor *neigh = THREAD_ARG(t);
struct pim_rpf rpf;
thread_add_timer(router->master, on_neighbor_jp_timer, neigh,
router->t_periodic, &neigh->jp_timer);
-
- return 0;
}
static void pim_neighbor_start_jp_timer(struct pim_neighbor *neigh)
#include "pim_errors.h"
#include "pim_bsm.h"
-static int on_pim_hello_send(struct thread *t);
+static void on_pim_hello_send(struct thread *t);
static const char *pim_pim_msgtype2str(enum pim_msg_type type)
{
static void pim_sock_read_on(struct interface *ifp);
-static int pim_sock_read(struct thread *t)
+static void pim_sock_read(struct thread *t)
{
struct interface *ifp, *orig_ifp;
struct pim_interface *pim_ifp;
if (result) {
++pim_ifp->pim_ifstat_hello_recvfail;
}
-
- return result;
}
static void pim_sock_read_on(struct interface *ifp)
/*
Periodic hello timer
*/
-static int on_pim_hello_send(struct thread *t)
+static void on_pim_hello_send(struct thread *t)
{
struct pim_interface *pim_ifp;
struct interface *ifp;
/*
* Send hello
*/
- return pim_hello_send(ifp, PIM_IF_DEFAULT_HOLDTIME(pim_ifp));
+ pim_hello_send(ifp, PIM_IF_DEFAULT_HOLDTIME(pim_ifp));
}
/*
return 0;
}
-static int ssmpingd_sock_read(struct thread *t)
+static void ssmpingd_sock_read(struct thread *t)
{
struct ssmpingd_sock *ss;
- int result;
ss = THREAD_ARG(t);
- result = ssmpingd_read_msg(ss);
+ ssmpingd_read_msg(ss);
/* Keep reading */
ssmpingd_read_on(ss);
-
- return result;
}
static void ssmpingd_read_on(struct ssmpingd_sock *ss)
pim_jp_agg_single_upstream_send(&up->rpf, up, 1 /* join */);
}
-static int on_join_timer(struct thread *t)
+static void on_join_timer(struct thread *t)
{
struct pim_upstream *up;
if (PIM_DEBUG_PIM_TRACE)
zlog_debug("%s: up %s RPF is not present", __func__,
up->sg_str);
- return 0;
+ return;
}
/*
* In the case of a HFR we will not ahve anyone to send this to.
*/
if (PIM_UPSTREAM_FLAG_TEST_FHR(up->flags))
- return 0;
+ return;
/*
* Don't send the join if the outgoing interface is a loopback
pim_upstream_send_join(up);
join_timer_start(up);
-
- return 0;
}
static void join_timer_stop(struct pim_upstream *up)
return up;
}
-static int pim_upstream_keep_alive_timer(struct thread *t)
+static void pim_upstream_keep_alive_timer(struct thread *t)
{
struct pim_upstream *up;
/* pull the stats and re-check */
if (pim_upstream_sg_running_proc(up))
/* kat was restarted because of new activity */
- return 0;
+ return;
pim_upstream_keep_alive_timer_proc(up);
- return 0;
}
void pim_upstream_keep_alive_timer_start(struct pim_upstream *up, uint32_t time)
}
/* MSDP on RP needs to know if a source is registerable to this RP */
-static int pim_upstream_msdp_reg_timer(struct thread *t)
+static void pim_upstream_msdp_reg_timer(struct thread *t)
{
struct pim_upstream *up = THREAD_ARG(t);
struct pim_instance *pim = up->channel_oil->pim;
/* source is no longer active - pull the SA from MSDP's cache */
pim_msdp_sa_local_del(pim, &up->sg);
- return 1;
}
+
void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)
{
THREAD_OFF(up->t_msdp_reg_timer);
return state_str;
}
-static int pim_upstream_register_stop_timer(struct thread *t)
+static void pim_upstream_register_stop_timer(struct thread *t)
{
struct pim_interface *pim_ifp;
struct pim_instance *pim;
zlog_debug("%s: up %s RPF is not present",
__func__, up->sg_str);
up->reg_state = PIM_REG_NOINFO;
- return 0;
+ return;
}
pim_ifp = up->rpf.source_nexthop.interface->info;
"%s: Interface: %s is not configured for pim",
__func__,
up->rpf.source_nexthop.interface->name);
- return 0;
+ return;
}
up->reg_state = PIM_REG_JOIN_PENDING;
pim_upstream_start_register_stop_timer(up, 1);
zlog_debug(
"%s: Stop sending the register, because I am the RP and we haven't seen a packet in a while",
__func__);
- return 0;
+ return;
}
pim_null_register_send(up);
break;
case PIM_REG_NOINFO:
break;
}
-
- return 0;
}
void pim_upstream_start_register_stop_timer(struct pim_upstream *up,
pim_vxlan_del_work(vxlan_sg);
}
-static int pim_vxlan_work_timer_cb(struct thread *t)
+static void pim_vxlan_work_timer_cb(struct thread *t)
{
pim_vxlan_do_reg_work();
pim_vxlan_work_timer_setup(true /* start */);
- return 0;
}
/* global 1second timer used for periodic processing */
pim_upstream_mroute_iif_update(c_oil, __func__);
}
-static int on_rpf_cache_refresh(struct thread *t)
+static void on_rpf_cache_refresh(struct thread *t)
{
struct pim_instance *pim = THREAD_ARG(t);
// It is called as part of pim_neighbor_add
// pim_rp_setup ();
- return 0;
}
void sched_rpf_cache_refresh(struct pim_instance *pim)
struct thread *zlookup_read;
static void zclient_lookup_sched(struct zclient *zlookup, int delay);
-static int zclient_lookup_read_pipe(struct thread *thread);
+static void zclient_lookup_read_pipe(struct thread *thread);
/* Connect to zebra for nexthop lookup. */
-static int zclient_lookup_connect(struct thread *t)
+static void zclient_lookup_connect(struct thread *t)
{
struct zclient *zlookup;
zlookup = THREAD_ARG(t);
if (zlookup->sock >= 0) {
- return 0;
+ return;
}
if (zclient_socket_connect(zlookup) < 0) {
if (zlookup->sock < 0) {
/* Since last connect failed, retry within 10 secs */
zclient_lookup_sched(zlookup, 10);
- return -1;
+ return;
}
thread_add_timer(router->master, zclient_lookup_read_pipe, zlookup, 60,
&zlookup_read);
- return 0;
}
/* Schedule connection with delay. */
return zclient_read_nexthop(pim, zlookup, nexthop_tab, tab_size, addr);
}
-int zclient_lookup_read_pipe(struct thread *thread)
+void zclient_lookup_read_pipe(struct thread *thread)
{
struct zclient *zlookup = THREAD_ARG(thread);
struct pim_instance *pim = pim_get_pim_instance(VRF_DEFAULT);
zclient_lookup_nexthop_once(pim, nexthop_tab, 10, l);
thread_add_timer(router->master, zclient_lookup_read_pipe, zlookup, 60,
&zlookup_read);
-
- return 1;
}
int zclient_lookup_nexthop(struct pim_instance *pim,
* Thsi thread reads the clients data from the Gloabl queue and encodes with
* protobuf and pass on to the MLAG socket.
*/
-static int pim_mlag_zthread_handler(struct thread *event)
+static void pim_mlag_zthread_handler(struct thread *event)
{
struct stream *read_s;
uint32_t wr_count = 0;
__func__, wr_count);
if (wr_count == 0)
- return 0;
+ return;
for (wr_count = 0; wr_count < PIM_MLAG_POST_LIMIT; wr_count++) {
/* FIFO is empty,wait for teh message to be add */
if (wr_count >= PIM_MLAG_POST_LIMIT)
pim_mlag_signal_zpthread();
-
- return 0;
}
}
/* Join to multicast group and send request to the interface. */
-static int rip_interface_wakeup(struct thread *t)
+static void rip_interface_wakeup(struct thread *t)
{
struct interface *ifp;
struct rip_interface *ri;
flog_err_sys(EC_LIB_SOCKET,
"multicast join failed, interface %s not running",
ifp->name);
- return 0;
+ return;
}
/* Set running flag. */
/* Send RIP request to the interface. */
rip_request_interface(ifp);
-
- return 0;
}
static void rip_connect_set(struct interface *ifp, int set)
}
/* RIP peer is timeout. */
-static int rip_peer_timeout(struct thread *t)
+static void rip_peer_timeout(struct thread *t)
{
struct rip_peer *peer;
peer = THREAD_ARG(t);
listnode_delete(peer->rip->peer_list, peer);
rip_peer_free(peer);
-
- return 0;
}
/* Get RIP peer. At the same time update timeout thread. */
/* Prototypes. */
static void rip_output_process(struct connected *, struct sockaddr_in *, int,
uint8_t);
-static int rip_triggered_update(struct thread *);
+static void rip_triggered_update(struct thread *);
static int rip_update_jitter(unsigned long);
static void rip_distance_table_node_cleanup(struct route_table *table,
struct route_node *node);
}
/* RIP route garbage collect timer. */
-static int rip_garbage_collect(struct thread *t)
+static void rip_garbage_collect(struct thread *t)
{
struct rip_info *rinfo;
struct route_node *rp;
/* Free RIP routing information. */
rip_info_free(rinfo);
-
- return 0;
}
static void rip_timeout_update(struct rip *rip, struct rip_info *rinfo);
}
/* Timeout RIP routes. */
-static int rip_timeout(struct thread *t)
+static void rip_timeout(struct thread *t)
{
struct rip_info *rinfo = THREAD_ARG(t);
struct rip *rip = rip_info_get_instance(rinfo);
rip_ecmp_delete(rip, rinfo);
-
- return 0;
}
static void rip_timeout_update(struct rip *rip, struct rip_info *rinfo)
}
/* First entry point of RIP packet. */
-static int rip_read(struct thread *t)
+static void rip_read(struct thread *t)
{
struct rip *rip = THREAD_ARG(t);
int sock;
if (len < 0) {
zlog_info("recvfrom failed (VRF %s): %s", rip->vrf_name,
safe_strerror(errno));
- return len;
+ return;
}
/* Check is this packet comming from myself? */
if (IS_RIP_DEBUG_PACKET)
zlog_debug("ignore packet comes from myself (VRF %s)",
rip->vrf_name);
- return -1;
+ return;
}
/* Which interface is this packet comes from. */
"rip_read: cannot find interface for packet from %pI4 port %d (VRF %s)",
&from.sin_addr, ntohs(from.sin_port),
rip->vrf_name);
- return -1;
+ return;
}
p.family = AF_INET;
"rip_read: cannot find connected address for packet from %pI4 port %d on interface %s (VRF %s)",
&from.sin_addr, ntohs(from.sin_port),
ifp->name, rip->vrf_name);
- return -1;
+ return;
}
/* Packet length check. */
zlog_warn("packet size %d is smaller than minimum size %d", len,
RIP_PACKET_MINSIZ);
rip_peer_bad_packet(rip, &from);
- return len;
+ return;
}
if (len > RIP_PACKET_MAXSIZ) {
zlog_warn("packet size %d is larger than max size %d", len,
RIP_PACKET_MAXSIZ);
rip_peer_bad_packet(rip, &from);
- return len;
+ return;
}
/* Packet alignment check. */
zlog_warn("packet size %d is wrong for RIP packet alignment",
len);
rip_peer_bad_packet(rip, &from);
- return len;
+ return;
}
/* Set RTE number. */
zlog_info("version 0 with command %d received.",
packet->command);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
/* Dump RIP packet. */
zlog_debug("RIP is not enabled on interface %s.",
ifp->name);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
/* RIP Version check. RFC2453, 4.6 and 5.1 */
" packet's v%d doesn't fit to if version spec",
packet->version);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
/* RFC2453 5.2 If the router is not configured to authenticate RIP-2
packet->version);
ripd_notif_send_auth_type_failure(ifp->name);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
/* RFC:
"RIPv1 dropped because authentication enabled");
ripd_notif_send_auth_type_failure(ifp->name);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
} else if (ri->auth_type != RIP_NO_AUTH) {
const char *auth_desc;
"RIPv2 authentication failed: no auth RTE in packet");
ripd_notif_send_auth_type_failure(ifp->name);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
/* First RTE must be an Authentication Family RTE */
"RIPv2 dropped because authentication enabled");
ripd_notif_send_auth_type_failure(ifp->name);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
/* Check RIPv2 authentication. */
auth_desc);
ripd_notif_send_auth_failure(ifp->name);
rip_peer_bad_packet(rip, &from);
- return -1;
+ return;
}
}
rip_peer_bad_packet(rip, &from);
break;
}
-
- return len;
}
/* Write routing table entry to the stream and return next index of
}
/* RIP's periodical timer. */
-static int rip_update(struct thread *t)
+static void rip_update(struct thread *t)
{
struct rip *rip = THREAD_ARG(t);
/* Register myself. */
rip_event(rip, RIP_UPDATE_EVENT, 0);
-
- return 0;
}
/* Walk down the RIP routing table then clear changed flag. */
}
/* Triggered update interval timer. */
-static int rip_triggered_interval(struct thread *t)
+static void rip_triggered_interval(struct thread *t)
{
struct rip *rip = THREAD_ARG(t);
rip->trigger = 0;
rip_triggered_update(t);
}
- return 0;
}
/* Execute triggered update. */
-static int rip_triggered_update(struct thread *t)
+static void rip_triggered_update(struct thread *t)
{
struct rip *rip = THREAD_ARG(t);
int interval;
thread_add_timer(master, rip_triggered_interval, rip, interval,
&rip->t_triggered_interval);
-
- return 0;
}
/* Withdraw redistributed route. */
}
/* Wake up interface. */
-static int ripng_interface_wakeup(struct thread *t)
+static void ripng_interface_wakeup(struct thread *t)
{
struct interface *ifp;
struct ripng_interface *ri;
flog_err_sys(EC_LIB_SOCKET,
"multicast join failed, interface %s not running",
ifp->name);
- return 0;
+ return;
}
/* Set running flag. */
/* Send RIP request to the interface. */
ripng_request(ifp);
-
- return 0;
}
static void ripng_connect_set(struct interface *ifp, int set)
/* RIPng peer is timeout.
* Garbage collector.
**/
-static int ripng_peer_timeout(struct thread *t)
+static void ripng_peer_timeout(struct thread *t)
{
struct ripng_peer *peer;
peer = THREAD_ARG(t);
listnode_delete(peer->ripng->peer_list, peer);
ripng_peer_free(peer);
-
- return 0;
}
/* Get RIPng peer. At the same time update timeout thread. */
static void ripng_instance_enable(struct ripng *ripng, struct vrf *vrf,
int sock);
static void ripng_instance_disable(struct ripng *ripng);
-int ripng_triggered_update(struct thread *);
+static void ripng_triggered_update(struct thread *);
static void ripng_if_rmap_update(struct if_rmap_ctx *ctx,
struct if_rmap *if_rmap);
}
/* RIPng route garbage collect timer. */
-static int ripng_garbage_collect(struct thread *t)
+static void ripng_garbage_collect(struct thread *t)
{
struct ripng_info *rinfo;
struct agg_node *rp;
/* Free RIPng routing information. */
ripng_info_free(rinfo);
-
- return 0;
}
static void ripng_timeout_update(struct ripng *ripng, struct ripng_info *rinfo);
}
/* Timeout RIPng routes. */
-static int ripng_timeout(struct thread *t)
+static void ripng_timeout(struct thread *t)
{
struct ripng_info *rinfo = THREAD_ARG(t);
struct ripng *ripng = ripng_info_get_instance(rinfo);
ripng_ecmp_delete(ripng, rinfo);
-
- return 0;
}
static void ripng_timeout_update(struct ripng *ripng, struct ripng_info *rinfo)
}
/* First entry point of reading RIPng packet. */
-static int ripng_read(struct thread *thread)
+static void ripng_read(struct thread *thread)
{
struct ripng *ripng = THREAD_ARG(thread);
int len;
if (len < 0) {
zlog_warn("RIPng recvfrom failed (VRF %s): %s.",
ripng->vrf_name, safe_strerror(errno));
- return len;
+ return;
}
/* Check RTE boundary. RTE size (Packet length - RIPng header size
zlog_warn("RIPng invalid packet size %d from %pI6 (VRF %s)",
len, &from.sin6_addr, ripng->vrf_name);
ripng_peer_bad_packet(ripng, &from);
- return 0;
+ return;
}
packet = (struct ripng_packet *)STREAM_DATA(ripng->ibuf);
zlog_warn(
"RIPng packet comes from unknown interface %d (VRF %s)",
ifindex, ripng->vrf_name);
- return 0;
+ return;
}
/* Packet version mismatch checking. */
"RIPng packet version %d doesn't fit to my version %d (VRF %s)",
packet->version, ripng->version, ripng->vrf_name);
ripng_peer_bad_packet(ripng, &from);
- return 0;
+ return;
}
/* Process RIPng packet. */
ripng_peer_bad_packet(ripng, &from);
break;
}
- return 0;
}
/* Walk down the RIPng routing table then clear changed flag. */
/* Regular update of RIPng route. Send all routing formation to RIPng
enabled interface. */
-static int ripng_update(struct thread *t)
+static void ripng_update(struct thread *t)
{
struct ripng *ripng = THREAD_ARG(t);
struct interface *ifp;
/* Reset flush event. */
ripng_event(ripng, RIPNG_UPDATE_EVENT, 0);
-
- return 0;
}
/* Triggered update interval timer. */
-static int ripng_triggered_interval(struct thread *t)
+static void ripng_triggered_interval(struct thread *t)
{
struct ripng *ripng = THREAD_ARG(t);
ripng->trigger = 0;
ripng_triggered_update(t);
}
- return 0;
}
/* Execute triggered update. */
-int ripng_triggered_update(struct thread *t)
+void ripng_triggered_update(struct thread *t)
{
struct ripng *ripng = THREAD_ARG(t);
struct interface *ifp;
thread_add_timer(master, ripng_triggered_interval, ripng, interval,
&ripng->t_triggered_interval);
-
- return 0;
}
/* Write routing table entry to the stream and return next index of
extern struct thread_master *master;
-static int logpump_done(struct thread *thread)
+static void logpump_done(struct thread *thread)
{
double x;
frr_pthread_stop(lpt, NULL);
frr_pthread_destroy(lpt);
lpt = NULL;
- return 0;
}
static void *logpump_run(void *arg)
}
static int timer_count;
-static int test_timer(struct thread *thread)
+static void test_timer(struct thread *thread)
{
int *count = THREAD_ARG(thread);
printf("run %d of timer\n", (*count)++);
thread_add_timer(master, test_timer, count, 5, NULL);
- return 0;
}
static void test_timer_init(void)
&frr_staticd_info, &frr_vrf_info,
};
-static int grpc_thread_stop(struct thread *thread);
+static void grpc_thread_stop(struct thread *thread);
static void _err_print(const void *cookie, const char *errstr)
{
return NULL;
}
-static int grpc_thread_start(struct thread *thread)
+static void grpc_thread_start(struct thread *thread)
{
struct frr_pthread_attr client = {
.start = grpc_client_test_start,
auto pth = frr_pthread_new(&client, "GRPC Client thread", "grpc");
frr_pthread_run(pth, NULL);
frr_pthread_wait_running(pth);
-
- return 0;
}
-static int grpc_thread_stop(struct thread *thread)
+static void grpc_thread_stop(struct thread *thread)
{
std::cout << __func__ << ": frr_pthread_stop_all" << std::endl;
frr_pthread_stop_all();
printf("%s did %d, x = %g\n", str, i, x);
}
-static int clear_something(struct thread *thread)
+static void clear_something(struct thread *thread)
{
struct work_state *ws = THREAD_ARG(thread);
if (thread_should_yield(thread)) {
thread_add_timer_msec(master, clear_something, ws, 0,
NULL);
- return 0;
+ return;
}
}
/* All done! */
XFREE(MTYPE_TMP, ws->str);
XFREE(MTYPE_TMP, ws);
- return 0;
}
DEFUN (clear_foo,
func2(6, buf);
}
-static int threadfunc(struct thread *thread)
+static void threadfunc(struct thread *thread)
{
func3();
- return 0;
}
int main(void)
exit(exit_code);
}
-static int timer_func(struct thread *thread)
+static void timer_func(struct thread *thread)
{
int rv;
timers_pending--;
if (!timers_pending)
terminate_test();
-
- return 0;
}
static int cmp_timeval(const void *a, const void *b)
struct thread_master *master;
-static int dummy_func(struct thread *thread)
+static void dummy_func(struct thread *thread)
{
- return 0;
}
int main(int argc, char **argv)
/* Forward decls */
static void vrrp_change_state(struct vrrp_router *r, int to);
-static int vrrp_adver_timer_expire(struct thread *thread);
-static int vrrp_master_down_timer_expire(struct thread *thread);
+static void vrrp_adver_timer_expire(struct thread *thread);
+static void vrrp_master_down_timer_expire(struct thread *thread);
/*
* Finds the first connected address of the appropriate family on a VRRP
/*
* Read and process next IPvX datagram.
*/
-static int vrrp_read(struct thread *thread)
+static void vrrp_read(struct thread *thread)
{
struct vrrp_router *r = thread->arg;
if (resched)
thread_add_read(master, vrrp_read, r, r->sock_rx, &r->t_read);
-
- return 0;
}
/*
/*
* Called when Adver_Timer expires.
*/
-static int vrrp_adver_timer_expire(struct thread *thread)
+static void vrrp_adver_timer_expire(struct thread *thread)
{
struct vrrp_router *r = thread->arg;
r->vr->vrid, family2str(r->family),
vrrp_state_names[r->fsm.state]);
}
-
- return 0;
}
/*
* Called when Master_Down_Timer expires.
*/
-static int vrrp_master_down_timer_expire(struct thread *thread)
+static void vrrp_master_down_timer_expire(struct thread *thread)
{
struct vrrp_router *r = thread->arg;
r->vr->advertisement_interval * CS2MS,
&r->t_adver_timer);
vrrp_change_state(r, VRRP_STATE_MASTER);
-
- return 0;
}
/*
{NULL, 0, NULL, 0}};
static int try_connect(struct daemon *dmn);
-static int wakeup_send_echo(struct thread *t_wakeup);
+static void wakeup_send_echo(struct thread *t_wakeup);
static void try_restart(struct daemon *dmn);
static void phase_check(void);
static void restart_done(struct daemon *dmn);
return result;
}
-static int restart_kill(struct thread *t_kill)
+static void restart_kill(struct thread *t_kill)
{
struct restart_info *restart = THREAD_ARG(t_kill);
struct timeval delay;
restart->kills++;
thread_add_timer(master, restart_kill, restart, gs.restart_timeout,
&restart->t_kill);
- return 0;
}
static struct restart_info *find_child(pid_t child)
FUZZY(gs.period), &(DMN)->t_wakeup); \
} while (0);
-static int wakeup_down(struct thread *t_wakeup)
+static void wakeup_down(struct thread *t_wakeup)
{
struct daemon *dmn = THREAD_ARG(t_wakeup);
SET_WAKEUP_DOWN(dmn);
if ((dmn->connect_tries > 1) && (dmn->state != DAEMON_UP))
try_restart(dmn);
- return 0;
}
-static int wakeup_init(struct thread *t_wakeup)
+static void wakeup_init(struct thread *t_wakeup)
{
struct daemon *dmn = THREAD_ARG(t_wakeup);
dmn->state = DAEMON_DOWN;
}
phase_check();
- return 0;
}
static void restart_done(struct daemon *dmn)
phase_check();
}
-static int handle_read(struct thread *t_read)
+static void handle_read(struct thread *t_read)
{
struct daemon *dmn = THREAD_ARG(t_read);
static const char resp[sizeof(PING_TOKEN) + 4] = PING_TOKEN "\n";
if (ERRNO_IO_RETRY(errno)) {
/* Pretend it never happened. */
SET_READ_HANDLER(dmn);
- return 0;
+ return;
}
snprintf(why, sizeof(why), "unexpected read error: %s",
safe_strerror(errno));
daemon_down(dmn, why);
- return 0;
+ return;
}
if (rc == 0) {
daemon_down(dmn, "read returned EOF");
- return 0;
+ return;
}
if (!dmn->echo_sent.tv_sec) {
char why[sizeof(buf) + 100];
"unexpected read returns %d bytes: %.*s", (int)rc,
(int)rc, buf);
daemon_down(dmn, why);
- return 0;
+ return;
}
/* We are expecting an echo response: is there any chance that the
"read returned bad echo response of %d bytes (expecting %u): %.*s",
(int)rc, (unsigned int)sizeof(resp), (int)rc, buf);
daemon_down(dmn, why);
- return 0;
+ return;
}
time_elapsed(&delay, &dmn->echo_sent);
SET_READ_HANDLER(dmn);
thread_cancel(&dmn->t_wakeup);
SET_WAKEUP_ECHO(dmn);
-
- return 0;
}
/*
phase_check();
}
-static int check_connect(struct thread *t_write)
+static void check_connect(struct thread *t_write)
{
struct daemon *dmn = THREAD_ARG(t_write);
int sockerr;
safe_strerror(errno));
daemon_down(dmn,
"getsockopt failed checking connection success");
- return 0;
+ return;
}
if ((reslen == sizeof(sockerr)) && sockerr) {
char why[100];
"getsockopt reports that connection attempt failed: %s",
safe_strerror(sockerr));
daemon_down(dmn, why);
- return 0;
+ return;
}
daemon_up(dmn, "delayed connect succeeded");
- return 0;
}
-static int wakeup_connect_hanging(struct thread *t_wakeup)
+static void wakeup_connect_hanging(struct thread *t_wakeup)
{
struct daemon *dmn = THREAD_ARG(t_wakeup);
char why[100];
snprintf(why, sizeof(why),
"connection attempt timed out after %ld seconds", gs.timeout);
daemon_down(dmn, why);
- return 0;
}
/* Making connection to protocol daemon. */
return 1;
}
-static int phase_hanging(struct thread *t_hanging)
+static void phase_hanging(struct thread *t_hanging)
{
gs.t_phase_hanging = NULL;
flog_err(EC_WATCHFRR_CONNECTION,
"Phase [%s] hanging for %ld seconds, aborting phased restart",
phase_str[gs.phase], PHASE_TIMEOUT);
gs.phase = PHASE_NONE;
- return 0;
}
static void set_phase(restart_phase_t new_phase)
run_job(&gs.restart, "restart", gs.restart_command, 0, 1);
}
-static int wakeup_unresponsive(struct thread *t_wakeup)
+static void wakeup_unresponsive(struct thread *t_wakeup)
{
struct daemon *dmn = THREAD_ARG(t_wakeup);
SET_WAKEUP_UNRESPONSIVE(dmn);
try_restart(dmn);
}
- return 0;
}
-static int wakeup_no_answer(struct thread *t_wakeup)
+static void wakeup_no_answer(struct thread *t_wakeup)
{
struct daemon *dmn = THREAD_ARG(t_wakeup);
dmn->t_wakeup = NULL;
dmn->state = DAEMON_UNRESPONSIVE;
if (dmn->ignore_timeout)
- return 0;
+ return;
flog_err(EC_WATCHFRR_CONNECTION,
"%s state -> unresponsive : no response yet to ping sent %ld seconds ago",
dmn->name, gs.timeout);
SET_WAKEUP_UNRESPONSIVE(dmn);
try_restart(dmn);
- return 0;
}
-static int wakeup_send_echo(struct thread *t_wakeup)
+static void wakeup_send_echo(struct thread *t_wakeup)
{
static const char echocmd[] = "echo " PING_TOKEN;
ssize_t rc;
thread_add_timer(master, wakeup_no_answer, dmn, gs.timeout,
&dmn->t_wakeup);
}
- return 0;
}
bool check_all_up(void)
return res;
}
-static int startup_timeout(struct thread *t_wakeup)
+static void startup_timeout(struct thread *t_wakeup)
{
daemon_send_ready(1);
- return 0;
}
#ifdef GNU_LINUX
/*
* Prototypes.
*/
-static int fpm_process_event(struct thread *t);
+static void fpm_process_event(struct thread *t);
static int fpm_nl_enqueue(struct fpm_nl_ctx *fnc, struct zebra_dplane_ctx *ctx);
-static int fpm_lsp_send(struct thread *t);
-static int fpm_lsp_reset(struct thread *t);
-static int fpm_nhg_send(struct thread *t);
-static int fpm_nhg_reset(struct thread *t);
-static int fpm_rib_send(struct thread *t);
-static int fpm_rib_reset(struct thread *t);
-static int fpm_rmac_send(struct thread *t);
-static int fpm_rmac_reset(struct thread *t);
+static void fpm_lsp_send(struct thread *t);
+static void fpm_lsp_reset(struct thread *t);
+static void fpm_nhg_send(struct thread *t);
+static void fpm_nhg_reset(struct thread *t);
+static void fpm_rib_send(struct thread *t);
+static void fpm_rib_reset(struct thread *t);
+static void fpm_rmac_send(struct thread *t);
+static void fpm_rmac_reset(struct thread *t);
/*
* CLI.
/*
* FPM functions.
*/
-static int fpm_connect(struct thread *t);
+static void fpm_connect(struct thread *t);
static void fpm_reconnect(struct fpm_nl_ctx *fnc)
{
&fnc->t_connect);
}
-static int fpm_read(struct thread *t)
+static void fpm_read(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
ssize_t rv;
/* Schedule next read. */
thread_add_read(fnc->fthread->master, fpm_read, fnc,
fnc->socket, &fnc->t_read);
- return 0;
+ return;
}
if (rv == 0) {
atomic_fetch_add_explicit(&fnc->counters.connection_closes, 1,
zlog_debug("%s: connection closed", __func__);
FPM_RECONNECT(fnc);
- return 0;
+ return;
}
if (rv == -1) {
atomic_fetch_add_explicit(&fnc->counters.connection_errors, 1,
zlog_warn("%s: connection failure: %s", __func__,
strerror(errno));
FPM_RECONNECT(fnc);
- return 0;
+ return;
}
stream_reset(fnc->ibuf);
thread_add_read(fnc->fthread->master, fpm_read, fnc, fnc->socket,
&fnc->t_read);
-
- return 0;
}
-static int fpm_write(struct thread *t)
+static void fpm_write(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
socklen_t statuslen;
memory_order_relaxed);
FPM_RECONNECT(fnc);
- return 0;
+ return;
}
fnc->connecting = false;
strerror(errno));
FPM_RECONNECT(fnc);
- return 0;
+ return;
}
/* Account all bytes sent. */
stream_pulldown(fnc->obuf);
thread_add_write(fnc->fthread->master, fpm_write, fnc,
fnc->socket, &fnc->t_write);
- return 0;
+ return;
}
-
- return 0;
}
-static int fpm_connect(struct thread *t)
+static void fpm_connect(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
struct sockaddr_in *sin = (struct sockaddr_in *)&fnc->addr;
strerror(errno));
thread_add_timer(fnc->fthread->master, fpm_connect, fnc, 3,
&fnc->t_connect);
- return 0;
+ return;
}
set_nonblocking(sock);
strerror(errno));
thread_add_timer(fnc->fthread->master, fpm_connect, fnc, 3,
&fnc->t_connect);
- return 0;
+ return;
}
fnc->connecting = (errno == EINPROGRESS);
if (!fnc->connecting)
thread_add_timer(zrouter.master, fpm_lsp_reset, fnc, 0,
&fnc->t_lspreset);
-
- return 0;
}
/**
return HASHWALK_CONTINUE;
}
-static int fpm_lsp_send(struct thread *t)
+static void fpm_lsp_send(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
struct zebra_vrf *zvrf = vrf_info_lookup(VRF_DEFAULT);
thread_add_timer(zrouter.master, fpm_lsp_send, fnc, 0,
&fnc->t_lspwalk);
}
-
- return 0;
}
/*
return HASHWALK_CONTINUE;
}
-static int fpm_nhg_send(struct thread *t)
+static void fpm_nhg_send(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
struct fpm_nhg_arg fna;
} else /* Otherwise reschedule next hop group again. */
thread_add_timer(zrouter.master, fpm_nhg_send, fnc, 0,
&fnc->t_nhgwalk);
-
- return 0;
}
/**
* Send all RIB installed routes to the connected data plane.
*/
-static int fpm_rib_send(struct thread *t)
+static void fpm_rib_send(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
rib_dest_t *dest;
thread_add_timer(zrouter.master, fpm_rib_send,
fnc, 1, &fnc->t_ribwalk);
- return 0;
+ return;
}
/* Mark as sent. */
/* Schedule next event: RMAC reset. */
thread_add_event(zrouter.master, fpm_rmac_reset, fnc, 0,
&fnc->t_rmacreset);
-
- return 0;
}
/*
hash_iterate(zl3vni->rmac_table, fpm_enqueue_rmac_table, zl3vni);
}
-static int fpm_rmac_send(struct thread *t)
+static void fpm_rmac_send(struct thread *t)
{
struct fpm_rmac_arg fra;
/* RMAC walk completed. */
if (fra.complete)
WALK_FINISH(fra.fnc, FNE_RMAC_FINISHED);
-
- return 0;
}
/*
UNSET_FLAG(nhe->flags, NEXTHOP_GROUP_FPM);
}
-static int fpm_nhg_reset(struct thread *t)
+static void fpm_nhg_reset(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
/* Schedule next step: send next hop groups. */
thread_add_event(zrouter.master, fpm_nhg_send, fnc, 0, &fnc->t_nhgwalk);
-
- return 0;
}
/*
UNSET_FLAG(lsp->flags, LSP_FLAG_FPM);
}
-static int fpm_lsp_reset(struct thread *t)
+static void fpm_lsp_reset(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
struct zebra_vrf *zvrf = vrf_info_lookup(VRF_DEFAULT);
/* Schedule next step: send LSPs */
thread_add_event(zrouter.master, fpm_lsp_send, fnc, 0, &fnc->t_lspwalk);
-
- return 0;
}
/**
* Resets the RIB FPM flags so we send all routes again.
*/
-static int fpm_rib_reset(struct thread *t)
+static void fpm_rib_reset(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
rib_dest_t *dest;
/* Schedule next step: send RIB routes. */
thread_add_event(zrouter.master, fpm_rib_send, fnc, 0, &fnc->t_ribwalk);
-
- return 0;
}
/*
hash_iterate(zl3vni->rmac_table, fpm_unset_rmac_table, zl3vni);
}
-static int fpm_rmac_reset(struct thread *t)
+static void fpm_rmac_reset(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
/* Schedule next event: send RMAC entries. */
thread_add_event(zrouter.master, fpm_rmac_send, fnc, 0,
&fnc->t_rmacwalk);
-
- return 0;
}
-static int fpm_process_queue(struct thread *t)
+static void fpm_process_queue(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
struct zebra_dplane_ctx *ctx;
*/
if (dplane_provider_out_ctx_queue_len(fnc->prov) > 0)
dplane_provider_work_ready();
-
- return 0;
}
/**
* Handles external (e.g. CLI, data plane or others) events.
*/
-static int fpm_process_event(struct thread *t)
+static void fpm_process_event(struct thread *t)
{
struct fpm_nl_ctx *fnc = THREAD_ARG(t);
int event = THREAD_VAL(t);
zlog_debug("%s: unhandled event %d", __func__, event);
break;
}
-
- return 0;
}
/*
static void if_down_del_nbr_connected(struct interface *ifp);
-static int if_zebra_speed_update(struct thread *thread)
+static void if_zebra_speed_update(struct thread *thread)
{
struct interface *ifp = THREAD_ARG(thread);
struct zebra_if *zif = ifp->info;
* note that loopback & virtual interfaces can return 0 as speed
*/
if (error < 0)
- return 1;
+ return;
if (new_speed != ifp->speed) {
zlog_info("%s: %s old speed: %u new speed: %u", __func__,
&zif->speed_update);
thread_ignore_late_timer(zif->speed_update);
}
-
- return 1;
}
static void zebra_if_node_destroy(route_table_delegate_t *delegate,
extern void irdp_if_init(void);
extern int irdp_sock_init(void);
extern int irdp_config_write(struct vty *, struct interface *);
-extern int irdp_send_thread(struct thread *t_advert);
+extern void irdp_send_thread(struct thread *t_advert);
extern void irdp_advert_off(struct interface *ifp);
extern void process_solicit(struct interface *ifp);
-extern int irdp_read_raw(struct thread *r);
+extern void irdp_read_raw(struct thread *r);
extern void send_packet(struct interface *ifp, struct stream *s, uint32_t dst,
struct prefix *p, uint32_t ttl);
stream_free(s);
}
-int irdp_send_thread(struct thread *t_advert)
+void irdp_send_thread(struct thread *t_advert)
{
uint32_t timer, tmp;
struct interface *ifp = THREAD_ARG(t_advert);
struct connected *ifc;
if (!irdp)
- return 0;
+ return;
irdp->flags &= ~IF_SOLICIT;
irdp->t_advertise = NULL;
thread_add_timer(zrouter.master, irdp_send_thread, ifp, timer,
&irdp->t_advertise);
- return 0;
}
void irdp_advert_off(struct interface *ifp)
return ret;
}
-int irdp_read_raw(struct thread *r)
+void irdp_read_raw(struct thread *r)
{
struct interface *ifp;
struct zebra_if *zi;
ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
if (!ifp)
- return ret;
+ return;
zi = ifp->info;
if (!zi)
- return ret;
+ return;
irdp = zi->irdp;
if (!irdp)
- return ret;
+ return;
if (!(irdp->flags & IF_ACTIVE)) {
if (irdp->flags & IF_DEBUG_MISC)
zlog_debug("IRDP: RX ICMP for disabled interface %s",
ifp->name);
- return 0;
+ return;
}
if (irdp->flags & IF_DEBUG_PACKET) {
}
parse_irdp_packet(buf, ret, ifp);
-
- return ret;
}
void send_packet(struct interface *ifp, struct stream *s, uint32_t dst,
return 0;
}
-static int kernel_read(struct thread *thread)
+static void kernel_read(struct thread *thread)
{
struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG(thread);
struct zebra_dplane_info dp_info;
thread_add_read(zrouter.master, kernel_read, zns, zns->netlink.sock,
&zns->t_netlink);
-
- return 0;
}
/*
#endif /* RTAX_MAX */
/* Kernel routing table and interface updates via routing socket. */
-static int kernel_read(struct thread *thread)
+static void kernel_read(struct thread *thread)
{
int sock;
int nbytes;
if (errno != EAGAIN && errno != EWOULDBLOCK)
flog_err_sys(EC_LIB_SOCKET, "routing socket error: %s",
safe_strerror(errno));
- return 0;
+ return;
}
if (nbytes == 0)
- return 0;
+ return;
thread_add_read(zrouter.master, kernel_read, NULL, sock, NULL);
zlog_debug(
"kernel_read: rtm->rtm_msglen %d, nbytes %d, type %d",
rtm->rtm_msglen, nbytes, rtm->rtm_type);
- return -1;
+ return;
}
switch (rtm->rtm_type) {
zlog_debug("Unprocessed RTM_type: %d", rtm->rtm_type);
break;
}
- return 0;
}
/* Make routing socket. */
* Final shutdown step for the zebra main thread. This is run after all
* async update processing has completed.
*/
-int zebra_finalize(struct thread *dummy)
+void zebra_finalize(struct thread *dummy)
{
zlog_info("Zebra final shutdown");
extern void rib_update(enum rib_update_event event);
extern void rib_update_table(struct route_table *table,
enum rib_update_event event, int rtype);
-extern int rib_sweep_route(struct thread *t);
+extern void rib_sweep_route(struct thread *t);
extern void rib_sweep_table(struct route_table *table);
extern void rib_close_table(struct route_table *table);
extern void rib_init(void);
zif->ra_sent++;
}
-static int rtadv_timer(struct thread *thread)
+static void rtadv_timer(struct thread *thread)
{
struct zebra_vrf *zvrf = THREAD_ARG(thread);
struct vrf *vrf;
}
}
}
-
- return 0;
}
static void rtadv_process_solicit(struct interface *ifp)
return;
}
-static int rtadv_read(struct thread *thread)
+static void rtadv_read(struct thread *thread)
{
int sock;
int len;
flog_err_sys(EC_LIB_SOCKET,
"RA/RS recv failed, socket %u error %s", sock,
safe_strerror(errno));
- return len;
+ return;
}
rtadv_process_packet(buf, (unsigned)len, ifindex, hoplimit, &from, zvrf);
-
- return 0;
}
static int rtadv_make_socket(ns_id_t ns_id)
#define DPLANE_PROV_UNLOCK(p) pthread_mutex_unlock(&((p)->dp_mutex))
/* Prototypes */
-static int dplane_thread_loop(struct thread *event);
+static void dplane_thread_loop(struct thread *event);
static void dplane_info_from_zns(struct zebra_dplane_info *ns_info,
struct zebra_ns *zns);
static enum zebra_dplane_result lsp_update_internal(struct zebra_lsp *lsp,
* Callback when an OS (netlink) incoming event read is ready. This runs
* in the dplane pthread.
*/
-static int dplane_incoming_read(struct thread *event)
+static void dplane_incoming_read(struct thread *event)
{
struct dplane_zns_info *zi = THREAD_ARG(event);
/* Re-start read task */
thread_add_read(zdplane_info.dg_master, dplane_incoming_read, zi,
zi->info.sock, &zi->t_read);
-
- return 0;
}
#endif /* HAVE_NETLINK */
* final zebra shutdown.
* This runs in the dplane pthread context.
*/
-static int dplane_check_shutdown_status(struct thread *event)
+static void dplane_check_shutdown_status(struct thread *event)
{
struct dplane_zns_info *zi;
*/
thread_add_event(zrouter.master, zebra_finalize, NULL, 0, NULL);
}
-
- return 0;
}
/*
* pthread can look for other pending work - such as i/o work on behalf of
* providers.
*/
-static int dplane_thread_loop(struct thread *event)
+static void dplane_thread_loop(struct thread *event)
{
struct dplane_ctx_q work_list;
struct dplane_ctx_q error_list;
/* Check for zebra shutdown */
if (!zdplane_info.dg_run)
- goto done;
+ return;
/* Dequeue some incoming work from zebra (if any) onto the temporary
* working list.
(zdplane_info.dg_results_cb)(&work_list);
TAILQ_INIT(&work_list);
-
-done:
- return 0;
}
/*
return buf;
}
-static int zebra_evpn_dad_mac_auto_recovery_exp(struct thread *t)
+static void zebra_evpn_dad_mac_auto_recovery_exp(struct thread *t)
{
struct zebra_vrf *zvrf = NULL;
struct zebra_mac *mac = NULL;
/* since this is asynchronous we need sanity checks*/
zvrf = vrf_info_lookup(mac->zevpn->vrf_id);
if (!zvrf)
- return 0;
+ return;
zevpn = zebra_evpn_lookup(mac->zevpn->vni);
if (!zevpn)
- return 0;
+ return;
mac = zebra_evpn_mac_lookup(zevpn, &mac->macaddr);
if (!mac)
- return 0;
+ return;
if (IS_ZEBRA_DEBUG_VXLAN) {
char mac_buf[MAC_BUF_SIZE];
if (zebra_evpn_mac_send_add_to_client(zevpn->vni, &mac->macaddr,
mac->flags, mac->loc_seq,
mac->es))
- return -1;
+ return;
/* Process all neighbors associated with this MAC. */
zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
/* Install the entry. */
zebra_evpn_rem_mac_install(zevpn, mac, false /* was_static */);
}
-
- return 0;
}
static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
* external neighmgr daemon to probe existing hosts to independently
* establish their presence on the ES.
*/
-static int zebra_evpn_mac_hold_exp_cb(struct thread *t)
+static void zebra_evpn_mac_hold_exp_cb(struct thread *t)
{
struct zebra_mac *mac;
bool old_bgp_ready;
* flag
*/
if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_ACTIVE))
- return 0;
+ return;
old_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
old_static = zebra_evpn_mac_is_static(mac);
if (old_bgp_ready != new_bgp_ready)
zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready,
new_bgp_ready);
-
- return 0;
}
static inline void zebra_evpn_mac_start_hold_timer(struct zebra_mac *mac)
zebra_evpn_acc_vl_adv_svi_mac_all();
}
-static int zebra_evpn_es_df_delay_exp_cb(struct thread *t)
+static void zebra_evpn_es_df_delay_exp_cb(struct thread *t)
{
struct zebra_evpn_es *es;
zlog_debug("es %s df-delay expired", es->esi_str);
zebra_evpn_es_run_df_election(es, __func__);
-
- return 0;
}
/* currently there is no global config to turn on MH instead we use
new_protodown);
}
-static int zebra_evpn_mh_startup_delay_exp_cb(struct thread *t)
+static void zebra_evpn_mh_startup_delay_exp_cb(struct thread *t)
{
if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
zlog_debug("startup-delay expired");
zebra_evpn_mh_update_protodown(ZEBRA_PROTODOWN_EVPN_STARTUP_DELAY,
false /* set */);
-
- return 0;
}
static void zebra_evpn_mh_startup_delay_timer_start(const char *rc)
* external neighmgr daemon to probe existing hosts to independently
* establish their presence on the ES.
*/
-static int zebra_evpn_neigh_hold_exp_cb(struct thread *t)
+static void zebra_evpn_neigh_hold_exp_cb(struct thread *t)
{
struct zebra_neigh *n;
bool old_bgp_ready;
* flag
*/
if (!CHECK_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_ACTIVE))
- return 0;
+ return;
old_bgp_ready = zebra_evpn_neigh_is_ready_for_bgp(n);
old_n_static = zebra_evpn_neigh_is_static(n);
if (old_bgp_ready != new_bgp_ready)
zebra_evpn_neigh_send_add_del_to_client(n, old_bgp_ready,
new_bgp_ready);
-
- return 0;
}
static inline void zebra_evpn_neigh_start_hold_timer(struct zebra_neigh *n)
return 0;
}
-static int zebra_evpn_dad_ip_auto_recovery_exp(struct thread *t)
+static void zebra_evpn_dad_ip_auto_recovery_exp(struct thread *t)
{
struct zebra_vrf *zvrf = NULL;
struct zebra_neigh *nbr = NULL;
/* since this is asynchronous we need sanity checks*/
zvrf = vrf_info_lookup(nbr->zevpn->vrf_id);
if (!zvrf)
- return 0;
+ return;
zevpn = zebra_evpn_lookup(nbr->zevpn->vni);
if (!zevpn)
- return 0;
+ return;
nbr = zebra_evpn_neigh_lookup(zevpn, &nbr->ip);
if (!nbr)
- return 0;
+ return;
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
} else if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE)) {
zebra_evpn_rem_neigh_install(zevpn, nbr, false /*was_static*/);
}
-
- return 0;
}
static void zebra_evpn_dup_addr_detect_for_neigh(
static int zfpm_trigger_update(struct route_node *rn, const char *reason);
-static int zfpm_read_cb(struct thread *thread);
-static int zfpm_write_cb(struct thread *thread);
+static void zfpm_read_cb(struct thread *thread);
+static void zfpm_write_cb(struct thread *thread);
static void zfpm_set_state(enum zfpm_state state, const char *reason);
static void zfpm_start_connect_timer(const char *reason);
* Callback for actions to be taken when the connection to the FPM
* comes up.
*/
-static int zfpm_conn_up_thread_cb(struct thread *thread)
+static void zfpm_conn_up_thread_cb(struct thread *thread)
{
struct route_node *rnode;
struct zfpm_rnodes_iter *iter;
zfpm_rnodes_iter_pause(iter);
thread_add_timer_msec(zfpm_g->master, zfpm_conn_up_thread_cb,
NULL, 0, &zfpm_g->t_conn_up);
- return 0;
+ return;
}
zfpm_g->stats.t_conn_up_finishes++;
done:
zfpm_rnodes_iter_cleanup(iter);
- return 0;
}
/*
* Callback that is invoked to clean up state after the TCP connection
* to the FPM goes down.
*/
-static int zfpm_conn_down_thread_cb(struct thread *thread)
+static void zfpm_conn_down_thread_cb(struct thread *thread)
{
struct route_node *rnode;
struct zfpm_rnodes_iter *iter;
zfpm_g->t_conn_down = NULL;
thread_add_timer_msec(zfpm_g->master, zfpm_conn_down_thread_cb,
NULL, 0, &zfpm_g->t_conn_down);
- return 0;
+ return;
}
zfpm_g->stats.t_conn_down_finishes++;
* Start the process of connecting to the FPM again.
*/
zfpm_start_connect_timer("cleanup complete");
- return 0;
}
/*
/*
* zfpm_read_cb
*/
-static int zfpm_read_cb(struct thread *thread)
+static void zfpm_read_cb(struct thread *thread)
{
size_t already;
struct stream *ibuf;
*/
if (zfpm_g->state == ZFPM_STATE_CONNECTING) {
zfpm_connect_check();
- return 0;
+ return;
}
assert(zfpm_g->state == ZFPM_STATE_ESTABLISHED);
zfpm_connection_down(buffer);
} else
zfpm_connection_down("closed socket in read");
- return 0;
+ return;
}
if (nbyte != (ssize_t)(FPM_MSG_HDR_LEN - already))
if (!fpm_msg_hdr_ok(hdr)) {
zfpm_connection_down("invalid message header");
- return 0;
+ return;
}
msg_len = fpm_msg_len(hdr);
zfpm_connection_down(buffer);
} else
zfpm_connection_down("failed to read message");
- return 0;
+ return;
}
if (nbyte != (ssize_t)(msg_len - already))
done:
zfpm_read_on();
- return 0;
}
static bool zfpm_updates_pending(void)
/*
* zfpm_write_cb
*/
-static int zfpm_write_cb(struct thread *thread)
+static void zfpm_write_cb(struct thread *thread)
{
struct stream *s;
int num_writes;
*/
if (zfpm_g->state == ZFPM_STATE_CONNECTING) {
zfpm_connect_check();
- return 0;
+ return;
}
assert(zfpm_g->state == ZFPM_STATE_ESTABLISHED);
break;
zfpm_connection_down("failed to write to socket");
- return 0;
+ return;
}
if (bytes_written != bytes_to_write) {
if (zfpm_writes_pending())
zfpm_write_on();
-
- return 0;
}
/*
* zfpm_connect_cb
*/
-static int zfpm_connect_cb(struct thread *t)
+static void zfpm_connect_cb(struct thread *t)
{
int sock, ret;
struct sockaddr_in serv;
zlog_err("Failed to create socket for connect(): %s",
strerror(errno));
zfpm_g->stats.connect_no_sock++;
- return 0;
+ return;
}
set_nonblocking(sock);
if (ret >= 0) {
zfpm_g->sock = sock;
zfpm_connection_up("connect succeeded");
- return 1;
+ return;
}
if (errno == EINPROGRESS) {
zfpm_write_on();
zfpm_set_state(ZFPM_STATE_CONNECTING,
"async connect in progress");
- return 0;
+ return;
}
zlog_info("can't connect to FPM %d: %s", sock, safe_strerror(errno));
* Restart timer for retrying connection.
*/
zfpm_start_connect_timer("connect() failed");
- return 0;
}
/*
/*
* struct zfpm_statsimer_cb
*/
-static int zfpm_stats_timer_cb(struct thread *t)
+static void zfpm_stats_timer_cb(struct thread *t)
{
zfpm_g->t_stats = NULL;
zfpm_stats_reset(&zfpm_g->stats);
zfpm_start_stats_timer();
-
- return 0;
}
/*
* Forward declaration.
*/
static struct zserv *zebra_gr_find_stale_client(struct zserv *client);
-static int32_t zebra_gr_route_stale_delete_timer_expiry(struct thread *thread);
+static void zebra_gr_route_stale_delete_timer_expiry(struct thread *thread);
static int32_t zebra_gr_delete_stale_routes(struct client_gr_info *info);
static void zebra_gr_process_client_stale_routes(struct zserv *client,
vrf_id_t vrf_id);
* Delete all the stale routes that have not been refreshed
* post restart.
*/
-static int32_t zebra_gr_route_stale_delete_timer_expiry(struct thread *thread)
+static void zebra_gr_route_stale_delete_timer_expiry(struct thread *thread)
{
struct client_gr_info *info;
int32_t cnt = 0;
info->current_afi = 0;
zebra_gr_delete_stale_client(info);
}
- return 0;
}
static bool test_mlag_in_progress;
static int zebra_mlag_signal_write_thread(void);
-static int zebra_mlag_terminate_pthread(struct thread *event);
-static int zebra_mlag_post_data_from_main_thread(struct thread *thread);
+static void zebra_mlag_terminate_pthread(struct thread *event);
+static void zebra_mlag_post_data_from_main_thread(struct thread *thread);
static void zebra_mlag_publish_process_state(struct zserv *client,
zebra_message_types_t msg_type);
* This thread reads the clients data from the Global queue and encodes with
* protobuf and pass on to the MLAG socket.
*/
-static int zebra_mlag_client_msg_handler(struct thread *event)
+static void zebra_mlag_client_msg_handler(struct thread *event)
{
struct stream *s;
uint32_t wr_count = 0;
*/
if (wr_count >= ZEBRA_MLAG_POST_LIMIT)
zebra_mlag_signal_write_thread();
- return 0;
}
/*
* main thread, because for that access was needed for clients list.
* so instead of forcing the locks, messages will be posted from main thread.
*/
-static int zebra_mlag_post_data_from_main_thread(struct thread *thread)
+static void zebra_mlag_post_data_from_main_thread(struct thread *thread)
{
struct stream *s = THREAD_ARG(thread);
struct stream *zebra_s = NULL;
uint32_t msg_len = 0;
if (!s)
- return -1;
+ return;
STREAM_GETL(s, msg_type);
if (IS_ZEBRA_DEBUG_MLAG)
}
stream_free(s);
- return 0;
+ return;
stream_failure:
stream_free(s);
if (zebra_s)
stream_free(zebra_s);
- return 0;
}
/*
* all clients are un-registered for MLAG Updates, terminate the
* MLAG write thread
*/
-static int zebra_mlag_terminate_pthread(struct thread *event)
+static void zebra_mlag_terminate_pthread(struct thread *event)
{
if (IS_ZEBRA_DEBUG_MLAG)
zlog_debug("Zebra MLAG write thread terminate called");
if (IS_ZEBRA_DEBUG_MLAG)
zlog_debug(
"Zebra MLAG: still some clients are interested");
- return 0;
+ return;
}
frr_pthread_stop(zrouter.mlag_info.zebra_pth_mlag, NULL);
* Send Notification to clean private data
*/
hook_call(zebra_mlag_private_cleanup_data);
- return 0;
}
/*
static struct thread_master *zmlag_master;
static int mlag_socket;
-static int zebra_mlag_connect(struct thread *thread);
-static int zebra_mlag_read(struct thread *thread);
+static void zebra_mlag_connect(struct thread *thread);
+static void zebra_mlag_read(struct thread *thread);
/*
* Write the data to MLAGD
&zrouter.mlag_info.t_read);
}
-static int zebra_mlag_read(struct thread *thread)
+static void zebra_mlag_read(struct thread *thread)
{
static uint32_t mlag_rd_buf_offset;
uint32_t *msglen;
mlag_socket);
close(mlag_socket);
zebra_mlag_handle_process_state(MLAG_DOWN);
- return -1;
+ return;
}
mlag_rd_buf_offset += data_len;
if (data_len != (ssize_t)(ZEBRA_MLAG_LEN_SIZE - curr_len)) {
/* Try again later */
zebra_mlag_sched_read();
- return 0;
+ return;
}
curr_len = ZEBRA_MLAG_LEN_SIZE;
}
mlag_socket);
close(mlag_socket);
zebra_mlag_handle_process_state(MLAG_DOWN);
- return -1;
+ return;
}
mlag_rd_buf_offset += data_len;
if (data_len != (ssize_t)(tot_len - curr_len)) {
/* Try again later */
zebra_mlag_sched_read();
- return 0;
+ return;
}
}
zebra_mlag_reset_read_buffer();
mlag_rd_buf_offset = 0;
zebra_mlag_sched_read();
- return 0;
}
-static int zebra_mlag_connect(struct thread *thread)
+static void zebra_mlag_connect(struct thread *thread)
{
struct sockaddr_un svr = {0};
mlag_socket = socket(svr.sun_family, SOCK_STREAM, 0);
if (mlag_socket < 0)
- return -1;
+ return;
if (connect(mlag_socket, (struct sockaddr *)&svr, sizeof(svr)) == -1) {
if (IS_ZEBRA_DEBUG_MLAG)
zrouter.mlag_info.timer_running = true;
thread_add_timer(zmlag_master, zebra_mlag_connect, NULL, 10,
&zrouter.mlag_info.t_read);
- return 0;
+ return;
}
set_nonblocking(mlag_socket);
* Connection is established with MLAGD, post to clients
*/
zebra_mlag_handle_process_state(MLAG_UP);
- return 0;
}
/*
unsigned int retries;
};
-static int zebra_ns_ready_read(struct thread *t);
+static void zebra_ns_ready_read(struct thread *t);
static void zebra_ns_notify_create_context_from_entry_name(const char *name);
static int zebra_ns_continue_read(struct zebra_netns_info *zns_info,
int stop_retry);
-static int zebra_ns_notify_read(struct thread *t);
+static void zebra_ns_notify_read(struct thread *t);
static struct vrf *vrf_handler_create(struct vty *vty, const char *vrfname)
{
return false;
}
-static int zebra_ns_ready_read(struct thread *t)
+static void zebra_ns_ready_read(struct thread *t)
{
struct zebra_netns_info *zns_info = THREAD_ARG(t);
const char *netnspath;
int err, stop_retry = 0;
if (!zns_info)
- return 0;
+ return;
if (!zns_info->netnspath) {
XFREE(MTYPE_NETNS_MISC, zns_info);
- return 0;
+ return;
}
netnspath = zns_info->netnspath;
if (--zns_info->retries == 0)
frr_with_privs(&zserv_privs) {
err = ns_switch_to_netns(netnspath);
}
- if (err < 0)
- return zebra_ns_continue_read(zns_info, stop_retry);
+ if (err < 0) {
+ zebra_ns_continue_read(zns_info, stop_retry);
+ return;
+ }
/* go back to default ns */
frr_with_privs(&zserv_privs) {
err = ns_switchback_to_initial();
}
- if (err < 0)
- return zebra_ns_continue_read(zns_info, stop_retry);
+ if (err < 0) {
+ zebra_ns_continue_read(zns_info, stop_retry);
+ return;
+ }
/* check default name is not already set */
if (strmatch(VRF_DEFAULT_NAME, basename(netnspath))) {
zlog_warn("NS notify : NS %s is already default VRF.Cancel VRF Creation", basename(netnspath));
- return zebra_ns_continue_read(zns_info, 1);
+ zebra_ns_continue_read(zns_info, 1);
+ return;
}
if (zebra_ns_notify_is_default_netns(basename(netnspath))) {
zlog_warn(
"NS notify : NS %s is default VRF. Ignore VRF creation",
basename(netnspath));
- return zebra_ns_continue_read(zns_info, 1);
+ zebra_ns_continue_read(zns_info, 1);
+ return;
}
/* success : close fd and create zns context */
zebra_ns_notify_create_context_from_entry_name(basename(netnspath));
- return zebra_ns_continue_read(zns_info, 1);
+ zebra_ns_continue_read(zns_info, 1);
}
-static int zebra_ns_notify_read(struct thread *t)
+static void zebra_ns_notify_read(struct thread *t)
{
int fd_monitor = THREAD_FD(t);
struct inotify_event *event;
flog_err_sys(EC_ZEBRA_NS_NOTIFY_READ,
"NS notify read: failed to read (%s)",
safe_strerror(errno));
- return 0;
+ return;
}
for (event = (struct inotify_event *)buf; (char *)event < &buf[len];
event = (struct inotify_event *)((char *)event + sizeof(*event)
thread_add_timer_msec(zrouter.master, zebra_ns_ready_read,
(void *)netnsinfo, 0, NULL);
}
- return 0;
}
void zebra_ns_notify_parse(void)
/* Prototypes */
/* Main event loop, processing incoming message queue */
-static int process_messages(struct thread *event);
+static void process_messages(struct thread *event);
static int handle_opq_registration(const struct zmsghdr *hdr,
struct stream *msg);
static int handle_opq_unregistration(const struct zmsghdr *hdr,
/*
* Pthread event loop, process the incoming message queue.
*/
-static int process_messages(struct thread *event)
+static void process_messages(struct thread *event)
{
struct stream_fifo fifo;
struct stream *msg;
/* This will also free any leftover messages, in the shutdown case */
stream_fifo_deinit(&fifo);
-
- return 0;
}
/*
struct zebra_ptm_cb ptm_cb;
static int zebra_ptm_socket_init(void);
-int zebra_ptm_sock_read(struct thread *);
+void zebra_ptm_sock_read(struct thread *thread);
static void zebra_ptm_install_commands(void);
static int zebra_ptm_handle_msg_cb(void *arg, void *in_ctxt);
void zebra_bfd_peer_replay_req(void);
close(ptm_cb.ptm_sock);
}
-static int zebra_ptm_flush_messages(struct thread *thread)
+static void zebra_ptm_flush_messages(struct thread *thread)
{
ptm_cb.t_write = NULL;
if (ptm_cb.ptm_sock == -1)
- return -1;
+ return;
errno = 0;
ptm_cb.t_timer = NULL;
thread_add_timer(zrouter.master, zebra_ptm_connect, NULL,
ptm_cb.reconnect_time, &ptm_cb.t_timer);
- return -1;
+ return;
case BUFFER_PENDING:
ptm_cb.t_write = NULL;
thread_add_write(zrouter.master, zebra_ptm_flush_messages, NULL,
case BUFFER_EMPTY:
break;
}
-
- return 0;
}
static int zebra_ptm_send_message(char *data, int size)
return 0;
}
-int zebra_ptm_connect(struct thread *t)
+void zebra_ptm_connect(struct thread *t)
{
int init = 0;
} else if (ptm_cb.reconnect_time >= ZEBRA_PTM_RECONNECT_TIME_MAX) {
ptm_cb.reconnect_time = ZEBRA_PTM_RECONNECT_TIME_INITIAL;
}
-
- return (errno);
}
DEFUN (zebra_ptm_enable,
}
}
-int zebra_ptm_sock_read(struct thread *thread)
+void zebra_ptm_sock_read(struct thread *thread)
{
int sock;
int rc;
sock = THREAD_FD(thread);
if (sock == -1)
- return -1;
+ return;
/* PTM communicates in CSV format */
do {
thread_add_timer(zrouter.master, zebra_ptm_connect, NULL,
ptm_cb.reconnect_time,
&ptm_cb.t_timer);
- return -1;
+ return;
}
ptm_cb.t_read = NULL;
thread_add_read(zrouter.master, zebra_ptm_sock_read, NULL,
ptm_cb.ptm_sock, &ptm_cb.t_read);
-
- return 0;
}
/* BFD peer/dst register/update */
void zebra_ptm_init(void);
void zebra_ptm_finish(void);
-int zebra_ptm_connect(struct thread *t);
+void zebra_ptm_connect(struct thread *t);
void zebra_ptm_write(struct vty *vty);
int zebra_ptm_get_enable_state(void);
static int zebra_pw_enabled(struct zebra_pw *);
static void zebra_pw_install(struct zebra_pw *);
static void zebra_pw_uninstall(struct zebra_pw *);
-static int zebra_pw_install_retry(struct thread *);
+static void zebra_pw_install_retry(struct thread *thread);
static int zebra_pw_check_reachability(const struct zebra_pw *);
static void zebra_pw_update_status(struct zebra_pw *, int);
zebra_pw_update_status(pw, pwstatus);
}
-static int zebra_pw_install_retry(struct thread *thread)
+static void zebra_pw_install_retry(struct thread *thread)
{
struct zebra_pw *pw = THREAD_ARG(thread);
pw->install_retry_timer = NULL;
zebra_pw_install(pw);
-
- return 0;
}
static void zebra_pw_update_status(struct zebra_pw *pw, int status)
XFREE(MTYPE_RIB_UPDATE_CTX, *ctx);
}
-static int rib_update_handler(struct thread *thread)
+static void rib_update_handler(struct thread *thread)
{
struct rib_update_ctx *ctx;
rib_update_handle_vrf(ctx->vrf_id, ctx->event, ZEBRA_ROUTE_ALL);
rib_update_ctx_fini(&ctx);
-
- return 0;
}
/*
}
/* Sweep all RIB tables. */
-int rib_sweep_route(struct thread *t)
+void rib_sweep_route(struct thread *t)
{
struct vrf *vrf;
struct zebra_vrf *zvrf;
zebra_router_sweep_route();
zebra_router_sweep_nhgs();
-
- return 0;
}
/* Remove specific by protocol routes from 'table'. */
* Handle results from the dataplane system. Dequeue update context
* structs, dispatch to appropriate internal handlers.
*/
-static int rib_process_dplane_results(struct thread *thread)
+static void rib_process_dplane_results(struct thread *thread)
{
struct zebra_dplane_ctx *ctx;
struct dplane_ctx_q ctxlist;
}
} while (1);
-
- return 0;
}
/*
zebra_nht_rm_update(rmap_name);
}
-static int zebra_route_map_update_timer(struct thread *thread)
+static void zebra_route_map_update_timer(struct thread *thread)
{
if (IS_ZEBRA_DEBUG_EVENT)
zlog_debug("Event driven route-map update triggered");
* 1) VRF Aware <sigh>
* 2) Route-map aware
*/
- return 0;
}
static void zebra_route_map_set_delay_timer(uint32_t value)
* allows us to expose information about input and output queues to the user in
* terms of number of packets rather than size of data.
*/
-static int zserv_write(struct thread *thread)
+static void zserv_write(struct thread *thread)
{
struct zserv *client = THREAD_ARG(thread);
struct stream *msg;
(uint32_t)monotime(NULL),
memory_order_relaxed);
zserv_client_event(client, ZSERV_CLIENT_WRITE);
- return 0;
+ return;
case BUFFER_EMPTY:
break;
}
(uint32_t)monotime(NULL),
memory_order_relaxed);
zserv_client_event(client, ZSERV_CLIENT_WRITE);
- return 0;
+ return;
case BUFFER_EMPTY:
break;
}
atomic_store_explicit(&client->last_write_time,
(uint32_t)monotime(NULL), memory_order_relaxed);
- return 0;
+ return;
zwrite_fail:
flog_warn(EC_ZEBRA_CLIENT_WRITE_FAILED,
"%s: could not write to %s [fd = %d], closing.", __func__,
zebra_route_string(client->proto), client->sock);
zserv_client_fail(client);
- return 0;
}
/*
*
* Any failure in any of these actions is handled by terminating the client.
*/
-static int zserv_read(struct thread *thread)
+static void zserv_read(struct thread *thread)
{
struct zserv *client = THREAD_ARG(thread);
int sock;
stream_fifo_free(cache);
- return 0;
+ return;
zread_fail:
stream_fifo_free(cache);
zserv_client_fail(client);
- return -1;
}
static void zserv_client_event(struct zserv *client,
* rely on the read thread to handle queuing this task enough times to process
* everything on the input queue.
*/
-static int zserv_process_messages(struct thread *thread)
+static void zserv_process_messages(struct thread *thread)
{
struct zserv *client = THREAD_ARG(thread);
struct stream *msg;
/* Reschedule ourselves if necessary */
if (need_resched)
zserv_event(client, ZSERV_PROCESS_MESSAGES);
-
- return 0;
}
int zserv_send_message(struct zserv *client, struct stream *msg)
* already have been closed and the thread will most likely have died, but its
* resources still need to be cleaned up.
*/
-static int zserv_handle_client_fail(struct thread *thread)
+static void zserv_handle_client_fail(struct thread *thread)
{
struct zserv *client = THREAD_ARG(thread);
zserv_close_client(client);
- return 0;
}
/*
/*
* Accept socket connection.
*/
-static int zserv_accept(struct thread *thread)
+static void zserv_accept(struct thread *thread)
{
int accept_sock;
int client_sock;
if (client_sock < 0) {
flog_err_sys(EC_LIB_SOCKET, "Can't accept zebra socket: %s",
safe_strerror(errno));
- return -1;
+ return;
}
/* Make client socket non-blocking. */
/* Create new zebra client. */
zserv_client_create(client_sock);
-
- return 0;
}
void zserv_close(void)
struct zmsghdr *hdr);
/* TODO */
-__attribute__((__noreturn__)) int zebra_finalize(struct thread *event);
+__attribute__((__noreturn__)) void zebra_finalize(struct thread *event);
/*
* Graceful restart functions.
projects / mirror_frr.git / commitdiff