static void
server_agent (void *args, zctx_t *ctx, void *pipe)
{
agent_t *self = agent_new (ctx, pipe);
zmq_pollitem_t items [] = {
{ self->pipe, 0, ZMQ_POLLIN, 0 },
{ self->router, 0, ZMQ_POLLIN, 0 }
};
while (!self->stopped) {
// Calculate tickless timer, up to 1 hour
uint64_t tickless = zclock_time () + 1000 * 3600;
zhash_foreach (self->clients, client_tickless, &tickless);
// Poll until at most next timer event
int rc = zmq_poll (items, 2,
(tickless - zclock_time ()) * ZMQ_POLL_MSEC);
if (rc == -1)
break; // Context has been shut down
// Process incoming message from either socket
if (items [0].revents & ZMQ_POLLIN)
agent_control_message (self);
if (items [1].revents & ZMQ_POLLIN)
agent_client_message (self);
// Send heartbeats to idle clients as needed
zhash_foreach (self->clients, client_ping, self->router);
}
agent_destroy (&self);
}
static void *
flcliapi_task (void *context)
{
agent_t *self = agent_new (context, "inproc://flcliapi");
zmq_pollitem_t items [] = {
{ self->control, 0, ZMQ_POLLIN, 0 },
{ self->router, 0, ZMQ_POLLIN, 0 }
};
while (!s_interrupted) {
// Calculate tickless timer, up to 1 hour
uint64_t tickless = s_clock () + 1000 * 3600;
if (self->request
&& tickless > self->expires)
tickless = self->expires;
zhash_apply (self->servers, server_tickless, &tickless);
int rc = zmq_poll (items, 2, (tickless - s_clock ()) * 1000);
if (rc == -1 && errno == ETERM)
break; // Context has been shut down
if (items [0].revents & ZMQ_POLLIN)
agent_control_message (self);
if (items [1].revents & ZMQ_POLLIN)
agent_router_message (self);
// If we're processing a request, dispatch to next server
if (self->request) {
if (s_clock () >= self->expires) {
// Request expired, kill it
zmsg_t *reply = zmsg_new ("FAILED");
zmsg_send (&reply, self->control);
zmsg_destroy (&self->request);
}
else {
// Find server to talk to, remove any expired ones
while (zlist_size (self->actives)) {
server_t *server = (server_t *) zlist_first (self->actives);
if (s_clock () >= server->expires) {
zlist_pop (self->actives);
server->alive = 0;
}
else {
zmsg_t *request = zmsg_dup (self->request);
zmsg_push (request, server->endpoint);
zmsg_send (&request, self->router);
break;
}
}
}
}
// Disconnect and delete any expired servers
// Send heartbeats to idle servers if needed
zhash_apply (self->servers, server_ping, self->router);
}
agent_destroy (&self);
return NULL;
}
static void
zre_node_agent (void *args, zctx_t *ctx, void *pipe)
{
// Create agent instance to pass around
agent_t *self = agent_new (ctx, pipe);
if (!self) // Interrupted
return;
// Send first beacon immediately
uint64_t ping_at = zclock_time ();
zmq_pollitem_t pollitems [] = {
{ self->pipe, 0, ZMQ_POLLIN, 0 },
{ self->inbox, 0, ZMQ_POLLIN, 0 },
{ 0, zre_udp_handle (self->udp), ZMQ_POLLIN, 0 },
{ fmq_client_handle (self->fmq_client), 0, ZMQ_POLLIN, 0 }
};
while (!zctx_interrupted) {
long timeout = (long) (ping_at - zclock_time ());
assert (timeout <= PING_INTERVAL);
if (timeout < 0)
timeout = 0;
if (zmq_poll (pollitems, 4, timeout * ZMQ_POLL_MSEC) == -1)
break; // Interrupted
if (pollitems [0].revents & ZMQ_POLLIN)
agent_recv_from_api (self);
if (pollitems [1].revents & ZMQ_POLLIN)
agent_recv_from_peer (self);
if (pollitems [2].revents & ZMQ_POLLIN)
agent_recv_udp_beacon (self);
if (pollitems [3].revents & ZMQ_POLLIN)
agent_recv_fmq_event (self);
if (zclock_time () >= ping_at) {
agent_beacon_send (self);
ping_at = zclock_time () + PING_INTERVAL;
// Ping all peers and reap any expired ones
zhash_foreach (self->peers, agent_ping_peer, self);
}
}
agent_destroy (&self);
}
/**
* @brief Create a new ssh session.
*
* @returns A new ssh_session pointer, NULL on error.
*/
ssh_session ssh_new(void) {
ssh_session session;
char *id = NULL;
int rc;
session = malloc(sizeof (struct ssh_session_struct));
if (session == NULL) {
return NULL;
}
ZERO_STRUCTP(session);
session->next_crypto = crypto_new();
if (session->next_crypto == NULL) {
goto err;
}
session->socket = ssh_socket_new(session);
if (session->socket == NULL) {
goto err;
}
session->out_buffer = ssh_buffer_new();
if (session->out_buffer == NULL) {
goto err;
}
session->in_buffer=ssh_buffer_new();
if (session->in_buffer == NULL) {
goto err;
}
session->alive = 0;
session->auth_methods = 0;
ssh_set_blocking(session, 1);
session->common.log_indent = 0;
session->maxchannel = FIRST_CHANNEL;
#ifndef _WIN32
session->agent = agent_new(session);
if (session->agent == NULL) {
goto err;
}
#endif /* _WIN32 */
/* OPTIONS */
session->opts.StrictHostKeyChecking = 1;
session->opts.port = 22;
session->opts.fd = -1;
session->opts.ssh2 = 1;
session->opts.compressionlevel=7;
#ifdef WITH_SSH1
session->opts.ssh1 = 1;
#else
session->opts.ssh1 = 0;
#endif
session->opts.identity = ssh_list_new();
if (session->opts.identity == NULL) {
goto err;
}
id = strdup("%d/id_rsa");
if (id == NULL) {
goto err;
}
rc = ssh_list_append(session->opts.identity, id);
if (rc == SSH_ERROR) {
goto err;
}
id = strdup("%d/id_dsa");
if (id == NULL) {
goto err;
}
rc = ssh_list_append(session->opts.identity, id);
if (rc == SSH_ERROR) {
goto err;
}
id = strdup("%d/identity");
if (id == NULL) {
goto err;
}
rc = ssh_list_append(session->opts.identity, id);
if (rc == SSH_ERROR) {
goto err;
}
return session;
err:
free(id);
ssh_free(session);
return NULL;
}
