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;
}
/*
vxlan_if = zl3vni_map_to_vxlan_if(zl3vni);
svi_if = zl3vni_map_to_svi_if(zl3vni);
- memset(&key, 0, sizeof(struct fpm_mac_info_t));
+ memset(&key, 0, sizeof(key));
memcpy(&key.macaddr, &rmac->macaddr, ETH_ALEN);
key.vni = zl3vni->vni;
UNSET_FLAG(fpm_mac->fpm_flags, ZEBRA_MAC_UPDATE_FPM);
return 0;
}
- } else {
+ } else
fpm_mac = hash_get(zfpm_g->fpm_mac_info_table, &key,
zfpm_mac_info_alloc);
- if (!fpm_mac)
- return 0;
- }
fpm_mac->r_vtep_ip.s_addr = rmac->fwd_info.r_vtep_ip.s_addr;
fpm_mac->zebra_flags = rmac->flags;
/*
* 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;
}
/*