if (status != SILC_NET_OK) {
/* Notify application of failure */
SILC_LOG_DEBUG(("Connecting failed"));
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR, 0,
- NULL, conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR;
silc_fsm_next(fsm, silc_client_st_connect_error);
SILC_FSM_CALL_CONTINUE(fsm);
return;
static void silc_client_ke_verify_key_cb(SilcBool success, void *context)
{
- VerifyKeyContext verify = (VerifyKeyContext)context;
+ SilcVerifyKeyContext verify = context;
SILC_LOG_DEBUG(("Start"));
SilcFSMThread fsm = context;
SilcClientConnection conn = silc_fsm_get_context(fsm);
SilcClient client = conn->client;
- VerifyKeyContext verify;
+ SilcVerifyKeyContext verify;
/* If we provided repository for SKE and we got here the key was not
found from the repository. */
conn->remote_host,
silc_ske_map_status(status));
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_KE;
+ conn->internal->error = status;
silc_ske_free_rekey_material(rekey);
silc_fsm_next(fsm, silc_client_st_connect_error);
"Error during key exchange with %s: cannot use keys",
conn->remote_host);
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR_KE, 0, NULL,
- conn->callback_context);
-
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_KE;
silc_ske_free_rekey_material(rekey);
silc_fsm_next(fsm, silc_client_st_connect_error);
"Error during key exchange with %s: cannot use keys",
conn->remote_host);
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR_KE, 0, NULL,
- conn->callback_context);
-
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_KE;
silc_ske_free_rekey_material(rekey);
silc_fsm_next(fsm, silc_client_st_connect_error);
client, conn, SILC_CLIENT_MESSAGE_ERROR,
"Authentication failed");
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR_AUTH, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_AUTH;
+ conn->internal->error = SILC_STATUS_ERR_AUTH_FAILED;
silc_fsm_next(fsm, silc_client_st_connect_error);
}
if (!conn->internal->auth_request) {
silc_packet_free(packet);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Parse the payload */
/* Continue authentication */
silc_fsm_continue_sync(&conn->internal->event_thread);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/*************************** Connect remote host ****************************/
SILC_TASK_CALLBACK(silc_client_connect_timeout)
{
SilcClientConnection conn = context;
- SilcClient client = conn->client;
SILC_LOG_DEBUG(("Connection timeout"));
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR_TIMEOUT, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_TIMEOUT;
+ conn->internal->error = SILC_STATUS_ERR_TIMEDOUT;
silc_fsm_next(&conn->internal->event_thread, silc_client_st_connect_error);
silc_fsm_continue_sync(&conn->internal->event_thread);
SILC_FSM_STATE(silc_client_st_connect)
{
SilcClientConnection conn = fsm_context;
- SilcClient client = conn->client;
SILC_LOG_DEBUG(("Connecting to %s:%d", conn->remote_host,
conn->remote_port));
if (!conn->internal->params.local_ip) {
/** IP address not given */
SILC_LOG_ERROR(("Local UDP IP address not specified"));
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR;
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Connect (UDP) */
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Create packet stream */
if (!conn->stream) {
/** Cannot create packet stream */
SILC_LOG_DEBUG(("Could not create packet stream"));
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR;
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_packet_set_context(conn->stream, conn);
/** Start key exchange */
silc_fsm_next(fsm, silc_client_st_connect_key_exchange);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Starts key exchange protocol with remote host */
conn->public_key, conn->private_key, fsm);
if (!conn->internal->ske) {
/** Out of memory */
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR_KE, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_KE;
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Set SKE callbacks */
/* Set up key exchange parameters */
params.version = client->internal->silc_client_version;
+ params.timeout_secs = conn->internal->params.timeout_secs;
params.flags = SILC_SKE_SP_FLAG_MUTUAL;
if (conn->internal->params.pfs)
params.flags |= SILC_SKE_SP_FLAG_PFS;
SILC_FSM_STATE(silc_client_st_connect_setup_udp)
{
SilcClientConnection conn = fsm_context;
- SilcClient client = conn->client;
SilcStream stream, old;
SilcSKESecurityProperties prop;
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Create new UDP stream */
conn->internal->schedule);
if (!stream) {
/** Cannot create UDP stream */
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR;
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Set the new stream to packet stream */
/** Start authentication */
silc_fsm_next(fsm, silc_client_st_connect_auth_resolve);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Resolved authentication method to be used in authentication protocol */
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* If authentication method and data is set, use them */
if (conn->internal->params.auth_set) {
/** Got authentication data */
silc_fsm_next(fsm, silc_client_st_connect_auth_start);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Send connection authentication request packet */
conn->internal->auth_request = TRUE;
conn->internal->params.auth_method = SILC_AUTH_NONE;
silc_fsm_next_later(fsm, silc_client_st_connect_auth_data, 2, 0);
- SILC_FSM_WAIT;
+ return SILC_FSM_WAIT;
}
/* Get authentication data to be used in authentication protocol */
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
conn->internal->auth_request = FALSE;
SILC_FSM_STATE(silc_client_st_connect_auth_start)
{
SilcClientConnection conn = fsm_context;
- SilcClient client = conn->client;
SilcConnAuth connauth;
SILC_LOG_DEBUG(("Starting connection authentication protocol"));
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* We always use the same key for connection authentication and SKE */
conn->internal->params.rekey_secs);
if (!connauth) {
/** Out of memory */
- conn->callback(client, conn, SILC_CLIENT_CONN_ERROR_AUTH, 0, NULL,
- conn->callback_context);
+ conn->internal->status = SILC_CLIENT_CONN_ERROR_AUTH;
+ conn->internal->error = SILC_STATUS_ERR_AUTH_FAILED;
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/** Start connection authentication */
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
SILC_LOG_DEBUG(("Connection established"));
silc_fsm_next(fsm, silc_client_st_register);
}
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
silc_schedule_task_del_by_all(conn->internal->schedule, 0,
conn->callback(client, conn, SILC_CLIENT_CONN_SUCCESS, 0, NULL,
conn->callback_context);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Error during connecting */
silc_schedule_task_del_by_all(conn->internal->schedule, 0,
silc_client_connect_timeout, conn);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/****************************** Connect rekey *******************************/
SILC_LOG_DEBUG(("Rekey"));
if (conn->internal->disconnected)
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
/* Allocate SKE */
conn->internal->ske =
conn->internal->params.repository,
conn->public_key, conn->private_key, fsm);
if (!conn->internal->ske)
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
/* Set SKE callbacks */
silc_ske_set_callbacks(conn->internal->ske, NULL,