Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2001 Pekka Riikonen
+ Copyright (C) 2001 - 2002 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
/* $Id$ */
#include "clientlibincludes.h"
+#include "client_internal.h"
+
+/******************************************************************************
+
+ Client Searching Locally
+
+******************************************************************************/
+
+/* Same as silc_client_get_clients function but does not resolve anything
+ from the server. This checks local cache and returns all matching
+ clients from the local cache. If none was found this returns NULL.
+ The `nickname' is the real nickname of the client, and the `format'
+ is the formatted nickname to find exact match from multiple found
+ entries. The format must be same as given in the SilcClientParams
+ structure to the client library. If the `format' is NULL all found
+ clients by `nickname' are returned. */
+
+SilcClientEntry *silc_client_get_clients_local(SilcClient client,
+ SilcClientConnection conn,
+ const char *nickname,
+ const char *format,
+ uint32 *clients_count)
+{
+ SilcIDCacheEntry id_cache;
+ SilcIDCacheList list = NULL;
+ SilcClientEntry entry, *clients;
+ int i = 0;
+ bool found = FALSE;
+
+ /* Find ID from cache */
+ if (!silc_idcache_find_by_name(conn->client_cache, (char *)nickname, &list))
+ return NULL;
+
+ if (!silc_idcache_list_count(list)) {
+ silc_idcache_list_free(list);
+ return NULL;
+ }
+
+ clients = silc_calloc(silc_idcache_list_count(list), sizeof(*clients));
+ *clients_count = silc_idcache_list_count(list);
+
+ if (!format) {
+ /* Take all without any further checking */
+ silc_idcache_list_first(list, &id_cache);
+ while (id_cache) {
+ clients[i++] = id_cache->context;
+ found = TRUE;
+ if (!silc_idcache_list_next(list, &id_cache))
+ break;
+ }
+ } else {
+ /* Check multiple cache entries for match */
+ silc_idcache_list_first(list, &id_cache);
+ while (id_cache) {
+ entry = (SilcClientEntry)id_cache->context;
+ if (strcasecmp(entry->nickname, format)) {
+ if (!silc_idcache_list_next(list, &id_cache)) {
+ break;
+ } else {
+ continue;
+ }
+ }
+
+ clients[i++] = id_cache->context;
+ found = TRUE;
+ if (!silc_idcache_list_next(list, &id_cache))
+ break;
+ }
+ }
+
+ if (list)
+ silc_idcache_list_free(list);
+
+ if (!found) {
+ *clients_count = 0;
+ if (clients)
+ silc_free(clients);
+ return NULL;
+ }
+
+ return clients;
+}
+
+
+/******************************************************************************
+
+ Client Resolving from Server
+
+******************************************************************************/
typedef struct {
- SilcClientCommandContext cmd;
+ SilcClient client;
+ SilcClientConnection conn;
SilcGetClientCallback completion;
+ void *context;
char *nickname;
char *server;
- void *context;
- int found;
} *GetClientInternal;
SILC_CLIENT_CMD_FUNC(get_client_callback)
uint32 clients_count;
/* Get the clients */
- clients = silc_client_get_clients_local(i->cmd->client, i->cmd->conn,
+ clients = silc_client_get_clients_local(i->client, i->conn,
i->nickname, i->server,
&clients_count);
if (clients) {
- i->completion(i->cmd->client, i->cmd->conn, clients,
- clients_count, i->context);
- i->found = TRUE;
+ i->completion(i->client, i->conn, clients, clients_count, i->context);
silc_free(clients);
+ } else {
+ i->completion(i->client, i->conn, NULL, 0, i->context);
}
-}
-static void silc_client_get_client_destructor(void *context)
-{
- GetClientInternal i = (GetClientInternal)context;
-
- if (i->found == FALSE)
- i->completion(i->cmd->client, i->cmd->conn, NULL, 0, i->context);
-
- silc_client_command_free(i->cmd);
- if (i->nickname)
- silc_free(i->nickname);
- if (i->server)
- silc_free(i->server);
+ silc_free(i->nickname);
+ silc_free(i->server);
silc_free(i);
}
SilcGetClientCallback completion,
void *context)
{
- char ident[512];
- SilcClientCommandContext ctx;
- GetClientInternal i = silc_calloc(1, sizeof(*i));
-
- /* No ID found. Do query from the server. The query is done by
- sending simple IDENTIFY command to the server. */
- ctx = silc_client_command_alloc();
- ctx->client = client;
- ctx->conn = conn;
- ctx->command = silc_client_command_find("IDENTIFY");
- memset(ident, 0, sizeof(ident));
- snprintf(ident, sizeof(ident), "IDENTIFY %s", nickname);
- silc_parse_command_line(ident, &ctx->argv, &ctx->argv_lens,
- &ctx->argv_types, &ctx->argc, 2);
-
- i->cmd = silc_client_command_dup(ctx);
- i->nickname = nickname ? strdup(nickname) : NULL;
+ GetClientInternal i;
+ char *userhost;
+
+ if (!nickname)
+ return;
+
+ i = silc_calloc(1, sizeof(*i));
+ i->client = client;
+ i->conn = conn;
+ i->nickname = strdup(nickname);
i->server = server ? strdup(server) : NULL;
i->completion = completion;
i->context = context;
- /* Call the command */
- ctx->command->cb(ctx, NULL);
+ if (nickname && server) {
+ userhost = silc_calloc(strlen(nickname) + strlen(server) + 2,
+ sizeof(*userhost));
+ strncat(userhost, nickname, strlen(nickname));
+ strncat(userhost, "@", 1);
+ strncat(userhost, server, strlen(server));
+ } else {
+ userhost = strdup(nickname);
+ }
+
+ /* 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);
+
+ /* Send the command */
+ silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident, 1, 1, userhost,
+ strlen(userhost));
/* Add pending callback */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_get_client_destructor,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
silc_client_command_get_client_callback,
(void *)i);
+
+ silc_free(userhost);
}
-/* Same as silc_client_get_clients function but does not resolve anything
- from the server. This checks local cache and returns all matching
- clients from the local cache. If none was found this returns NULL.
- The `nickname' is the real nickname of the client, and the `format'
- is the formatted nickname to find exact match from multiple found
- entries. The format must be same as given in the SilcClientParams
- structure to the client library. If the `format' is NULL all found
- clients by `nickname' are returned. */
+/* The old style function to find client entry. This is used by the
+ library internally. If `query' is TRUE then the client information is
+ requested by the server. The pending command callback must be set
+ by the caller. */
+/* XXX This function should be removed */
-SilcClientEntry *silc_client_get_clients_local(SilcClient client,
- SilcClientConnection conn,
- const char *nickname,
- const char *format,
- uint32 *clients_count)
+SilcClientEntry silc_idlist_get_client(SilcClient client,
+ SilcClientConnection conn,
+ const char *nickname,
+ const char *format,
+ bool query)
{
SilcIDCacheEntry id_cache;
SilcIDCacheList list = NULL;
- SilcClientEntry entry, *clients;
- int i = 0;
- bool found = FALSE;
+ SilcClientEntry entry = NULL;
+
+ SILC_LOG_DEBUG(("Start"));
/* Find ID from cache */
- if (!silc_idcache_find_by_name(conn->client_cache, (char *)nickname, &list))
- return NULL;
+ if (!silc_idcache_find_by_name(conn->client_cache, (char *)nickname,
+ &list)) {
+ identify:
- if (!silc_idcache_list_count(list)) {
- silc_idcache_list_free(list);
+ if (query) {
+ SILC_LOG_DEBUG(("Requesting Client ID from server"));
+
+ /* 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);
+
+ /* Send the command */
+ silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident, 1, 1, nickname,
+ strlen(nickname));
+
+ if (list)
+ silc_idcache_list_free(list);
+
+ return NULL;
+ }
return NULL;
}
- clients = silc_calloc(silc_idcache_list_count(list), sizeof(*clients));
- *clients_count = silc_idcache_list_count(list);
-
if (!format) {
- /* Take all without any further checking */
- silc_idcache_list_first(list, &id_cache);
- while (id_cache) {
- clients[i++] = id_cache->context;
- found = TRUE;
- if (!silc_idcache_list_next(list, &id_cache))
- break;
- }
+ /* Take first found cache entry */
+ if (!silc_idcache_list_first(list, &id_cache))
+ goto identify;
+
+ entry = (SilcClientEntry)id_cache->context;
} else {
/* Check multiple cache entries for match */
silc_idcache_list_first(list, &id_cache);
while (id_cache) {
entry = (SilcClientEntry)id_cache->context;
+
if (strcasecmp(entry->nickname, format)) {
if (!silc_idcache_list_next(list, &id_cache)) {
+ entry = NULL;
break;
} else {
+ entry = NULL;
continue;
}
}
-
- clients[i++] = id_cache->context;
- found = TRUE;
- if (!silc_idcache_list_next(list, &id_cache))
- break;
+
+ break;
}
+
+ /* If match weren't found, request it */
+ if (!entry)
+ goto identify;
}
if (list)
silc_idcache_list_free(list);
- if (!found) {
- *clients_count = 0;
- if (clients)
- silc_free(clients);
- return NULL;
- }
-
- return clients;
+ return entry;
}
+
typedef struct {
SilcClient client;
SilcClientConnection conn;
SilcBuffer client_id_list;
SilcGetClientCallback completion;
void *context;
- int found;
} *GetClientsByListInternal;
SILC_CLIENT_CMD_FUNC(get_clients_list_callback)
SilcBuffer client_id_list = i->client_id_list;
SilcClientEntry *clients = NULL;
uint32 clients_count = 0;
+ bool found = FALSE;
int c;
+ SILC_LOG_DEBUG(("Start"));
+
for (c = 0; c < i->list_count; c++) {
uint16 idp_len;
SilcClientID *client_id;
SILC_GET16_MSB(idp_len, client_id_list->data + 2);
idp_len += 4;
client_id = silc_id_payload_parse_id(client_id_list->data, idp_len);
- if (!client_id)
+ if (!client_id) {
+ silc_buffer_pull(client_id_list, idp_len);
continue;
+ }
/* Get the client entry */
if (silc_idcache_find_by_id_one_ext(i->conn->client_cache,
(clients_count + 1));
clients[clients_count] = (SilcClientEntry)id_cache->context;
clients_count++;
- i->found = TRUE;
+ found = TRUE;
}
silc_free(client_id);
silc_buffer_pull(client_id_list, idp_len);
}
- if (i->found) {
+ if (found) {
i->completion(i->client, i->conn, clients, clients_count, i->context);
silc_free(clients);
- }
-}
-
-static void silc_client_get_clients_list_destructor(void *context)
-{
- GetClientsByListInternal i = (GetClientsByListInternal)context;
-
- if (i->found == FALSE)
+ } else {
i->completion(i->client, i->conn, NULL, 0, i->context);
+ }
if (i->client_id_list)
silc_buffer_free(i->client_id_list);
uint32 *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
GetClientsByListInternal in;
+ SILC_LOG_DEBUG(("Start"));
+
in = silc_calloc(1, sizeof(*in));
in->client = client;
in->conn = conn;
SILC_GET16_MSB(idp_len, client_id_list->data + 2);
idp_len += 4;
client_id = silc_id_payload_parse_id(client_id_list->data, idp_len);
- if (!client_id)
+ if (!client_id) {
+ silc_buffer_pull(client_id_list, idp_len);
continue;
+ }
/* Check if we have this client cached already. */
id_cache = NULL;
it from the server. */
entry = id_cache ? (SilcClientEntry)id_cache->context : NULL;
if (!id_cache || !entry->nickname) {
+
+ if (entry) {
+ if (entry->status & SILC_CLIENT_STATUS_RESOLVING) {
+ entry->status &= ~SILC_CLIENT_STATUS_RESOLVING;
+ silc_free(client_id);
+ silc_buffer_pull(client_id_list, idp_len);
+ continue;
+ }
+
+ entry->status |= SILC_CLIENT_STATUS_RESOLVING;
+ }
+
/* No we don't have it, query it from the server. Assemble argument
table that will be sent fr the IDENTIFY command later. */
res_argv = silc_realloc(res_argv, sizeof(*res_argv) *
NULL, 0, NULL, NULL, res_cmd->data, res_cmd->len,
TRUE);
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_get_clients_list_destructor,
+ /* 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);
+
+ /* Process the applications request after reply has been received */
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
silc_client_command_get_clients_list_callback,
(void *)in);
silc_client_command_get_clients_list_callback((void *)in, NULL);
}
-/* The old style function to find client entry. This is used by the
- library internally. If `query' is TRUE then the client information is
- requested by the server. The pending command callback must be set
- by the caller. */
-
-SilcClientEntry silc_idlist_get_client(SilcClient client,
- SilcClientConnection conn,
- const char *nickname,
- const char *format,
- bool query)
-{
- SilcIDCacheEntry id_cache;
- SilcIDCacheList list = NULL;
- SilcClientEntry entry = NULL;
-
- /* Find ID from cache */
- if (!silc_idcache_find_by_name(conn->client_cache, (char *)nickname,
- &list)) {
- identify:
-
- if (query) {
- char ident[512];
- SilcClientCommandContext ctx;
-
- SILC_LOG_DEBUG(("Requesting Client ID from server"));
-
- /* No ID found. Do query from the server. The query is done by
- sending simple IDENTIFY command to the server. */
- ctx = silc_client_command_alloc();
- ctx->client = client;
- ctx->conn = conn;
- ctx->command = silc_client_command_find("IDENTIFY");
- memset(ident, 0, sizeof(ident));
- snprintf(ident, sizeof(ident), "IDENTIFY %s", nickname);
- silc_parse_command_line(ident, &ctx->argv, &ctx->argv_lens,
- &ctx->argv_types, &ctx->argc, 2);
- ctx->command->cb(ctx, NULL);
-
- if (list)
- silc_idcache_list_free(list);
-
- return NULL;
- }
- return NULL;
- }
-
- if (!format) {
- /* Take first found cache entry */
- if (!silc_idcache_list_first(list, &id_cache))
- goto identify;
-
- entry = (SilcClientEntry)id_cache->context;
- } else {
- /* Check multiple cache entries for match */
- silc_idcache_list_first(list, &id_cache);
- while (id_cache) {
- entry = (SilcClientEntry)id_cache->context;
-
- if (strcasecmp(entry->nickname, format)) {
- if (!silc_idcache_list_next(list, &id_cache)) {
- entry = NULL;
- break;
- } else {
- entry = NULL;
- continue;
- }
- }
-
- break;
- }
-
- /* If match weren't found, request it */
- if (!entry)
- goto identify;
- }
-
- if (list)
- silc_idcache_list_free(list);
-
- return entry;
-}
-
/* Finds entry for client by the client's ID. Returns the entry or NULL
if the entry was not found. */
SilcClientID *client_id;
SilcGetClientCallback completion;
void *context;
- int found;
} *GetClientByIDInternal;
SILC_CLIENT_CMD_FUNC(get_client_by_id_callback)
SilcClientEntry entry;
/* Get the client */
- entry = silc_client_get_client_by_id(i->client, i->conn,
- i->client_id);
- if (entry) {
+ entry = silc_client_get_client_by_id(i->client, i->conn, i->client_id);
+ if (entry)
i->completion(i->client, i->conn, &entry, 1, i->context);
- i->found = TRUE;
- }
-}
-
-static void silc_client_get_client_by_id_destructor(void *context)
-{
- GetClientByIDInternal i = (GetClientByIDInternal)context;
-
- if (i->found == FALSE)
+ else
i->completion(i->client, i->conn, NULL, 0, i->context);
- if (i->client_id)
- silc_free(i->client_id);
+ silc_free(i->client_id);
silc_free(i);
}
SilcBuffer idp;
GetClientByIDInternal i = silc_calloc(1, sizeof(*i));
- idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
- silc_client_send_command(client, conn, SILC_COMMAND_WHOIS,
- ++conn->cmd_ident,
- 1, 3, idp->data, idp->len);
- silc_buffer_free(idp);
+ SILC_LOG_DEBUG(("Start"));
i->client = client;
i->conn = conn;
i->completion = completion;
i->context = context;
+ /* Register our own command reply for this command */
+ silc_client_command_register(client, SILC_COMMAND_WHOIS, NULL, NULL,
+ silc_client_command_reply_whois_i, 0,
+ ++conn->cmd_ident);
+
+ /* Send the command */
+ idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
+ silc_client_command_send(client, conn, SILC_COMMAND_WHOIS, conn->cmd_ident,
+ 1, 3, idp->data, idp->len);
+ silc_buffer_free(idp);
+
/* Add pending callback */
- silc_client_command_pending(conn, SILC_COMMAND_WHOIS,
- conn->cmd_ident,
- silc_client_get_client_by_id_destructor,
+ silc_client_command_pending(conn, SILC_COMMAND_WHOIS, conn->cmd_ident,
silc_client_command_get_client_by_id_callback,
(void *)i);
}
+
+/******************************************************************************
+
+ Client, Channel and Server entry manipulation
+
+******************************************************************************/
+
+
/* Creates new client entry and adds it to the ID cache. Returns pointer
to the new entry. */
SilcClientEntry client_entry;
char *nick = NULL;
+ SILC_LOG_DEBUG(("Start"));
+
/* Save the client infos */
client_entry = silc_calloc(1, sizeof(*client_entry));
client_entry->id = id;
+ client_entry->valid = TRUE;
silc_parse_userfqdn(nickname, &nick, &client_entry->server);
silc_parse_userfqdn(username, &client_entry->username,
&client_entry->hostname);
/* Add client to cache, the non-formatted nickname is saved to cache */
if (!silc_idcache_add(conn->client_cache, nick, client_entry->id,
- (void *)client_entry, FALSE)) {
+ (void *)client_entry, 0, NULL)) {
silc_free(client_entry->nickname);
silc_free(client_entry->username);
silc_free(client_entry->hostname);
{
char *nick = NULL;
+ SILC_LOG_DEBUG(("Start"));
+
if (!client_entry->username && username)
silc_parse_userfqdn(username, &client_entry->username,
&client_entry->hostname);
/* Remove the old cache entry and create a new one */
silc_idcache_del_by_context(conn->client_cache, client_entry);
silc_idcache_add(conn->client_cache, nick, client_entry->id,
- client_entry, FALSE);
+ client_entry, 0, NULL);
}
}
/* Deletes the client entry and frees all memory. */
void silc_client_del_client_entry(SilcClient client,
+ SilcClientConnection conn,
SilcClientEntry client_entry)
{
+ SILC_LOG_DEBUG(("Start"));
+
silc_free(client_entry->nickname);
silc_free(client_entry->username);
silc_free(client_entry->realname);
+ silc_free(client_entry->hostname);
silc_free(client_entry->server);
silc_free(client_entry->id);
+ silc_free(client_entry->fingerprint);
if (client_entry->send_key)
silc_cipher_free(client_entry->send_key);
if (client_entry->receive_key)
silc_cipher_free(client_entry->receive_key);
silc_free(client_entry->key);
+ silc_client_ftp_session_free_client(conn, client_entry);
+ if (client_entry->ke)
+ silc_client_abort_key_agreement(client, conn, client_entry);
silc_free(client_entry);
}
SilcClientEntry client_entry)
{
bool ret = silc_idcache_del_by_context(conn->client_cache, client_entry);
- silc_client_del_client_entry(client, client_entry);
+
+ /* 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);
+
return ret;
}
silc_cipher_free(channel->channel_key);
if (channel->hmac)
silc_hmac_free(channel->hmac);
+ if (channel->old_channel_key)
+ silc_cipher_free(channel->old_channel_key);
+ if (channel->old_hmac)
+ silc_hmac_free(channel->old_hmac);
+ if (channel->rekey_task)
+ silc_schedule_task_del(conn->client->schedule, channel->rekey_task);
silc_client_del_channel_private_keys(client, conn, channel);
silc_free(channel);
return ret;
SilcIDCacheEntry id_cache;
SilcChannelEntry entry;
+ SILC_LOG_DEBUG(("Start"));
+
if (!silc_idcache_find_by_name_one(conn->channel_cache, channel,
&id_cache))
return NULL;
entry = (SilcChannelEntry)id_cache->context;
+ SILC_LOG_DEBUG(("Found"));
+
return entry;
}
SilcIDCacheEntry id_cache;
SilcChannelEntry entry;
+ SILC_LOG_DEBUG(("Start"));
+
if (!silc_idcache_find_by_id_one(conn->channel_cache, channel_id,
&id_cache))
return NULL;
entry = (SilcChannelEntry)id_cache->context;
+ SILC_LOG_DEBUG(("Found"));
+
return entry;
}
SilcChannelID *channel_id;
SilcGetChannelCallback completion;
void *context;
- int found;
} *GetChannelByIDInternal;
SILC_CLIENT_CMD_FUNC(get_channel_by_id_callback)
GetChannelByIDInternal i = (GetChannelByIDInternal)context;
SilcChannelEntry entry;
+ SILC_LOG_DEBUG(("Start"));
+
/* Get the channel */
- entry = silc_client_get_channel_by_id(i->client, i->conn,
- i->channel_id);
+ entry = silc_client_get_channel_by_id(i->client, i->conn, i->channel_id);
if (entry) {
i->completion(i->client, i->conn, &entry, 1, i->context);
- i->found = TRUE;
- }
-}
-
-static void silc_client_get_channel_by_id_destructor(void *context)
-{
- GetChannelByIDInternal i = (GetChannelByIDInternal)context;
-
- if (i->found == FALSE)
+ } else {
i->completion(i->client, i->conn, NULL, 0, i->context);
+ }
silc_free(i->channel_id);
silc_free(i);
SilcBuffer idp;
GetChannelByIDInternal i = silc_calloc(1, sizeof(*i));
- idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
- silc_client_send_command(client, conn, SILC_COMMAND_IDENTIFY,
- ++conn->cmd_ident,
- 1, 5, idp->data, idp->len);
- silc_buffer_free(idp);
+ SILC_LOG_DEBUG(("Start"));
i->client = client;
i->conn = conn;
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);
+
+ /* 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);
+
/* Add pending callback */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_get_channel_by_id_destructor,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
silc_client_command_get_channel_by_id_callback,
(void *)i);
}
SilcBuffer idp;
SilcChannelEntry channel;
+ SILC_LOG_DEBUG(("Start"));
+
channel = silc_client_get_channel_by_id(client, conn, channel_id);
if (channel)
return channel;
if (query) {
+ /* 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);
+
+ /* Send the command */
idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
- silc_client_send_command(client, conn, SILC_COMMAND_IDENTIFY,
- ++conn->cmd_ident,
+ silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident,
1, 5, idp->data, idp->len);
silc_buffer_free(idp);
}
SilcIDCacheEntry id_cache;
SilcServerEntry entry;
+ SILC_LOG_DEBUG(("Start"));
+
if (!silc_idcache_find_by_name_one(conn->server_cache, server_name,
&id_cache))
return NULL;
SilcIDCacheEntry id_cache;
SilcServerEntry entry;
+ SILC_LOG_DEBUG(("Start"));
+
if (!silc_idcache_find_by_id_one(conn->server_cache, (void *)server_id,
&id_cache))
return NULL;
char *newnick = NULL;
int i, off = 0, len;
SilcClientEntry *clients;
- uint32 clients_count;
+ uint32 clients_count = 0;
+ SilcClientEntry unformatted = NULL;
+
+ SILC_LOG_DEBUG(("Start"));
- if (!client->params->nickname_format[0])
+ if (!client->internal->params->nickname_format[0])
return;
if (!client_entry->nickname)
clients = silc_client_get_clients_local(client, conn,
client_entry->nickname, NULL,
&clients_count);
- if (!clients && !client->params->nickname_force_format)
+ if (!clients && !client->internal->params->nickname_force_format)
return;
- cp = client->params->nickname_format;
+ len = 0;
+ for (i = 0; i < clients_count; i++)
+ if (clients[i]->valid && clients[i] != client_entry)
+ len++;
+ if (!len)
+ return;
+
+ cp = client->internal->params->nickname_format;
while (*cp) {
if (*cp == '%') {
cp++;
char tmp[6];
int num, max = 1;
- if (clients_count == 1)
+ if (clients_count == 1) {
+ unformatted = clients[0];
break;
+ }
for (i = 0; i < clients_count; i++) {
- if (strncmp(clients[i]->nickname, newnick, off))
+ if (!strncasecmp(clients[i]->nickname, client_entry->nickname,
+ strlen(clients[i]->nickname)))
+ unformatted = clients[i];
+ if (strncasecmp(clients[i]->nickname, newnick, off))
continue;
if (strlen(clients[i]->nickname) <= off)
continue;
if (num > max)
max = num;
}
-
+
memset(tmp, 0, sizeof(tmp));
snprintf(tmp, sizeof(tmp) - 1, "%d", ++max);
len = strlen(tmp);
newnick = silc_realloc(newnick, sizeof(*newnick) * (off + 1));
newnick[off] = 0;
+ /* 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_free(client_entry->nickname);
client_entry->nickname = newnick;
silc_free(clients);