SILC_FSM_EVENT_SIGNAL(&thread->server->thread_up);
/* Wait here for this thread to finish */
- SILC_FSM_WAIT;
+ return SILC_FSM_WAIT;
}
/* Thread's machine's main state where we wait for various events. */
silc_list_init(thread->packet_queue, struct SilcPacketStruct, next);
thread->new_packet = FALSE;
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_mutex_lock(thread->server->lock);
thread->new_connection = FALSE;
silc_mutex_unlock(thread->server->lock);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* NOT REACHED */
#if defined(SILC_DEBUG)
assert(FALSE);
#endif /* SILC_DEBUG */
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Call running callbcak back to application */
server->run_callback = FALSE;
server->running(server, server->running_context);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (server->new_connection) {
/** New connection */
silc_fsm_next(fsm, silc_server_st_new_connection);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (server->connect_router) {
/** Connect to router(s) */
silc_fsm_next(fsm, silc_server_st_connect_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (server->get_statistics) {
/** Retrieve statistics */
silc_fsm_next(fsm, silc_server_st_get_stats);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (server->reconfigure) {
/** Reconfigure server */
silc_fsm_next(fsm, silc_server_st_reconfigure);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (server->server_shutdown) {
/** Shutdown server */
silc_fsm_next(fsm, silc_server_st_stop);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* NOT REACHED */
#if defined(SILC_DEBUG)
assert(FALSE);
#endif /* SILC_DEBUG */
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* New connection received */
}
silc_fsm_next(fsm, silc_server_st_wait_new_thread);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_list_del(server->new_conns, ac);
/** Connections processed */
silc_fsm_next(fsm, silc_server_st_run);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Wait here until newly created thread is up */
/** Process new connections */
silc_fsm_next(fsm, silc_server_st_new_connection);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Stops server */
/** Wait events */
silc_fsm_next(fsm, silc_server_st_run);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Reconfigure server */
/** Wait events */
server->reconfigure = FALSE;
silc_fsm_next(fsm, silc_server_st_run);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Get statistics */
/** Wait events */
server->get_statistics = FALSE;
silc_fsm_next(fsm, silc_server_st_run);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Cannot create packet stream */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_packet_set_context(ac->packet_stream, ac);
/** Out of memory */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (!silc_socket_stream_get_info(ac->stream, NULL, &ac->hostname,
/** Bad socket stream */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Check whether this connection is denied to connect to us. */
SILC_LOG_INFO(("Connection %s (%s) is denied", ac->hostname, ac->ip));
ac->error = SILC_STATUS_ERR_BANNED_FROM_SERVER;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
server->params->refcnt++;
ac->ip));
ac->error = SILC_STATUS_ERR_BANNED_FROM_SERVER;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_LOG_INFO(("Incoming connection %s (%s)", ac->hostname, ac->ip));
/** Out of memory */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_ske_set_callbacks(ac->data.ske, silc_server_accept_verify_key,
silc_server_accept_completed, ac);
silc_ske_map_status(ac->status), ac->hostname, ac->ip));
ac->error = SILC_STATUS_ERR_KEY_EXCHANGE_FAILED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Setting keys into use"));
/** Error setting keys */
ac->error = SILC_STATUS_ERR_KEY_EXCHANGE_FAILED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_packet_set_ciphers(ac->packet_stream, send_key, receive_key);
silc_packet_set_hmacs(ac->packet_stream, hmac_send, hmac_receive);
/** Error allocating auth protocol */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Waiting authentication completion */
SILC_CONNTYPE_STRING(ac->data.type)));
ac->error = SILC_STATUS_ERR_AUTH_FAILED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Checking whether connection is allowed"));
ac->error = SILC_STATUS_ERR_BAD_VERSION;
ac->error_string = strdup("You support too old protocol version");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Match software version */
ac->error = SILC_STATUS_ERR_BAD_VERSION;
ac->error_string = strdup("You support too old software version");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Regex match vendor version */
ac->error = SILC_STATUS_ERR_BAD_VERSION;
ac->error_string = strdup("Your software is not supported");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_free(r_vendor_version);
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
ac->error_string = strdup("Server is full, try again later");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* XXX */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
ac->error_string = strdup("Too many connections from your host");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* If we are waiting backup router connection, do not accept any other
ac->error_string = strdup("We do not have connection to backup router "
"established, try later");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* If we are backup router and this is incoming server connection
ac->error_string = strdup("We do not have connection to primary router "
"established, try later");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_client)
ac->hostname, ac->ip));
ac->error = SILC_STATUS_ERR_NOT_REGISTERED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Connection %s (%s) is client", ac->hostname, ac->ip));
if (ac->register_packet->type == SILC_PACKET_RESUME_CLIENT) {
/** Resume client connection */
silc_fsm_next(fsm, silc_server_st_accept_resume_client);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Get connection parameters */
ac->error = SILC_STATUS_ERR_INCOMPLETE_INFORMATION;
ac->error_string = strdup("Bad NEW_CLIENT packet");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (!username) {
ac->error = SILC_STATUS_ERR_INCOMPLETE_INFORMATION;
ac->error_string = strdup("You did not send username");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (username_len > 128) {
ac->error = SILC_STATUS_ERR_INCOMPLETE_INFORMATION;
ac->error_string = strdup("You sent wrong hostname string");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_snprintf(n, sizeof(n), "%s", u);
silc_snprintf(u, sizeof(u) - 1, "%s@%s", n, h);
/** Out of memory */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
username_len = strlen(scramble);
ac->error = SILC_STATUS_ERR_BAD_NICKNAME;
ac->error_string = strdup("Bad nickname");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Create client entry */
SILC_LOG_ERROR(("Could not create new client entry"));
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Save entry data */
/** Out of memory */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Send the new client ID to the client. */
/** Connection accepted */
silc_fsm_next(fsm, silc_server_st_accept_finish);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_resume_client)
/** Connection accepted */
silc_fsm_next(fsm, silc_server_st_accept_finish);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_server)
ac->hostname, ac->ip));
ac->error = SILC_STATUS_ERR_NOT_REGISTERED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Get connection parameters */
ac->error = SILC_STATUS_ERR_INCOMPLETE_INFORMATION;
ac->error_string = strdup("Bad NEW_SERVER packet");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
if (name_len > 256) {
ac->error = SILC_STATUS_ERR_INCOMPLETE_INFORMATION;
ac->error_string = strdup("Bad Server ID");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Check for valid server ID */
ac->error_string = strdup("Your Server ID is not based on your real "
"IP address. Check your configuration.");
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Create server entry */
SILC_LOG_ERROR(("Could not create new server entry"));
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Save entry data */
/** Out of memory */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* If the incoming connection is router and marked as backup router
/** Connection accepted */
silc_fsm_next(fsm, silc_server_st_accept_finish);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_finish)
SILC_LOG_DEBUG(("New connection accepted"));
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_accept_error)
if (ac->connauth)
server->stat.auth_failures++;
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, \
0); \
silc_server_command_free(cmd); \
- SILC_FSM_FINISH; \
+ return SILC_FSM_FINISH; \
} \
if (_argc > max) { \
SILC_LOG_DEBUG(("Too many parameters in command")); \
SILC_STATUS_ERR_TOO_MANY_PARAMS, \
0); \
silc_server_command_free(cmd); \
- SILC_FSM_FINISH; \
+ return SILC_FSM_FINISH; \
} \
} while(0)
cmd = silc_server_command_alloc(thread);
if (!cmd) {
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
cmd->packet = packet;
if (!cmd->payload) {
SILC_LOG_ERROR(("Bad command payload"));
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* If client executes commands more frequently than once in 2 seconds,
default:
SILC_LOG_DEBUG(("Unknown command %d", silc_command_get(cmd->payload)));
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
break;
}
/* Statistics */
thread->server->stat.commands_received++;
- return timeout ? SILC_FSM_WAIT : SILC_FSM_CONTINUE;
+ return timeout ? SILC_FSM_WAIT : return SILC_FSM_CONTINUE;
}
/********************************* WHOIS ************************************/
/** WHOIS query */
silc_fsm_next(fsm, silc_server_st_query_whois);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** WHOWAS query */
silc_fsm_next(fsm, silc_server_st_query_whowas);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** IDENTIFY query */
silc_fsm_next(fsm, silc_server_st_query_identify);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
out:
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_command_info)
{
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
out:
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
cmd = silc_server_command_alloc(thread);
if (!cmd) {
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
cmd->packet = packet;
if (!cmd->payload) {
SILC_LOG_DEBUG(("Bad command reply payload"));
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Client is allowed to send reply only to WHOIS command. */
if (data->type == SILC_CONN_CLIENT &&
silc_command_get(cmd->payload) != SILC_COMMAND_WHOIS) {
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Get all command pending for this reply */
SILC_LOG_DEBUG(("Unknown command %d", silc_command_get(cmd->payload)));
cmd->pending = NULL;
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
break;
}
/* Statistics */
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/** Wait events */
server->connect_router = FALSE;
silc_fsm_next(fsm, silc_server_st_run);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SilcPacket packet = state_context;
SilcEntryData data = silc_packet_get_context(packet->stream);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SilcPacket packet = fsm_context;
SilcEntryData data = silc_packet_get_context(packet->stream);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_channel_message)
silc_server_channel_message(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_channel_key)
silc_server_channel_key(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_private_message)
silc_server_private_message(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_private_message_key)
silc_server_private_message_key(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_new_id)
silc_server_new_id(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_new_channel)
silc_server_new_channel(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_key_agreement)
silc_server_key_agreement(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_ftp)
silc_server_ftp(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_resume_router)
silc_server_backup_resume_router(server, sock, packet);
#endif
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_received)
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_channel_message);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_PRIVATE_MESSAGE:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_private_message);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NOTIFY:
/** Packet NOTIFY */
silc_fsm_next(fsm, silc_server_st_packet_notify);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_COMMAND:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_command);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_COMMAND_REPLY:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_command_reply);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_CHANNEL_KEY:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_channel_key);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NEW_ID:
/** Packet NEW_ID */
silc_fsm_next(fsm, silc_server_st_packet_new_id);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NEW_CLIENT:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_new_client);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NEW_SERVER:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_new_server);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NEW_CHANNEL:
/** Packet NEW_CHANNEL */
silc_fsm_next(fsm, silc_server_st_packet_new_channel);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_KEY_AGREEMENT:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_key_agreement);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_FTP:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_ftp);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_RESUME_CLIENT:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_resume_client);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_RESUME_ROUTER:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_resume_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_DISCONNECT:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_disconnect);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_PRIVATE_MESSAGE_KEY:
if (packet->flags & SILC_PACKET_FLAG_LIST)
break;
silc_fsm_next(fsm, silc_server_st_packet_private_message_key);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
break;
case SILC_PACKET_HEARTBEAT:
}
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Received NEW_CLIENT packet, used to register client to SILC network. */
if (!ac || ac->register_packet) {
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Signal that client registers to network */
ac->register_packet = packet;
SILC_FSM_EVENT_SIGNAL(&ac->wait_register);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Received NEW_SERVER packet, used to register server to SILC network. */
if (!ac || ac->register_packet) {
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Signal that server registers to network */
ac->register_packet = packet;
SILC_FSM_EVENT_SIGNAL(&ac->wait_register);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Received RESUME_CLIENT packet, used to resume detached session. */
if (!ac || ac->register_packet) {
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Signal that client resumes session */
ac->register_packet = packet;
SILC_FSM_EVENT_SIGNAL(&ac->wait_register);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
query = silc_calloc(1, sizeof(*query));
if (!query) {
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
query->querycmd = SILC_COMMAND_WHOIS;
silc_argument_get_arg_type(args, 3, NULL)))) {
/** Send query to router */
silc_fsm_next(fsm, silc_server_st_query_send_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Parse WHOIS query */
silc_fsm_next(fsm, silc_server_st_query_parse);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
query = silc_calloc(1, sizeof(*query));
if (!query) {
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
query->querycmd = SILC_COMMAND_WHOWAS;
cmd->packet->stream != SILC_PRIMARY_ROUTE(server)) {
/** Send query to router */
silc_fsm_next(fsm, silc_server_st_query_send_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Parse WHOWAS query */
silc_fsm_next(fsm, silc_server_st_query_parse);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
query = silc_calloc(1, sizeof(*query));
if (!query) {
silc_server_command_free(cmd);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
query->querycmd = SILC_COMMAND_IDENTIFY;
!silc_argument_get_arg_type(args, 5, NULL)) {
/** Send query to router */
silc_fsm_next(fsm, silc_server_st_query_send_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Parse IDENTIFY query */
silc_fsm_next(fsm, silc_server_st_query_parse);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_RESOURCE_LIMIT, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_command_set_ident(query->cmd->payload, old_ident);
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_RESOURCE_LIMIT, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Wait router reply */
query->resolved = TRUE;
silc_fsm_next(fsm, silc_server_st_query_router_reply)
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Wait for router reply and process the reply when it arrives. */
silc_server_command_pending_free(thread, pending);
silc_server_query_send_error(server, query, SILC_STATUS_ERR_TIMEDOUT, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Check if the query failed */
/** Query error received */
silc_server_command_pending_free(thread, pending);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_server_command_pending_free(thread, pending);
/** Parse query command */
silc_fsm_next(fsm, silc_server_st_query_parse);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/***************************** Query processing *****************************/
/** Not enough arguments */
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Get the nickname@server string and parse it */
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_NICKNAME, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Check nickname */
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_NICKNAME, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* XXX why free nickname */
silc_free(query->nickname);
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_RESOURCE_LIMIT, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
for (i = 0; i < argc - 3; i++) {
query->ids = NULL;
query->ids_count = 0;
silc_fsm_next(fsm, silc_server_st_query_send_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
query->ids[query->ids_count] = id;
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Get the nickname@server string and parse it */
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_NICKNAME, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Check nickname */
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_NICKNAME, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* XXX why free nickname */
silc_free(query->nickname);
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_NICKNAME, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* XXX why free nickname */
silc_free(query->nickname);
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_SERVER, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
query->server_name = tmp;
}
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_BAD_CHANNEL, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
query->channel_name = tmp;
}
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
} else {
query->ids = NULL;
query->ids_count = 0;
silc_fsm_next(fsm, silc_server_st_query_send_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
} else {
/* For now all other ID's except Client ID's are explicitly
query->ids = NULL;
query->ids_count = 0;
silc_fsm_next(fsm, silc_server_st_query_send_router);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
}
/** Find entries for query */
silc_fsm_next(fsm, silc_server_st_query_find);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Find the entries according to the query */
if (query->attrs) {
/** Check user attributes */
silc_fsm_next(fsm, silc_server_st_query_check_attrs);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Process found entries */
silc_fsm_next(fsm, silc_server_st_query_process);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Check user attributes to narrow down clients in WHOIS query */
/** Proecss found entries */
silc_fsm_next(fsm, silc_server_st_query_process);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Process found entries */
!silc_list_count(query->servers)) {
/** Nothing found, send errors */
silc_fsm_next(fsm, silc_server_st_query_reply);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
#if 0
if (silc_list_count(query->resolve)) {
/** Resolve entries */
silc_fsm_next(fsm, silc_server_st_query_resolve);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Send reply to query */
silc_fsm_next(fsm, silc_server_st_query_reply);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Resolve incomplete client entries. Other types of entries need not
silc_server_query_send_error(server, query,
SILC_STATUS_ERR_RESOURCE_LIMIT, 0);
silc_fsm_next(fsm, silc_server_st_query_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_packet_send(res->stream, SILC_PACKET_COMMAND, 0,
/** Wait all resolvings */
silc_fsm_next(fsm, silc_server_st_query_resolved);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Wait for resolving command reply */
/* Signal main thread that reply was received */
SILC_FSM_EVENT_SIGNAL(&query->wait_resolve);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Wait here that all resolvings has been received */
/* Wait here until all resolvings has arrived */
SILC_FSM_EVENT_WAIT(&query->wait_resolve);
if (silc_list_count(query->resolvings) > 0)
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
projects / silc.git / commitdiff