if (!silc_client_nickname_parse(client, conn, (char *)nick, &parsed))
return NULL;
- if (!get_all && parsed)
+ if (!get_all)
format = (char *)nick;
- if (!parsed) {
- parsed = silc_memdup(nick, strlen(nick));
- if (!parsed)
- return NULL;
- }
SILC_LOG_DEBUG(("Find clients by nickname %s", parsed));
}
silc_list_start(list);
- if (!format && get_all) {
+ if (get_all) {
/* Take all without any further checking */
while ((id_cache = silc_list_get(list))) {
entry = id_cache->context;
SilcUInt32 *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
SilcUInt16 idp_len, cmd_ident;
SilcID id;
- va_list tmp;
int i;
SILC_LOG_DEBUG(("Resolve clients from Client ID list"));
/* We have the clients in cache, get them and call the completion */
silc_client_get_clients_list_cb(client, conn, SILC_COMMAND_WHOIS,
- SILC_STATUS_OK, SILC_STATUS_OK, in, tmp);
+ SILC_STATUS_OK, SILC_STATUS_OK, in, NULL);
return 0;
err:
SilcUInt32 mode)
{
SilcClientEntry client_entry;
- char *nick = NULL;
+ char *nick = NULL, parsed[128 + 1];
SILC_LOG_DEBUG(("Adding new client entry"));
return NULL;
silc_rwlock_alloc(&client_entry->internal.lock);
- silc_atomic_init8(&client_entry->internal.refcnt, 0);
+ silc_atomic_init32(&client_entry->internal.refcnt, 0);
+ silc_atomic_init32(&client_entry->internal.deleted, 1);
client_entry->id = *id;
client_entry->mode = mode;
client_entry->realname = userinfo ? strdup(userinfo) : NULL;
- silc_parse_userfqdn(nickname, client_entry->nickname,
- sizeof(client_entry->nickname),
- client_entry->server,
- sizeof(client_entry->server));
+
+ silc_parse_userfqdn(nickname, parsed, sizeof(parsed),
+ client_entry->server, sizeof(client_entry->server));
+ if (nickname && client->internal->params->full_nicknames)
+ silc_snprintf(client_entry->nickname, sizeof(client_entry->nickname),
+ nickname);
+ else if (nickname)
+ silc_snprintf(client_entry->nickname, sizeof(client_entry->nickname),
+ parsed);
+
silc_parse_userfqdn(username, client_entry->username,
sizeof(client_entry->username),
client_entry->hostname,
sizeof(client_entry->hostname));
- client_entry->channels = silc_hash_table_alloc(1, silc_hash_ptr, NULL, NULL,
- NULL, NULL, NULL, TRUE);
+
+ client_entry->channels = silc_hash_table_alloc(NULL, 1, silc_hash_ptr, NULL,
+ NULL, NULL, NULL, NULL, TRUE);
if (!client_entry->channels) {
silc_free(client_entry->realname);
silc_free(client_entry);
/* Normalize nickname */
if (client_entry->nickname[0]) {
- nick = silc_identifier_check(client_entry->nickname,
- strlen(client_entry->nickname),
+ nick = silc_identifier_check(parsed, strlen(parsed),
SILC_STRING_UTF8, 128, NULL);
if (!nick) {
silc_free(client_entry->realname);
const char *userinfo,
SilcUInt32 mode)
{
- char *nick = NULL;
+ char *nick = NULL, parsed[128 + 1];
SILC_LOG_DEBUG(("Update client entry"));
if (!client_entry->realname && userinfo)
client_entry->realname = strdup(userinfo);
+
if ((!client_entry->username[0] || !client_entry->hostname[0]) && username)
silc_parse_userfqdn(username, client_entry->username,
sizeof(client_entry->username),
client_entry->hostname,
sizeof(client_entry->username));
+
if (!client_entry->nickname[0] && nickname) {
- silc_parse_userfqdn(nickname, client_entry->nickname,
- sizeof(client_entry->nickname),
- client_entry->server,
- sizeof(client_entry->server));
+ silc_parse_userfqdn(nickname, parsed, sizeof(parsed),
+ client_entry->server, sizeof(client_entry->server));
+ if (client->internal->params->full_nicknames)
+ silc_snprintf(client_entry->nickname, sizeof(client_entry->nickname),
+ nickname);
+ else
+ silc_snprintf(client_entry->nickname, sizeof(client_entry->nickname),
+ parsed);
/* Normalize nickname */
- nick = silc_identifier_check(client_entry->nickname,
- strlen(client_entry->nickname),
+ nick = silc_identifier_check(parsed, strlen(parsed),
SILC_STRING_UTF8, 128, NULL);
if (!nick) {
silc_rwlock_unlock(client_entry->internal.lock);
silc_client_ftp_session_free_client(client, client_entry);
if (client_entry->internal.ke)
silc_client_abort_key_agreement(client, conn, client_entry);
- silc_atomic_uninit8(&client_entry->internal.refcnt);
+ silc_atomic_uninit32(&client_entry->internal.deleted);
+ silc_atomic_uninit32(&client_entry->internal.refcnt);
silc_rwlock_free(client_entry->internal.lock);
silc_free(client_entry);
}
SilcBool silc_client_del_client(SilcClient client, SilcClientConnection conn,
SilcClientEntry client_entry)
{
- SilcBool ret;
-
if (!client_entry)
return FALSE;
- if (silc_atomic_sub_int8(&client_entry->internal.refcnt, 1) > 0)
- return FALSE;
-
- SILC_LOG_DEBUG(("Deleting client %p", client_entry));
+ SILC_LOG_DEBUG(("Marking client entry %p deleted"));
- silc_mutex_lock(conn->internal->lock);
- ret = silc_idcache_del_by_context(conn->internal->client_cache,
- client_entry, NULL);
- silc_mutex_unlock(conn->internal->lock);
-
- if (ret) {
- /* Remove from channels */
- silc_client_remove_from_channels(client, conn, client_entry);
-
- /* Free the client entry data */
- silc_client_del_client_entry(client, conn, client_entry);
+ if (silc_atomic_sub_int32(&client_entry->internal.deleted, 1) != 0) {
+ SILC_LOG_DEBUG(("Client entry %p already marked deleted"));
+ return FALSE;
}
- return ret;
+ silc_client_unref_client(client, conn, client_entry);
+ return TRUE;
}
/* Internal routine used to find client by ID and if not found this creates
SilcClientConnection conn,
SilcClientEntry client_entry)
{
- silc_atomic_add_int8(&client_entry->internal.refcnt, 1);
+ silc_atomic_add_int32(&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)));
+ silc_atomic_get_int32(&client_entry->internal.refcnt) - 1,
+ silc_atomic_get_int32(&client_entry->internal.refcnt)));
return client_entry;
}
void silc_client_unref_client(SilcClient client, SilcClientConnection conn,
SilcClientEntry client_entry)
{
- if (client_entry) {
- SILC_LOG_DEBUG(("Client %p refcnt %d->%d", client_entry,
- silc_atomic_get_int8(&client_entry->internal.refcnt),
- silc_atomic_get_int8(&client_entry->internal.refcnt) - 1));
- silc_client_del_client(client, conn, client_entry);
+ SilcBool ret;
+
+ if (!client_entry)
+ return;
+
+ SILC_LOG_DEBUG(("Client %p refcnt %d->%d", client_entry,
+ silc_atomic_get_int32(&client_entry->internal.refcnt),
+ silc_atomic_get_int32(&client_entry->internal.refcnt) - 1));
+
+ if (silc_atomic_sub_int32(&client_entry->internal.refcnt, 1) > 0)
+ return;
+
+ SILC_LOG_DEBUG(("Deleting client %p (%d)", client_entry,
+ silc_atomic_get_int32(&client_entry->internal.deleted)));
+
+ silc_mutex_lock(conn->internal->lock);
+ ret = silc_idcache_del_by_context(conn->internal->client_cache,
+ client_entry, NULL);
+ silc_mutex_unlock(conn->internal->lock);
+
+ if (ret) {
+ /* Remove from channels */
+ silc_client_remove_from_channels(client, conn, client_entry);
+
+ /* Free the client entry data */
+ silc_client_del_client_entry(client, conn, client_entry);
}
}
}
newnick[off] = 0;
+ memset(client_entry->nickname, 0, sizeof(client_entry->nickname));
memcpy(client_entry->nickname, newnick, strlen(newnick));
silc_client_list_free(client, conn, clients);
int len;
if (!client->internal->params->nickname_format[0]) {
- *ret_nick = NULL;
+ *ret_nick = silc_strdup(nickname);
return TRUE;
}
SilcClientConnection conn,
char *channel)
{
+ SilcList list;
SilcIDCacheEntry id_cache;
- SilcChannelEntry entry;
+ SilcChannelEntry entry = NULL;
+ char chname[256 + 1], server[256 + 1];
if (!client || !conn || !channel)
return NULL;
SILC_LOG_DEBUG(("Find channel %s", channel));
+ /* Parse server name from channel name */
+ silc_parse_userfqdn(channel, chname, sizeof(chname), server, sizeof(server));
+
/* Normalize name for search */
- channel = silc_channel_name_check(channel, strlen(channel), SILC_STRING_UTF8,
+ channel = silc_channel_name_check(chname, strlen(chname), SILC_STRING_UTF8,
256, NULL);
if (!channel)
return NULL;
silc_mutex_lock(conn->internal->lock);
- if (!silc_idcache_find_by_name_one(conn->internal->channel_cache, channel,
- &id_cache)) {
+ if (!silc_idcache_find_by_name(conn->internal->channel_cache, channel,
+ &list)) {
silc_mutex_unlock(conn->internal->lock);
silc_free(channel);
return NULL;
}
- SILC_LOG_DEBUG(("Found"));
+ /* If server name was specified with channel name, find the correct
+ channel entry with the server name. There can only be one channel
+ with same name on same server. */
+ silc_list_start(list);
+ if (server[0]) {
+ while ((id_cache = silc_list_get(list))) {
+ entry = id_cache->context;
+ if (!entry->server[0])
+ continue;
+ if (silc_utf8_strcasecmp(entry->server, server))
+ break;
+ }
+ } else {
+ /* Get first channel without server name specified or one with our
+ current server connection name */
+ while ((id_cache = silc_list_get(list))) {
+ entry = id_cache->context;
+ if (!entry->server[0])
+ break;
+ if (silc_utf8_strcasecmp(entry->server, conn->remote_host))
+ break;
+ }
+ }
- entry = id_cache->context;
+ if (!id_cache) {
+ silc_mutex_unlock(conn->internal->lock);
+ silc_free(channel);
+ return NULL;
+ }
+
+ SILC_LOG_DEBUG(("Found channel %s%s%s", entry->channel_name,
+ entry->server[0] ? "@" : "", entry->server));
/* Reference */
silc_client_ref_channel(client, conn, entry);
SilcChannelID *channel_id)
{
SilcChannelEntry channel;
- char *channel_namec;
+ char *channel_namec, name[256 + 1];
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Adding channel %s", channel_name));
channel = silc_calloc(1, sizeof(*channel));
if (!channel)
return NULL;
silc_rwlock_alloc(&channel->internal.lock);
- silc_atomic_init16(&channel->internal.refcnt, 0);
+ silc_atomic_init32(&channel->internal.refcnt, 0);
+ silc_atomic_init32(&channel->internal.deleted, 1);
channel->id = *channel_id;
channel->mode = mode;
- channel->channel_name = strdup(channel_name);
+ silc_parse_userfqdn(channel_name, name, sizeof(name),
+ channel->server, sizeof(channel->server));
+ if (client->internal->params->full_channel_names)
+ channel->channel_name = strdup(channel_name);
+ else
+ channel->channel_name = strdup(name);
+
if (!channel->channel_name) {
+ silc_rwlock_free(channel->internal.lock);
+ silc_atomic_uninit32(&channel->internal.refcnt);
silc_free(channel);
return NULL;
}
- channel->user_list = silc_hash_table_alloc(1, silc_hash_ptr, NULL, NULL,
+ channel->user_list = silc_hash_table_alloc(NULL, 1, silc_hash_ptr, NULL, NULL,
NULL, NULL, NULL, TRUE);
if (!channel->user_list) {
+ silc_rwlock_free(channel->internal.lock);
+ silc_atomic_uninit32(&channel->internal.refcnt);
silc_free(channel->channel_name);
silc_free(channel);
return NULL;
}
/* Normalize channel name */
- channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
+ channel_namec = silc_channel_name_check(name, strlen(name),
SILC_STRING_UTF8, 256, NULL);
if (!channel_namec) {
+ silc_rwlock_free(channel->internal.lock);
+ silc_atomic_uninit32(&channel->internal.refcnt);
silc_free(channel->channel_name);
silc_hash_table_free(channel->user_list);
silc_free(channel);
/* Add channel to cache, the normalized channel name is saved to cache */
if (!silc_idcache_add(conn->internal->channel_cache, channel_namec,
&channel->id, channel)) {
+ silc_rwlock_free(channel->internal.lock);
+ silc_atomic_uninit32(&channel->internal.refcnt);
silc_free(channel_namec);
silc_free(channel->channel_name);
silc_hash_table_free(channel->user_list);
SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
SilcChannelEntry channel)
{
- SilcIDCacheEntry id_cache;
- SilcBool ret = TRUE;
- SilcCipher key;
- SilcHmac hmac;
- char *namec;
if (!channel)
return FALSE;
- if (silc_atomic_sub_int16(&channel->internal.refcnt, 1) > 0)
- return FALSE;
-
- SILC_LOG_DEBUG(("Deleting channel %p", channel));
+ SILC_LOG_DEBUG(("Marking channel entry %p deleted"));
- silc_mutex_lock(conn->internal->lock);
- if (silc_idcache_find_by_context(conn->internal->channel_cache, channel,
- &id_cache)) {
- namec = id_cache->name;
- ret = silc_idcache_del_by_context(conn->internal->channel_cache,
- channel, NULL);
- silc_free(namec);
- }
- silc_mutex_unlock(conn->internal->lock);
- if (!ret)
+ if (silc_atomic_sub_int32(&channel->internal.deleted, 1) != 0) {
+ SILC_LOG_DEBUG(("Channel entry %p already marked deleted"));
return FALSE;
-
- silc_client_empty_channel(client, conn, channel);
- silc_hash_table_free(channel->user_list);
- silc_free(channel->channel_name);
- silc_free(channel->topic);
- if (channel->founder_key)
- silc_pkcs_public_key_free(channel->founder_key);
- if (channel->internal.send_key)
- silc_cipher_free(channel->internal.send_key);
- if (channel->internal.receive_key)
- silc_cipher_free(channel->internal.receive_key);
- if (channel->internal.hmac)
- silc_hmac_free(channel->internal.hmac);
- if (channel->internal.old_channel_keys) {
- silc_dlist_start(channel->internal.old_channel_keys);
- while ((key = silc_dlist_get(channel->internal.old_channel_keys)))
- silc_cipher_free(key);
- silc_dlist_uninit(channel->internal.old_channel_keys);
- }
- if (channel->internal.old_hmacs) {
- silc_dlist_start(channel->internal.old_hmacs);
- while ((hmac = silc_dlist_get(channel->internal.old_hmacs)))
- silc_hmac_free(hmac);
- silc_dlist_uninit(channel->internal.old_hmacs);
- }
- if (channel->channel_pubkeys)
- silc_argument_list_free(channel->channel_pubkeys,
- 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);
+ }
- return ret;
+ silc_client_unref_channel(client, conn, channel);
+ return TRUE;
}
/* Replaces the channel ID of the `channel' to `new_id'. Returns FALSE
SilcClientConnection conn,
SilcChannelEntry channel_entry)
{
- silc_atomic_add_int16(&channel_entry->internal.refcnt, 1);
+ silc_atomic_add_int32(&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)));
+ silc_atomic_get_int32(&channel_entry->internal.refcnt) - 1,
+ silc_atomic_get_int32(&channel_entry->internal.refcnt)));
return channel_entry;
}
void silc_client_unref_channel(SilcClient client, SilcClientConnection conn,
SilcChannelEntry channel_entry)
{
- if (channel_entry) {
- SILC_LOG_DEBUG(("Channel %p refcnt %d->%d", channel_entry,
- silc_atomic_get_int16(&channel_entry->internal.refcnt),
- silc_atomic_get_int16(&channel_entry->internal.refcnt)
- - 1));
- silc_client_del_channel(client, conn, channel_entry);
+ SilcIDCacheEntry id_cache;
+ SilcBool ret = TRUE;
+ SilcCipher key;
+ SilcHmac hmac;
+ char *namec;
+
+ if (!channel_entry)
+ return;
+
+ SILC_LOG_DEBUG(("Channel %p refcnt %d->%d", channel_entry,
+ silc_atomic_get_int32(&channel_entry->internal.refcnt),
+ silc_atomic_get_int32(&channel_entry->internal.refcnt)
+ - 1));
+
+ if (silc_atomic_sub_int32(&channel_entry->internal.refcnt, 1) > 0)
+ return;
+
+ SILC_LOG_DEBUG(("Deleting channel %p", channel_entry));
+
+ silc_mutex_lock(conn->internal->lock);
+ if (silc_idcache_find_by_context(conn->internal->channel_cache, channel_entry,
+ &id_cache)) {
+ namec = id_cache->name;
+ ret = silc_idcache_del_by_context(conn->internal->channel_cache,
+ channel_entry, NULL);
+ silc_free(namec);
+ }
+ silc_mutex_unlock(conn->internal->lock);
+
+ if (!ret)
+ return;
+
+ silc_client_empty_channel(client, conn, channel_entry);
+ silc_client_del_channel_private_keys(client, conn, channel_entry);
+ silc_hash_table_free(channel_entry->user_list);
+ silc_free(channel_entry->channel_name);
+ silc_free(channel_entry->topic);
+ if (channel_entry->founder_key)
+ silc_pkcs_public_key_free(channel_entry->founder_key);
+ if (channel_entry->internal.send_key)
+ silc_cipher_free(channel_entry->internal.send_key);
+ if (channel_entry->internal.receive_key)
+ silc_cipher_free(channel_entry->internal.receive_key);
+ if (channel_entry->internal.hmac)
+ silc_hmac_free(channel_entry->internal.hmac);
+ if (channel_entry->internal.old_channel_keys) {
+ silc_dlist_start(channel_entry->internal.old_channel_keys);
+ while ((key = silc_dlist_get(channel_entry->internal.old_channel_keys)))
+ silc_cipher_free(key);
+ silc_dlist_uninit(channel_entry->internal.old_channel_keys);
+ }
+ if (channel_entry->internal.old_hmacs) {
+ silc_dlist_start(channel_entry->internal.old_hmacs);
+ while ((hmac = silc_dlist_get(channel_entry->internal.old_hmacs)))
+ silc_hmac_free(hmac);
+ silc_dlist_uninit(channel_entry->internal.old_hmacs);
}
+ if (channel_entry->channel_pubkeys)
+ silc_argument_list_free(channel_entry->channel_pubkeys,
+ SILC_ARGUMENT_PUBLIC_KEY);
+ silc_atomic_uninit32(&channel_entry->internal.deleted);
+ silc_atomic_uninit32(&channel_entry->internal.refcnt);
+ silc_rwlock_free(channel_entry->internal.lock);
+ silc_schedule_task_del_by_context(conn->client->schedule, channel_entry);
+ silc_free(channel_entry);
}
/* Free channel entry list */
return NULL;
silc_rwlock_alloc(&server_entry->internal.lock);
- silc_atomic_init8(&server_entry->internal.refcnt, 0);
+ silc_atomic_init32(&server_entry->internal.refcnt, 0);
server_entry->id = *server_id;
if (server_name)
server_entry->server_name = strdup(server_name);
if (!server)
return FALSE;
- if (silc_atomic_sub_int8(&server->internal.refcnt, 1) > 0)
+ if (silc_atomic_sub_int32(&server->internal.refcnt, 1) > 0)
return FALSE;
SILC_LOG_DEBUG(("Deleting server %p", server));
silc_free(server->server_info);
if (server->public_key)
silc_pkcs_public_key_free(server->public_key);
- silc_atomic_uninit8(&server->internal.refcnt);
+ silc_atomic_uninit32(&server->internal.refcnt);
silc_rwlock_free(server->internal.lock);
silc_free(server);
SilcClientConnection conn,
SilcServerEntry server_entry)
{
- silc_atomic_add_int8(&server_entry->internal.refcnt, 1);
+ silc_atomic_add_int32(&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)));
+ silc_atomic_get_int32(&server_entry->internal.refcnt) - 1,
+ silc_atomic_get_int32(&server_entry->internal.refcnt)));
return server_entry;
}
{
if (server_entry) {
SILC_LOG_DEBUG(("Server %p refcnt %d->%d", server_entry,
- silc_atomic_get_int8(&server_entry->internal.refcnt),
- silc_atomic_get_int8(&server_entry->internal.refcnt)
+ silc_atomic_get_int32(&server_entry->internal.refcnt),
+ silc_atomic_get_int32(&server_entry->internal.refcnt)
- 1));
silc_client_del_server(client, conn, server_entry);
}
projects / silc.git / blobdiff