int ccnet_processor_start (CcnetProcessor *processor, int argc, char **argv)
{
/* set this value to now even if this is a master processor and
has not received any packet yet for simplifying the keepalive
logic. */
g_assert (processor->start_time == 0);
time_t now = time(NULL);
processor->start_time = now;
if (IS_SLAVE(processor))
processor->t_packet_recv = now;
else
processor->t_packet_recv = 0;
processor->failure = PROC_NOTSET;
if (processor->peer->net_state != PEER_CONNECTED) {
if (IS_SLAVE(processor)) {
ccnet_processor_send_response (processor, SC_NETDOWN, SS_NETDOWN,
NULL, 0);
}
processor->failure = PROC_NETDOWN;
ccnet_processor_done (processor, FALSE);
return -1;
}
return CCNET_PROCESSOR_GET_CLASS (processor)->start (
processor, argc, argv);
}
void
ccnet_processor_done (CcnetProcessor *processor,
gboolean success)
{
if (processor->thread_running) {
processor->delay_shutdown = TRUE;
processor->was_success = success;
return;
}
if (processor->state == STATE_IN_SHUTDOWN) {
return;
}
processor->state = STATE_IN_SHUTDOWN;
if (processor->failure == PROC_NOTSET && success)
processor->failure = PROC_DONE;
g_debug ("[proc] Processor %s(%d) done %d\n", GET_PNAME(processor),
PRINT_ID(processor->id), success);
/* Notify */
if (!IS_SLAVE (processor) && success) {
ccnet_processor_send_update (processor, SC_PROC_DONE, SS_PROC_DONE,
NULL, 0);
}
g_signal_emit (processor, signals[DONE_SIG], 0, success);
ccnet_client_remove_processor (processor->session, processor);
ccnet_processor_release_resource (processor);
ccnet_proc_factory_recycle (processor->session->proc_factory, processor);
}
static void ccnet_processor_keep_alive_response (CcnetProcessor *processor)
{
if (IS_SLAVE (processor))
ccnet_processor_send_response (processor, SC_PROC_ALIVE,
SS_PROC_ALIVE, NULL, 0);
else
ccnet_processor_send_update (processor, SC_PROC_ALIVE,
SS_PROC_ALIVE, NULL, 0);
}
static void msm_bus_bimc_node_init(void *hw_data,
struct msm_bus_inode_info *info)
{
struct msm_bus_bimc_info *binfo =
(struct msm_bus_bimc_info *)hw_data;
if (!IS_SLAVE(info->node_info->priv_id) &&
(info->node_info->hw_sel != MSM_BUS_RPM))
msm_bus_bimc_mas_init(binfo, info);
}
void ccnet_processor_keep_alive (CcnetProcessor *processor)
{
if (IS_SLAVE (processor))
ccnet_processor_send_response (processor, SC_PROC_KEEPALIVE,
SS_PROC_KEEPALIVE, NULL, 0);
else
ccnet_processor_send_update (processor, SC_PROC_KEEPALIVE,
SS_PROC_KEEPALIVE, NULL, 0);
processor->t_keepalive_sent = time (NULL);
}
void
ccnet_processor_done (CcnetProcessor *processor, gboolean success)
{
if (processor->thread_running) {
processor->delay_shutdown = TRUE;
processor->was_success = success;
return;
}
if (processor->state == STATE_IN_SHUTDOWN) {
return;
}
processor->state = STATE_IN_SHUTDOWN;
if (processor->failure == PROC_NOTSET)
processor->failure = PROC_DONE;
if (!processor->peer->is_local)
ccnet_debug ("Processsor %s(%d) done %d\n", GET_PNAME(processor),
PRINT_ID(processor->id), success);
if (!processor->detached && success)
{
if (!IS_SLAVE (processor)) {
ccnet_processor_send_update (processor, SC_PROC_DONE, SS_PROC_DONE,
NULL, 0);
}
}
/* When we emit the done signal, the corresponding handler may
* shutdown the peer, we should remove this processor from the
* peers processor list, otherwise this processor will be freed
* twice. */
g_signal_emit (processor, signals[DONE_SIG], 0, success);
if (!processor->detached) {
ccnet_peer_remove_processor (processor->peer, processor);
}
ccnet_processor_release_resource (processor);
ccnet_proc_factory_recycle (processor->session->proc_factory, processor);
}
static int keepalive_start (CcnetProcessor *processor,
int argc, char **argv)
{
CcnetKeepaliveProcPriv *priv = GET_PRIV (processor);
if (IS_SLAVE(processor)) {
char buf[16];
int v, len;
if (argc == 0) {
priv->used_version = 0;
ccnet_processor_send_response (processor,
SC_VERSION_MISMATCH, SS_VERSION_MISMATCH, NULL, 0);
ccnet_processor_done (processor, FALSE);
return 0;
} else {
v = get_version(argv[0]);
if ((priv->used_version = get_used_version(v)) == -1) {
ccnet_processor_send_response (processor,
SC_VERSION_MISMATCH, SS_VERSION_MISMATCH, NULL, 0);
ccnet_processor_done (processor, FALSE);
return 0;
}
len = snprintf (buf, 16, "v%d", priv->used_version);
ccnet_processor_send_response (processor,
SC_OK, SS_OK, buf, len + 1);
return 0;
}
}
/* master */
g_assert (processor->peer->keepalive_sending == 0);
priv->count = 0;
processor->state = INIT;
processor->peer->keepalive_sending = 1;
send_request (processor);
reset_timeout (processor);
return 0;
}
static void proc_shutdown (CcnetProcessor *processor)
{
CcnetPeer *peer = processor->peer;
if (IS_SLAVE(processor))
return;
if (peer->net_state == PEER_INDIRECT) {
/* In indirect connection, we may receive SC_PROC_DEAD,
* which cause shutdown be called.
*/
/* detach from the peer */
ccnet_peer_remove_processor (processor->peer, processor);
ccnet_peer_shutdown (peer);
peer->num_fails++;
} else {
/* Otherwise the shutdown of keepalive is only be called in
* peer shutdown */
g_assert (peer->in_shutdown);
}
}
static int
protocol_ssl_disconnect(protocol_t * p)
{
int r;
ssl_private_t *ssl_p = (ssl_private_t *) p->_protocol_p;
if (!p)
return (0);
/*
* workaround for the bug calling protocol_disconnect multiple
* times
*/
if (ssl_p->ssl != NULL) {
r = SSL_shutdown(ssl_p->ssl);
if ((!r) && (IS_SLAVE(options))) {
shutdown(p->fd, 1);
r = SSL_shutdown(ssl_p->ssl);
}
switch (r) {
case 1:
case 0:
case -1:
break;
default:
uperf_log_msg(UPERF_LOG_ERROR, 0,
"ssl shutdown failed");
return (-1);
}
if (!ssl_p->ssl)
SSL_free(ssl_p->ssl);
} /* workaround ends */
return (close(p->fd));
}
