/* Finds clients by nickname from local cache. */
-SilcDList silc_client_get_clients_local(SilcClient client,
- SilcClientConnection conn,
- const char *nickname,
- const char *format)
+SilcDList silc_client_get_clients_local_ext(SilcClient client,
+ SilcClientConnection conn,
+ const char *nickname,
+ SilcBool get_all,
+ SilcBool get_valid)
{
SilcIDCacheEntry id_cache;
SilcList list;
SilcDList clients;
SilcClientEntry entry;
- char *nicknamec;
+ char *nicknamec, *parsed = NULL, *format = NULL;
if (!client || !conn || !nickname)
return NULL;
- SILC_LOG_DEBUG(("Find clients by nickname %s", nickname));
+ /* Parse nickname in case it is formatted */
+ if (!silc_client_nickname_parse(client, conn, (char *)nickname, &parsed))
+ return NULL;
+
+ if (!get_all && parsed)
+ format = (char *)nickname;
+ if (!parsed) {
+ parsed = silc_memdup(nickname, strlen(nickname));
+ if (!parsed)
+ return NULL;
+ }
+
+ SILC_LOG_DEBUG(("Find clients by nickname %s", parsed));
/* Normalize nickname for search */
- nicknamec = silc_identifier_check(nickname, strlen(nickname),
+ nicknamec = silc_identifier_check(parsed, strlen(parsed),
SILC_STRING_UTF8, 128, NULL);
- if (!nicknamec)
+ if (!nicknamec) {
+ silc_free(parsed);
return NULL;
+ }
clients = silc_dlist_init();
if (!clients) {
silc_free(nicknamec);
+ silc_free(parsed);
return NULL;
}
&list)) {
silc_mutex_unlock(conn->internal->lock);
silc_free(nicknamec);
+ silc_free(parsed);
silc_dlist_uninit(clients);
return NULL;
}
+ silc_list_start(list);
- if (!format) {
+ if (!format && get_all) {
/* Take all without any further checking */
- silc_list_start(list);
while ((id_cache = silc_list_get(list))) {
- silc_client_ref_client(client, conn, id_cache->context);
- silc_dlist_add(clients, id_cache->context);
+ entry = id_cache->context;
+ if (!get_valid || entry->internal.valid) {
+ silc_client_ref_client(client, conn, id_cache->context);
+ silc_dlist_add(clients, id_cache->context);
+ }
}
} else {
/* Check multiple cache entries for exact match */
- silc_list_start(list);
while ((id_cache = silc_list_get(list))) {
entry = id_cache->context;
- if (silc_utf8_strcasecmp(entry->nickname, format)) {
+ if (silc_utf8_strcasecmp(entry->nickname,
+ format ? format : parsed) &&
+ (!get_valid || entry->internal.valid)) {
silc_client_ref_client(client, conn, entry);
silc_dlist_add(clients, entry);
+
+ /* If format is NULL, we find one exact match with the base
+ nickname (parsed). */
+ if (!format)
+ break;
}
}
}
silc_mutex_unlock(conn->internal->lock);
- silc_dlist_start(clients);
-
silc_free(nicknamec);
+ silc_free(parsed);
+
+ if (!silc_dlist_count(clients)) {
+ silc_dlist_uninit(clients);
+ return NULL;
+ }
+
+ SILC_LOG_DEBUG(("Found %d clients", silc_dlist_count(clients)));
+
+ silc_dlist_start(clients);
return clients;
}
+/* Finds clients by nickname from local cache. */
+
+SilcDList silc_client_get_clients_local(SilcClient client,
+ SilcClientConnection conn,
+ const char *nickname,
+ SilcBool return_all)
+{
+ return silc_client_get_clients_local_ext(client, conn, nickname, return_all,
+ TRUE);
+}
+
/********************** Client Resolving from Server ************************/
/* Resolving context */
SilcDList clients;
SilcGetClientCallback completion;
void *context;
+ SilcClientEntry client_entry;
} *SilcClientGetClientInternal;
/* Resolving command callback */
if (error != SILC_STATUS_OK) {
SILC_LOG_DEBUG(("Resolving failed: %s", silc_get_status_message(error)));
+
+ if (i->client_entry) {
+ i->client_entry->internal.resolve_cmd_ident = 0;
+ silc_client_unref_client(client, conn, i->client_entry);
+ }
+
if (i->completion)
i->completion(client, conn, error, NULL, i->context);
goto out;
/* Deliver the clients to the caller */
if (i->completion) {
SILC_LOG_DEBUG(("Resolved %d clients", silc_dlist_count(i->clients)));
+
+ if (i->client_entry) {
+ i->client_entry->internal.resolve_cmd_ident = 0;
+ silc_client_unref_client(client, conn, i->client_entry);
+ }
+
silc_dlist_start(i->clients);
i->completion(client, conn, SILC_STATUS_OK, i->clients, i->context);
}
if (!cmd_ident && completion)
completion(client, conn, SILC_STATUS_ERR_RESOURCE_LIMIT, NULL, context);
- if (client_entry && cmd_ident)
+ if (client_entry && cmd_ident) {
client_entry->internal.resolve_cmd_ident = cmd_ident;
+ i->client_entry = client_entry;
+ } else {
+ silc_client_unref_client(client, conn, client_entry);
+ }
- silc_client_unref_client(client, conn, client_entry);
silc_buffer_free(idp);
return cmd_ident;
void *context)
{
SilcClientGetClientInternal i;
- char userhost[768 + 1];
+ char nick[128 + 1], serv[256 + 1], userhost[768 + 1], *parsed = NULL;
int len;
SILC_LOG_DEBUG(("Resolve client by %s command",
if (!nickname && !attributes)
return 0;
+ /* Parse server name from the nickname if set */
+ if (silc_parse_userfqdn(nickname, nick, sizeof(nick),
+ serv, sizeof(serv) == 2))
+ server = (const char *)serv;
+ nickname = (const char *)nick;
+
+ /* Parse nickname in case it is formatted */
+ if (silc_client_nickname_parse(client, conn, (char *)nickname, &parsed))
+ nickname = (const char *)parsed;
+
i = silc_calloc(1, sizeof(*i));
- if (!i)
+ if (!i) {
+ silc_free(parsed);
return 0;
+ }
i->clients = silc_dlist_init();
if (!i->clients) {
+ silc_free(parsed);
silc_free(i);
return 0;
}
} else if (nickname) {
silc_strncat(userhost, sizeof(userhost) - 1, nickname, strlen(nickname));
}
+ silc_free(parsed);
/* Send the command */
if (command == SILC_COMMAND_IDENTIFY)
silc_rwlock_alloc(&client_entry->internal.lock);
silc_atomic_init8(&client_entry->internal.refcnt, 0);
client_entry->id = *id;
- client_entry->internal.valid = TRUE;
client_entry->mode = mode;
client_entry->realname = userinfo ? strdup(userinfo) : NULL;
silc_parse_userfqdn(nickname, client_entry->nickname,
/* Format the nickname */
silc_client_nickname_format(client, conn, client_entry, FALSE);
+ if (client_entry->nickname[0])
+ client_entry->internal.valid = TRUE;
+
SILC_LOG_DEBUG(("Added %p", client_entry));
return client_entry;
client_entry, NULL, nick, TRUE);
silc_mutex_unlock(conn->internal->lock);
client_entry->nickname_normalized = nick;
+ client_entry->internal.valid = TRUE;
}
client_entry->mode = mode;
0, NULL);
}
+ client_entry->internal.valid = TRUE;
return TRUE;
}
silc_hmac_free(client_entry->internal.hmac_send);
if (client_entry->internal.hmac_receive)
silc_hmac_free(client_entry->internal.hmac_receive);
-#if 0
- silc_client_ftp_session_free_client(conn, client_entry);
- if (client_entry->internal->ke)
+ silc_client_ftp_session_free_client(client, client_entry);
+ if (client_entry->internal.ke)
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;
}
+/* Internal routine used to find client by ID and if not found this creates
+ new client entry and returns it. */
+
+SilcClientEntry silc_client_get_client(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientID *client_id)
+{
+ SilcClientEntry client_entry;
+
+ client_entry = silc_client_get_client_by_id(client, conn, client_id);
+ if (!client_entry) {
+ client_entry = silc_client_add_client(client, conn, NULL, NULL, NULL,
+ client_id, 0);
+ if (!client_entry)
+ return NULL;
+ silc_client_ref_client(client, conn, client_entry);
+ }
+
+ return client_entry;
+}
+
/* Lock client */
void silc_client_lock_client(SilcClientEntry client_entry)
SilcDList clients;
SilcClientEntry entry, unformatted = NULL;
- SILC_LOG_DEBUG(("Format nickname"));
-
if (!client->internal->params->nickname_format[0])
return client_entry;
if (!client_entry->nickname[0])
return NULL;
+ SILC_LOG_DEBUG(("Format nickname"));
+
/* 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);
+ clients = silc_client_get_clients_local_ext(client, conn,
+ client_entry->nickname,
+ TRUE, FALSE);
if (!clients)
return NULL;
if (silc_dlist_count(clients) == 1 &&
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 */
{
SilcBool n = FALSE;
int len;
- if (!client->internal->params->nickname_format[0])
+ if (!client->internal->params->nickname_format[0]) {
+ *ret_nick = NULL;
return TRUE;
+ }
if (!nickname || !nickname[0])
return FALSE;
case 'h':
case 'H':
- case 's':
- case 'S':
case 'a':
break;
break;
}
- cp++;
+ cp++;
}
if (!n)
return FALSE;
SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
SilcChannelEntry channel)
{
+ SilcIDCacheEntry id_cache;
SilcBool ret;
SilcCipher key;
SilcHmac hmac;
SILC_LOG_DEBUG(("Deleting channel %p", channel));
silc_mutex_lock(conn->internal->lock);
+ if (silc_idcache_find_by_context(conn->internal->channel_cache, channel,
+ &id_cache))
+ silc_free(id_cache->name);
ret = silc_idcache_del_by_context(conn->internal->channel_cache,
channel, NULL);
silc_mutex_unlock(conn->internal->lock);
silc_rwlock_rdlock(channel_entry->internal.lock);
}
-/* Unlock client */
+/* Unlock channel */
void silc_client_unlock_channel(SilcChannelEntry channel_entry)
{
SilcBool silc_client_del_server(SilcClient client, SilcClientConnection conn,
SilcServerEntry server)
{
+ SilcIDCacheEntry id_cache;
SilcBool ret;
if (!server)
SILC_LOG_DEBUG(("Deleting server %p", server));
silc_mutex_lock(conn->internal->lock);
+ if (silc_idcache_find_by_context(conn->internal->server_cache, server,
+ &id_cache))
+ silc_free(id_cache->name);
ret = silc_idcache_del_by_context(conn->internal->server_cache,
server, NULL);
silc_mutex_unlock(conn->internal->lock);
projects / silc.git / blobdiff