When closing SilcClientConnection all threads must first be finished
before the connection machine is finished. This is done by finishing
all running command threads. That will also finish all waiting packet
- and notify threads as they are always waiting for a command. If any
- thread is waiting for something else than a command (such as event
- threads) they must be explicitly finished. The threads are finished by
- continuing them synchronously. The threads will detect that we are
- disconnected (see below). SILC_FSM_YIELD must be returned in
- st_close() as that gives the FSM scheduler time to finish the threads
+ and notify threads as they are always waiting for a command. If any
+ thread is waiting for something else than a command (such as event
+ threads) they must be explicitly finished. The threads are finished by
+ continuing them synchronously. The threads will detect that we are
+ disconnected (see below). SILC_FSM_YIELD must be returned in
+ st_close() as that gives the FSM scheduler time to finish the threads
first. After that the machine can be finished.
Also, any thread that runs in SilcClientConnection machine must always
If disconnected the thread must finish immediately by returning
SILC_FSM_FINISH.
+Entry locking
+
+ All entires have a read/write lock. It is used to protect the entries
+ when library updates them at the same time application is reading data
+ from the entries. An API for application to read-lock the entires
+ exist. Library only needs to use write-lock. Using read-lock is not
+ necessary inside library because all connection related stuff, including
+ updating connection related entries are done in one thread. When library
+ is reading data from the entries it cannot be updating them at the same
+ time. Hence, using read-lock inside library is not necessary.
if (conn->internal->connect) {
SILC_LOG_DEBUG(("Event: connect"));
conn->internal->connect = FALSE;
+ SILC_ASSERT(silc_fsm_is_started(thread) == FALSE);
/*** Event: connect */
silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
if (conn->internal->key_exchange) {
SILC_LOG_DEBUG(("Event: key exchange"));
conn->internal->key_exchange = FALSE;
+ SILC_ASSERT(silc_fsm_is_started(thread) == FALSE);
/*** Event: key exchange */
silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
if (conn->internal->rekeying) {
SILC_LOG_DEBUG(("Event: rekey"));
conn->internal->rekeying = FALSE;
+ SILC_ASSERT(silc_fsm_is_started(thread) == FALSE);
/*** Event: rekey */
silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
/* 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 is called
- in this state if it set. */
+ in this state if it is set. */
SILC_FSM_STATE(silc_client_connection_st_close)
{
SILC_LOG_DEBUG(("Closing connection %p", conn));
/* Signal to close connection */
+ conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
if (!conn->internal->disconnected) {
conn->internal->disconnected = TRUE;
SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
typedef struct SilcChannelEntryStruct *SilcChannelEntry;
typedef struct SilcServerEntryStruct *SilcServerEntry;
-typedef struct SilcClientAwayStruct SilcClientAway;
typedef struct SilcClientKeyAgreementStruct *SilcClientKeyAgreement;
typedef struct SilcClientFtpSessionStruct *SilcClientFtpSession;
typedef struct SilcClientCommandReplyContextStruct
/* Internal client entry context */
typedef struct SilcClientEntryInternalStruct {
+ SilcRwLock lock; /* Read/write lock */
SilcCipher send_key; /* Private message key for sending */
SilcCipher receive_key; /* Private message key for receiving */
SilcHmac hmac_send; /* Private mesage key HMAC for sending */
/* Internal channel entry context */
typedef struct SilcChannelEntryInternalStruct {
+ SilcRwLock lock; /* Read/write lock */
+
/* SilcChannelEntry status information */
SilcDList old_channel_keys;
SilcDList old_hmacs;
/* Internal server entry context */
typedef struct SilcServerEntryInternalStruct {
+ SilcRwLock lock; /* Read/write lock */
SilcUInt16 resolve_cmd_ident; /* Resolving identifier */
SilcAtomic8 refcnt; /* Reference counter */
} SilcServerEntryInternal;
}
/* Adds client to channel. Returns TRUE if user was added or is already
- added to the channel, FALSE on error. */
+ added to the channel, FALSE on error. Must be called with both `channel'
+ and `client_entry' locked. */
SilcBool silc_client_add_to_channel(SilcClient client,
SilcClientConnection conn,
return TRUE;
}
-/* Removes client from a channel */
+/* Removes client from a channel. This handles entry locking internally. */
SilcBool silc_client_remove_from_channel(SilcClient client,
SilcClientConnection conn,
SILC_LOG_DEBUG(("Remove client %s from channel", client_entry->nickname));
+ silc_rwlock_wrlock(client_entry->internal.lock);
+ silc_rwlock_wrlock(channel->internal.lock);
+
silc_hash_table_del(chu->client->channels, chu->channel);
silc_hash_table_del(chu->channel->user_list, chu->client);
silc_free(chu);
if (!silc_hash_table_count(channel->user_list))
silc_client_del_channel(client, conn, channel);
+ silc_rwlock_unlock(client_entry->internal.lock);
+ silc_rwlock_unlock(channel->internal.lock);
+
silc_client_unref_client(client, conn, client_entry);
silc_client_unref_channel(client, conn, channel);
return TRUE;
}
-/* Removes a client entry from all channels it has joined. */
+/* Removes a client entry from all channels it has joined. This handles
+ entry locking internally. */
void silc_client_remove_from_channels(SilcClient client,
SilcClientConnection conn,
SILC_LOG_DEBUG(("Remove client from all joined channels"));
+ silc_rwlock_wrlock(client_entry->internal.lock);
+
silc_hash_table_list(client_entry->channels, &htl);
while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
+ silc_rwlock_wrlock(chu->channel->internal.lock);
+
silc_hash_table_del(chu->client->channels, chu->channel);
silc_hash_table_del(chu->channel->user_list, chu->client);
if (!silc_hash_table_count(chu->channel->user_list))
silc_client_del_channel(client, conn, chu->channel);
+ silc_rwlock_unlock(chu->channel->internal.lock);
+
silc_client_unref_client(client, conn, chu->client);
silc_client_unref_channel(client, conn, chu->channel);
silc_free(chu);
}
+ silc_rwlock_unlock(client_entry->internal.lock);
+
silc_hash_table_list_reset(&htl);
}
-/* Empties channel from users. */
+/* Empties channel from users. This handles entry locking internally. */
void silc_client_empty_channel(SilcClient client,
SilcClientConnection conn,
SilcHashTableList htl;
SilcChannelUser chu;
+ silc_rwlock_wrlock(channel->internal.lock);
+
silc_hash_table_list(channel->user_list, &htl);
while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
silc_hash_table_del(chu->client->channels, chu->channel);
silc_client_unref_channel(client, conn, chu->channel);
silc_free(chu);
}
+
+ silc_rwlock_unlock(channel->internal.lock);
+
silc_hash_table_list_reset(&htl);
}
+
+/* Save public keys to channel public key list. Removes keys that are
+ marked to be removed. Must be called with `channel' locked. */
+
+SilcBool silc_client_channel_save_public_keys(SilcChannelEntry channel,
+ unsigned char *chpk_list,
+ SilcUInt32 chpk_list_len)
+{
+ SilcArgumentDecodedList a, b;
+ SilcDList chpks;
+ SilcBool found;
+
+ chpks = silc_argument_list_parse_decoded(chpk_list, chpk_list_len,
+ SILC_ARGUMENT_PUBLIC_KEY);
+ if (!chpks)
+ return FALSE;
+
+ if (!channel->channel_pubkeys) {
+ channel->channel_pubkeys = chpks;
+ return TRUE;
+ }
+
+ silc_dlist_start(chpks);
+ while ((a = silc_dlist_get(chpks))) {
+ found = FALSE;
+ silc_dlist_start(channel->channel_pubkeys);
+ while ((b = silc_dlist_get(channel->channel_pubkeys))) {
+ if (silc_pkcs_public_key_compare(a->argument, b->argument)) {
+ found = TRUE;
+ break;
+ }
+ }
+
+ if ((a->arg_type == 0x00 || a->arg_type == 0x03) && !found) {
+ silc_dlist_add(channel->channel_pubkeys, a);
+ silc_dlist_del(chpks, a);
+ } else if (a->arg_type == 0x01 && found) {
+ silc_dlist_del(channel->channel_pubkeys, b);
+ }
+ }
+
+ silc_argument_list_free(chpks, SILC_ARGUMENT_PUBLIC_KEY);
+
+ return TRUE;
+}
void silc_client_empty_channel(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel);
+SilcBool silc_client_channel_save_public_keys(SilcChannelEntry channel,
+ unsigned char *chpk_list,
+ SilcUInt32 chpk_list_len);
#endif /* CLIENT_CHANNEL_H */
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. */
if (!client_entry)
return NULL;
+ silc_rwlock_alloc(&client_entry->internal.lock);
silc_atomic_init8(&client_entry->internal.refcnt, 0);
client_entry->id = *id;
client_entry->internal.valid = TRUE;
return client_entry;
}
-/* Updates the `client_entry' with the new information sent as argument. */
+/* Updates the `client_entry' with the new information sent as argument.
+ This handles entry locking internally. */
void silc_client_update_client(SilcClient client,
SilcClientConnection conn,
SILC_LOG_DEBUG(("Update client entry"));
+ silc_rwlock_wrlock(client_entry->internal.lock);
+
if (!client_entry->realname && userinfo)
client_entry->realname = strdup(userinfo);
if ((!client_entry->username[0] || !client_entry->hostname[0]) && username)
nick = silc_identifier_check(client_entry->nickname,
strlen(client_entry->nickname),
SILC_STRING_UTF8, 128, NULL);
- if (!nick)
+ if (!nick) {
+ silc_rwlock_unlock(client_entry->internal.lock);
return;
+ }
/* Format nickname */
silc_client_nickname_format(client, conn, client_entry,
client_entry->nickname_normalized = nick;
}
client_entry->mode = mode;
+
+ silc_rwlock_unlock(client_entry->internal.lock);
}
-/* Change a client's nickname */
+/* Change a client's nickname. Must be called with `client_entry' locked. */
SilcBool silc_client_change_nickname(SilcClient client,
SilcClientConnection conn,
silc_client_abort_key_agreement(client, conn, client_entry);
#endif /* 0 */
silc_atomic_uninit8(&client_entry->internal.refcnt);
+ silc_rwlock_free(client_entry->internal.lock);
silc_free(client_entry);
}
return ret;
}
+/* Lock client */
+
+void silc_client_lock_client(SilcClientEntry client_entry)
+{
+ silc_rwlock_rdlock(client_entry->internal.lock);
+}
+
+/* Unlock client */
+
+void silc_client_unlock_client(SilcClientEntry client_entry)
+{
+ silc_rwlock_unlock(client_entry->internal.lock);
+}
+
/* Take reference of client entry */
-void silc_client_ref_client(SilcClient client, SilcClientConnection conn,
- SilcClientEntry client_entry)
+SilcClientEntry silc_client_ref_client(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry)
{
silc_atomic_add_int8(&client_entry->internal.refcnt, 1);
SILC_LOG_DEBUG(("Client %p refcnt %d->%d", client_entry,
silc_atomic_get_int8(&client_entry->internal.refcnt) - 1,
silc_atomic_get_int8(&client_entry->internal.refcnt)));
+ return client_entry;
}
/* Release reference of client entry */
if (!channel)
return NULL;
+ silc_rwlock_alloc(&channel->internal.lock);
silc_atomic_init16(&channel->internal.refcnt, 0);
channel->id = *channel_id;
channel->mode = mode;
SILC_ARGUMENT_PUBLIC_KEY);
silc_client_del_channel_private_keys(client, conn, channel);
silc_atomic_uninit16(&channel->internal.refcnt);
+ silc_rwlock_free(channel->internal.lock);
silc_schedule_task_del_by_context(conn->client->schedule, channel);
silc_free(channel);
}
/* Replaces the channel ID of the `channel' to `new_id'. Returns FALSE
- if the ID could not be changed. */
+ if the ID could not be changed. This handles entry locking internally. */
SilcBool silc_client_replace_channel_id(SilcClient client,
SilcClientConnection conn,
silc_id_render(new_id, SILC_ID_CHANNEL)));
/* Update the ID */
+ silc_rwlock_wrlock(channel->internal.lock);
silc_mutex_lock(conn->internal->lock);
silc_idcache_update_by_context(conn->internal->channel_cache, channel,
new_id, NULL, FALSE);
silc_mutex_unlock(conn->internal->lock);
+ silc_rwlock_unlock(channel->internal.lock);
return ret;
}
+/* Lock channel */
+
+void silc_client_lock_channel(SilcChannelEntry channel_entry)
+{
+ silc_rwlock_rdlock(channel_entry->internal.lock);
+}
+
+/* Unlock client */
+
+void silc_client_unlock_channel(SilcChannelEntry channel_entry)
+{
+ silc_rwlock_unlock(channel_entry->internal.lock);
+}
+
/* Take reference of channel entry */
-void silc_client_ref_channel(SilcClient client, SilcClientConnection conn,
- SilcChannelEntry channel_entry)
+SilcChannelEntry silc_client_ref_channel(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelEntry channel_entry)
{
silc_atomic_add_int16(&channel_entry->internal.refcnt, 1);
SILC_LOG_DEBUG(("Channel %p refcnt %d->%d", channel_entry,
silc_atomic_get_int16(&channel_entry->internal.refcnt) - 1,
silc_atomic_get_int16(&channel_entry->internal.refcnt)));
+ return channel_entry;
}
/* Release reference of channel entry */
if (!server_entry)
return NULL;
+ silc_rwlock_alloc(&server_entry->internal.lock);
silc_atomic_init8(&server_entry->internal.refcnt, 0);
server_entry->id = *server_id;
if (server_name)
if (server->public_key)
silc_pkcs_public_key_free(server->public_key);
silc_atomic_uninit8(&server->internal.refcnt);
+ silc_rwlock_free(server->internal.lock);
silc_free(server);
return ret;
}
}
+/* Lock server */
+
+void silc_client_lock_server(SilcServerEntry server_entry)
+{
+ silc_rwlock_rdlock(server_entry->internal.lock);
+}
+
+/* Unlock server */
+
+void silc_client_unlock_server(SilcServerEntry server_entry)
+{
+ silc_rwlock_unlock(server_entry->internal.lock);
+}
+
/* Take reference of server entry */
-void silc_client_ref_server(SilcClient client, SilcClientConnection conn,
- SilcServerEntry server_entry)
+SilcServerEntry silc_client_ref_server(SilcClient client,
+ SilcClientConnection conn,
+ SilcServerEntry server_entry)
{
silc_atomic_add_int8(&server_entry->internal.refcnt, 1);
SILC_LOG_DEBUG(("Server %p refcnt %d->%d", server_entry,
silc_atomic_get_int8(&server_entry->internal.refcnt) - 1,
silc_atomic_get_int8(&server_entry->internal.refcnt)));
+ return server_entry;
}
/* Release reference of server entry */
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2006 Pekka Riikonen
+ Copyright (C) 2006 - 2007 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void silc_client_del_client_entry(SilcClient client,
SilcClientConnection conn,
SilcClientEntry client_entry);
+SilcBool silc_client_del_client(SilcClient client, SilcClientConnection conn,
+ SilcClientEntry client_entry);
SilcClientEntry silc_idlist_get_client(SilcClient client,
SilcClientConnection conn,
const char *nickname,
const char *channel_name,
SilcUInt32 mode,
SilcChannelID *channel_id);
+SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
+ SilcChannelEntry channel);
+bool silc_client_replace_channel_id(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelEntry channel,
+ SilcChannelID *new_id);
SilcServerEntry silc_client_add_server(SilcClient client,
SilcClientConnection conn,
const char *server_name,
SilcServerEntry server_entry,
const char *server_name,
const char *server_info);
-bool silc_client_replace_channel_id(SilcClient client,
- SilcClientConnection conn,
- SilcChannelEntry channel,
- SilcChannelID *new_id);
+SilcBool silc_client_del_server(SilcClient client, SilcClientConnection conn,
+ SilcServerEntry server);
SilcBool silc_client_nickname_parse(SilcClient client,
SilcClientConnection conn,
char *nickname,
SilcSKE ske;
SilcSKEVerifyCbCompletion completion;
void *completion_context;
-} *VerifyKeyContext;
-
-/* Structure to hold away messages set by user. This is mainly created
- for future extensions where away messages could be set according filters
- such as nickname and hostname. For now only one away message can
- be set in one connection. */
-struct SilcClientAwayStruct {
- char *away;
- struct SilcClientAwayStruct *next;
-};
+} *SilcVerifyKeyContext;
/* Command and command reply context used to hold registered commands
in the SILC client. */
/* Internal context for the client->internal pointer in the SilcClient. */
struct SilcClientInternalStruct {
SilcFSMStruct fsm; /* Client's FSM */
- SilcFSMEventStruct wait_event; /* Event signaller */
+ SilcFSMEventStruct wait_event; /* Event signaller */
SilcClientOperations *ops; /* Client operations */
SilcClientParams *params; /* Client parameters */
SilcPacketEngine packet_engine; /* Packet engine */
SilcAsyncOperation cop; /* Async operation for application */
SilcHashTable attrs; /* Configured user attributes */
char *disconnect_message; /* Disconnection message */
+ char *away_message; /* Away message */
+ void *prv_waiter; /* Private message packet waiter */
SilcIDCache client_cache; /* Client entry cache */
SilcIDCache channel_cache; /* Channel entry cache */
unsigned int registering : 1; /* Set when registering to network */
unsigned int rekey_responder : 1; /* Set when rekeying as responder */
unsigned int auth_request : 1; /* Set when requesting auth method */
-
- SilcClientAway *away;
- SilcClientFtpSession active_session;
- SilcHashTable privmsg_wait; /* Waited private messages */
};
SILC_FSM_STATE(silc_client_connection_st_run);
SILC_FSM_STATE(silc_client_st_stop);
void silc_client_del_connection(SilcClient client, SilcClientConnection conn);
-SilcBool silc_client_del_client(SilcClient client, SilcClientConnection conn,
- SilcClientEntry client_entry);
-SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
- SilcChannelEntry channel);
-SilcBool silc_client_del_server(SilcClient client, SilcClientConnection conn,
- SilcServerEntry server);
-SilcUInt16 silc_client_command_send_argv(SilcClient client,
- SilcClientConnection conn,
- SilcCommand command,
- SilcClientCommandReply reply,
- void *reply_context,
- SilcUInt32 argc,
- unsigned char **argv,
- SilcUInt32 *argv_lens,
- SilcUInt32 *argv_types);
-void silc_client_command_free(SilcClientCommandContext cmd);
void silc_client_fsm_destructor(SilcFSM fsm, void *fsm_context,
void *destructor_context);
+void silc_client_command_free(SilcClientCommandContext cmd);
-void silc_client_ftp(SilcClient client, SilcClientConnection conn,
- SilcPacket packet);
-void silc_client_connection_auth_request(SilcClient client,
- SilcClientConnection conn,
- SilcPacket packet);
-
-#endif
+#endif /* CLIENT_INTERNAL_H */
static void silc_client_keyagr_verify_key_cb(SilcBool success, void *context)
{
- VerifyKeyContext verify = context;
+ SilcVerifyKeyContext verify = context;
/* Call the completion callback back to the SKE */
verify->completion(verify->ske, success ? SILC_SKE_STATUS_OK :
SilcClientKeyAgreement ke = client_entry->internal.ke;
SilcClientConnection conn = ke->conn;
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. */
/* NOT REACHED */
}
+ silc_rwlock_wrlock(client_entry->internal.lock);
+ silc_rwlock_wrlock(channel->internal.lock);
+
if (client_entry != conn->local_entry)
silc_client_nickname_format(client, conn, client_entry, FALSE);
/* Join the client to channel */
- if (!silc_client_add_to_channel(client, conn, channel, client_entry, 0))
+ if (!silc_client_add_to_channel(client, conn, channel, client_entry, 0)) {
+ silc_rwlock_unlock(channel->internal.lock);
+ silc_rwlock_unlock(client_entry->internal.lock);
goto out;
+ }
+
+ silc_rwlock_unlock(channel->internal.lock);
+ silc_rwlock_unlock(client_entry->internal.lock);
/* Notify application. */
NOTIFY(client, conn, type, client_entry, channel);
entry = channel_entry;
}
+ silc_rwlock_wrlock(channel->internal.lock);
silc_free(channel->topic);
channel->topic = silc_memdup(tmp, strlen(tmp));
+ silc_rwlock_unlock(channel->internal.lock);
/* Notify application. */
NOTIFY(client, conn, type, id.type, entry, channel->topic, channel);
if (!tmp)
goto out;
+ silc_rwlock_wrlock(client_entry->internal.lock);
+
/* Check whether nickname changed at all. It is possible that nick
change notify is received but nickname didn't change, only the
ID changes. If Client ID hash match, nickname didn't change. */
silc_idcache_update_by_context(conn->internal->client_cache, client_entry,
&id2.u.client_id, NULL, FALSE);
silc_mutex_unlock(conn->internal->lock);
+ silc_rwlock_unlock(client_entry->internal.lock);
goto out;
}
/* Change the nickname */
memcpy(oldnick, client_entry->nickname, sizeof(client_entry->nickname));
if (!silc_client_change_nickname(client, conn, client_entry, tmp,
- &id2.u.client_id, NULL, 0))
+ &id2.u.client_id, NULL, 0)) {
+ silc_rwlock_unlock(client_entry->internal.lock);
goto out;
+ }
+
+ silc_rwlock_unlock(client_entry->internal.lock);
/* Notify application */
NOTIFY(client, conn, type, client_entry, client_entry->nickname, oldnick);
entry = channel_entry;
}
+ silc_rwlock_wrlock(channel->internal.lock);
+
/* Get the channel founder key if it was set */
tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
if (tmp) {
- if (!silc_public_key_payload_decode(tmp, tmp_len, &founder_key))
+ if (!silc_public_key_payload_decode(tmp, tmp_len, &founder_key)) {
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
+ }
if (!channel->founder_key) {
channel->founder_key = founder_key;
founder_key = NULL;
unsigned char hash[SILC_HASH_MAXLEN];
SilcHmac newhmac;
- if (!silc_hmac_alloc(hmac, NULL, &newhmac))
+ if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
+ }
/* Get HMAC key from the old HMAC context, and update it to the new one */
tmp = (unsigned char *)silc_hmac_get_key(channel->internal.hmac, &tmp_len);
/* Get the channel public key that was added or removed */
tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
if (tmp)
- chpks = silc_argument_list_parse_decoded(tmp, tmp_len,
- SILC_ARGUMENT_PUBLIC_KEY);
+ silc_client_channel_save_public_keys(channel, tmp, tmp_len);
- /* XXX add to/remove from channel pubkeys channel->channel_pubkeys */
+ silc_rwlock_unlock(channel->internal.lock);
/* Notify application. */
NOTIFY(client, conn, type, id.type, entry, mode, cipher, hmac,
}
/* Save the mode */
+ silc_rwlock_wrlock(channel->internal.lock);
chu = silc_client_on_channel(channel, client_entry2);
if (chu)
chu->mode = mode;
+ silc_rwlock_unlock(channel->internal.lock);
/* Notify application. */
NOTIFY(client, conn, type, id.type, entry, mode, client_entry2, channel);
/* See if we are away (gone). If we are away we will reply to the
sender with the set away message. */
- if (conn->internal->away && conn->internal->away->away &&
+ if (conn->internal->away_message &&
!(flags & SILC_MESSAGE_FLAG_NOREPLY)) {
/* If it's me, ignore */
if (SILC_ID_CLIENT_COMPARE(&remote_id, conn->local_id))
silc_client_send_private_message(client, conn, remote_client,
SILC_MESSAGE_FLAG_AUTOREPLY |
SILC_MESSAGE_FLAG_NOREPLY, NULL,
- conn->internal->away->away,
- strlen(conn->internal->away->away));
+ conn->internal->away_message,
+ strlen(conn->internal->away_message));
}
out:
return SILC_FSM_FINISH;
}
+/* Initialize private message waiter for the `conn' connection. */
+
+SilcBool silc_client_private_message_wait_init(SilcClient client,
+ SilcClientConnection conn)
+{
+ if (conn->internal->prv_waiter)
+ return TRUE;
+
+ conn->internal->prv_waiter =
+ silc_packet_wait_init(conn->stream, SILC_PACKET_PRIVATE_MESSAGE, -1);
+ if (!conn->internal->prv_waiter)
+ return FALSE;
+
+ return TRUE;
+}
+
+/* Uninitializes private message waiter. */
+
+void silc_client_private_message_wait_uninit(SilcClient client,
+ SilcClientConnection conn)
+{
+ if (!conn->internal->prv_waiter)
+ return;
+ silc_packet_wait_uninit(conn->internal->prv_waiter, conn->stream);
+ conn->internal->prv_waiter = NULL;
+}
+
/* Blocks the calling process or thread until private message has been
received from the specified client. */
-SilcBool silc_client_private_message_wait(SilcClientConnection conn,
+SilcBool silc_client_private_message_wait(SilcClient client,
+ SilcClientConnection conn,
SilcClientEntry client_entry,
- void *waiter,
SilcMessagePayload *payload)
{
SilcPacket packet;
SilcClientID remote_id;
SilcFSMThread thread;
+ if (!conn->internal->prv_waiter)
+ return FALSE;
+
/* Block until private message arrives */
do {
- if ((silc_packet_wait(waiter, 0, &packet)) < 0)
+ if ((silc_packet_wait(conn->internal->prv_waiter, 0, &packet)) < 0)
return FALSE;
/* Parse sender ID */
new one. If `message' is NULL the old away message is removed.
The sender may freely free the memory of the `message'. */
-void silc_client_set_away_message(SilcClient client,
- SilcClientConnection conn,
- char *message)
+SilcBool silc_client_set_away_message(SilcClient client,
+ SilcClientConnection conn,
+ char *message)
{
- assert(client && conn);
+ if (!client || !conn)
+ return FALSE;
- if (!message && conn->internal->away) {
- silc_free(conn->internal->away->away);
- silc_free(conn->internal->away);
- conn->internal->away = NULL;
+ if (!message) {
+ silc_free(conn->internal->away_message);
+ conn->internal->away_message = NULL;
+ return TRUE;
}
- if (message) {
- if (!conn->internal->away)
- conn->internal->away = silc_calloc(1, sizeof(*conn->internal->away));
- if (conn->internal->away->away)
- silc_free(conn->internal->away->away);
- conn->internal->away->away = strdup(message);
- }
+ if (conn->internal->away_message)
+ silc_free(conn->internal->away_message);
+
+ conn->internal->away_message = strdup(message);
+ if (!conn->internal->away_message)
+ return FALSE;
+
+ return TRUE;
}
/********************************** KILL ************************************/
-
/* Command KILL. Router operator can use this command to remove an client
fromthe SILC Network. */
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2006 Pekka Riikonen
+ Copyright (C) 2006 - 2007 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
SILC_FSM_STATE(silc_client_command_getkey);
SILC_FSM_STATE(silc_client_command_service);
+SilcUInt16 silc_client_command_send_argv(SilcClient client,
+ SilcClientConnection conn,
+ SilcCommand command,
+ SilcClientCommandReply reply,
+ void *reply_context,
+ SilcUInt32 argc,
+ unsigned char **argv,
+ SilcUInt32 *argv_lens,
+ SilcUInt32 *argv_types);
void silc_client_commands_register(SilcClient client);
void silc_client_commands_unregister(SilcClient client);
nickname, username, realname, mode);
}
+ silc_rwlock_wrlock(client_entry->internal.lock);
+
if (fingerprint && fingerprint_len == sizeof(client_entry->fingerprint))
memcpy(client_entry->fingerprint, fingerprint, fingerprint_len);
client_entry->attrs = silc_attribute_payload_parse(tmp, len);
}
+ silc_rwlock_unlock(client_entry->internal.lock);
+
/* Parse channel and channel user mode list */
if (has_channels) {
channel_list = silc_channel_payload_parse_list(silc_buffer_data(&channels),
goto out;
}
+ silc_rwlock_wrlock(conn->local_entry->internal.lock);
+
/* Change the nickname */
old_client_id = *conn->local_id;
if (!silc_client_change_nickname(client, conn, conn->local_entry,
goto out;
}
+ silc_rwlock_unlock(conn->local_entry->internal.lock);
+
/* Notify application */
silc_client_command_callback(cmd, conn->local_entry,
conn->local_entry->nickname, &old_client_id);
goto out;
}
+ silc_rwlock_wrlock(channel->internal.lock);
+
/* Take topic */
topic = silc_argument_get_arg_type(args, 3, &len);
if (topic) {
channel->topic = silc_memdup(topic, len);
}
+ silc_rwlock_unlock(channel->internal.lock);
+
/* Notify application */
silc_client_command_callback(cmd, channel, channel->topic);
}
silc_buffer_set(&client_mode_list, tmp, len);
+ silc_rwlock_wrlock(channel->internal.lock);
+
/* Add clients we received in the reply to the channel */
for (i = 0; i < list_count; i++) {
SilcUInt16 idp_len;
continue;
/* Join client to the channel */
+ silc_rwlock_wrlock(client_entry->internal.lock);
silc_client_add_to_channel(client, conn, channel, client_entry, mode);
+ silc_rwlock_unlock(client_entry->internal.lock);
silc_client_unref_client(client, conn, client_entry);
- if (!silc_buffer_pull(&client_id_list, idp_len))
+ if (!silc_buffer_pull(&client_id_list, idp_len)) {
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
- if (!silc_buffer_pull(&client_mode_list, 4))
+ }
+ if (!silc_buffer_pull(&client_mode_list, 4)) {
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
+ }
}
/* Get hmac */
SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
"Cannot join channel: Unsupported HMAC `%s'", hmac);
ERROR_CALLBACK(SILC_STATUS_ERR_UNKNOWN_ALGORITHM);
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
}
}
/* Get channel public key list */
tmp = silc_argument_get_arg_type(args, 16, &len);
if (tmp)
- channel->channel_pubkeys =
- silc_argument_list_parse_decoded(tmp, len, SILC_ARGUMENT_PUBLIC_KEY);
+ silc_client_channel_save_public_keys(channel, tmp, len);
/* Set current channel */
conn->current_channel = channel;
+ silc_rwlock_unlock(channel->internal.lock);
+
cipher = (channel->internal.send_key ?
silc_cipher_get_name(channel->internal.send_key) : NULL);
silc_hash_table_list(channel->user_list, &htl);
}
SILC_GET32_MSB(mode, tmp);
+ silc_rwlock_wrlock(conn->local_entry->internal.lock);
conn->local_entry->mode = mode;
+ silc_rwlock_unlock(conn->local_entry->internal.lock);
/* Notify application */
silc_client_command_callback(cmd, mode);
goto out;
}
- /* Save the mode */
- SILC_GET32_MSB(mode, tmp);
- channel->mode = mode;
-
/* Get founder public key */
tmp = silc_argument_get_arg_type(args, 4, &len);
if (tmp)
silc_public_key_payload_decode(tmp, len, &public_key);
+ silc_rwlock_wrlock(channel->internal.lock);
+
+ /* Save the mode */
+ SILC_GET32_MSB(mode, tmp);
+ channel->mode = mode;
+
/* Get user limit */
tmp = silc_argument_get_arg_type(args, 6, &len);
if (tmp && len == 4)
/* Get channel public key(s) */
tmp = silc_argument_get_arg_type(args, 5, &len);
if (tmp)
- channel_pubkeys =
- silc_argument_list_parse_decoded(tmp, len, SILC_ARGUMENT_PUBLIC_KEY);
+ silc_client_channel_save_public_keys(channel, tmp, len);
+
+ silc_rwlock_unlock(channel->internal.lock);
/* Notify application */
silc_client_command_callback(cmd, channel, mode, public_key,
}
/* Save the mode */
+ silc_rwlock_wrlock(channel->internal.lock);
chu = silc_client_on_channel(channel, client_entry);
if (chu)
chu->mode = mode;
+ silc_rwlock_unlock(channel->internal.lock);
/* Notify application */
silc_client_command_callback(cmd, mode, channel, client_entry);
SILC_LOG_DEBUG(("channel %s, %d users", channel->channel_name, list_count));
+ silc_rwlock_wrlock(channel->internal.lock);
+
/* Cache the received Client ID's and modes. */
for (i = 0; i < list_count; i++) {
SILC_GET16_MSB(idp_len, client_id_list.data + 2);
/* Save the client on this channel. Unknown clients are ignored as they
clearly do not exist since the resolving didn't find them. */
client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
- if (client_entry)
+ if (client_entry) {
+ silc_rwlock_wrlock(client_entry->internal.lock);
silc_client_add_to_channel(client, conn, channel, client_entry, mode);
+ silc_rwlock_unlock(client_entry->internal.lock);
+ }
silc_client_unref_client(client, conn, client_entry);
- if (!silc_buffer_pull(&client_id_list, idp_len))
+ if (!silc_buffer_pull(&client_id_list, idp_len)) {
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
- if (!silc_buffer_pull(&client_mode_list, 4))
+ }
+ if (!silc_buffer_pull(&client_mode_list, 4)) {
+ silc_rwlock_unlock(channel->internal.lock);
goto out;
+ }
}
/* Notify application */
goto out;
}
+ silc_rwlock_wrlock(client_entry->internal.lock);
+
/* Save fingerprint */
if (!client_entry->fingerprint)
silc_hash_make(conn->internal->sha1hash, tmp + 4, len - 4,
public_key = NULL;
}
+ silc_rwlock_unlock(client_entry->internal.lock);
+
/* Notify application */
silc_client_command_callback(cmd, SILC_ID_CLIENT, client_entry,
client_entry->public_key);
goto out;
}
+ silc_rwlock_wrlock(server_entry->internal.lock);
+
if (!server_entry->public_key) {
server_entry->public_key = public_key;
public_key = NULL;
}
+ silc_rwlock_unlock(server_entry->internal.lock);
+
/* Notify application */
silc_client_command_callback(cmd, SILC_ID_SERVER, server_entry,
server_entry->public_key);
* DESCRIPTION
*
* This interface defines the SILC Client Library API for the application.
- * The client operations are defined first. These are callback functions that
- * the application MUST implement since the library may call the functions
- * at any time. At the end of file is the API for the application that
- * it can use from the library. This is the only file that the application
- * may include from the SIlC Client Library.
- *
- * o SILC Client Operations
- *
- * These functions must be implemented by the application calling the SILC
- * client library. The client library can call these functions at any time.
- *
- * To use this structure: define a static SilcClientOperations variable,
- * fill it and pass its pointer to silc_client_alloc function.
- *
- * o SILC Client Library API
- *
- * This is the API that is published by the SILC Client Library for the
- * applications. These functions are implemented in the SILC Client Library.
- * Application may freely call these functions from the library.
+ * The Client Library is a full features SILC client without a user interface.
+ * A simple interface called SILC Client Operations (SilcClientOperations)
+ * is provided for applications to implmeent the necessary functions to use
+ * the client library. The silcclient.h header file includes client library
+ * API, such as command handling and message sending. The silcclient_entry.h
+ * header file includes entry handling, such as channel and user entry
+ * handling.
+ *
+ * Practically all functions in the Client Library API accepts SilcClient
+ * and SilcClientConnection as their first two argument. The first argument
+ * is the actual SilcClient context and the second is the SilcClientConnection
+ * context of the connection in question. Application may create and handle
+ * multiple connections in one SilcClient. Connections can be created to
+ * servers and other clients.
+ *
+ * The Client Library support multiple threads and is threads safe is used
+ * correctly. Messages can be sent from multiple threads without any
+ * locking. Messages however are always received only in one thread unless
+ * message waiting (see silc_client_private_message_wait as an example) is
+ * used. The threads can be turned on and off by giving a parameter to the
+ * SilcClient. When turned on, each new connection to remote host is always
+ * executed in an own thread. All tasks related to that connection are then
+ * executed in that thread. This means that client operation callbacks for
+ * that connections may be called from threads and application will need to
+ * employ concurrency control if the callbacks need to access shared data
+ * in the application. Messages are also received in that thread.
+ *
+ * All entries (SilcClientEntry, SilcChannelEntry and SilcServerEntry) are
+ * reference counted. If application wishes to save an entry pointer it must
+ * always first acquire a reference. The reference must be released once the
+ * entry is not needed anymore. If application wants to read any data from
+ * the entry structure it must first lock the entry. This protects access to
+ * the entries in multithreaded environment. If threads are not used, locking
+ * the entries is not needed. They however still must be referenced even
+ * when threads are not used.
*
***/
unsigned char *data,
SilcUInt32 data_len);
-/* Block process until channel message from `channel' is received */
-SilcBool
-silc_client_receive_channel_message(SilcClient client,
- SilcClientConnection conn,
- SilcChannelEntry channel,
- SilcClientEntry *return_sender,
- SilcMessageFlags *return_flags,
- const unsigned char **return_message,
- SilcUInt32 *return_message_len);
-
/****f* silcclient/SilcClientAPI/silc_client_send_private_message
*
* SYNOPSIS
unsigned char *data,
SilcUInt32 data_len);
+/****f* silcclient/SilcClientAPI/silc_client_private_message_wait_init
+ *
+ * SYNOPSIS
+ *
+ * SilcBool
+ * silc_client_private_message_wait_init(SilcClient client,
+ * SilcClientConnection conn);
+ *
+ * DESCRIPTION
+ *
+ * Initializes private message waiting functionality for the connection
+ * indicated by `conn'. Once this is called private message from remote
+ * connection indicated by `conn' for any client entry beloning to that
+ * connection may be waited for, for example in an thread. The function
+ * silc_client_private_message_wait is used to block the current thread
+ * until a private message is received from a specified client entry.
+ * Return FALSE on error.
+ *
+ ***/
+SilcBool silc_client_private_message_wait_init(SilcClient client,
+ SilcClientConnection conn);
+
+/****f* silcclient/SilcClientAPI/silc_client_private_message_wait_uninit
+ *
+ * SYNOPSIS
+ *
+ * void
+ * silc_client_private_message_wait_uninit(SilcClient client,
+ * SilcClientConnection conn);
+ *
+ * DESCRIPTION
+ *
+ * Unintializes private message waiting for connection indicated by
+ * `conn'. After this call private message cannot be waited anymore.
+ * This call may be called from any thread. This call will signal all
+ * private message waiting threads to stop waiting.
+ *
+ ***/
+void silc_client_private_message_wait_uninit(SilcClient client,
+ SilcClientConnection conn);
+
+/****f* silcclient/SilcClientAPI/silc_client_private_message_wait
+ *
+ * SYNOPSIS
+ *
+ * SilcBool
+ * silc_client_private_message_wait(SilcClient client,
+ * SilcClientConnection conn,
+ * SilcClientEntry client_entry,
+ * SilcMessagePayload *payload);
+ *
+ * DESCRIPTION
+ *
+ * Blocks current thread or process until a private message has been
+ * received from the remote client indicated by `client_entry'. Before
+ * private messages can be waited the silc_client_private_message_wait_init
+ * must be called. This function can be used from a thread to wait for
+ * private message from the specified client. Multiple threads can be
+ * created to wait messages from multiple clients. Any other private
+ * message received from the connection indicated by `conn' will be
+ * forwarded to the normal `private_message' client operation. The
+ * private messages from `client_entry' will not be delivered to the
+ * `private_message' client operation.
+ *
+ * Returns TRUE and the received private message into `payload'. The caller
+ * must free the returned SilcMessagePayload. If this function returns
+ * FALSE the private messages cannot be waited anymore. This happens
+ * when some other thread calls silc_client_private_message_wait_uninit.
+ * This returns FALSE also if silc_client_private_message_wait_init has
+ * not been called.
+ *
+ ***/
+SilcBool silc_client_private_message_wait(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry,
+ SilcMessagePayload *payload);
+
/****f* silcclient/SilcClientAPI/silc_client_on_channel
*
* SYNOPSIS
*
* SYNOPSIS
*
- * void silc_client_set_away_message(SilcClient client,
- * SilcClientConnection conn,
- * char *message);
+ * SilcBool silc_client_set_away_message(SilcClient client,
+ * SilcClientConnection conn,
+ * char *message);
*
* DESCRIPTION
*
* automatically back to the the client who send private message. If
* away message is already set this replaces the old message with the
* new one. If `message' is NULL the old away message is removed.
- * The sender may freely free the memory of the `message'.
+ * The sender may freely free the memory of the `message'. Returns
+ * FALSE on error.
*
***/
-void silc_client_set_away_message(SilcClient client,
- SilcClientConnection conn,
- char *message);
+SilcBool silc_client_set_away_message(SilcClient client,
+ SilcClientConnection conn,
+ char *message);
/****d* silcclient/SilcClientAPI/SilcClientMonitorStatus
*
SilcDList clients,
void *context);
+/****f* silcclient/SilcClientAPI/silc_client_lock_client
+ *
+ * SYNOPSIS
+ *
+ * void silc_client_lock_client(SilcClientEntry client_entry);
+ *
+ * DESCRIPTION
+ *
+ * Acquires lock for the client entry indicate by `client_entry'. When
+ * application wants to access `client_entry' it must lock the entry
+ * before reading any data from the `client_entry'. The lock must be
+ * unlocked with silc_client_unlock_client.
+ *
+ * The entry must be unlocked before calling any Client Library API
+ * functions where the entry is given as argument.
+ *
+ * This function is not needed if application is not multithreaded
+ *
+ ***/
+void silc_client_lock_client(SilcClientEntry client_entry);
+
+/****f* silcclient/SilcClientAPI/silc_client_unlock_client
+ *
+ * SYNOPSIS
+ *
+ * void silc_client_unlock_client(SilcClientEntry client_entry);
+ *
+ * DESCRIPTION
+ *
+ * Releases the lock acquired with silc_client_lock_client.
+ *
+ ***/
+void silc_client_unlock_client(SilcClientEntry client_entry);
+
/****f* silcclient/SilcClientAPI/silc_client_ref_client
*
* SYNOPSIS
*
- * void silc_client_ref_client(SilcClient client,
- * SilcClientConnection conn,
- * SilcClientEntry client_entry);
+ * SilcClientEntry
+ * silc_client_ref_client(SilcClient client,
+ * SilcClientConnection conn,
+ * SilcClientEntry client_entry);
*
* DESCRIPTION
*
* Takes a reference of the client entry indicated by `client_entry'
* The reference must be released by calling silc_client_unref_client
- * after it is not needed anymore.
+ * after it is not needed anymore. Returns `client_entry'.
*
***/
-void silc_client_ref_client(SilcClient client, SilcClientConnection conn,
- SilcClientEntry client_entry);
+SilcClientEntry silc_client_ref_client(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry);
/****f* silcclient/SilcClientAPI/silc_client_unref_client
*
SilcDList channels,
void *context);
+/****f* silcclient/SilcClientAPI/silc_client_lock_channel
+ *
+ * SYNOPSIS
+ *
+ * void silc_client_lock_channel(SilcChannelEntry channel_entry);
+ *
+ * DESCRIPTION
+ *
+ * Acquires lock for the channel entry indicate by `channel_entry'. When
+ * application wants to access `channel_entry' it must lock the entry
+ * before reading any data from the `channel_entry'. The lock must be
+ * unlocked with silc_client_unlock_channel.
+ *
+ * The entry must be unlocked before calling any Client Library API
+ * functions where the entry is given as argument.
+ *
+ * This function is not needed if application is not multithreaded
+ *
+ ***/
+void silc_client_lock_channel(SilcChannelEntry channel_entry);
+
+/****f* silcclient/SilcClientAPI/silc_client_unlock_channel
+ *
+ * SYNOPSIS
+ *
+ * void silc_client_unlock_channel(SilcChannelEntry channel_entry);
+ *
+ * DESCRIPTION
+ *
+ * Releases the lock acquired with silc_client_lock_channel.
+ *
+ ***/
+void silc_client_unlock_channel(SilcChannelEntry channel_entry);
+
/****f* silcclient/SilcClientAPI/silc_client_ref_channel
*
* SYNOPSIS
*
- * void silc_client_ref_channel(SilcClient client,
- * SilcClientConnection conn,
- * SilcChannelEntry channel_entry);
+ * SilcChannelEntry
+ * silc_client_ref_channel(SilcClient client,
+ * SilcClientConnection conn,
+ * SilcChannelEntry channel_entry);
*
* DESCRIPTION
*
* Takes a reference of the channel entry indicated by `channel_entry'
* The reference must be released by calling silc_client_unref_channel
- * after it is not needed anymore.
+ * after it is not needed anymore. Returns `channel_entry'.
*
***/
-void silc_client_ref_channel(SilcClient client, SilcClientConnection conn,
- SilcChannelEntry channel_entry);
+SilcChannelEntry silc_client_ref_channel(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelEntry channel_entry);
/****f* silcclient/SilcClientAPI/silc_client_unref_channel
*
SilcDList servers,
void *context);
+/****f* silcclient/SilcClientAPI/silc_client_lock_server
+ *
+ * SYNOPSIS
+ *
+ * void silc_client_lock_server(SilcServerEntry server_entry);
+ *
+ * DESCRIPTION
+ *
+ * Acquires lock for the server entry indicate by `server_entry'. When
+ * application wants to access `server_entry' it must lock the entry
+ * before reading any data from the `server_entry'. The lock must be
+ * unlocked with silc_client_unlock_server.
+ *
+ * The entry must be unlocked before calling any Client Library API
+ * functions where the entry is given as argument.
+ *
+ * This function is not needed if application is not multithreaded
+ *
+ ***/
+void silc_client_lock_server(SilcServerEntry server_entry);
+
+/****f* silcclient/SilcClientAPI/silc_client_unlock_server
+ *
+ * SYNOPSIS
+ *
+ * void silc_client_unlock_server(SilcServerEntry server_entry);
+ *
+ * DESCRIPTION
+ *
+ * Releases the lock acquired with silc_client_lock_server.
+ *
+ ***/
+void silc_client_unlock_server(SilcServerEntry server_entry);
+
/****f* silcclient/SilcClientAPI/silc_client_ref_server
*
* SYNOPSIS
*
- * void silc_client_ref_server(SilcClient client,
- * SilcClientConnection conn,
- * SilcServerEntry server_entry);
+ * SilcServerEntry
+ * silc_client_ref_server(SilcClient client,
+ * SilcClientConnection conn,
+ * SilcServerEntry server_entry);
*
* DESCRIPTION
*
* Takes a reference of the server entry indicated by `server_entry'
* The reference must be released by calling silc_client_unref_server
- * after it is not needed anymore.
+ * after it is not needed anymore. Returns `server_entry'.
*
***/
-void silc_client_ref_server(SilcClient client, SilcClientConnection conn,
- SilcServerEntry server_entry);
+SilcServerEntry silc_client_ref_server(SilcClient client,
+ SilcClientConnection conn,
+ SilcServerEntry server_entry);
/****f* silcclient/SilcClientAPI/silc_client_unref_server
*
projects / silc.git / commitdiff