/* Signal thread that packet has arrived */
if (!thread->new_packet) {
thread->new_packet = TRUE;
- SILC_FSM_SEMA_POST(&thread->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&thread->wait_event);
}
return TRUE;
/* Signal server of new connection */
if (!server->new_connection) {
server->new_connection = TRUE;
- SILC_FSM_SEMA_POST(&server->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&server->wait_event);
}
}
/*** Run thread's machine */
silc_fsm_init(&thread->fsm, thread, NULL, NULL, silc_fsm_get_schedule(fsm));
- silc_fsm_sema_init(&thread->wait_event, &thread->fsm, 0);
+ silc_fsm_event_init(&thread->wait_event, &thread->fsm, 0);
silc_fsm_start_sync(&thread->fsm, silc_server_thread_st_run);
/* Signal server that we are up */
- SILC_FSM_SEMA_POST(&thread->server->thread_up);
+ SILC_FSM_EVENT_SIGNAL(&thread->server->thread_up);
/* Wait here for this thread to finish */
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Thread's machine's main state where we wait for various events. */
SILC_LOG_DEBUG(("Start"));
/* Wait for events */
- SILC_FSM_SEMA_WAIT(&thread->wait_event);
+ SILC_FSM_EVENT_WAIT(&thread->wait_event);
/* Process events */
silc_list_init(thread->packet_queue, struct SilcPacketStruct, next);
thread->new_packet = FALSE;
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_mutex_lock(thread->server->lock);
thread->new_connection = FALSE;
silc_mutex_unlock(thread->server->lock);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* NOT REACHED */
#if defined(SILC_DEBUG)
assert(FALSE);
#endif /* SILC_DEBUG */
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Start"));
/* Wait for events */
- SILC_FSM_SEMA_WAIT(&server->wait_event);
+ SILC_FSM_EVENT_WAIT(&server->wait_event);
/* Process events */
/* Call running callbcak back to application */
server->run_callback = FALSE;
server->running(server, server->running_context);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (server->new_connection) {
/** New connection */
silc_fsm_next(fsm, silc_server_st_new_connection);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (server->connect_router) {
/** Connect to router(s) */
silc_fsm_next(fsm, silc_server_st_connect_router);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (server->get_statistics) {
/** Retrieve statistics */
silc_fsm_next(fsm, silc_server_st_get_stats);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (server->reconfigure) {
/** Reconfigure server */
silc_fsm_next(fsm, silc_server_st_reconfigure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (server->server_shutdown) {
/** Shutdown server */
silc_fsm_next(fsm, silc_server_st_stop);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* NOT REACHED */
#if defined(SILC_DEBUG)
assert(FALSE);
#endif /* SILC_DEBUG */
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* New connection received */
}
silc_fsm_next(fsm, silc_server_st_wait_new_thread);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_list_del(server->new_conns, ac);
/* Signal the thread for new connection */
if (!thread->new_connection) {
thread->new_connection = TRUE;
- SILC_FSM_SEMA_POST(&thread->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&thread->wait_event);
}
silc_mutex_unlock(server->lock);
}
/** Connections processed */
silc_fsm_next(fsm, silc_server_st_run);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Wait here until newly created thread is up */
SilcServer server = fsm_context;
/* Wait here until new thread is up */
- SILC_FSM_SEMA_WAIT(&server->thread_up);
+ SILC_FSM_EVENT_WAIT(&server->thread_up);
/** Process new connections */
silc_fsm_next(fsm, silc_server_st_new_connection);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Stops server */
/** Wait events */
silc_fsm_next(fsm, silc_server_st_run);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Reconfigure server */
/** Wait events */
server->reconfigure = FALSE;
silc_fsm_next(fsm, silc_server_st_run);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Get statistics */
/** Wait events */
server->get_statistics = FALSE;
silc_fsm_next(fsm, silc_server_st_run);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_fsm_init(&server->fsm, server, silc_server_destructor, NULL, schedule);
/* Init semaphore signallers */
- silc_fsm_sema_init(&server->wait_event, &server->fsm, 0);
- silc_fsm_sema_init(&server->thread_up, &server->fsm, 0);
+ silc_fsm_event_init(&server->wait_event, &server->fsm, 0);
+ silc_fsm_event_init(&server->thread_up, &server->fsm, 0);
/* Initialize lists */
silc_list_init(server->new_conns, struct SilcServerAcceptStruct, next);
/* Signal the application when we are running */
server->run_callback = TRUE;
- SILC_FSM_SEMA_POST(&server->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&server->wait_event);
/* Signal to connect to router */
server->connect_router = TRUE;
- SILC_FSM_SEMA_POST(&server->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&server->wait_event);
/* Start getting statistics from the network on normal server */
if (server->server_type != SILC_ROUTER) {
server->get_statistics = TRUE;
- SILC_FSM_SEMA_POST(&server->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&server->wait_event);
}
}
/* Signal that server is going down */
server->server_shutdown = TRUE;
- SILC_FSM_SEMA_POST(&server->wait_event);
+ SILC_FSM_EVENT_SIGNAL(&server->wait_event);
}
/* Disconnects remote connection */
/* Pending command context */
typedef struct {
- SilcFSMSemaStruct wait_reply; /* Pending command signaller */
+ SilcFSMEventStruct wait_reply; /* Pending command signaller */
SilcServerCommand reply; /* Command reply context */
SilcUInt16 cmd_ident; /* Command identifier */
SilcInt16 refcnt; /* Reference counter */
SilcStream stream; /* Remote connection */
SilcPacketStream packet_stream; /* Remote connection */
SilcConnAuth connauth; /* Connection authentication context */
- SilcFSMSemaStruct wait_register; /* Signaller when registering received */
+ SilcFSMEventStruct wait_register; /* Signaller when registering received */
SilcPacket register_packet; /* NEW_CLIENT/NEW_SERVER packet */
SilcServerParamClient cconfig;
SilcPacketEngine packet_engine; /* Packet engine */
SilcFSMThreadStruct thread; /* FSM thread */
SilcFSMStruct fsm; /* Thread's FSM */
- SilcFSMSemaStruct wait_event; /* Thread's event signaller */
+ SilcFSMEventStruct wait_event; /* Thread's event signaller */
SilcUInt32 num_conns; /* Number of connections in the thread */
SilcList new_conns; /* New network connections */
SilcList packet_queue; /* Incoming packet queue */
SilcList command_pool; /* Command context freelist */
SilcHashTable pending_commands; /* Pending commands */
- SilcFSMSemaStruct wait_event; /* Main state signaller */
- SilcFSMSemaStruct thread_up; /* Signaller when thread is up */
+ SilcFSMEventStruct wait_event; /* Main state signaller */
+ SilcFSMEventStruct thread_up; /* Signaller when thread is up */
SilcIDCache clients; /* Client entry cache */
SilcIDCache servers; /* Server entry cache */
/** Cannot create packet stream */
ac->error = SILC_STATUS_ERR_RESOURCE_LIMIT;
silc_fsm_next(fsm, silc_server_st_accept_error);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Checking whether connection is allowed"));
conn_number = server->stat.my_routers;
}
- silc_fsm_sema_init(&ac->wait_register, silc_fsm_get_machine(fsm), 0);
+ silc_fsm_event_init(&ac->wait_register, silc_fsm_get_machine(fsm), 0);
/* Check version */
l_protocol_version = silc_version_to_num(params && params->version_protocol ?
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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_client)
int ret;
/* Wait here for the NEW_CLIENT or RESUME_CLIENT packet */
- SILC_FSM_SEMA_TIMEDWAIT(&ac->wait_register, 20, 0, &timedout);
+ SILC_FSM_EVENT_TIMEDWAIT(&ac->wait_register, 20, 0, &timedout);
if (!ac->register_packet || timedout) {
/** Client did not register */
ac->hostname, ac->ip));
ac->error = SILC_STATUS_ERR_NOT_REGISTERED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
snprintf(n, sizeof(n), "%s", u);
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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Send the new client ID to the client. */
/** Connection accepted */
silc_fsm_next(fsm, silc_server_st_accept_finish);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_resume_client)
/** Connection accepted */
silc_fsm_next(fsm, silc_server_st_accept_finish);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_server)
#if 0
/* Wait here for the NEW_SERVER packet */
- SILC_FSM_SEMA_TIMEDWAIT(&ac->wait_register, 20, 0, &timedout);
+ SILC_FSM_EVENT_TIMEDWAIT(&ac->wait_register, 20, 0, &timedout);
if (!ac->register_packet || timedout) {
/** Server did not register */
ac->hostname, ac->ip));
ac->error = SILC_STATUS_ERR_NOT_REGISTERED;
silc_fsm_next(fsm, silc_server_st_accept_error);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_server_st_accept_finish)
SILC_LOG_DEBUG(("New connection accepted"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_accept_error)
if (ac->connauth)
server->stat.auth_failures++;
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, \
0); \
silc_server_command_free(cmd); \
- return SILC_FSM_FINISH; \
+ 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); \
- return SILC_FSM_FINISH; \
+ SILC_FSM_FINISH; \
} \
} while(0)
return NULL;
}
- silc_fsm_sema_init(&pending->wait_reply, &thread->fsm, 0);
+ silc_fsm_event_init(&pending->wait_reply, &thread->fsm, 0);
pending->refcnt = 1;
pending->cmd_ident = cmd_ident;
/* Signal */
pending->reply = cmd;
- SILC_FSM_SEMA_POST(&pending->wait_reply);
+ SILC_FSM_EVENT_SIGNAL(&pending->wait_reply);
/* Remove from pending */
silc_hash_table_del_by_context(thread->server->pending_commands,
cmd = silc_server_command_alloc(thread);
if (!cmd) {
silc_packet_free(packet);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
cmd->packet = packet;
if (!cmd->payload) {
SILC_LOG_ERROR(("Bad command payload"));
silc_server_command_free(cmd);
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
break;
}
/** WHOIS query */
silc_fsm_next(fsm, silc_server_st_query_whois);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** WHOWAS query */
silc_fsm_next(fsm, silc_server_st_query_whowas);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** IDENTIFY query */
silc_fsm_next(fsm, silc_server_st_query_identify);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
out:
silc_server_command_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_command_info)
{
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
out:
silc_server_command_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcServerCommand cmd = state_context;
SilcArgumentPayload args = silc_command_get_args(cmd->payload);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
cmd = silc_server_command_alloc(thread);
if (!cmd) {
silc_packet_free(packet);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
cmd->packet = packet;
if (!cmd->payload) {
SILC_LOG_DEBUG(("Bad command reply payload"));
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
break;
}
/* Statistics */
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
err:
silc_server_command_reply_free(cmd);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/** Wait events */
server->connect_router = FALSE;
silc_fsm_next(fsm, silc_server_st_run);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SilcPacket packet = state_context;
SilcEntryData data = silc_packet_get_context(packet->stream);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcPacket packet = fsm_context;
SilcEntryData data = silc_packet_get_context(packet->stream);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_channel_message)
silc_server_channel_message(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_channel_key)
silc_server_channel_key(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_private_message)
silc_server_private_message(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_private_message_key)
silc_server_private_message_key(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_new_id)
silc_server_new_id(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_new_channel)
silc_server_new_channel(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_key_agreement)
silc_server_key_agreement(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_ftp)
silc_server_ftp(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_server_st_packet_resume_router)
silc_server_backup_resume_router(server, sock, packet);
#endif
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NOTIFY:
/** Packet NOTIFY */
silc_fsm_next(fsm, silc_server_st_packet_notify);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NEW_ID:
/** Packet NEW_ID */
silc_fsm_next(fsm, silc_server_st_packet_new_id);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
break;
case SILC_PACKET_NEW_CHANNEL:
/** Packet NEW_CHANNEL */
silc_fsm_next(fsm, silc_server_st_packet_new_channel);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
break;
case SILC_PACKET_HEARTBEAT:
}
silc_packet_free(packet);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Received NEW_CLIENT packet, used to register client to SILC network. */
if (!ac || ac->register_packet) {
silc_packet_free(packet);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Signal that client registers to network */
ac->register_packet = packet;
- SILC_FSM_SEMA_POST(&ac->wait_register);
+ SILC_FSM_EVENT_SIGNAL(&ac->wait_register);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Received NEW_SERVER packet, used to register server to SILC network. */
if (!ac || ac->register_packet) {
silc_packet_free(packet);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Signal that server registers to network */
ac->register_packet = packet;
- SILC_FSM_SEMA_POST(&ac->wait_register);
+ SILC_FSM_EVENT_SIGNAL(&ac->wait_register);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Received RESUME_CLIENT packet, used to resume detached session. */
if (!ac || ac->register_packet) {
silc_packet_free(packet);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Signal that client resumes session */
ac->register_packet = packet;
- SILC_FSM_SEMA_POST(&ac->wait_register);
+ SILC_FSM_EVENT_SIGNAL(&ac->wait_register);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcUInt32 ids_count; /* number of queried IDs */
SilcUInt32 reply_count; /* Requested reply count */
SilcDList attrs; /* Requested Attributes in WHOIS */
- SilcFSMSemaStruct wait_resolve; /* Resolving signaller */
+ SilcFSMEventStruct wait_resolve; /* Resolving signaller */
/* Query session data */
SilcServerComman cmd; /* Command context for query */
query = silc_calloc(1, sizeof(*query));
if (!query) {
silc_server_command_free(cmd);
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Parse WHOIS query */
silc_fsm_next(fsm, silc_server_st_query_parse);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
query = silc_calloc(1, sizeof(*query));
if (!query) {
silc_server_command_free(cmd);
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Parse WHOWAS query */
silc_fsm_next(fsm, silc_server_st_query_parse);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
query = silc_calloc(1, sizeof(*query));
if (!query) {
silc_server_command_free(cmd);
- return SILC_FSM_FINISH;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Parse IDENTIFY query */
silc_fsm_next(fsm, silc_server_st_query_parse);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Wait router reply */
query->resolved = TRUE;
silc_fsm_next(fsm, silc_server_st_query_router_reply)
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Wait for router reply and process the reply when it arrives. */
SilcBool timedout;
/* Wait here for the reply */
- SILC_FSM_SEMA_TIMEDWAIT(&pending->wait_reply, 10, 0, &timedout);
+ SILC_FSM_EVENT_TIMEDWAIT(&pending->wait_reply, 10, 0, &timedout);
if (timedout) {
/** Timeout waiting reply */
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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_server_command_pending_free(thread, pending);
/** Parse query command */
silc_fsm_next(fsm, silc_server_st_query_parse);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/***************************** Query processing *****************************/
/** Not enough arguments */
silc_fsm_next(fsm, silc_server_st_query_error);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
} else {
query->ids = NULL;
query->ids_count = 0;
silc_fsm_next(fsm, silc_server_st_query_send_router);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
}
/** Find entries for query */
silc_fsm_next(fsm, silc_server_st_query_find);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Process found entries */
silc_fsm_next(fsm, silc_server_st_query_process);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Process found entries */
!silc_list_count(query->servers)) {
/** Nothing found, send errors */
silc_fsm_next(fsm, silc_server_st_query_reply);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
#if 0
if (silc_list_count(query->resolve)) {
/** Resolve entries */
silc_fsm_next(fsm, silc_server_st_query_resolve);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Send reply to query */
silc_fsm_next(fsm, silc_server_st_query_reply);
- return SILC_FSM_CONTINUE;
+ 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);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_packet_send(res->stream, SILC_PACKET_COMMAND, 0,
/** Wait all resolvings */
silc_fsm_next(fsm, silc_server_st_query_resolved);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Wait for resolving command reply */
SilcBool timedout;
/* Wait here for the reply */
- SILC_FSM_SEMA_TIMEDWAIT(&res->pending->wait_reply,
+ SILC_FSM_EVENT_TIMEDWAIT(&res->pending->wait_reply,
res->local ? 3 : 10, 0, &timedout);
silc_free(res);
/* Signal main thread that reply was received */
- SILC_FSM_SEMA_POST(&query->wait_resolve);
+ SILC_FSM_EVENT_SIGNAL(&query->wait_resolve);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Wait here that all resolvings has been received */
SilcServerCommand cmd = query->cmd;
/* Wait here until all resolvings has arrived */
- SILC_FSM_SEMA_WAIT(&query->wait_resolve);
+ SILC_FSM_EVENT_WAIT(&query->wait_resolve);
if (silc_list_count(query->resolvings) > 0)
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
int payload_len = 0;
unsigned char *auth_data = NULL;
SilcUInt32 auth_data_len = 0;
+ SilcPacketFlags flags = 0;
SILC_LOG_DEBUG(("Start"));
if (connauth->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_connauth_st_initiator_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Start timeout */
if (!auth_data) {
/** Out of memory */
silc_fsm_next(fsm, silc_connauth_st_initiator_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
auth_data_len = connauth->auth_data_len;
+ flags = SILC_PACKET_FLAG_LONG_PAD;
break;
case SILC_AUTH_PUBLIC_KEY:
if (!silc_connauth_get_signature(connauth, &auth_data, &auth_data_len)) {
/** Error computing signature */
silc_fsm_next(fsm, silc_connauth_st_initiator_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
break;
}
if (!packet) {
/** Out of memory */
silc_fsm_next(fsm, silc_connauth_st_initiator_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_buffer_format(packet,
SILC_STR_END);
/* Send the packet */
- if (!silc_packet_send(connauth->ske->stream, SILC_PACKET_CONNECTION_AUTH, 0,
- packet->data, silc_buffer_len(packet))) {
+ if (!silc_packet_send(connauth->ske->stream, SILC_PACKET_CONNECTION_AUTH,
+ flags, packet->data, silc_buffer_len(packet))) {
/** Error sending packet */
silc_fsm_next(fsm, silc_connauth_st_initiator_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (auth_data) {
/** Wait for responder */
silc_fsm_next(fsm, silc_connauth_st_initiator_result);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(silc_connauth_st_initiator_result)
if (connauth->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_connauth_st_initiator_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Check the status of authentication */
/* Call completion callback */
connauth->completion(connauth, connauth->success, connauth->context);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_connauth_st_initiator_failure)
&silc_connauth_stream_cbs, connauth);
silc_schedule_task_del_by_context(silc_fsm_get_schedule(fsm), connauth);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcAsyncOperation
if (connauth->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Start timeout */
/** Wait for initiator */
silc_fsm_next(fsm, silc_connauth_st_responder_authenticate);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(silc_connauth_st_responder_authenticate)
/** Aborted */
silc_packet_free(connauth->packet);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (connauth->packet->type != SILC_PACKET_CONNECTION_AUTH) {
/** Protocol failure */
silc_packet_free(connauth->packet);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Parse the received authentication data packet. The received
SILC_LOG_ERROR(("Bad payload in authentication packet"));
silc_packet_free(connauth->packet);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (payload_len != silc_buffer_len(&connauth->packet->buffer)) {
SILC_LOG_ERROR(("Bad payload length in authentication packet"));
silc_packet_free(connauth->packet);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
payload_len -= 4;
conn_type));
silc_packet_free(connauth->packet);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (payload_len > 0) {
SILC_LOG_DEBUG(("Bad payload in authentication payload"));
silc_packet_free(connauth->packet);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
}
silc_packet_free(connauth->packet);
/** Connection not configured */
SILC_LOG_ERROR(("Remote connection not configured"));
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Verify */
if (!memcmp(auth_data, passphrase, passphrase_len)) {
/** Authentication failed */
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
} else if (repository) {
/* Digital signature */
if (!find || !connauth->auth_data) {
/** Out of memory */
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_skr_find_set_pkcs_type(find, connauth->ske->pk_type);
/** Authentication successful */
silc_fsm_next(fsm, silc_connauth_st_responder_success);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_connauth_st_responder_authenticate_pk)
if (connauth->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (connauth->skr_status != SILC_SKR_OK) {
/** Public key not found */
SILC_LOG_DEBUG(("Public key not found, error %d", connauth->skr_status));
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Found %d public keys",
SILC_LOG_DEBUG(("Invalid signature"));
silc_free(connauth->auth_data);
silc_fsm_next(fsm, silc_connauth_st_responder_failure);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_free(connauth->auth_data);
/** Authentication successful */
silc_fsm_next(fsm, silc_connauth_st_responder_success);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(silc_connauth_st_responder_success)
&silc_connauth_stream_cbs, connauth);
silc_schedule_task_del_by_context(silc_fsm_get_schedule(fsm), connauth);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(silc_connauth_st_responder_failure)
&silc_connauth_stream_cbs, connauth);
silc_schedule_task_del_by_context(silc_fsm_get_schedule(fsm), connauth);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SilcAsyncOperation
if (ske->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_ske_st_initiator_aborted);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Encode the payload */
/** Error encoding Start Payload */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Save the the payload buffer for future use. It is later used to
SILC_LOG_DEBUG(("Error sending packet"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* XXX timeout */
/** Wait for responder proposal */
SILC_LOG_DEBUG(("Waiting for reponder proposal"));
silc_fsm_next(fsm, silc_ske_st_initiator_phase1);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Phase-1. Receives responder's proposal */
silc_ske_install_retransmission(ske);
silc_packet_free(ske->packet);
ske->packet = NULL;
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Decode the payload */
ske->packet = NULL;
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Get remote ID and set it to stream */
SILC_LOG_ERROR(("Invalid cookie, modified or unsupported feature"));
ske->status = SILC_SKE_STATUS_INVALID_COOKIE;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Check version string */
/** Version mismatch */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Free our KE Start Payload context, we don't need it anymore. */
/** Send KE Payload */
silc_fsm_next(fsm, silc_ske_st_initiator_phase2);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
err:
if (payload)
/** Error */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Phase-2. Send KE payload */
/** Out of memory */
ske->status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_mp_init(x);
status =
silc_free(x);
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Encode the result to Key Exchange Payload. */
silc_free(x);
ske->status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->ke1_payload = payload;
ske->ke1_payload = NULL;
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
payload->pk_len = pk_len;
payload->pk_type = silc_pkcs_get_type(ske->public_key);
ske->ke1_payload = NULL;
ske->status = SILC_SKE_STATUS_SIGNATURE_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
payload->sign_data = silc_memdup(sign, sign_len);
if (payload->sign_data)
ske->ke1_payload = NULL;
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->x = x;
SILC_LOG_DEBUG(("Error sending packet"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_buffer_free(payload_buf);
/** Waiting responder's KE payload */
silc_fsm_next(fsm, silc_ske_st_initiator_phase3);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Phase-3. Process responder's KE payload */
silc_ske_install_retransmission(ske);
silc_packet_free(ske->packet);
ske->packet = NULL;
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Decode the payload */
ske->packet = NULL;
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_packet_free(ske->packet);
ske->packet = NULL;
/** Process key material */
silc_fsm_next(fsm, silc_ske_st_initiator_phase4);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
err:
silc_ske_payload_ke_free(payload);
/** Error */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Process key material */
if (ske->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_ske_st_initiator_aborted);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Check result of public key verification */
/** Public key not verified */
SILC_LOG_DEBUG(("Public key verification failed"));
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
payload = ske->ke2_payload;
if (ske->rekey) {
/** Finish rekey */
silc_fsm_next(fsm, silc_ske_st_rekey_initiator_done);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Process key material */
SILC_LOG_DEBUG(("Error sending packet"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Waiting completion */
silc_fsm_next(fsm, silc_ske_st_initiator_end);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
err:
memset(hash, 'F', sizeof(hash));
/** Error */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Protocol completed */
silc_ske_install_retransmission(ske);
silc_packet_free(ske->packet);
ske->packet = NULL;
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_LOG_DEBUG(("Key exchange completed successfully"));
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Aborted by application */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Error occurred. Send error to remote host */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Failure received from remote */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Starts the protocol as initiator */
if (ske->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_ske_st_responder_aborted);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Start timeout */
/** Wait for initiator */
silc_fsm_next(fsm, silc_ske_st_responder_phase1);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Decode initiator's start payload. Select the security properties from
ske->packet = NULL;
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Take a copy of the payload buffer for future use. It is used to
silc_ske_payload_start_free(remote_payload);
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_ske_payload_start_free(remote_payload);
/** Waiting initiator's KE payload */
silc_fsm_next(fsm, silc_ske_st_responder_phase2);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
err:
if (ske->prop->group)
/** Error */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Phase-2. Decode initiator's KE payload */
silc_ske_install_retransmission(ske);
silc_packet_free(ske->packet);
ske->packet = NULL;
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Decode Key Exchange Payload */
ske->packet = NULL;
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->ke1_payload = recv_payload;
"certificate), even though we require it"));
ske->status = SILC_SKE_STATUS_PUBLIC_KEY_NOT_PROVIDED;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Decode the remote's public key */
SILC_LOG_ERROR(("Unsupported/malformed public key received"));
ske->status = SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
if (ske->prop->public_key && (ske->callbacks->verify_key ||
if (!find) {
ske->status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_skr_find_set_pkcs_type(find,
silc_pkcs_get_type(ske->prop->public_key));
/** Generate KE2 payload */
silc_fsm_next(fsm, silc_ske_st_responder_phase4);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Phase-4. Generate KE2 payload */
if (ske->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_ske_st_responder_aborted);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Check result of public key verification */
/** Public key not verified */
SILC_LOG_DEBUG(("Public key verification failed"));
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
recv_payload = ske->ke1_payload;
/** Error computing hash */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Verifying signature (HASH_i)"));
SILC_LOG_ERROR(("Signature verification failed, incorrect signature"));
ske->status = SILC_SKE_STATUS_INCORRECT_SIGNATURE;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Signature is Ok"));
silc_free(x);
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Save the results for later processing */
/** Send KE2 payload */
silc_fsm_next(fsm, silc_ske_st_responder_phase5);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Phase-5. Send KE2 payload */
/** Error encoding public key */
status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->ke2_payload->pk_data = pk;
ske->ke2_payload->pk_len = pk_len;
/** Error computing hash */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->hash = silc_memdup(hash, hash_len);
/** Error computing signature */
status = SILC_SKE_STATUS_SIGNATURE_ERROR;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->ke2_payload->sign_data = silc_memdup(sign, sign_len);
ske->ke2_payload->sign_len = sign_len;
/** Error encoding KE payload */
ske->status = status;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Send the packet. */
SILC_LOG_DEBUG(("Error sending packet"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_buffer_free(payload_buf);
/** Waiting completion */
silc_fsm_next(fsm, silc_ske_st_responder_end);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Protocol completed */
silc_ske_install_retransmission(ske);
silc_packet_free(ske->packet);
ske->packet = NULL;
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
silc_packet_free(ske->packet);
ske->packet = NULL;
/** Error processing key material */
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_responder_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Send SUCCESS packet */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Aborted by application */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Failure received from remote */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Error occurred */
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Starts the protocol as responder. */
if (ske->aborted) {
/** Aborted */
silc_fsm_next(fsm, silc_ske_st_initiator_aborted);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* XXX timeout */
/** No memory */
ske->status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Send REKEY packet to start rekey protocol */
SILC_LOG_DEBUG(("Error sending packet"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* If doing rekey without PFS, move directly to the end of the protocol. */
if (!ske->rekey->pfs) {
/** Rekey without PFS */
silc_fsm_next(fsm, silc_ske_st_rekey_initiator_done);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
status = silc_ske_group_get_by_number(ske->rekey->ske_group,
if (status != SILC_SKE_STATUS_OK) {
/** Unknown group */
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Rekey with PFS */
silc_fsm_next(fsm, silc_ske_st_initiator_phase2);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Sends REKEY_DONE packet to finish the protocol. */
/** Cannot allocate hash */
ske->status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
hash_len = silc_hash_len(hash);
if (!ske->keymat) {
SILC_LOG_ERROR(("Error processing key material"));
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
ske->prop->cipher = send_key;
/** Cannot get keys */
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Set the new keys into use. This will also send REKEY_DONE packet. Any
SILC_LOG_DEBUG(("Cannot set new keys, error sending REKEY_DONE"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/** Wait for REKEY_DONE */
silc_fsm_next(fsm, silc_ske_st_rekey_initiator_end);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
/* Rekey protocol end */
SILC_LOG_DEBUG(("Remote retransmitted an old packet"));
silc_packet_free(ske->packet);
ske->packet = NULL;
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
silc_packet_get_keys(ske->stream, NULL, &receive_key, NULL, &hmac_receive);
/** Cannot get keys */
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Set new receiving keys into use. All packets received after this will
SILC_LOG_DEBUG(("Cannot set new keys"));
ske->status = SILC_SKE_STATUS_ERROR;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Rekey completed successfully"));
/** No memory */
ske->status = SILC_SKE_STATUS_OUT_OF_MEMORY;
silc_fsm_next(fsm, silc_ske_st_initiator_error);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
rekey->pfs = ske->rekey->pfs;
ske->rekey = rekey;
silc_packet_stream_unlink(ske->stream, &silc_ske_stream_cbs, ske);
silc_schedule_task_del_by_context(ske->schedule, ske);
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Starts rekey protocol as initiator */
SILC_FSM_STATE(silc_ske_st_rekey_responder_start)
{
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
/* Starts rekey protocol as responder */
SilcHmac *ret_hmac_receive,
SilcHash *ret_hash)
{
+ unsigned char iv[32];
+
/* Allocate ciphers to be used in the communication */
if (ret_send_key) {
if (!silc_cipher_alloc((char *)silc_cipher_get_name(prop->cipher),
}
/* Set key material */
+ memset(iv, 0, sizeof(iv));
if (ske->responder) {
if (ret_send_key) {
silc_cipher_set_key(*ret_send_key, keymat->receive_enc_key,
keymat->enc_key_len, TRUE);
- silc_cipher_set_iv(*ret_send_key, keymat->receive_iv);
+
+ if (silc_cipher_get_mode(*ret_send_key) == SILC_CIPHER_MODE_CTR) {
+ memcpy(iv, ske->hash, 4);
+ memcpy(iv + 4, keymat->receive_iv, 4);
+ silc_cipher_set_iv(*ret_send_key, iv);
+ } else {
+ silc_cipher_set_iv(*ret_send_key, keymat->receive_iv);
+ }
}
if (ret_receive_key) {
silc_cipher_set_key(*ret_receive_key, keymat->send_enc_key,
keymat->enc_key_len, FALSE);
- silc_cipher_set_iv(*ret_receive_key, keymat->send_iv);
+
+ if (silc_cipher_get_mode(*ret_receive_key) == SILC_CIPHER_MODE_CTR) {
+ memcpy(iv, ske->hash, 4);
+ memcpy(iv + 4, keymat->send_iv, 4);
+ silc_cipher_set_iv(*ret_receive_key, iv);
+ } else {
+ silc_cipher_set_iv(*ret_receive_key, keymat->send_iv);
+ }
}
if (ret_hmac_send)
silc_hmac_set_key(*ret_hmac_send, keymat->receive_hmac_key,
if (ret_send_key) {
silc_cipher_set_key(*ret_send_key, keymat->send_enc_key,
keymat->enc_key_len, TRUE);
- silc_cipher_set_iv(*ret_send_key, keymat->send_iv);
+
+ if (silc_cipher_get_mode(*ret_send_key) == SILC_CIPHER_MODE_CTR) {
+ memcpy(iv, ske->hash, 4);
+ memcpy(iv + 4, keymat->send_iv, 4);
+ silc_cipher_set_iv(*ret_send_key, iv);
+ } else {
+ silc_cipher_set_iv(*ret_send_key, keymat->send_iv);
+ }
}
if (ret_receive_key) {
silc_cipher_set_key(*ret_receive_key, keymat->receive_enc_key,
keymat->enc_key_len, FALSE);
- silc_cipher_set_iv(*ret_receive_key, keymat->receive_iv);
+
+ if (silc_cipher_get_mode(*ret_receive_key) == SILC_CIPHER_MODE_CTR) {
+ memcpy(iv, ske->hash, 4);
+ memcpy(iv + 4, keymat->receive_iv, 4);
+ silc_cipher_set_iv(*ret_receive_key, iv);
+ } else {
+ silc_cipher_set_iv(*ret_receive_key, keymat->receive_iv);
+ }
}
if (ret_hmac_send)
silc_hmac_set_key(*ret_hmac_send, keymat->send_hmac_key,
typedef struct {
SilcFSM fsm;
- SilcFSMSemaStruct sema;
+ SilcFSMEventStruct sema;
SilcAsyncOperation op;
Callback cb;
void *cb_context;
Foo f = context;
SILC_LOG_DEBUG(("*******Callback, signal and continue to next state"));
f->op = NULL;
- SILC_FSM_SEMA_POST(&f->sema);
+ SILC_FSM_EVENT_SIGNAL(&f->sema);
SILC_FSM_CALL_CONTINUE(f->fsm);
}
SILC_LOG_DEBUG(("test_st_start"));
- silc_fsm_sema_init(&f->sema, fsm, 0);
+ silc_fsm_event_init(&f->sema, fsm);
/** Wait async callback */
SILC_LOG_DEBUG(("Call async call"));
SILC_LOG_DEBUG(("test_st_second"));
- SILC_FSM_SEMA_TIMEDWAIT(&f->sema, 0, 1, &timedout);
+ SILC_FSM_EVENT_TIMEDWAIT(&f->sema, 0, 1, &timedout);
if (timedout == TRUE) {
SILC_LOG_DEBUG(("Sema timedout, aborting async operation"));
/** Finish */
silc_fsm_next_later(fsm, test_st_finish, 2, 0);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(test_st_finish)
SILC_LOG_DEBUG(("test_st_finish"));
SILC_LOG_DEBUG(("Finish machine"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
static void destructor(SilcFSM fsm, void *fsm_context,
{
unlink("/tmp/test_silcfdstream");
unlink("/tmp/test_silcfdstream_copy");
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(st_readwrite)
if (i == -1) {
SILC_LOG_DEBUG(("Would block, write later"));
silc_fsm_next(fsm, st_end);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
if (i == -2) {
if (ret == -1) {
SILC_LOG_DEBUG(("Would block, read later"));
silc_fsm_next(fsm, st_end);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
if (ret == -2) {
}
silc_fsm_next(fsm, st_end);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
err:
silc_fsm_next(fsm, st_end);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(st_write)
if (ret == -1) {
SILC_LOG_DEBUG(("Would block, write later"));
silc_fsm_next(fsm, st_readwrite);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
if (ret == -2) {
SILC_LOG_DEBUG(("Continue to next state"));
silc_fsm_next(fsm, st_readwrite);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
err:
silc_fsm_next(fsm, st_end);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
static void fsm_dest(SilcFSM fsm, void *fsm_context, void *context)
typedef struct {
SilcFSMThreadStruct thread;
- SilcFSMSemaStruct sema;
+ SilcFSMEventStruct sema;
SilcBool finished;
int rounds;
Foo f;
SilcFSM fsm;
SilcFSMThreadStruct thread;
int timeout;
- SilcFSMSemaStruct sema;
+ SilcFSMEventStruct sema;
SilcSchedule schedule;
Callback cb;
void *cb_context;
/** Move to second state */
SILC_LOG_DEBUG(("Move to next state"));
silc_fsm_next(fsm, test_st_second);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_st_second)
/** Move to second timeout state, timeout */
SILC_LOG_DEBUG(("Move to next state with 2 second timeout"));
silc_fsm_next_later(fsm, test_st_second_timeout, 2, 0);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_TASK_CALLBACK(test_second_timeout)
silc_fsm_next_later(fsm, test_st_third, 3, 0);
silc_schedule_task_add_timeout(silc_fsm_get_schedule(fsm),
test_second_timeout, f, 2, 500000);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
static void async_call_cb(void *context)
/** Move to final state, timeout */
SILC_LOG_DEBUG(("Move to final state with %d second timeout", f->timeout));
silc_fsm_next_later(fsm, test_thread_st_finish, f->timeout, 0);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(test_thread_st_finish)
SILC_LOG_DEBUG(("test_thread_st_finish"));
SILC_LOG_DEBUG(("Finishing the thread"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(test_st_fifth)
f->timeout = 7;
- SILC_LOG_DEBUG(("Creating FSM semaphore"));
- silc_fsm_sema_init(&f->sema, fsm, 0);
+ SILC_LOG_DEBUG(("Creating FSM event"));
+ silc_fsm_event_init(&f->sema, fsm);
SILC_LOG_DEBUG(("Creating FSM thread"));
silc_fsm_thread_init(&f->thread, fsm, f, NULL, NULL, TRUE);
/** Waiting thread to terminate, timeout */
SILC_LOG_DEBUG(("Waiting for thread to terminate for 5 seconds"));
silc_fsm_next(fsm, test_st_sixth);
- SILC_FSM_SEMA_TIMEDWAIT(&f->sema, 5, 0, NULL);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_EVENT_TIMEDWAIT(&f->sema, 5, 0, NULL);
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_thread2_st_start)
/** Move to final state, timeout */
SILC_LOG_DEBUG(("Move to final state with %d second timeout", f->timeout));
silc_fsm_next_later(fsm, test_thread2_st_finish, f->timeout, 0);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(test_thread2_st_finish)
SILC_LOG_DEBUG(("test_thread2_st_finish"));
SILC_LOG_DEBUG(("Post semaphore"));
- SILC_FSM_SEMA_POST(&f->sema);
+ SILC_FSM_EVENT_SIGNAL(&f->sema);
SILC_LOG_DEBUG(("Finishing the thread"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(test_st_sixth)
/** Move to next state, timeout */
SILC_LOG_DEBUG(("Continue to next state with 4 second timeout"));
silc_fsm_next_later(fsm, test_st_seventh, 4, 0);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(test_thread3_st_start)
T *t = fsm_context;
if (t->rounds == 0) {
- SILC_FSM_SEMA_POST(&t->sema);
- return SILC_FSM_FINISH;
+ SILC_FSM_EVENT_SIGNAL(&t->sema);
+ SILC_FSM_FINISH;
}
t->rounds--;
/** Call in recursive */
silc_fsm_next(fsm, test_thread3_st_start);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_st_seventh)
for (i = 0; i < NUM_THREADS; i++) {
f->threads[i].rounds = 10;
f->threads[i].f = f;
- silc_fsm_sema_init(&f->threads[i].sema, fsm, 0);
+ silc_fsm_event_init(&f->threads[i].sema, fsm);
silc_fsm_thread_init(&f->threads[i].thread, fsm,
&f->threads[i], NULL, NULL, FALSE);
silc_fsm_start(&f->threads[i].thread, test_thread3_st_start);
/** Move to wait threads */
silc_fsm_next(fsm, test_st_eighth);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_st_eighth)
for (i = 0; i < NUM_THREADS; i++) {
if (f->threads[i].finished == FALSE) {
- SILC_FSM_SEMA_WAIT(&f->threads[i].sema);
+ SILC_FSM_EVENT_WAIT(&f->threads[i].sema);
f->threads[i].finished = TRUE;
}
}
/** Move to next thread */
silc_fsm_next(fsm, test_st_ninth);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_thread4_st_start)
T *t = fsm_context;
if (t->rounds == 0) {
- SILC_FSM_SEMA_POST(&t->sema);
- return SILC_FSM_FINISH;
+ SILC_FSM_EVENT_SIGNAL(&t->sema);
+ SILC_FSM_FINISH;
}
t->rounds--;
/** Call in recursive */
silc_fsm_next(fsm, test_thread4_st_start);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_st_ninth)
SILC_LOG_DEBUG(("test_st_ninth"));
- SILC_LOG_DEBUG(("Creating FSM semaphore"));
- silc_fsm_sema_init(&f->sema, fsm, NUM_THREADS + 1);
+ SILC_LOG_DEBUG(("Creating FSM event"));
+ silc_fsm_event_init(&f->sema, fsm);
SILC_LOG_DEBUG(("Creating %d real FSM threads", NUM_THREADS));
for (i = 0; i < NUM_THREADS; i++) {
f->threads2[i].rounds = 10;
f->threads2[i].f = f;
- silc_fsm_sema_init(&f->threads2[i].sema, fsm, 0);
+ silc_fsm_event_init(&f->threads2[i].sema, fsm);
silc_fsm_thread_init(&f->threads2[i].thread, fsm,
&f->threads2[i], NULL, NULL, TRUE);
silc_fsm_start(&f->threads2[i].thread, test_thread4_st_start);
/** Move to wait threads */
silc_fsm_next(fsm, test_st_tenth);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_st_tenth)
for (i = 0; i < NUM_THREADS; i++)
if (f->threads2[i].finished == FALSE) {
- SILC_FSM_SEMA_WAIT(&f->threads2[i].sema);
+ SILC_FSM_EVENT_WAIT(&f->threads2[i].sema);
f->threads2[i].finished = TRUE;
}
/** Finished successfully */
silc_fsm_next_later(fsm, test_st_finish, 2, 0);
- return SILC_FSM_WAIT;
+ SILC_FSM_WAIT;
}
SILC_FSM_STATE(test_st_finish)
SILC_LOG_DEBUG(("test_st_finish"));
SILC_LOG_DEBUG(("Finish machine"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
static void destructor(SilcFSM fsm, void *fsm_context,
typedef struct {
SilcFSM fsm;
- SilcFSMSemaStruct sema;
+ SilcFSMEventStruct sema;
SilcFSMThreadStruct thread;
SilcNetListener server;
SilcStream client_stream;
SILC_LOG_DEBUG(("Accepted new connection"));
f->client_status = status;
f->client_stream = stream;
- SILC_FSM_SEMA_POST(&f->sema);
+ SILC_FSM_EVENT_SIGNAL(&f->sema);
}
static void test_connected(SilcNetStatus status, SilcStream stream,
if (f->server_status != SILC_NET_OK) {
SILC_LOG_DEBUG(("Creating connection failed"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
silc_socket_stream_get_info(f->server_stream, NULL, &host, &ip, &port);
SILC_LOG_DEBUG(("Connected to server %s, %s:%d", host, ip, port));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
SILC_FSM_STATE(test_st_start)
/** Creating network listener failed */
SILC_LOG_DEBUG(("Listener creation failed"));
silc_fsm_next(fsm, test_st_finish);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
/* Create thread to connect to the listener */
/** Start waiting connection */
SILC_LOG_DEBUG(("Start waiting for incoming connections"));
- silc_fsm_sema_init(&f->sema, fsm, 0);
+ silc_fsm_event_init(&f->sema, fsm);
silc_fsm_next(fsm, test_st_second);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
SILC_FSM_STATE(test_st_second)
SILC_LOG_DEBUG(("test_st_second"));
- SILC_FSM_SEMA_WAIT(&f->sema);
+ SILC_FSM_EVENT_WAIT(&f->sema);
if (f->client_status != SILC_NET_OK) {
/** Accepting new connection failed */
SILC_LOG_DEBUG(("Accepting failed %d", f->client_status));
silc_fsm_next(fsm, test_st_finish);
- return SILC_FSM_CONTINUE;
+ SILC_FSM_CONTINUE;
}
silc_socket_stream_get_info(f->client_stream, NULL, &host, &ip, &port);
silc_net_close_listener(f->server);
SILC_LOG_DEBUG(("Finish machine"));
- return SILC_FSM_FINISH;
+ SILC_FSM_FINISH;
}
static void destructor(SilcFSM fsm, void *fsm_context,
projects / silc.git / commitdiff