SilcClientConnection conn = fsm_context;
SilcFSMThread thread = destructor_context;
+ SILC_LOG_DEBUG(("Connection %p finished", conn));
+
/* Delete connection */
silc_client_del_connection(conn->client, conn);
silc_fsm_finish(thread);
}
+/* Connection thread FSM destructor. This was the thread where the connection
+ machine was running (may be real thread). From here we notify client
+ that the connection thread has finished. */
+
+static void silc_client_connection_finished(SilcFSMThread fsm,
+ void *fsm_context,
+ void *destructor_context)
+{
+ SilcClient client = silc_fsm_get_state_context(fsm);
+
+ /* Signal client that we have finished */
+ silc_atomic_sub_int16(&client->internal->conns, 1);
+ client->internal->connection_closed = TRUE;
+ SILC_FSM_SEMA_POST(&client->internal->wait_event);
+
+ silc_fsm_free(fsm);
+}
+
+
/* Packet FSM thread destructor */
static void silc_client_packet_destructor(SilcFSMThread thread,
case SILC_PACKET_KEY_EXCHANGE:
case SILC_PACKET_KEY_EXCHANGE_1:
case SILC_PACKET_KEY_EXCHANGE_2:
- case SILC_PACKET_REKEY:
case SILC_PACKET_REKEY_DONE:
case SILC_PACKET_CONNECTION_AUTH:
case SILC_PACKET_CONNECTION_AUTH_REQUEST:
void *callback_context,
void *stream_context)
{
- SILC_LOG_DEBUG(("End of stream received"));
+ SilcClientConnection conn = stream_context;
+ SilcClient client = conn->client;
+
+ SILC_LOG_DEBUG(("Remote disconnected connection"));
+
+ /* Call connection callback */
+ if (!conn->internal->callback_called)
+ conn->callback(client, conn, SILC_CLIENT_CONN_DISCONNECTED, 0, NULL,
+ conn->callback_context);
+ conn->internal->callback_called = TRUE;
+
+ /* Signal to close connection */
+ if (!conn->internal->disconnected) {
+ conn->internal->disconnected = TRUE;
+ SILC_FSM_SEMA_POST(&conn->internal->wait_event);
+ }
}
/* Packet engine callback to indicate error */
void *callback_context,
void *stream_context)
{
-
+ /* Nothing */
}
/* Packet stream callbacks */
silc_fsm_free(fsm);
}
+/* Connect abort operation */
+
+static void silc_client_connect_abort(SilcAsyncOperation op, void *context)
+{
+ SilcClientConnection conn = context;
+
+ SILC_LOG_DEBUG(("Connection %p aborted by application", conn));
+
+ /* Signal to close connection */
+ if (!conn->internal->disconnected) {
+ conn->internal->disconnected = TRUE;
+ SILC_FSM_SEMA_POST(&conn->internal->wait_event);
+ }
+}
/************************** Connection's machine ****************************/
return SILC_FSM_CONTINUE;
}
+ if (conn->internal->rekeying) {
+ SILC_LOG_DEBUG(("Event: rekey"));
+ conn->internal->rekeying = FALSE;
+
+ /*** Event: rekey */
+ silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
+ NULL, NULL, FALSE);
+ silc_fsm_start_sync(thread, silc_client_st_rekey);
+ return SILC_FSM_CONTINUE;
+ }
+
if (conn->internal->disconnected) {
/** Event: disconnected */
SILC_LOG_DEBUG(("Event: disconnected"));
- conn->internal->disconnected = FALSE;
silc_fsm_next(fsm, silc_client_connection_st_close);
- return SILC_FSM_CONTINUE;
+ return SILC_FSM_YIELD;
}
/* NOT REACHED */
SILC_FSM_STATE(silc_client_connection_st_packet)
{
+ SilcClientConnection conn = fsm_context;
SilcPacket packet = state_context;
SILC_LOG_DEBUG(("Parsing %s packet", silc_get_packet_name(packet->type)));
break;
case SILC_PACKET_KEY_AGREEMENT:
- /* Key agreement */
- // silc_client_key_agreement(client, conn, packet);
+ /** Key agreement */
+ silc_fsm_next(fsm, silc_client_key_agreement);
break;
case SILC_PACKET_COMMAND:
case SILC_PACKET_NEW_ID:
/** New ID */
silc_fsm_next(fsm, silc_client_new_id);
+ break;
case SILC_PACKET_CONNECTION_AUTH_REQUEST:
/* Reply to connection authentication request to resolve authentication
// silc_client_connection_auth_request(client, conn, packet);
break;
+ case SILC_PACKET_REKEY:
+ /* Signal to start rekey */
+ conn->internal->rekey_responder = TRUE;
+ conn->internal->rekeying = TRUE;
+ SILC_FSM_SEMA_POST(&conn->internal->wait_event);
+
+ silc_packet_free(packet);
+ return SILC_FSM_FINISH;
+ break;
+
default:
silc_packet_free(packet);
return SILC_FSM_FINISH;
return SILC_FSM_CONTINUE;
}
-/* Disconnection even to close remote connection. We close the connection
+/* Disconnection event to close remote connection. We close the connection
and finish the connection machine in this state. The connection context
is deleted in the machine destructor. The connection callback must be
already called back to application before getting here. */
SILC_FSM_STATE(silc_client_connection_st_close)
{
SilcClientConnection conn = fsm_context;
+ SilcClientCommandContext cmd;
+
+ /* Finish running command threads. This will also finish waiting packet
+ thread, as they are always waiting for some command. If any thread is
+ waiting something else than command, they must be finished explicitly. */
+ if (silc_list_count(conn->internal->pending_commands)) {
+ SILC_LOG_DEBUG(("Finish pending commands"));
+ silc_list_start(conn->internal->pending_commands);
+ while ((cmd = silc_list_get(conn->internal->pending_commands))) {
+ if (silc_fsm_is_started(&cmd->thread)) {
+ cmd->verbose = FALSE;
+ silc_fsm_continue_sync(&cmd->thread);
+ }
+ }
- SILC_LOG_DEBUG(("Closing remote connection"));
+ /* Give threads time to finish */
+ return SILC_FSM_YIELD;
+ }
- /* XXX abort any ongoing events (protocols) */
+ /* Abort ongoing event */
+ if (conn->internal->op) {
+ SILC_LOG_DEBUG(("Abort event"));
+ silc_async_abort(conn->internal->op, NULL, NULL);
+ conn->internal->op = NULL;
+ }
+
+ /* If event thread is running, finish it. */
+ if (silc_fsm_is_started(&conn->internal->event_thread)) {
+ SILC_LOG_DEBUG(("Finish event thread"));
+ silc_fsm_continue_sync(&conn->internal->event_thread);
+ return SILC_FSM_YIELD;
+ }
+
+ SILC_LOG_DEBUG(("Closing remote connection"));
/* Close connection */
silc_packet_stream_destroy(conn->stream);
silc_buffer_len(&packet->buffer));
/* Call connection callback */
- conn->callback(client, conn, SILC_CLIENT_CONN_DISCONNECTED, status,
- message, conn->callback_context);
+ if (!conn->internal->callback_called)
+ conn->callback(client, conn, SILC_CLIENT_CONN_DISCONNECTED, status,
+ message, conn->callback_context);
+ conn->internal->callback_called = TRUE;
silc_free(message);
silc_packet_free(packet);
/* Signal to close connection */
- conn->internal->disconnected = TRUE;
- SILC_FSM_SEMA_POST(&conn->internal->wait_event);
+ if (!conn->internal->disconnected) {
+ conn->internal->disconnected = TRUE;
+ SILC_FSM_SEMA_POST(&conn->internal->wait_event);
+ }
return SILC_FSM_FINISH;
}
/* Process events */
- if (client->internal->run_callback && client->internal->ops->running) {
+ if (client->internal->run_callback && client->internal->running) {
/* Call running callbcak back to application */
+ SILC_LOG_DEBUG(("We are up, call running callback"));
client->internal->run_callback = FALSE;
- client->internal->ops->running(client, client->application);
+ client->internal->running(client, client->internal->running_context);
+ return SILC_FSM_CONTINUE;
+ }
+
+ if (client->internal->connection_closed) {
+ /* A connection finished */
+ SILC_LOG_DEBUG(("Event: connection closed"));
+ client->internal->connection_closed = FALSE;
+ if (silc_atomic_get_int16(&client->internal->conns) == 0 &&
+ client->internal->stop)
+ SILC_FSM_SEMA_POST(&client->internal->wait_event);
+ return SILC_FSM_CONTINUE;
+ }
+
+ if (client->internal->stop) {
+ /* Stop client libarry. If we have running connections, wait until
+ they finish first. */
+ SILC_LOG_DEBUG(("Event: stop"));
+ if (silc_atomic_get_int16(&client->internal->conns) == 0)
+ silc_fsm_next(fsm, silc_client_st_stop);
return SILC_FSM_CONTINUE;
}
return SILC_FSM_CONTINUE;
}
+/* Stop event. Stops the client library. */
+
+SILC_FSM_STATE(silc_client_st_stop)
+{
+ SilcClient client = fsm_context;
+
+ SILC_LOG_DEBUG(("Client stopped"));
+
+ /* Stop scheduler */
+ silc_schedule_stop(client->schedule);
+ silc_client_commands_unregister(client);
+
+ /* Call stopped callback to application */
+ if (client->internal->running)
+ client->internal->running(client, client->internal->running_context);
+
+ return SILC_FSM_FINISH;
+}
+
/******************************* Private API ********************************/
/* Adds new connection. Creates the connection context and returns it. */
silc_free(conn);
return NULL;
}
+ conn->internal->retry_timer = SILC_CLIENT_RETRY_MIN;
+ silc_mutex_alloc(&conn->internal->lock);
+ silc_atomic_init16(&conn->internal->cmd_ident, 0);
if (!silc_hash_alloc("sha1", &conn->internal->sha1hash)) {
silc_free(conn);
silc_free(conn->internal);
return NULL;
}
+
+ /* Set parameters */
if (params)
conn->internal->params = *params;
+ if (!conn->internal->params.rekey_secs)
+ conn->internal->params.rekey_secs = 3600;
+#ifndef SILC_DIST_INPLACE
+ if (conn->internal->params.rekey_secs < 300)
+ conn->internal->params.rekey_secs = 300;
+#endif /* SILC_DIST_INPLACE */
+
conn->internal->verbose = TRUE;
silc_list_init(conn->internal->pending_commands,
struct SilcClientCommandContextStruct, next);
silc_list_init(conn->internal->thread_pool, SilcFSMThreadStruct, next);
+ /* Allocate client, channel and serve caches */
conn->internal->client_cache = silc_idcache_alloc(0, SILC_ID_CLIENT,
NULL, NULL);
conn->internal->channel_cache = silc_idcache_alloc(0, SILC_ID_CHANNEL,
conn->internal->ftp_sessions = silc_dlist_init();
+ /* Initialize our async operation so that application may abort us
+ while we're connecting. */
+ conn->internal->cop = silc_async_alloc(silc_client_connect_abort,
+ NULL, conn);
+ if (!conn->internal->cop) {
+ silc_client_del_connection(client, conn);
+ return NULL;
+ }
+
/* Run the connection state machine. If threads are in use the machine
is always run in a real thread. */
thread = silc_fsm_thread_alloc(&client->internal->fsm, conn,
- silc_client_fsm_destructor, NULL,
+ silc_client_connection_finished, NULL,
client->internal->params->threads);
if (!thread) {
silc_client_del_connection(client, conn);
return NULL;
}
+ silc_fsm_set_state_context(thread, client);
silc_fsm_start(thread, silc_client_connection_st_start);
+ SILC_LOG_DEBUG(("New connection %p", conn));
+ silc_atomic_add_int16(&client->internal->conns, 1);
+
return conn;
}
-/* Removes connection from client. Frees all memory. */
+/* Deletes connection. This is always called from the connection machine
+ destructor. Do not call this directly other places. */
void silc_client_del_connection(SilcClient client, SilcClientConnection conn)
{
-#if 0
- SilcClientConnection c;
- SilcIDCacheList list;
+ SilcList list;
SilcIDCacheEntry entry;
- SilcClientCommandPending *r;
- SilcBool ret;
-
- silc_dlist_start(client->internal->conns);
- while ((c = silc_dlist_get(client->internal->conns)) != SILC_LIST_END) {
- if (c != conn)
- continue;
-
- /* Free all cache entries */
- if (silc_idcache_get_all(conn->internal->client_cache, &list)) {
- ret = silc_idcache_list_first(list, &entry);
- while (ret) {
- silc_client_del_client(client, conn, entry->context);
- ret = silc_idcache_list_next(list, &entry);
- }
- silc_idcache_list_free(list);
- }
-
- if (silc_idcache_get_all(conn->internal->channel_cache, &list)) {
- ret = silc_idcache_list_first(list, &entry);
- while (ret) {
- silc_client_del_channel(client, conn, entry->context);
- ret = silc_idcache_list_next(list, &entry);
- }
- silc_idcache_list_free(list);
- }
-
- if (silc_idcache_get_all(conn->internal->server_cache, &list)) {
- ret = silc_idcache_list_first(list, &entry);
- while (ret) {
- silc_client_del_server(client, conn, entry->context);
- ret = silc_idcache_list_next(list, &entry);
- }
- silc_idcache_list_free(list);
- }
+ SilcFSMThread thread;
- /* Clear ID caches */
- if (conn->internal->client_cache)
- silc_idcache_free(conn->internal->client_cache);
- if (conn->internal->channel_cache)
- silc_idcache_free(conn->internal->channel_cache);
- if (conn->internal->server_cache)
- silc_idcache_free(conn->internal->server_cache);
-
- /* Free data (my ID is freed in above silc_client_del_client).
- conn->nickname is freed when freeing the local_entry->nickname. */
- silc_free(conn->remote_host);
- silc_free(conn->local_id_data);
- if (conn->internal->send_key)
- silc_cipher_free(conn->internal->send_key);
- if (conn->internal->receive_key)
- silc_cipher_free(conn->internal->receive_key);
- if (conn->internal->hmac_send)
- silc_hmac_free(conn->internal->hmac_send);
- if (conn->internal->hmac_receive)
- silc_hmac_free(conn->internal->hmac_receive);
- silc_free(conn->internal->rekey);
-
- if (conn->internal->active_session) {
- if (conn->sock)
- conn->sock->user_data = NULL;
- silc_client_ftp_session_free(conn->internal->active_session);
- conn->internal->active_session = NULL;
- }
+ SILC_LOG_DEBUG(("Freeing connection %p", conn));
- silc_client_ftp_free_sessions(client, conn);
+ silc_schedule_task_del_by_context(conn->internal->schedule, conn);
- if (conn->internal->pending_commands) {
- silc_dlist_start(conn->internal->pending_commands);
- while ((r = silc_dlist_get(conn->internal->pending_commands))
- != SILC_LIST_END)
- silc_dlist_del(conn->internal->pending_commands, r);
- silc_dlist_uninit(conn->internal->pending_commands);
+ /* Free all cache entries */
+ if (silc_idcache_get_all(conn->internal->server_cache, &list)) {
+ silc_list_start(list);
+ while ((entry = silc_list_get(list)))
+ silc_client_del_server(client, conn, entry->context);
+ }
+ if (silc_idcache_get_all(conn->internal->channel_cache, &list)) {
+ silc_list_start(list);
+ while ((entry = silc_list_get(list))) {
+ silc_client_empty_channel(client, conn, entry->context);
+ silc_client_del_channel(client, conn, entry->context);
}
-
- silc_free(conn->internal);
- memset(conn, 0, sizeof(*conn));
- silc_free(conn);
-
- silc_dlist_del(client->internal->conns, conn);
}
-#endif /* 0 */
-}
+ if (silc_idcache_get_all(conn->internal->client_cache, &list)) {
+ silc_list_start(list);
+ while ((entry = silc_list_get(list)))
+ silc_client_del_client(client, conn, entry->context);
+ }
+ /* Free ID caches */
+ if (conn->internal->client_cache)
+ silc_idcache_free(conn->internal->client_cache);
+ if (conn->internal->channel_cache)
+ silc_idcache_free(conn->internal->channel_cache);
+ if (conn->internal->server_cache)
+ silc_idcache_free(conn->internal->server_cache);
+
+ /* Free thread pool */
+ silc_list_start(conn->internal->thread_pool);
+ while ((thread = silc_list_get(conn->internal->thread_pool)))
+ silc_fsm_free(thread);
+
+ silc_free(conn->remote_host);
+ silc_buffer_free(conn->internal->local_idp);
+ silc_buffer_free(conn->internal->remote_idp);
+ silc_mutex_free(conn->internal->lock);
+ if (conn->internal->hash)
+ silc_hash_free(conn->internal->hash);
+ if (conn->internal->sha1hash)
+ silc_hash_free(conn->internal->sha1hash);
+ silc_atomic_uninit16(&conn->internal->cmd_ident);
+
+ silc_free(conn->internal);
+ memset(conn, 'F', sizeof(*conn));
+ silc_free(conn);
+}
/******************************* Client API *********************************/
to remote SILC server. Performs key exchange also. Returns the
connection context to the connection callback. */
-SilcBool silc_client_connect_to_server(SilcClient client,
- SilcClientConnectionParams *params,
- SilcPublicKey public_key,
- SilcPrivateKey private_key,
- char *remote_host, int port,
- SilcClientConnectCallback callback,
- void *context)
+SilcAsyncOperation
+silc_client_connect_to_server(SilcClient client,
+ SilcClientConnectionParams *params,
+ SilcPublicKey public_key,
+ SilcPrivateKey private_key,
+ char *remote_host, int port,
+ SilcClientConnectCallback callback,
+ void *context)
{
SilcClientConnection conn;
+ SILC_LOG_DEBUG(("Connecting to server"));
+
if (!client || !remote_host)
- return FALSE;
+ return NULL;
/* Add new connection */
conn = silc_client_add_connection(client, SILC_CONN_SERVER, params,
port, callback, context);
if (!conn) {
callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
- return FALSE;
+ return NULL;
}
client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
/* Signal connection machine to start connecting */
conn->internal->connect = TRUE;
- return TRUE;
+ return conn->internal->cop;
}
/* Connects to remote client. Performs key exchange also. Returns the
connection context to the connection callback. */
-SilcBool silc_client_connect_to_client(SilcClient client,
- SilcClientConnectionParams *params,
- SilcPublicKey public_key,
- SilcPrivateKey private_key,
- char *remote_host, int port,
- SilcClientConnectCallback callback,
- void *context)
+SilcAsyncOperation
+silc_client_connect_to_client(SilcClient client,
+ SilcClientConnectionParams *params,
+ SilcPublicKey public_key,
+ SilcPrivateKey private_key,
+ char *remote_host, int port,
+ SilcClientConnectCallback callback,
+ void *context)
{
SilcClientConnection conn;
+ SILC_LOG_DEBUG(("Connecting to client"));
+
if (!client || !remote_host)
- return FALSE;
+ return NULL;
/* Add new connection */
conn = silc_client_add_connection(client, SILC_CONN_CLIENT, params,
port, callback, context);
if (!conn) {
callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
- return FALSE;
+ return NULL;
}
- client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
- "Connecting to port %d of client host %s",
- port, remote_host);
-
/* Signal connection machine to start connecting */
conn->internal->connect = TRUE;
- return TRUE;
+ return conn->internal->cop;
}
/* Starts key exchange in the remote stream indicated by `stream'. This
creates the connection context and returns it in the connection callback. */
-SilcBool silc_client_key_exchange(SilcClient client,
- SilcClientConnectionParams *params,
- SilcPublicKey public_key,
- SilcPrivateKey private_key,
- SilcStream stream,
- SilcConnectionType conn_type,
- SilcClientConnectCallback callback,
- void *context)
+SilcAsyncOperation
+silc_client_key_exchange(SilcClient client,
+ SilcClientConnectionParams *params,
+ SilcPublicKey public_key,
+ SilcPrivateKey private_key,
+ SilcStream stream,
+ SilcConnectionType conn_type,
+ SilcClientConnectCallback callback,
+ void *context)
{
SilcClientConnection conn;
const char *host;
SilcUInt16 port;
+ SILC_LOG_DEBUG(("Performing key exchange"));
+
if (!client || !stream)
- return FALSE;
+ return NULL;
- if (!silc_socket_stream_get_info(stream, NULL, &host, NULL, &port))
- return FALSE;
+ if (!silc_socket_stream_get_info(stream, NULL, &host, NULL, &port)) {
+ SILC_LOG_ERROR(("Socket stream does not have remote host name set"));
+ callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
+ return NULL;
+ }
/* Add new connection */
conn = silc_client_add_connection(client, conn_type, params,
(char *)host, port, callback, context);
if (!conn) {
callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
- return FALSE;
+ return NULL;
}
conn->stream = (void *)stream;
/* Signal connection to start key exchange */
conn->internal->key_exchange = TRUE;
- return TRUE;
+ return conn->internal->cop;
}
/* Closes remote connection */
void silc_client_close_connection(SilcClient client,
SilcClientConnection conn)
{
+ SILC_LOG_DEBUG(("Closing connection %p", conn));
-}
-
-#if 0
-/* Finalizes the connection to the remote SILC server. This is called
- after authentication protocol has been completed. This send our
- user information to the server to receive our client ID from
- server. */
-
-SILC_TASK_CALLBACK(silc_client_connect_to_server_final)
-{
- SilcProtocol protocol = (SilcProtocol)context;
- SilcClientConnAuthInternalContext *ctx =
- (SilcClientConnAuthInternalContext *)protocol->context;
- SilcClient client = (SilcClient)ctx->client;
- SilcClientConnection conn = (SilcClientConnection)ctx->sock->user_data;
- SilcBuffer packet;
-
- SILC_LOG_DEBUG(("Start"));
-
- if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
- protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
- /* Error occured during protocol */
- SILC_LOG_DEBUG(("Error during authentication protocol"));
- ctx->status = SILC_CLIENT_CONN_ERROR_AUTH;
- goto err;
- }
-
- if (conn->internal->params.detach_data) {
- /* Send RESUME_CLIENT packet to the server, which is used to resume
- old detached session back. */
- SilcBuffer auth;
- SilcClientID *old_client_id;
- unsigned char *old_id;
- SilcUInt16 old_id_len;
-
- if (!silc_client_process_detach_data(client, conn, &old_id, &old_id_len)) {
- ctx->status = SILC_CLIENT_CONN_ERROR_RESUME;
- goto err;
- }
-
- old_client_id = silc_id_str2id(old_id, old_id_len, SILC_ID_CLIENT);
- if (!old_client_id) {
- silc_free(old_id);
- ctx->status = SILC_CLIENT_CONN_ERROR_RESUME;
- goto err;
- }
-
- /* Generate authentication data that server will verify */
- auth = silc_auth_public_key_auth_generate(client->public_key,
- client->private_key,
- client->rng,
- conn->internal->hash,
- old_client_id, SILC_ID_CLIENT);
- if (!auth) {
- silc_free(old_client_id);
- silc_free(old_id);
- ctx->status = SILC_CLIENT_CONN_ERROR_RESUME;
- goto err;
- }
-
- packet = silc_buffer_alloc_size(2 + old_id_len + auth->len);
- silc_buffer_format(packet,
- SILC_STR_UI_SHORT(old_id_len),
- SILC_STR_UI_XNSTRING(old_id, old_id_len),
- SILC_STR_UI_XNSTRING(auth->data, auth->len),
- SILC_STR_END);
-
- /* Send the packet */
- silc_client_packet_send(client, ctx->sock, SILC_PACKET_RESUME_CLIENT,
- NULL, 0, NULL, NULL,
- packet->data, packet->len, TRUE);
- silc_buffer_free(packet);
- silc_buffer_free(auth);
- silc_free(old_client_id);
- silc_free(old_id);
- } else {
- /* Send NEW_CLIENT packet to the server. We will become registered
- to the SILC network after sending this packet and we will receive
- client ID from the server. */
- packet = silc_buffer_alloc(2 + 2 + strlen(client->username) +
- strlen(client->realname));
- silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
- silc_buffer_format(packet,
- SILC_STR_UI_SHORT(strlen(client->username)),
- SILC_STR_UI_XNSTRING(client->username,
- strlen(client->username)),
- SILC_STR_UI_SHORT(strlen(client->realname)),
- SILC_STR_UI_XNSTRING(client->realname,
- strlen(client->realname)),
- SILC_STR_END);
-
- /* Send the packet */
- silc_client_packet_send(client, ctx->sock, SILC_PACKET_NEW_CLIENT,
- NULL, 0, NULL, NULL,
- packet->data, packet->len, TRUE);
- silc_buffer_free(packet);
- }
-
- /* Save remote ID. */
- conn->remote_id = ctx->dest_id;
- conn->remote_id_data = silc_id_id2str(ctx->dest_id, SILC_ID_SERVER);
- conn->remote_id_data_len = silc_id_get_len(ctx->dest_id, SILC_ID_SERVER);
-
- /* Register re-key timeout */
- conn->internal->rekey->timeout = client->internal->params->rekey_secs;
- conn->internal->rekey->context = (void *)client;
- silc_schedule_task_add(client->schedule, conn->sock->sock,
- silc_client_rekey_callback,
- (void *)conn->sock, conn->internal->rekey->timeout, 0,
- SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
-
- silc_protocol_free(protocol);
- silc_free(ctx->auth_data);
- if (ctx->ske)
- silc_ske_free(ctx->ske);
- silc_socket_free(ctx->sock);
- silc_free(ctx);
- conn->sock->protocol = NULL;
- return;
-
- err:
- silc_protocol_free(protocol);
- silc_free(ctx->auth_data);
- silc_free(ctx->dest_id);
- if (ctx->ske)
- silc_ske_free(ctx->ske);
- conn->sock->protocol = NULL;
- silc_socket_free(ctx->sock);
-
- /* Notify application of failure */
- silc_schedule_task_add(client->schedule, ctx->sock->sock,
- silc_client_connect_failure_auth, ctx,
- 0, 1, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
-}
-
-/* Client session resuming callback. If the session was resumed
- this callback is called after the resuming is completed. This
- will call the `connect' client operation to the application
- since it has not been called yet. */
-
-static void silc_client_resume_session_cb(SilcClient client,
- SilcClientConnection conn,
- SilcBool success,
- void *context)
-{
- SilcBuffer sidp;
-
- /* Notify application that connection is created to server */
- client->internal->ops->connected(client, conn, success ?
- SILC_CLIENT_CONN_SUCCESS_RESUME :
- SILC_CLIENT_CONN_ERROR_RESUME);
-
- if (success) {
- /* Issue INFO command to fetch the real server name and server
- information and other stuff. */
- silc_client_command_register(client, SILC_COMMAND_INFO, NULL, NULL,
- silc_client_command_reply_info_i, 0,
- ++conn->cmd_ident);
- sidp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
- silc_client_command_send(client, conn, SILC_COMMAND_INFO,
- conn->cmd_ident, 1, 2, sidp->data, sidp->len);
- silc_buffer_free(sidp);
+ /* Signal to close connection */
+ if (!conn->internal->disconnected) {
+ conn->internal->disconnected = TRUE;
+ SILC_FSM_SEMA_POST(&conn->internal->wait_event);
}
}
+#if 0
/* Processes incoming connection authentication method request packet.
It is a reply to our previously sent request. The packet can be used
to resolve the authentication method for the current session if the
}
#endif /* 0 */
-
/* Allocates new client object. This has to be done before client may
work. After calling this one must call silc_client_init to initialize
the client. The `application' is application specific user data pointer
if (params)
memcpy(new_client->internal->params, params, sizeof(*params));
- if (!new_client->internal->params->task_max)
- new_client->internal->params->task_max = 200;
-
- if (!new_client->internal->params->rekey_secs)
- new_client->internal->params->rekey_secs = 3600;
-
if (!new_client->internal->params->connauth_request_secs)
new_client->internal->params->connauth_request_secs = 2;
nickname_format[sizeof(new_client->internal->
params->nickname_format) - 1] = 0;
+ silc_atomic_init16(&new_client->internal->conns, 0);
+
return new_client;
}
void silc_client_free(SilcClient client)
{
- if (client) {
- if (client->rng)
- silc_rng_free(client->rng);
-
- if (!client->internal->params->dont_register_crypto_library) {
- silc_cipher_unregister_all();
- silc_pkcs_unregister_all();
- silc_hash_unregister_all();
- silc_hmac_unregister_all();
- }
+ silc_schedule_uninit(client->schedule);
+
+ if (client->rng)
+ silc_rng_free(client->rng);
- silc_free(client->internal->params);
- silc_free(client->internal->silc_client_version);
- silc_free(client->internal);
- silc_free(client);
+ if (!client->internal->params->dont_register_crypto_library) {
+ silc_cipher_unregister_all();
+ silc_pkcs_unregister_all();
+ silc_hash_unregister_all();
+ silc_hmac_unregister_all();
}
+
+ silc_atomic_uninit16(&client->internal->conns);
+ silc_free(client->username);
+ silc_free(client->hostname);
+ silc_free(client->realname);
+ silc_free(client->internal->params);
+ silc_free(client->internal->silc_client_version);
+ silc_free(client->internal);
+ silc_free(client);
}
/* Initializes the client. This makes all the necessary steps to make
client. Returns FALSE if error occured, TRUE otherwise. */
SilcBool silc_client_init(SilcClient client, const char *username,
- const char *hostname, const char *realname)
+ const char *hostname, const char *realname,
+ SilcClientRunning running, void *context)
{
SILC_LOG_DEBUG(("Initializing client"));
if (!client)
return FALSE;
- if (!username || !hostname || !realname) {
- SILC_LOG_ERROR(("Username, hostname and realname must be given to "
+ if (!username || !hostname) {
+ SILC_LOG_ERROR(("Username and hostname must be given to "
"silc_client_init"));
return FALSE;
}
+ if (!realname)
+ realname = username;
/* Validate essential strings */
if (!silc_identifier_verify(username, strlen(username),
/* Initialize random number generator */
client->rng = silc_rng_alloc();
+ if (!client->rng)
+ return FALSE;
silc_rng_init(client->rng);
silc_rng_global_init(client->rng);
/* Initialize the scheduler */
- client->schedule =
- silc_schedule_init(client->internal->params->task_max ?
- client->internal->params->task_max : 0, client);
+ client->schedule = silc_schedule_init(0, client);
if (!client->schedule)
return FALSE;
+ /* Allocate client lock */
+ silc_mutex_alloc(&client->internal->lock);
+
+ /* Register commands */
+ silc_client_commands_register(client);
+
/* Start packet engine */
client->internal->packet_engine =
silc_packet_engine_start(client->rng, FALSE, &silc_client_stream_cbs,
if (!client->internal->packet_engine)
return FALSE;
- /* Initialize FSM */
- if (!silc_fsm_init(&client->internal->fsm, client, NULL, NULL,
- client->schedule))
- return FALSE;
+ /* Initialize and start the client FSM */
+ client->internal->running = running;
+ client->internal->running_context = context;
+ silc_fsm_init(&client->internal->fsm, client, NULL, NULL, client->schedule);
silc_fsm_sema_init(&client->internal->wait_event, &client->internal->fsm, 0);
-
- /* Allocate client lock */
- silc_mutex_alloc(&client->internal->lock);
-
- /* Register commands */
- silc_client_commands_register(client);
-
- /* Start the client machine */
silc_fsm_start_sync(&client->internal->fsm, silc_client_st_run);
/* Signal the application when we are running */
return TRUE;
}
-/* Stops the client. This is called to stop the client and thus to stop
- the program. */
-
-void silc_client_stop(SilcClient client)
-{
- SILC_LOG_DEBUG(("Stopping client"));
-
- silc_schedule_stop(client->schedule);
- silc_schedule_uninit(client->schedule);
- silc_client_commands_unregister(client);
-
- SILC_LOG_DEBUG(("Client stopped"));
-}
-
/* Starts the SILC client FSM machine and blocks here. When this returns
the client has ended. */
silc_schedule(client->schedule);
}
-/* Call scheduler one iteration and return. This cannot be called if threads
- are in use. */
+/* Call scheduler one iteration and return. */
void silc_client_run_one(SilcClient client)
{
- silc_schedule_one(client->schedule, -1);
+ if (silc_fsm_is_started(&client->internal->fsm))
+ silc_schedule_one(client->schedule, 0);
+}
+
+/* Stops the client. This is called to stop the client and thus to stop
+ the program. */
+
+void silc_client_stop(SilcClient client, SilcClientStopped stopped,
+ void *context)
+{
+ SILC_LOG_DEBUG(("Stopping client"));
+
+ client->internal->running = (SilcClientRunning)stopped;
+ client->internal->running_context = context;
+
+ /* Signal to stop */
+ client->internal->stop = TRUE;
+ SILC_FSM_SEMA_POST(&client->internal->wait_event);
}
projects / silc.git / blobdiff