Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2001 - 2006 Pekka Riikonen
+ Copyright (C) 2001 - 2007 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "silcclient.h"
#include "client_internal.h"
-/* XXX locking */
-
/************************ Client Searching Locally **************************/
/* Finds entry for client by the client's ID. Returns the entry or NULL
/* 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 nick[128 + 1], *nicknamec, *parsed = NULL, *format = NULL;
+ char server[256 + 1];
if (!client || !conn || !nickname)
return NULL;
+ /* Get nickname from nickname@server string */
+ silc_parse_userfqdn(nickname, nick, sizeof(nick), server, sizeof(server));
+
+ /* Parse nickname in case it is formatted */
+ if (!silc_client_nickname_parse(client, conn, (char *)nick, &parsed))
+ return NULL;
+
+ if (!get_all && parsed)
+ format = (char *)nick;
+ if (!parsed) {
+ parsed = silc_memdup(nick, strlen(nick));
+ 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)
- silc_free(nicknamec);
+ if (!nicknamec) {
+ silc_free(parsed);
return NULL;
+ }
clients = silc_dlist_init();
if (!clients) {
silc_free(nicknamec);
+ silc_free(parsed);
return NULL;
}
silc_mutex_lock(conn->internal->lock);
/* Find from cache */
+ silc_list_init(list, struct SilcIDCacheEntryStruct, next);
if (!silc_idcache_find_by_name(conn->internal->client_cache, nicknamec,
&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, entry);
- 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 server was provided, find entries that either have no server
+ set or have the same server. Ignore those that have different
+ server. */
+ if (server[0] && entry->server &&
+ !silc_utf8_strcasecmp(entry->server, server))
+ continue;
+
+ 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);
}
SilcBuffer idp;
SilcUInt16 cmd_ident;
- if (!client || !conn | !client_id)
+ if (!client || !conn | !client_id) {
+ SILC_LOG_ERROR(("Missing arguments to "
+ "silc_client_get_clients_by_id_resolve call"));
return 0;
+ }
SILC_LOG_DEBUG(("Resolve client by ID (%s)",
silc_id_render(client_id, SILC_ID_CLIENT)));
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",
silc_get_command_name(command)));
- if (!client || !conn)
+ if (!client || !conn) {
+ SILC_LOG_ERROR(("Missing arguments to silc_client_get_clients call"));
return 0;
- if (!nickname && !attributes)
+ }
+ if (!nickname && !attributes) {
+ SILC_LOG_ERROR(("Missing arguments to silc_client_get_clients call"));
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)
out:
if (status != SILC_STATUS_OK && i->completion)
i->completion(client, conn, status, NULL, i->context);
+
silc_client_list_free(client, conn, clients);
+ silc_buffer_free(i->client_id_list);
silc_free(i);
+
return FALSE;
}
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"));
res_argv[res_argc] = client_id_list->data;
res_argv_lens[res_argc] = idp_len;
- res_argv_types[res_argc] = res_argc + 5;
+ res_argv_types[res_argc] = res_argc + 4;
res_argc++;
}
silc_client_unref_client(client, conn, entry);
/* 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, NULL);
+ SILC_STATUS_OK, SILC_STATUS_OK, in, tmp);
return 0;
err:
SilcUInt32 mode)
{
SilcClientEntry client_entry;
- char *nick = NULL;
+ char *nick = NULL, parsed[128 + 1];
SILC_LOG_DEBUG(("Adding new client entry"));
if (!client_entry)
return NULL;
+ silc_rwlock_alloc(&client_entry->internal.lock);
+ silc_atomic_init8(&client_entry->internal.refcnt, 0);
client_entry->id = *id;
- client_entry->internal.valid = TRUE;
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);
if (!client_entry->channels) {
/* 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);
}
}
- /* 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 */
silc_mutex_unlock(conn->internal->lock);
silc_client_ref_client(client, conn, client_entry);
+ /* 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;
}
-/* Updates the `client_entry' with the new information sent as argument. */
+/* Updates the `client_entry' with the new information sent as argument.
+ This handles entry locking internally. */
void silc_client_update_client(SilcClient client,
SilcClientConnection conn,
const char *userinfo,
SilcUInt32 mode)
{
- char *nick = NULL;
+ char *nick = NULL, parsed[128 + 1];
SILC_LOG_DEBUG(("Update client entry"));
+ silc_rwlock_wrlock(client_entry->internal.lock);
+
if (!client_entry->realname && userinfo)
client_entry->realname = strdup(userinfo);
+
if ((!client_entry->username[0] || !client_entry->hostname[0]) && username)
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)
+ if (!nick) {
+ silc_rwlock_unlock(client_entry->internal.lock);
return;
+ }
/* Format nickname */
- silc_client_nickname_format(client, conn, client_entry);
+ silc_client_nickname_format(client, conn, client_entry,
+ client_entry == conn->local_entry);
- /* Remove the old cache entry and create a new one */
- silc_idcache_del_by_context(conn->internal->client_cache, client_entry,
- NULL);
- silc_idcache_add(conn->internal->client_cache, nick, &client_entry->id,
- client_entry);
+ /* Update cache entry */
+ silc_mutex_lock(conn->internal->lock);
+ silc_idcache_update_by_context(conn->internal->client_cache,
+ 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;
+
+ silc_rwlock_unlock(client_entry->internal.lock);
+}
+
+/* Change a client's nickname. Must be called with `client_entry' locked. */
+
+SilcBool silc_client_change_nickname(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry,
+ const char *new_nick,
+ SilcClientID *new_id,
+ const unsigned char *idp,
+ SilcUInt32 idp_len)
+{
+ char *tmp;
+
+ SILC_LOG_DEBUG(("Change nickname %s to %s", client_entry->nickname,
+ new_nick));
+
+ /* Normalize nickname */
+ tmp = silc_identifier_check(new_nick, strlen(new_nick),
+ SILC_STRING_UTF8, 128, NULL);
+ if (!tmp)
+ return FALSE;
+
+ /* Update the client entry */
+ silc_mutex_lock(conn->internal->lock);
+ if (!silc_idcache_update_by_context(conn->internal->client_cache,
+ client_entry, new_id, tmp, TRUE)) {
+ silc_free(tmp);
+ silc_mutex_unlock(conn->internal->lock);
+ return FALSE;
+ }
+ silc_mutex_unlock(conn->internal->lock);
+
+ memset(client_entry->nickname, 0, sizeof(client_entry->nickname));
+ memcpy(client_entry->nickname, new_nick, strlen(new_nick));
+ client_entry->nickname_normalized = tmp;
+ silc_client_nickname_format(client, conn, client_entry,
+ client_entry == conn->local_entry);
+
+ /* For my client entry, update ID and set new ID to packet stream */
+ if (client_entry == conn->local_entry) {
+ if (idp && idp_len) {
+ silc_buffer_enlarge(conn->internal->local_idp, idp_len);
+ silc_buffer_put(conn->internal->local_idp, idp, idp_len);
+ }
+ if (new_id)
+ silc_packet_set_ids(conn->stream, SILC_ID_CLIENT, conn->local_id,
+ 0, NULL);
+ }
+
+ client_entry->internal.valid = TRUE;
+ return TRUE;
}
/* Deletes the client entry and frees all memory. */
SilcClientConnection conn,
SilcClientEntry client_entry)
{
- SILC_LOG_DEBUG(("Start"));
-
silc_free(client_entry->realname);
+ silc_free(client_entry->nickname_normalized);
+ silc_free(client_entry->internal.key);
if (client_entry->public_key)
silc_pkcs_public_key_free(client_entry->public_key);
silc_hash_table_free(client_entry->channels);
silc_cipher_free(client_entry->internal.send_key);
if (client_entry->internal.receive_key)
silc_cipher_free(client_entry->internal.receive_key);
- silc_free(client_entry->internal.key);
-#if 0
- silc_client_ftp_session_free_client(conn, client_entry);
- if (client_entry->internal->ke)
+ if (client_entry->internal.hmac_send)
+ silc_hmac_free(client_entry->internal.hmac_send);
+ if (client_entry->internal.hmac_receive)
+ silc_hmac_free(client_entry->internal.hmac_receive);
+ 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);
}
SilcBool silc_client_del_client(SilcClient client, SilcClientConnection conn,
SilcClientEntry client_entry)
{
- SilcBool ret = silc_idcache_del_by_context(conn->internal->client_cache,
- client_entry, NULL);
-#if 0
+ 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_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);
}
-#endif
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)
+{
+ silc_rwlock_rdlock(client_entry->internal.lock);
+}
+
+/* Unlock client */
+
+void silc_client_unlock_client(SilcClientEntry client_entry)
+{
+ silc_rwlock_unlock(client_entry->internal.lock);
+}
+
/* Take reference of client entry */
-void silc_client_ref_client(SilcClient client, SilcClientConnection conn,
- SilcClientEntry client_entry)
+SilcClientEntry silc_client_ref_client(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry)
{
silc_atomic_add_int8(&client_entry->internal.refcnt, 1);
+ SILC_LOG_DEBUG(("Client %p refcnt %d->%d", client_entry,
+ silc_atomic_get_int8(&client_entry->internal.refcnt) - 1,
+ silc_atomic_get_int8(&client_entry->internal.refcnt)));
+ return client_entry;
}
/* Release reference of client entry */
void silc_client_unref_client(SilcClient client, SilcClientConnection conn,
SilcClientEntry client_entry)
{
- if (client_entry &&
- silc_atomic_sub_int8(&client_entry->internal.refcnt, 1) == 0)
+ 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);
+ }
}
/* Free client entry list */
}
}
-
/* 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. */
+ format string is not specified then this function has no effect.
+ Returns the client entry that was formatted. */
-void silc_client_nickname_format(SilcClient client,
- SilcClientConnection conn,
- SilcClientEntry client_entry)
+SilcClientEntry silc_client_nickname_format(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry,
+ SilcBool priority)
{
char *cp;
char newnick[128 + 1];
int i, off = 0, len;
- SilcBool freebase;
SilcDList clients;
SilcClientEntry entry, unformatted = NULL;
-
- SILC_LOG_DEBUG(("Start"));
+ SilcBool formatted = FALSE;
if (!client->internal->params->nickname_format[0])
- return;
-
+ return client_entry;
if (!client_entry->nickname[0])
- return;
+ 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);
- if (!clients && !client->internal->params->nickname_force_format)
- return;
+ clients = silc_client_get_clients_local_ext(client, conn,
+ client_entry->nickname,
+ TRUE, FALSE);
+ if (!clients)
+ return NULL;
+ if (silc_dlist_count(clients) == 1 && !priority &&
+ !client->internal->params->nickname_force_format) {
+ silc_client_list_free(client, conn, clients);
+ return client_entry;
+ }
+
+ /* Is the requested client formatted already */
+ if (client_entry->nickname_normalized &&
+ !silc_utf8_strcasecmp(client_entry->nickname,
+ client_entry->nickname_normalized))
+ formatted = TRUE;
- len = 0;
- freebase = TRUE;
+ if (client->internal->params->nickname_force_format)
+ formatted = FALSE;
+
+ /* Find unformatted client entry */
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;
+ if (!entry->internal.valid)
+ continue;
+ if (entry == client_entry)
+ continue;
+ if (silc_utf8_strcasecmp(entry->nickname, entry->nickname_normalized)) {
unformatted = entry;
+ break;
}
}
- 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)
+ /* If there are no other unformatted clients and the requested client is
+ unformatted, just return it. */
+ if (!unformatted && !formatted) {
+ silc_client_list_free(client, conn, clients);
+ return client_entry;
+ }
+
+ /* If priority formatting then the requested client will get the
+ unformatted nickname, and the unformatted client will get a new
+ formatted nickname. */
+ if (priority) {
+ if (formatted) {
+ /* Simply change the client's nickname to unformatted */
+ if (!silc_client_nickname_parse(client, conn, client_entry->nickname,
+ &cp))
+ return NULL;
+
+ silc_snprintf(client_entry->nickname, sizeof(client_entry->nickname),
+ cp);
+ silc_free(cp);
+ }
+
+ if (!unformatted) {
+ /* There was no other unformatted client */
+ silc_client_list_free(client, conn, clients);
+ return client_entry;
+ }
+
+ /* Now format the previously unformatted client */
client_entry = unformatted;
+ formatted = FALSE;
+ }
+
+ /* If already formatted just return it */
+ if (formatted) {
+ silc_client_list_free(client, conn, clients);
+ return client_entry;
+ }
memset(newnick, 0, sizeof(newnick));
cp = client->internal->params->nickname_format;
- while (*cp) {
+ while (cp && *cp) {
if (*cp == '%') {
cp++;
continue;
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 */
{
}
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "%d", ++max);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "%d", ++max);
len = strlen(tmp);
memcpy(&newnick[off], tmp, len);
off += len;
}
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);
+
+ return client_entry;
+}
+
+/* Parses nickname according to nickname format string */
+
+SilcBool silc_client_nickname_parse(SilcClient client,
+ SilcClientConnection conn,
+ char *nickname,
+ char **ret_nick)
+{
+ char *cp, s = 0, e = 0, *nick;
+ SilcBool n = FALSE;
+ int len;
+
+ if (!client->internal->params->nickname_format[0]) {
+ *ret_nick = NULL;
+ return TRUE;
+ }
+
+ if (!nickname || !nickname[0])
+ return FALSE;
+
+ cp = client->internal->params->nickname_format;
+ while (cp && *cp) {
+ if (*cp == '%') {
+ cp++;
+ continue;
+ }
+
+ switch(*cp) {
+ case 'n':
+ n = TRUE;
+ break;
+
+ case 'h':
+ case 'H':
+ case 'a':
+ break;
+
+ default:
+ /* Get separator character */
+ if (n)
+ e = *cp;
+ else
+ s = *cp;
+ break;
+ }
+
+ cp++;
+ }
+ if (!n)
+ return FALSE;
+
+ /* Parse the nickname */
+ nick = nickname;
+ len = strlen(nick);
+ if (s)
+ if (strchr(nickname, s))
+ nick = strchr(nickname, s) + 1;
+ if (e)
+ if (strchr(nick, e))
+ len = strchr(nick, e) - nick;
+ if (!len)
+ return FALSE;
+
+ *ret_nick = silc_memdup(nick, len);
+ if (!(*ret_nick))
+ return FALSE;
+
+ SILC_LOG_DEBUG(("Parsed nickname: %s", *ret_nick));
+
+ return TRUE;
}
/************************ Channel Searching Locally *************************/
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);
void *context)
{
SilcClientGetChannelInternal i;
- SilcChannelEntry channel;
SilcBuffer idp;
SilcUInt16 cmd_ident;
if (!cmd_ident && completion)
completion(client, conn, SILC_STATUS_ERR_RESOURCE_LIMIT, NULL, context);
- silc_client_unref_channel(client, conn, channel);
-
return cmd_ident;
}
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);
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_uninit16(&channel->internal.refcnt);
silc_free(channel);
return NULL;
}
channel->user_list = silc_hash_table_alloc(1, silc_hash_ptr, NULL, NULL,
NULL, NULL, NULL, TRUE);
if (!channel->user_list) {
+ silc_rwlock_free(channel->internal.lock);
+ silc_atomic_uninit16(&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_uninit16(&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_uninit16(&channel->internal.refcnt);
silc_free(channel_namec);
silc_free(channel->channel_name);
silc_hash_table_free(channel->user_list);
silc_mutex_unlock(conn->internal->lock);
silc_client_ref_channel(client, conn, channel);
+ SILC_LOG_DEBUG(("Added %p", channel));
+
return channel;
}
-/* Foreach callbcak to free all users from the channel when deleting a
- channel entry. */
+/* Removes channel from the cache by the channel entry. */
-static void silc_client_del_channel_foreach(void *key, void *context,
- void *user_context)
+SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
+ SilcChannelEntry channel)
{
- SilcChannelUser chu = (SilcChannelUser)context;
+ SilcIDCacheEntry id_cache;
+ SilcBool ret = TRUE;
+ SilcCipher key;
+ SilcHmac hmac;
+ char *namec;
- SILC_LOG_DEBUG(("Start"));
+ if (!channel)
+ return FALSE;
- /* 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);
-}
+ if (silc_atomic_sub_int16(&channel->internal.refcnt, 1) > 0)
+ return FALSE;
-/* Removes channel from the cache by the channel entry. */
+ SILC_LOG_DEBUG(("Deleting channel %p", channel));
-SilcBool silc_client_del_channel(SilcClient client, SilcClientConnection conn,
- SilcChannelEntry channel)
-{
- SilcBool ret = silc_idcache_del_by_context(conn->internal->channel_cache,
- channel, NULL);
-#if 0
+ 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);
- SILC_LOG_DEBUG(("Start"));
+ if (!ret)
+ return FALSE;
- /* 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_client_empty_channel(client, conn, channel);
+ silc_client_del_channel_private_keys(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);
- 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)
+ 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->old_channel_keys);
+ silc_dlist_uninit(channel->internal.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)
+ 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->old_hmacs);
+ silc_dlist_uninit(channel->internal.old_hmacs);
}
+ if (channel->channel_pubkeys)
+ silc_argument_list_free(channel->channel_pubkeys,
+ SILC_ARGUMENT_PUBLIC_KEY);
+ silc_atomic_uninit16(&channel->internal.refcnt);
+ silc_rwlock_free(channel->internal.lock);
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;
}
/* Replaces the channel ID of the `channel' to `new_id'. Returns FALSE
- if the ID could not be changed. */
+ if the ID could not be changed. This handles entry locking internally. */
SilcBool silc_client_replace_channel_id(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
SilcChannelID *new_id)
{
- SilcIDCacheEntry id_cache;
SilcBool ret = FALSE;
if (!new_id)
SILC_LOG_DEBUG(("New Channel ID id(%s)",
silc_id_render(new_id, SILC_ID_CHANNEL)));
- silc_mutex_lock(conn->internal->lock);
-
/* 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_rwlock_wrlock(channel->internal.lock);
+ silc_mutex_lock(conn->internal->lock);
+ silc_idcache_update_by_context(conn->internal->channel_cache, channel,
+ new_id, NULL, FALSE);
silc_mutex_unlock(conn->internal->lock);
+ silc_rwlock_unlock(channel->internal.lock);
return ret;
}
+/* Lock channel */
+
+void silc_client_lock_channel(SilcChannelEntry channel_entry)
+{
+ silc_rwlock_rdlock(channel_entry->internal.lock);
+}
+
+/* Unlock channel */
+
+void silc_client_unlock_channel(SilcChannelEntry channel_entry)
+{
+ silc_rwlock_unlock(channel_entry->internal.lock);
+}
+
/* Take reference of channel entry */
-void silc_client_ref_channel(SilcClient client, SilcClientConnection conn,
- SilcChannelEntry channel_entry)
+SilcChannelEntry silc_client_ref_channel(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelEntry channel_entry)
{
- silc_atomic_add_int8(&channel_entry->internal.refcnt, 1);
+ silc_atomic_add_int16(&channel_entry->internal.refcnt, 1);
+ SILC_LOG_DEBUG(("Channel %p refcnt %d->%d", channel_entry,
+ silc_atomic_get_int16(&channel_entry->internal.refcnt) - 1,
+ silc_atomic_get_int16(&channel_entry->internal.refcnt)));
+ return channel_entry;
}
/* Release reference of channel entry */
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)
+ 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);
+ }
}
/* Free channel entry list */
if (!silc_idcache_find_by_name_one(conn->internal->server_cache,
server_name, &id_cache)) {
silc_free(server_name);
+ silc_mutex_unlock(conn->internal->lock);
return NULL;
}
silc_mutex_lock(conn->internal->lock);
if (!silc_idcache_find_by_id_one(conn->internal->server_cache,
- server_id, &id_cache))
+ server_id, &id_cache)) {
+ silc_mutex_unlock(conn->internal->lock);
return NULL;
+ }
SILC_LOG_DEBUG(("Found"));
SilcServerEntry server_entry;
char *server_namec = NULL;
- SILC_LOG_DEBUG(("Start"));
+ if (!server_id)
+ return NULL;
+
+ SILC_LOG_DEBUG(("Adding new server %s", server_name));
server_entry = silc_calloc(1, sizeof(*server_entry));
- if (!server_entry || !server_id)
+ if (!server_entry)
return NULL;
+ silc_rwlock_alloc(&server_entry->internal.lock);
+ silc_atomic_init8(&server_entry->internal.refcnt, 0);
server_entry->id = *server_id;
if (server_name)
server_entry->server_name = strdup(server_name);
silc_mutex_unlock(conn->internal->lock);
silc_client_ref_server(client, conn, server_entry);
+ SILC_LOG_DEBUG(("Added %p", server_entry));
+
return server_entry;
}
SilcBool silc_client_del_server(SilcClient client, SilcClientConnection conn,
SilcServerEntry server)
{
- SilcBool ret = silc_idcache_del_by_context(conn->internal->server_cache,
- server, NULL);
+ SilcIDCacheEntry id_cache;
+ SilcBool ret = TRUE;
+ char *namec;
+
+ if (!server)
+ return FALSE;
+
+ if (silc_atomic_sub_int8(&server->internal.refcnt, 1) > 0)
+ return FALSE;
+
+ 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)) {
+ namec = id_cache->name;
+ ret = silc_idcache_del_by_context(conn->internal->server_cache,
+ server, NULL);
+ silc_free(namec);
+ }
+ silc_mutex_unlock(conn->internal->lock);
+
silc_free(server->server_name);
silc_free(server->server_info);
+ if (server->public_key)
+ silc_pkcs_public_key_free(server->public_key);
+ silc_atomic_uninit8(&server->internal.refcnt);
+ silc_rwlock_free(server->internal.lock);
silc_free(server);
+
return ret;
}
{
char *server_namec = NULL;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Updating server %p", server_entry));
if (server_name &&
(!server_entry->server_name ||
!silc_utf8_strcasecmp(server_entry->server_name, server_name))) {
- silc_idcache_del_by_context(conn->internal->server_cache,
- server_entry, NULL);
+ server_namec = silc_identifier_check(server_name, strlen(server_name),
+ SILC_STRING_UTF8, 256, NULL);
+ if (!server_namec)
+ return;
+
silc_free(server_entry->server_name);
server_entry->server_name = strdup(server_name);
+ if (!server_entry->server_name)
+ return;
- /* Normalize server name */
- if (server_name) {
- server_namec = silc_identifier_check(server_name, strlen(server_name),
- SILC_STRING_UTF8, 256, NULL);
- if (!server_namec)
- return;
-
- silc_idcache_add(conn->internal->server_cache, server_namec,
- &server_entry->id, server_entry);
- }
+ /* Update cache entry */
+ silc_mutex_lock(conn->internal->lock);
+ silc_idcache_update_by_context(conn->internal->server_cache, server_entry,
+ NULL, server_namec, TRUE);
+ silc_mutex_unlock(conn->internal->lock);
}
if (server_info &&
}
}
+/* Lock server */
+
+void silc_client_lock_server(SilcServerEntry server_entry)
+{
+ silc_rwlock_rdlock(server_entry->internal.lock);
+}
+
+/* Unlock server */
+
+void silc_client_unlock_server(SilcServerEntry server_entry)
+{
+ silc_rwlock_unlock(server_entry->internal.lock);
+}
+
/* Take reference of server entry */
-void silc_client_ref_server(SilcClient client, SilcClientConnection conn,
- SilcServerEntry server_entry)
+SilcServerEntry silc_client_ref_server(SilcClient client,
+ SilcClientConnection conn,
+ SilcServerEntry server_entry)
{
silc_atomic_add_int8(&server_entry->internal.refcnt, 1);
+ SILC_LOG_DEBUG(("Server %p refcnt %d->%d", server_entry,
+ silc_atomic_get_int8(&server_entry->internal.refcnt) - 1,
+ silc_atomic_get_int8(&server_entry->internal.refcnt)));
+ return server_entry;
}
/* Release reference of server entry */
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)
+ 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)
+ - 1));
silc_client_del_server(client, conn, server_entry);
+ }
}
/* Free server entry list */