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;
/* Connection created successfully */
SILC_LOG_DEBUG(("Connected"));
- conn->stream = (void *)stream;
+ conn->internal->user_stream = stream;
SILC_FSM_CALL_CONTINUE(fsm);
}
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->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);
- SILC_FSM_CALL_CONTINUE(fsm);
+ SILC_FSM_CALL_CONTINUE_SYNC(fsm);
return;
}
"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);
- SILC_FSM_CALL_CONTINUE(fsm);
+ SILC_FSM_CALL_CONTINUE_SYNC(fsm);
return;
}
"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);
- SILC_FSM_CALL_CONTINUE(fsm);
+ SILC_FSM_CALL_CONTINUE_SYNC(fsm);
return;
}
SILC_LOG_DEBUG(("Key Exchange completed"));
/* Key exchange done */
- SILC_FSM_CALL_CONTINUE(fsm);
+ SILC_FSM_CALL_CONTINUE_SYNC(fsm);
}
/* Rekey protocol completion callback */
conn->remote_host,
silc_ske_map_status(status));
+ silc_ske_free(conn->internal->ske);
+ conn->internal->ske = NULL;
silc_fsm_finish(fsm);
return;
}
silc_ske_free_rekey_material(conn->internal->rekey);
conn->internal->rekey = rekey;
- SILC_LOG_DEBUG(("Rekey completed"));
+ silc_ske_free(conn->internal->ske);
+ conn->internal->ske = NULL;
+
+ SILC_LOG_DEBUG(("Rekey completed conn %p", conn));
/* Rekey done */
silc_fsm_finish(fsm);
/* Callback called by application to return authentication data */
static void silc_client_connect_auth_method(SilcAuthMethod auth_meth,
- void *auth, SilcUInt32 auth_len,
+ const void *auth,
+ SilcUInt32 auth_len,
void *context)
{
SilcFSMThread fsm = context;
SilcClientConnection conn = silc_fsm_get_context(fsm);
conn->internal->params.auth_method = auth_meth;
- conn->internal->params.auth = auth;
+ if (auth_meth == SILC_AUTH_PASSWORD)
+ conn->internal->params.auth = silc_memdup(auth, auth_len);
+ else
+ conn->internal->params.auth = (void *)auth;
conn->internal->params.auth_len = auth_len;
SILC_FSM_CALL_CONTINUE(fsm);
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);
}
- SILC_FSM_CALL_CONTINUE(fsm);
+ SILC_FSM_CALL_CONTINUE_SYNC(fsm);
}
/********************** CONNECTION_AUTH_REQUEST packet **********************/
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);
return SILC_FSM_CONTINUE;
}
/* Create packet stream */
conn->stream = silc_packet_stream_create(client->internal->packet_engine,
conn->internal->schedule,
- (SilcStream)conn->stream);
+ conn->internal->user_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);
return SILC_FSM_CONTINUE;
}
SilcClientConnection conn = fsm_context;
SilcClient client = conn->client;
SilcSKEParamsStruct params;
+ SilcClientID cid;
SILC_LOG_DEBUG(("Starting key exchange protocol"));
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);
return SILC_FSM_CONTINUE;
}
/** Run key exchange (TCP) */
silc_fsm_next(fsm, silc_client_st_connect_auth_resolve);
+ /* Old server version requires empty Client ID in packets. Remove this
+ backwards support somepoint after 1.1 server is released. */
+ memset(&cid, 0, sizeof(cid));
+ cid.ip.data_len = 4;
+ silc_packet_set_ids(conn->stream, SILC_ID_CLIENT, &cid, 0, NULL);
+
SILC_FSM_CALL(conn->internal->op = silc_ske_initiator(conn->internal->ske,
conn->stream,
¶ms, NULL));
SILC_FSM_STATE(silc_client_st_connect_setup_udp)
{
SilcClientConnection conn = fsm_context;
- SilcClient client = conn->client;
SilcStream stream, old;
SilcSKESecurityProperties prop;
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);
return SILC_FSM_CONTINUE;
}
return SILC_FSM_CONTINUE;
}
-/* Resolved authentication method to be used in authentication protocol */
+/* Resolve authentication method to be used in authentication protocol */
SILC_FSM_STATE(silc_client_st_connect_auth_resolve)
{
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"));
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);
return SILC_FSM_CONTINUE;
}
SilcClientConnection conn = fsm_context;
SilcClient client = conn->client;
+ /* Get SILC protocol version remote supports */
+ silc_ske_parse_version(conn->internal->ske, &conn->internal->remote_version,
+ NULL, NULL, NULL, NULL);
+
silc_ske_free(conn->internal->ske);
conn->internal->ske = NULL;
+ if (!conn->internal->params.auth_set &&
+ conn->internal->params.auth_method == SILC_AUTH_PASSWORD &&
+ conn->internal->params.auth) {
+ silc_free(conn->internal->params.auth);
+ conn->internal->params.auth = NULL;
+ }
+
if (conn->internal->disconnected) {
/** Disconnected */
silc_fsm_next(fsm, silc_client_st_connect_error);
SILC_LOG_DEBUG(("Connection established"));
/* Install rekey timer */
- silc_schedule_task_add_timeout(conn->internal->schedule,
- silc_client_rekey_timer, conn,
- conn->internal->params.rekey_secs, 0);
+ if (conn->type != SILC_CONN_CLIENT)
+ silc_schedule_task_add_timeout(conn->internal->schedule,
+ silc_client_rekey_timer, conn,
+ conn->internal->params.rekey_secs, 0);
/* If we connected to server, now register to network. */
if (conn->type == SILC_CONN_SERVER &&
conn->callback(client, conn, SILC_CLIENT_CONN_SUCCESS, 0, NULL,
conn->callback_context);
+ silc_async_free(conn->internal->cop);
+ conn->internal->cop = NULL;
+
return SILC_FSM_FINISH;
}
SilcClientConnection conn = context;
/* Signal to start rekey */
- conn->internal->rekey_responder = FALSE;
- conn->internal->rekeying = TRUE;
- SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
+ if (!silc_fsm_is_started(&conn->internal->event_thread)) {
+ conn->internal->rekey_responder = FALSE;
+ conn->internal->rekeying = TRUE;
+ SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
+ }
/* Reinstall rekey timer */
silc_schedule_task_add_timeout(conn->internal->schedule,
SilcClientConnection conn = fsm_context;
SilcClient client = conn->client;
- SILC_LOG_DEBUG(("Rekey"));
+ SILC_LOG_DEBUG(("Rekey conn %p", conn));
if (conn->internal->disconnected)
return SILC_FSM_FINISH;
/* Allocate SKE */
conn->internal->ske =
- silc_ske_alloc(client->rng, conn->internal->schedule,
- conn->internal->params.repository,
- conn->public_key, conn->private_key, fsm);
+ silc_ske_alloc(client->rng, conn->internal->schedule, NULL,
+ conn->public_key, NULL, fsm);
if (!conn->internal->ske)
return SILC_FSM_FINISH;
SILC_FSM_CALL(conn->internal->op = silc_ske_rekey_responder(
conn->internal->ske,
conn->stream,
- conn->internal->rekey));
+ conn->internal->rekey,
+ NULL));
}
projects / silc.git / blobdiff