/* Find ID from cache */
if (!silc_idcache_find_by_id_one(conn->internal->client_cache, client_id,
- &id_cache))
+ &id_cache)) {
+ silc_mutex_unlock(conn->internal->lock);
return NULL;
+ }
client_entry = id_cache->context;
/* Reference */
silc_client_ref_client(client, conn, client_entry);
- silc_mutex_lock(conn->internal->lock);
+ silc_mutex_unlock(conn->internal->lock);
SILC_LOG_DEBUG(("Found"));
client_entry = va_arg(ap, SilcClientEntry);
silc_client_ref_client(client, conn, client_entry);
silc_dlist_add(i->clients, client_entry);
+ client_entry->internal.resolve_cmd_ident = 0;
}
if (status == SILC_STATUS_OK || status == SILC_STATUS_LIST_END) {
void *context)
{
SilcClientGetClientInternal i;
+ SilcClientEntry client_entry;
SilcBuffer idp;
+ SilcUInt16 cmd_ident;
if (!client || !conn | !client_id)
return;
return;
i->completion = completion;
i->context = context;
+ i->clients = silc_dlist_init();
+ if (!i->clients) {
+ silc_free(i);
+ return;
+ }
+
+ /* Attach to resolving, if on going */
+ client_entry = silc_client_get_client_by_id(client, conn, client_id);
+ if (client_entry && client_entry->internal.resolve_cmd_ident) {
+ SILC_LOG_DEBUG(("Attach to existing resolving"));
+ silc_client_unref_client(client, conn, client_entry);
+ silc_client_command_pending(conn, SILC_COMMAND_NONE,
+ client_entry->internal.resolve_cmd_ident,
+ silc_client_get_clients_cb, i);
+ return;
+ }
/* Send the command */
idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
- silc_client_command_send(client, conn, SILC_COMMAND_WHOIS,
- silc_client_get_clients_cb, i,
- 2, 3, silc_buffer_datalen(attributes),
- 4, silc_buffer_datalen(idp));
+ cmd_ident = silc_client_command_send(client, conn, SILC_COMMAND_WHOIS,
+ silc_client_get_clients_cb, i,
+ 2, 3, silc_buffer_datalen(attributes),
+ 4, silc_buffer_datalen(idp));
+ if (!cmd_ident)
+ completion(client, conn, SILC_STATUS_ERR_RESOURCE_LIMIT, NULL, context);
+
+ if (client_entry && cmd_ident)
+ client_entry->internal.resolve_cmd_ident = cmd_ident;
+
+ silc_client_unref_client(client, conn, client_entry);
silc_buffer_free(idp);
}
if (!i)
return 0;
i->clients = silc_dlist_init();
- if (!i->clients)
+ if (!i->clients) {
+ silc_free(i);
return 0;
+ }
i->completion = completion;
i->context = context;
/* Get client entry */
client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
- if (client_entry) {
- silc_client_ref_client(client, conn, client_entry);
+ if (client_entry)
silc_dlist_add(clients, client_entry);
- }
if (!silc_buffer_pull(i->client_id_list, idp_len)) {
status = SILC_STATUS_ERR_BAD_CLIENT_ID;
/* Check if we have this client cached already. If we don't have the
entry or it has incomplete info, then resolve it from the server. */
entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
- if (!entry || !entry->nickname || !entry->username || !entry->realname) {
+ if (!entry || !entry->nickname[0] || !entry->username[0] ||
+ !entry->realname) {
if (!res_argv) {
res_argv = silc_calloc(list_count, sizeof(*res_argv));
res_argv_lens = silc_calloc(list_count, sizeof(*res_argv_lens));
res_argv_types = silc_calloc(list_count, sizeof(*res_argv_types));
- if (!res_argv || !res_argv_lens || !res_argv_types)
+ if (!res_argv || !res_argv_lens || !res_argv_types) {
+ silc_client_unref_client(client, conn, entry);
goto err;
+ }
}
res_argv[res_argc] = client_id_list->data;
res_argv_types[res_argc] = res_argc + 5;
res_argc++;
}
+ silc_client_unref_client(client, conn, entry);
if (!silc_buffer_pull(client_id_list, idp_len))
goto err;
entry = chu->client;
/* If the entry has incomplete info, then resolve it from the server. */
- if (!entry->nickname || !entry->realname) {
+ if (!entry->nickname[0] || !entry->realname) {
if (entry->status & SILC_CLIENT_STATUS_RESOLVING) {
/* Attach to this resolving and wait until it finishes */
silc_client_command_pending(
/* Format the nickname */
silc_client_nickname_format(client, conn, client_entry);
+ silc_mutex_lock(conn->internal->lock);
+
/* Add client to cache, the normalized nickname is saved to cache */
if (!silc_idcache_add(conn->internal->client_cache, nick,
&client_entry->id, client_entry)) {
silc_free(client_entry->realname);
silc_hash_table_free(client_entry->channels);
silc_free(client_entry);
+ silc_mutex_unlock(conn->internal->lock);
return NULL;
}
client_entry->nickname_normalized = nick;
+ silc_mutex_unlock(conn->internal->lock);
+
return client_entry;
}
void silc_client_unref_client(SilcClient client, SilcClientConnection conn,
SilcClientEntry client_entry)
{
- if (silc_atomic_sub_int8(&client_entry->internal.refcnt, 1) == 0) {
+ if (client_entry &&
+ silc_atomic_sub_int8(&client_entry->internal.refcnt, 1) == 0)
silc_client_del_client(client, conn, client_entry);
- return;
- }
}
/* Free client entry list */
{
SilcClientEntry client_entry;
- silc_dlist_start(client_list);
- while ((client_entry = silc_dlist_get(client_list)))
- silc_client_unref_client(client, conn, client_entry);
+ if (client_list) {
+ silc_dlist_start(client_list);
+ while ((client_entry = silc_dlist_get(client_list)))
+ silc_client_unref_client(client, conn, client_entry);
- silc_dlist_uninit(client_list);
+ silc_dlist_uninit(client_list);
+ }
}
-/************************* Channel Entry Routines ***************************/
+/* Formats the nickname of the client specified by the `client_entry'.
+ If the format is specified by the application this will format the
+ nickname and replace the old nickname in the client entry. If the
+ format string is not specified then this function has no effect. */
-/* Add new channel entry to the ID Cache */
+void silc_client_nickname_format(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry)
+{
+ char *cp;
+ char newnick[128 + 1];
+ int i, off = 0, len;
+ SilcBool freebase;
+ SilcDList clients;
+ SilcClientEntry entry, unformatted = NULL;
-SilcChannelEntry silc_client_add_channel(SilcClient client,
+ SILC_LOG_DEBUG(("Start"));
+
+ if (!client->internal->params->nickname_format[0])
+ return;
+
+ if (!client_entry->nickname[0])
+ return;
+
+ /* Get all clients with same nickname. Do not perform the formatting
+ if there aren't any clients with same nickname unless the application
+ is forcing us to do so. */
+ clients = silc_client_get_clients_local(client, conn,
+ client_entry->nickname, NULL);
+ if (!clients && !client->internal->params->nickname_force_format)
+ return;
+
+ len = 0;
+ freebase = TRUE;
+ while ((entry = silc_dlist_get(clients))) {
+ if (entry->internal.valid && entry != client_entry)
+ len++;
+ if (entry->internal.valid && entry != client_entry &&
+ silc_utf8_strcasecmp(entry->nickname, client_entry->nickname)) {
+ freebase = FALSE;
+ unformatted = entry;
+ }
+ }
+ if (!len || freebase)
+ return;
+
+ /* If we are changing nickname of our local entry we'll enforce
+ that we will always get the unformatted nickname. Give our
+ format number to the one that is not formatted now. */
+ if (unformatted && client_entry == conn->local_entry)
+ client_entry = unformatted;
+
+ memset(newnick, 0, sizeof(newnick));
+ cp = client->internal->params->nickname_format;
+ while (*cp) {
+ if (*cp == '%') {
+ cp++;
+ continue;
+ }
+
+ switch(*cp) {
+ case 'n':
+ /* Nickname */
+ if (!client_entry->nickname[0])
+ break;
+ len = strlen(client_entry->nickname);
+ memcpy(&newnick[off], client_entry->nickname, len);
+ off += len;
+ break;
+ case 'h':
+ /* Stripped hostname */
+ if (!client_entry->hostname[0])
+ break;
+ len = strcspn(client_entry->hostname, ".");
+ i = strcspn(client_entry->hostname, "-");
+ if (i < len)
+ len = i;
+ memcpy(&newnick[off], client_entry->hostname, len);
+ off += len;
+ break;
+ case 'H':
+ /* Full hostname */
+ if (!client_entry->hostname[0])
+ break;
+ len = strlen(client_entry->hostname);
+ memcpy(&newnick[off], client_entry->hostname, len);
+ off += len;
+ break;
+ case 's':
+ /* Stripped server name */
+ if (!client_entry->server)
+ break;
+ len = strcspn(client_entry->server, ".");
+ memcpy(&newnick[off], client_entry->server, len);
+ off += len;
+ break;
+ case 'S':
+ /* Full server name */
+ if (!client_entry->server)
+ break;
+ len = strlen(client_entry->server);
+ memcpy(&newnick[off], client_entry->server, len);
+ off += len;
+ break;
+ case 'a':
+ /* Ascending number */
+ {
+ char tmp[6];
+ int num, max = 1;
+
+ if (silc_dlist_count(clients) == 1)
+ break;
+
+ silc_dlist_start(clients);
+ while ((entry = silc_dlist_get(clients))) {
+ if (!silc_utf8_strncasecmp(entry->nickname, newnick, off))
+ continue;
+ if (strlen(entry->nickname) <= off)
+ continue;
+ num = atoi(&entry->nickname[off]);
+ if (num > max)
+ max = num;
+ }
+
+ memset(tmp, 0, sizeof(tmp));
+ snprintf(tmp, sizeof(tmp) - 1, "%d", ++max);
+ len = strlen(tmp);
+ memcpy(&newnick[off], tmp, len);
+ off += len;
+ }
+ break;
+ default:
+ /* Some other character in the string */
+ memcpy(&newnick[off], cp, 1);
+ off++;
+ break;
+ }
+
+ cp++;
+ }
+
+ newnick[off] = 0;
+ memcpy(client_entry->nickname, newnick, strlen(newnick));
+ silc_client_list_free(client, conn, clients);
+}
+
+/************************ Channel Searching Locally *************************/
+
+/* Finds entry for channel by the channel name. Returns the entry or NULL
+ if the entry was not found. It is found only if the client is joined
+ to the channel. */
+
+SilcChannelEntry silc_client_get_channel(SilcClient client,
SilcClientConnection conn,
- const char *channel_name,
- SilcUInt32 mode,
- SilcChannelID *channel_id)
+ char *channel)
{
- SilcChannelEntry channel;
- char *channel_namec;
+ SilcIDCacheEntry id_cache;
+ SilcChannelEntry entry;
- SILC_LOG_DEBUG(("Start"));
+ if (!client || !conn || !channel)
+ return NULL;
- channel = silc_calloc(1, sizeof(*channel));
- channel->channel_name = strdup(channel_name);
- channel->id = channel_id;
- channel->mode = mode;
- channel->user_list = silc_hash_table_alloc(1, silc_hash_ptr, NULL, NULL,
- NULL, NULL, NULL, TRUE);
+ SILC_LOG_DEBUG(("Find channel %s", channel));
- /* Normalize channel name */
- channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
- SILC_STRING_UTF8, 256, NULL);
- if (!channel_namec) {
- silc_free(channel->channel_name);
- silc_hash_table_free(channel->user_list);
- silc_free(channel);
+ /* Normalize name for search */
+ channel = silc_channel_name_check(channel, strlen(channel), SILC_STRING_UTF8,
+ 256, NULL);
+ if (!channel)
return NULL;
- }
- /* Put it to the ID cache */
- if (!silc_idcache_add(conn->internal->channel_cache, channel_namec,
- (void *)channel->id, (void *)channel)) {
- silc_free(channel_namec);
- silc_free(channel->channel_name);
- silc_hash_table_free(channel->user_list);
+ silc_mutex_lock(conn->internal->lock);
+
+ if (!silc_idcache_find_by_name_one(conn->internal->channel_cache, channel,
+ &id_cache)) {
+ silc_mutex_unlock(conn->internal->lock);
silc_free(channel);
return NULL;
}
- return channel;
-}
+ SILC_LOG_DEBUG(("Found"));
-/* Foreach callbcak to free all users from the channel when deleting a
- channel entry. */
+ entry = id_cache->context;
-static void silc_client_del_channel_foreach(void *key, void *context,
- void *user_context)
-{
- SilcChannelUser chu = (SilcChannelUser)context;
+ /* Reference */
+ silc_client_ref_channel(client, conn, entry);
+ silc_mutex_unlock(conn->internal->lock);
- SILC_LOG_DEBUG(("Start"));
+ silc_free(channel);
- /* Remove the context from the client's channel hash table as that
- table and channel's user_list hash table share this same context. */
- silc_hash_table_del(chu->client->channels, chu->channel);
- silc_free(chu);
+ return entry;
}
-/* Removes channel from the cache by the channel entry. */
+/* Finds entry for channel by the channel ID. Returns the entry or NULL
+ if the entry was not found. It is found only if the client is joined
+ to the channel. */
-SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
- SilcChannelEntry channel)
+SilcChannelEntry silc_client_get_channel_by_id(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelID *channel_id)
{
- SilcBool ret = silc_idcache_del_by_context(conn->internal->channel_cache,
- channel, NULL);
+ SilcIDCacheEntry id_cache;
+ SilcChannelEntry entry;
- SILC_LOG_DEBUG(("Start"));
+ if (!client || !conn || !channel_id)
+ return NULL;
- /* Free all client entrys from the users list. The silc_hash_table_free
- will free all the entries so they are not freed at the foreach
- callback. */
- silc_hash_table_foreach(channel->user_list, silc_client_del_channel_foreach,
- NULL);
- silc_hash_table_free(channel->user_list);
+ SILC_LOG_DEBUG(("Find channel by id %s",
+ silc_id_render(channel_id, SILC_ID_CHANNEL)));
- silc_free(channel->channel_name);
- silc_free(channel->topic);
- silc_free(channel->id);
- if (channel->founder_key)
- silc_pkcs_public_key_free(channel->founder_key);
- silc_free(channel->key);
- if (channel->channel_key)
- silc_cipher_free(channel->channel_key);
- if (channel->hmac)
- silc_hmac_free(channel->hmac);
- if (channel->old_channel_keys) {
- SilcCipher key;
- silc_dlist_start(channel->old_channel_keys);
- while ((key = silc_dlist_get(channel->old_channel_keys)) != SILC_LIST_END)
- silc_cipher_free(key);
- silc_dlist_uninit(channel->old_channel_keys);
- }
- if (channel->old_hmacs) {
- SilcHmac hmac;
- silc_dlist_start(channel->old_hmacs);
- while ((hmac = silc_dlist_get(channel->old_hmacs)) != SILC_LIST_END)
- silc_hmac_free(hmac);
- silc_dlist_uninit(channel->old_hmacs);
+ silc_mutex_lock(conn->internal->lock);
+
+ if (!silc_idcache_find_by_id_one(conn->internal->channel_cache, channel_id,
+ &id_cache)) {
+ silc_mutex_unlock(conn->internal->lock);
+ return NULL;
}
- silc_schedule_task_del_by_context(conn->client->schedule, channel);
- silc_client_del_channel_private_keys(client, conn, channel);
- silc_free(channel);
- return ret;
+
+ SILC_LOG_DEBUG(("Found"));
+
+ entry = id_cache->context;
+
+ /* Reference */
+ silc_client_ref_channel(client, conn, entry);
+ silc_mutex_unlock(conn->internal->lock);
+
+ return entry;
}
-/* Replaces the channel ID of the `channel' to `new_id'. Returns FALSE
- if the ID could not be changed. */
+/********************** Channel Resolving from Server ***********************/
-SilcBool silc_client_replace_channel_id(SilcClient client,
- SilcClientConnection conn,
- SilcChannelEntry channel,
- SilcChannelID *new_id)
+/* Channel resolving context */
+typedef struct {
+ SilcDList channels;
+ SilcGetChannelCallback completion;
+ void *context;
+} *SilcClientGetChannelInternal;
+
+/* Resolving command callback */
+
+static SilcBool silc_client_get_channel_cb(SilcClient client,
+ SilcClientConnection conn,
+ SilcCommand command,
+ SilcStatus status,
+ SilcStatus error,
+ void *context,
+ va_list ap)
{
- char *channel_namec;
+ SilcClientGetChannelInternal i = context;
+ SilcChannelEntry entry;
- if (!new_id)
- return FALSE;
+ if (error != SILC_STATUS_OK) {
+ SILC_LOG_DEBUG(("Resolving failed: %s", silc_get_status_message(error)));
+ if (i->completion)
+ i->completion(client, conn, error, NULL, i->context);
+ goto out;
+ }
- SILC_LOG_DEBUG(("Old Channel ID id(%s)",
- silc_id_render(channel->id, SILC_ID_CHANNEL)));
- SILC_LOG_DEBUG(("New Channel ID id(%s)",
- silc_id_render(new_id, SILC_ID_CHANNEL)));
+ /* Add the returned channel to list */
+ if (i->completion) {
+ entry = va_arg(ap, SilcChannelEntry);
+ silc_client_ref_channel(client, conn, entry);
+ silc_dlist_add(i->channels, entry);
+ }
- silc_idcache_del_by_id(conn->internal->channel_cache, channel->id, NULL);
- silc_free(channel->id);
- channel->id = new_id;
+ if (status == SILC_STATUS_OK || status == SILC_STATUS_LIST_END) {
+ /* Deliver the channels to the caller */
+ if (i->completion) {
+ SILC_LOG_DEBUG(("Resolved %d channels", silc_dlist_count(i->channels)));
+ silc_dlist_start(i->channels);
+ i->completion(client, conn, SILC_STATUS_OK, i->channels, i->context);
+ }
+ goto out;
+ }
- /* Normalize channel name */
- channel_namec = silc_channel_name_check(channel->channel_name,
- strlen(channel->channel_name),
- SILC_STRING_UTF8, 256, NULL);
- if (!channel_namec)
- return FALSE;
+ return TRUE;
- return silc_idcache_add(conn->internal->channel_cache, channel_namec,
- channel->id, channel) != NULL;
+ out:
+ silc_client_list_free_channels(client, conn, i->channels);
+ silc_free(i);
+ return FALSE;
}
-/* Finds entry for channel by the channel name. Returns the entry or NULL
- if the entry was not found. It is found only if the client is joined
- to the channel. */
+/* Resolves channel entry from the server by the channel name. */
-SilcChannelEntry silc_client_get_channel(SilcClient client,
- SilcClientConnection conn,
- char *channel)
+void silc_client_get_channel_resolve(SilcClient client,
+ SilcClientConnection conn,
+ char *channel_name,
+ SilcGetChannelCallback completion,
+ void *context)
{
- SilcIDCacheEntry id_cache;
- SilcChannelEntry entry;
+ SilcClientGetChannelInternal i;
- assert(client && conn);
- if (!channel)
- return NULL;
+ if (!client || !conn || !channel_name || !completion)
+ return;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Resolve channel %s", channel_name));
- /* Normalize name for search */
- channel = silc_channel_name_check(channel, strlen(channel), SILC_STRING_UTF8,
- 256, NULL);
- if (!channel)
- return NULL;
+ i = silc_calloc(1, sizeof(*i));
+ if (!i)
+ return;
+ i->completion = completion;
+ i->context = context;
+ i->channels = silc_dlist_init();
+ if (!i->channels) {
+ silc_free(i);
+ return;
+ }
- if (!silc_idcache_find_by_name_one(conn->internal->channel_cache, channel,
- &id_cache)) {
- silc_free(channel);
- return NULL;
+ /* Send the command */
+ if (!silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
+ silc_client_get_channel_cb, i, 1,
+ 3, channel_name, strlen(channel_name)))
+ completion(client, conn, SILC_STATUS_ERR_RESOURCE_LIMIT, NULL, context);
+}
+
+/* Resolves channel information from the server by the channel ID. */
+
+void silc_client_get_channel_by_id_resolve(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelID *channel_id,
+ SilcGetChannelCallback completion,
+ void *context)
+{
+ SilcClientGetChannelInternal i;
+ SilcChannelEntry channel;
+ SilcBuffer idp;
+ SilcUInt16 cmd_ident;
+
+ if (!client || !conn || !channel_id || !completion)
+ return;
+
+ SILC_LOG_DEBUG(("Resolve channel by id %s",
+ silc_id_render(channel_id, SILC_ID_CHANNEL)));
+
+ i = silc_calloc(1, sizeof(*i));
+ if (!i)
+ return;
+ i->completion = completion;
+ i->context = context;
+ i->channels = silc_dlist_init();
+ if (!i->channels) {
+ silc_free(i);
+ return;
}
- entry = (SilcChannelEntry)id_cache->context;
+ /* Attach to resolving, if on going */
+ channel = silc_client_get_channel_by_id(client, conn, channel_id);
+ if (channel && channel->internal.resolve_cmd_ident) {
+ SILC_LOG_DEBUG(("Attach to existing resolving"));
+ silc_client_unref_channel(client, conn, channel);
+ silc_client_command_pending(conn, SILC_COMMAND_NONE,
+ channel->internal.resolve_cmd_ident,
+ silc_client_get_channel_cb, i);
+ return;
+ }
- SILC_LOG_DEBUG(("Found"));
+ /* Send the command */
+ idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
+ cmd_ident = silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
+ silc_client_get_channel_cb, i, 1,
+ 5, silc_buffer_datalen(idp));
+ silc_buffer_free(idp);
+ if (!cmd_ident)
+ completion(client, conn, SILC_STATUS_ERR_RESOURCE_LIMIT, NULL, context);
- silc_free(channel);
+ if (channel && cmd_ident)
+ channel->internal.resolve_cmd_ident = cmd_ident;
- return entry;
+ silc_client_unref_channel(client, conn, channel);
}
-/* Finds entry for channel by the channel ID. Returns the entry or NULL
- if the entry was not found. It is found only if the client is joined
- to the channel. */
+/************************* Channel Entry Routines ***************************/
-SilcChannelEntry silc_client_get_channel_by_id(SilcClient client,
- SilcClientConnection conn,
- SilcChannelID *channel_id)
+/* Add new channel entry to the ID Cache */
+
+SilcChannelEntry silc_client_add_channel(SilcClient client,
+ SilcClientConnection conn,
+ const char *channel_name,
+ SilcUInt32 mode,
+ SilcChannelID *channel_id)
{
- SilcIDCacheEntry id_cache;
- SilcChannelEntry entry;
+ SilcChannelEntry channel;
+ char *channel_namec;
+
+ SILC_LOG_DEBUG(("Start"));
- assert(client && conn);
- if (!channel_id)
+ channel = silc_calloc(1, sizeof(*channel));
+ if (!channel)
return NULL;
- SILC_LOG_DEBUG(("Start"));
+ channel->id = *channel_id;
+ channel->mode = mode;
- if (!silc_idcache_find_by_id_one(conn->internal->channel_cache, channel_id,
- &id_cache))
+ channel->channel_name = strdup(channel_name);
+ if (!channel->channel_name) {
+ silc_free(channel);
return NULL;
+ }
- entry = (SilcChannelEntry)id_cache->context;
+ channel->user_list = silc_hash_table_alloc(1, silc_hash_ptr, NULL, NULL,
+ NULL, NULL, NULL, TRUE);
+ if (!channel->user_list) {
+ silc_free(channel->channel_name);
+ silc_free(channel);
+ return NULL;
+ }
- SILC_LOG_DEBUG(("Found"));
+ /* Normalize channel name */
+ channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
+ SILC_STRING_UTF8, 256, NULL);
+ if (!channel_namec) {
+ silc_free(channel->channel_name);
+ silc_hash_table_free(channel->user_list);
+ silc_free(channel);
+ return NULL;
+ }
- return entry;
+ /* 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_free(channel_namec);
+ silc_free(channel->channel_name);
+ silc_hash_table_free(channel->user_list);
+ silc_free(channel);
+ return NULL;
+ }
+
+ return channel;
}
-#if 0
-typedef struct {
- SilcClient client;
- SilcClientConnection conn;
- union {
- SilcChannelID *channel_id;
- char *channel_name;
- } u;
- SilcGetChannelCallback completion;
- void *context;
-} *GetChannelInternal;
+/* Foreach callbcak to free all users from the channel when deleting a
+ channel entry. */
-SILC_CLIENT_CMD_FUNC(get_channel_resolve_callback)
+static void silc_client_del_channel_foreach(void *key, void *context,
+ void *user_context)
{
- GetChannelInternal i = (GetChannelInternal)context;
- SilcChannelEntry entry;
+ SilcChannelUser chu = (SilcChannelUser)context;
SILC_LOG_DEBUG(("Start"));
- /* Get the channel */
- entry = silc_client_get_channel(i->client, i->conn, i->u.channel_name);
- if (entry) {
- i->completion(i->client, i->conn, &entry, 1, i->context);
- } else {
- i->completion(i->client, i->conn, NULL, 0, i->context);
- }
-
- silc_free(i->u.channel_name);
- silc_free(i);
+ /* Remove the context from the client's channel hash table as that
+ table and channel's user_list hash table share this same context. */
+ silc_hash_table_del(chu->client->channels, chu->channel);
+ silc_free(chu);
}
-/* Resolves channel entry from the server by the channel name. */
+/* Removes channel from the cache by the channel entry. */
-void silc_client_get_channel_resolve(SilcClient client,
- SilcClientConnection conn,
- char *channel_name,
- SilcGetChannelCallback completion,
- void *context)
+SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
+ SilcChannelEntry channel)
{
- GetChannelInternal i = silc_calloc(1, sizeof(*i));
-
- assert(client && conn && channel_name);
+ SilcBool ret = silc_idcache_del_by_context(conn->internal->channel_cache,
+ channel, NULL);
+#if 0
SILC_LOG_DEBUG(("Start"));
- i->client = client;
- i->conn = conn;
- i->u.channel_name = strdup(channel_name);
- i->completion = completion;
- i->context = context;
-
- /* Register our own command reply for this command */
- silc_client_command_register(client, SILC_COMMAND_IDENTIFY, NULL, NULL,
- silc_client_command_reply_identify_i, 0,
- ++conn->cmd_ident);
+ /* Free all client entrys from the users list. The silc_hash_table_free
+ will free all the entries so they are not freed at the foreach
+ callback. */
+ silc_hash_table_foreach(channel->user_list, silc_client_del_channel_foreach,
+ NULL);
+ silc_hash_table_free(channel->user_list);
- /* Send the command */
- silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- 1, 3, channel_name, strlen(channel_name));
-
- /* Add pending callback */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
- silc_client_command_get_channel_resolve_callback,
- (void *)i);
+ silc_free(channel->channel_name);
+ silc_free(channel->topic);
+ if (channel->founder_key)
+ silc_pkcs_public_key_free(channel->founder_key);
+ silc_free(channel->key);
+ if (channel->channel_key)
+ silc_cipher_free(channel->channel_key);
+ if (channel->hmac)
+ silc_hmac_free(channel->hmac);
+ if (channel->old_channel_keys) {
+ SilcCipher key;
+ silc_dlist_start(channel->old_channel_keys);
+ while ((key = silc_dlist_get(channel->old_channel_keys)) != SILC_LIST_END)
+ silc_cipher_free(key);
+ silc_dlist_uninit(channel->old_channel_keys);
+ }
+ if (channel->old_hmacs) {
+ SilcHmac hmac;
+ silc_dlist_start(channel->old_hmacs);
+ while ((hmac = silc_dlist_get(channel->old_hmacs)) != SILC_LIST_END)
+ silc_hmac_free(hmac);
+ silc_dlist_uninit(channel->old_hmacs);
+ }
+ silc_schedule_task_del_by_context(conn->client->schedule, channel);
+ silc_client_del_channel_private_keys(client, conn, channel);
+ silc_free(channel);
+#endif
+ return ret;
}
-SILC_CLIENT_CMD_FUNC(get_channel_by_id_callback)
-{
- GetChannelInternal i = (GetChannelInternal)context;
- SilcChannelEntry entry;
+/* Replaces the channel ID of the `channel' to `new_id'. Returns FALSE
+ if the ID could not be changed. */
+
+SilcBool silc_client_replace_channel_id(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelEntry channel,
+ SilcChannelID *new_id)
+{
+ SilcIDCacheEntry id_cache;
+ SilcBool ret = FALSE;
+
+ if (!new_id)
+ return FALSE;
+
+ SILC_LOG_DEBUG(("Old Channel ID id(%s)",
+ silc_id_render(&channel->id, SILC_ID_CHANNEL)));
+ SILC_LOG_DEBUG(("New Channel ID id(%s)",
+ silc_id_render(new_id, SILC_ID_CHANNEL)));
- SILC_LOG_DEBUG(("Start"));
+ silc_mutex_lock(conn->internal->lock);
- /* Get the channel */
- entry = silc_client_get_channel_by_id(i->client, i->conn, i->u.channel_id);
- if (entry) {
- i->completion(i->client, i->conn, &entry, 1, i->context);
- } else {
- i->completion(i->client, i->conn, NULL, 0, i->context);
- }
+ /* Update the ID */
+ if (silc_idcache_find_by_id_one(conn->internal->channel_cache,
+ &channel->id, &id_cache))
+ ret = silc_idcache_update(conn->internal->channel_cache, id_cache,
+ &channel->id, new_id, NULL, NULL, FALSE);
- silc_free(i->u.channel_id);
- silc_free(i);
+ silc_mutex_unlock(conn->internal->lock);
+
+ return ret;
}
-/* Resolves channel information from the server by the channel ID. */
+/* Take reference of channel entry */
-void silc_client_get_channel_by_id_resolve(SilcClient client,
- SilcClientConnection conn,
- SilcChannelID *channel_id,
- SilcGetChannelCallback completion,
- void *context)
+void silc_client_ref_channel(SilcClient client, SilcClientConnection conn,
+ SilcChannelEntry channel_entry)
{
- SilcBuffer idp;
- GetChannelInternal i = silc_calloc(1, sizeof(*i));
+ silc_atomic_add_int8(&channel_entry->internal.refcnt, 1);
+}
- assert(client && conn && channel_id);
+/* Release reference of channel entry */
- SILC_LOG_DEBUG(("Start"));
+void silc_client_unref_channel(SilcClient client, SilcClientConnection conn,
+ SilcChannelEntry channel_entry)
+{
+ if (channel_entry &&
+ silc_atomic_sub_int8(&channel_entry->internal.refcnt, 1) == 0)
+ silc_client_del_channel(client, conn, channel_entry);
+}
- i->client = client;
- i->conn = conn;
- i->u.channel_id = silc_id_dup(channel_id, SILC_ID_CHANNEL);
- i->completion = completion;
- i->context = context;
+/* Free channel entry list */
- /* Register our own command reply for this command */
- silc_client_command_register(client, SILC_COMMAND_IDENTIFY, NULL, NULL,
- silc_client_command_reply_identify_i, 0,
- ++conn->cmd_ident);
+void silc_client_list_free_channels(SilcClient client,
+ SilcClientConnection conn,
+ SilcDList channel_list)
+{
+ SilcChannelEntry channel_entry;
- /* Send the command */
- idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
- silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- 1, 5, idp->data, idp->len);
- silc_buffer_free(idp);
+ if (channel_list) {
+ silc_dlist_start(channel_list);
+ while ((channel_entry = silc_dlist_get(channel_list)))
+ silc_client_unref_channel(client, conn, channel_entry);
- /* Add pending callback */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
- silc_client_command_get_channel_by_id_callback,
- (void *)i);
+ silc_dlist_uninit(channel_list);
+ }
}
-#endif /* 0 */
+
+/************************* Server Searching Locally *************************/
/* Finds entry for server by the server name. */
SilcIDCacheEntry id_cache;
SilcServerEntry entry;
- assert(client && conn);
- if (!server_name)
+ if (!client || !conn || !server_name)
return NULL;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Find server by name %s", server_name));
/* Normalize server name for search */
server_name = silc_identifier_check(server_name, strlen(server_name),
if (!server_name)
return NULL;
+ silc_mutex_lock(conn->internal->lock);
+
if (!silc_idcache_find_by_name_one(conn->internal->server_cache,
server_name, &id_cache)) {
silc_free(server_name);
return NULL;
}
- entry = (SilcServerEntry)id_cache->context;
+ SILC_LOG_DEBUG(("Found"));
+
+ /* Reference */
+ entry = id_cache->context;
+ silc_client_ref_server(client, conn, entry);
+
+ silc_mutex_unlock(conn->internal->lock);
silc_free(server_name);
SilcIDCacheEntry id_cache;
SilcServerEntry entry;
- assert(client && conn);
- if (!server_id)
+ if (!client || !conn || !server_id)
return NULL;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Find server by id %s",
+ silc_id_render(server_id, SILC_ID_SERVER)));
+
+ silc_mutex_lock(conn->internal->lock);
if (!silc_idcache_find_by_id_one(conn->internal->server_cache,
(void *)server_id, &id_cache))
return NULL;
+ SILC_LOG_DEBUG(("Found"));
+
+ /* Reference */
entry = (SilcServerEntry)id_cache->context;
+ silc_client_ref_server(client, conn, entry);
+
+ silc_mutex_unlock(conn->internal->lock);
return entry;
}
+/*********************** Server Resolving from Server ***********************/
+
+/* Resolving context */
+typedef struct {
+ SilcDList servers;
+ SilcGetServerCallback completion;
+ void *context;
+} *SilcClientGetServerInternal;
+
+/* Resolving command callback */
+
+static SilcBool silc_client_get_server_cb(SilcClient client,
+ SilcClientConnection conn,
+ SilcCommand command,
+ SilcStatus status,
+ SilcStatus error,
+ void *context,
+ va_list ap)
+{
+ SilcClientGetServerInternal i = context;
+ SilcServerEntry server;
+
+ if (error != SILC_STATUS_OK) {
+ SILC_LOG_DEBUG(("Resolving failed: %s", silc_get_status_message(error)));
+ if (i->completion)
+ i->completion(client, conn, error, NULL, i->context);
+ goto out;
+ }
+
+ /* Add the returned servers to list */
+ if (i->completion) {
+ server = va_arg(ap, SilcServerEntry);
+ silc_client_ref_server(client, conn, server);
+ silc_dlist_add(i->servers, server);
+ server->internal.resolve_cmd_ident = 0;
+ }
+
+ if (status == SILC_STATUS_OK || status == SILC_STATUS_LIST_END) {
+ /* Deliver the servers to the caller */
+ if (i->completion) {
+ SILC_LOG_DEBUG(("Resolved %d servers", silc_dlist_count(i->servers)));
+ silc_dlist_start(i->servers);
+ i->completion(client, conn, SILC_STATUS_OK, i->servers, i->context);
+ }
+ goto out;
+ }
+
+ return TRUE;
+
+ out:
+ silc_client_list_free_servers(client, conn, i->servers);
+ silc_free(i);
+ return FALSE;
+}
+
+/* Resolve server by server ID */
+
+void silc_client_get_server_by_id_resolve(SilcClient client,
+ SilcClientConnection conn,
+ SilcServerID *server_id,
+ SilcGetServerCallback completion,
+ void *context)
+{
+ SilcClientGetServerInternal i;
+ SilcServerEntry server;
+ SilcBuffer idp;
+ SilcUInt16 cmd_ident;
+
+ if (!client || !conn || !server_id || !completion)
+ return;
+
+ SILC_LOG_DEBUG(("Resolve server by id %s",
+ silc_id_render(server_id, SILC_ID_SERVER)));
+
+ i = silc_calloc(1, sizeof(*i));
+ if (!i)
+ return;
+ i->completion = completion;
+ i->context = context;
+ i->servers = silc_dlist_init();
+ if (!i->servers) {
+ silc_free(i);
+ return;
+ }
+
+ /* Attach to resolving, if on going */
+ server = silc_client_get_server_by_id(client, conn, server_id);
+ if (server && server->internal.resolve_cmd_ident) {
+ SILC_LOG_DEBUG(("Attach to existing resolving"));
+ silc_client_unref_server(client, conn, server);
+ silc_client_command_pending(conn, SILC_COMMAND_NONE,
+ server->internal.resolve_cmd_ident,
+ silc_client_get_server_cb, i);
+ return;
+ }
+
+ /* Send the command */
+ idp = silc_id_payload_encode(server_id, SILC_ID_SERVER);
+ cmd_ident = silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
+ silc_client_get_server_cb, i, 1,
+ 5, silc_buffer_datalen(idp));
+ silc_buffer_free(idp);
+ if (!cmd_ident)
+ completion(client, conn, SILC_STATUS_ERR_RESOURCE_LIMIT, NULL, context);
+
+ if (server && cmd_ident)
+ server->internal.resolve_cmd_ident = cmd_ident;
+
+ silc_client_unref_server(client, conn, server);
+}
+
+/************************** Server Entry Routines ***************************/
+
/* Add new server entry */
SilcServerEntry silc_client_add_server(SilcClient client,
if (!server_entry || !server_id)
return NULL;
- server_entry->server_id = server_id;
+ server_entry->id = *server_id;
if (server_name)
server_entry->server_name = strdup(server_name);
if (server_info)
server_namec = silc_identifier_check(server_name, strlen(server_name),
SILC_STRING_UTF8, 256, NULL);
if (!server_namec) {
- silc_free(server_entry->server_id);
silc_free(server_entry->server_name);
silc_free(server_entry->server_info);
silc_free(server_entry);
}
}
+ silc_mutex_lock(conn->internal->lock);
+
/* Add server to cache */
if (!silc_idcache_add(conn->internal->server_cache, server_namec,
- server_entry->server_id, server_entry)) {
+ &server_entry->id, server_entry)) {
silc_free(server_namec);
- silc_free(server_entry->server_id);
silc_free(server_entry->server_name);
silc_free(server_entry->server_info);
silc_free(server_entry);
+ silc_mutex_unlock(conn->internal->lock);
return NULL;
}
+ silc_mutex_unlock(conn->internal->lock);
+
return server_entry;
}
/* Removes server from the cache by the server entry. */
SilcBool silc_client_del_server(SilcClient client, SilcClientConnection conn,
- SilcServerEntry server)
+ SilcServerEntry server)
{
SilcBool ret = silc_idcache_del_by_context(conn->internal->server_cache,
server, NULL);
silc_free(server->server_name);
silc_free(server->server_info);
- silc_free(server->server_id);
silc_free(server);
return ret;
}
return;
silc_idcache_add(conn->internal->server_cache, server_namec,
- server_entry->server_id, server_entry);
+ &server_entry->id, server_entry);
}
}
}
}
-/* Formats the nickname of the client specified by the `client_entry'.
- If the format is specified by the application this will format the
- nickname and replace the old nickname in the client entry. If the
- format string is not specified then this function has no effect. */
+/* Take reference of server entry */
-void silc_client_nickname_format(SilcClient client,
- SilcClientConnection conn,
- SilcClientEntry client_entry)
+void silc_client_ref_server(SilcClient client, SilcClientConnection conn,
+ SilcServerEntry server_entry)
{
- char *cp;
- char newnick[128 + 1];
- int i, off = 0, len;
- SilcBool freebase;
- SilcDList clients;
- SilcClientEntry entry, unformatted = NULL;
-
- SILC_LOG_DEBUG(("Start"));
-
- if (!client->internal->params->nickname_format[0])
- return;
-
- if (!client_entry->nickname)
- return;
-
- /* Get all clients with same nickname. Do not perform the formatting
- if there aren't any clients with same nickname unless the application
- is forcing us to do so. */
- clients = silc_client_get_clients_local(client, conn,
- client_entry->nickname, NULL);
- if (!clients && !client->internal->params->nickname_force_format)
- return;
-
- len = 0;
- freebase = TRUE;
- while ((entry = silc_dlist_get(clients))) {
- if (entry->internal.valid && entry != client_entry)
- len++;
- if (entry->internal.valid && entry != client_entry &&
- silc_utf8_strcasecmp(entry->nickname, client_entry->nickname)) {
- freebase = FALSE;
- unformatted = entry;
- }
- }
- if (!len || freebase)
- return;
-
- /* If we are changing nickname of our local entry we'll enforce
- that we will always get the unformatted nickname. Give our
- format number to the one that is not formatted now. */
- if (unformatted && client_entry == conn->local_entry)
- client_entry = unformatted;
+ silc_atomic_add_int8(&server_entry->internal.refcnt, 1);
+}
- memset(newnick, 0, sizeof(newnick));
- cp = client->internal->params->nickname_format;
- while (*cp) {
- if (*cp == '%') {
- cp++;
- continue;
- }
+/* Release reference of server entry */
- switch(*cp) {
- case 'n':
- /* Nickname */
- if (!client_entry->nickname[0])
- break;
- len = strlen(client_entry->nickname);
- memcpy(&newnick[off], client_entry->nickname, len);
- off += len;
- break;
- case 'h':
- /* Stripped hostname */
- if (!client_entry->hostname[0])
- break;
- len = strcspn(client_entry->hostname, ".");
- i = strcspn(client_entry->hostname, "-");
- if (i < len)
- len = i;
- memcpy(&newnick[off], client_entry->hostname, len);
- off += len;
- break;
- case 'H':
- /* Full hostname */
- if (!client_entry->hostname[0])
- break;
- len = strlen(client_entry->hostname);
- memcpy(&newnick[off], client_entry->hostname, len);
- off += len;
- break;
- case 's':
- /* Stripped server name */
- if (!client_entry->server)
- break;
- len = strcspn(client_entry->server, ".");
- memcpy(&newnick[off], client_entry->server, len);
- off += len;
- break;
- case 'S':
- /* Full server name */
- if (!client_entry->server)
- break;
- len = strlen(client_entry->server);
- memcpy(&newnick[off], client_entry->server, len);
- off += len;
- break;
- case 'a':
- /* Ascending number */
- {
- char tmp[6];
- int num, max = 1;
+void silc_client_unref_server(SilcClient client, SilcClientConnection conn,
+ SilcServerEntry server_entry)
+{
+ if (server_entry &&
+ silc_atomic_sub_int8(&server_entry->internal.refcnt, 1) == 0)
+ silc_client_del_server(client, conn, server_entry);
+}
- if (silc_dlist_count(clients) == 1)
- break;
+/* Free server entry list */
- silc_dlist_start(clients);
- while ((entry = silc_dlist_get(clients))) {
- if (!silc_utf8_strncasecmp(entry->nickname, newnick, off))
- continue;
- if (strlen(entry->nickname) <= off)
- continue;
- num = atoi(&entry->nickname[off]);
- if (num > max)
- max = num;
- }
+void silc_client_list_free_servers(SilcClient client,
+ SilcClientConnection conn,
+ SilcDList server_list)
+{
+ SilcServerEntry server_entry;
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "%d", ++max);
- len = strlen(tmp);
- memcpy(&newnick[off], tmp, len);
- off += len;
- }
- break;
- default:
- /* Some other character in the string */
- memcpy(&newnick[off], cp, 1);
- off++;
- break;
- }
+ if (server_list) {
+ silc_dlist_start(server_list);
+ while ((server_entry = silc_dlist_get(server_list)))
+ silc_client_unref_server(client, conn, server_entry);
- cp++;
+ silc_dlist_uninit(server_list);
}
-
- newnick[off] = 0;
- memcpy(client_entry->nickname, newnick, strlen(newnick));
- silc_dlist_uninit(clients);
}
projects / silc.git / blobdiff