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
SilcUInt32 *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
SilcUInt16 idp_len, cmd_ident;
SilcID id;
+ va_list tmp;
int i;
SILC_LOG_DEBUG(("Resolve clients from Client ID list"));
/* We have the clients in cache, get them and call the completion */
silc_client_get_clients_list_cb(client, conn, SILC_COMMAND_WHOIS,
- SILC_STATUS_OK, SILC_STATUS_OK, in, NULL);
+ SILC_STATUS_OK, SILC_STATUS_OK, in, tmp);
return 0;
err:
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;
}
}
- /* 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);
+
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,
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)
nick = silc_identifier_check(client_entry->nickname,
strlen(client_entry->nickname),
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);
/* Update cache entry */
silc_mutex_lock(conn->internal->lock);
client_entry->nickname_normalized = nick;
}
client_entry->mode = mode;
+
+ silc_rwlock_unlock(client_entry->internal.lock);
}
-/* Change a client's nickname */
+/* Change a client's nickname. Must be called with `client_entry' locked. */
SilcBool silc_client_change_nickname(SilcClient client,
SilcClientConnection conn,
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);
+ 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) {
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;
}
+/* 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 */
/* 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];
SilcDList clients;
SilcClientEntry entry, unformatted = NULL;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Format nickname"));
if (!client->internal->params->nickname_format[0])
- return;
-
+ return client_entry;
if (!client_entry->nickname[0])
- return;
+ return NULL;
/* 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;
+ if (!clients)
+ return NULL;
+ if (silc_dlist_count(clients) == 1 &&
+ !client->internal->params->nickname_force_format) {
+ silc_client_list_free(client, conn, clients);
+ return client_entry;
+ }
- if (clients) {
- 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) {
- silc_client_list_free(client, conn, clients);
- 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;
+ break;
}
}
+ if (!len || freebase) {
+ silc_client_list_free(client, conn, clients);
+ return client_entry;
+ }
- /* 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 priority formatting, this client always gets unformatted nickname. */
+ if (unformatted && priority)
client_entry = unformatted;
memset(newnick, 0, sizeof(newnick));
char tmp[6];
int num, max = 1;
- if (clients && silc_dlist_count(clients) == 1)
+ if (silc_dlist_count(clients) == 1)
break;
- if (clients) {
- 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;
- }
+ 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);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "%d", ++max);
len = strlen(tmp);
memcpy(&newnick[off], tmp, len);
off += len;
newnick[off] = 0;
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])
+ 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 's':
+ case 'S':
+ 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 *************************/
if (!channel)
return NULL;
+ silc_rwlock_alloc(&channel->internal.lock);
silc_atomic_init16(&channel->internal.refcnt, 0);
channel->id = *channel_id;
channel->mode = mode;
silc_free(channel->topic);
if (channel->founder_key)
silc_pkcs_public_key_free(channel->founder_key);
- if (channel->internal.channel_key)
- silc_cipher_free(channel->internal.channel_key);
+ if (channel->internal.send_key)
+ silc_cipher_free(channel->internal.send_key);
+ if (channel->internal.receive_key)
+ silc_cipher_free(channel->internal.receive_key);
if (channel->internal.hmac)
silc_hmac_free(channel->internal.hmac);
if (channel->internal.old_channel_keys) {
SILC_ARGUMENT_PUBLIC_KEY);
silc_client_del_channel_private_keys(client, conn, channel);
silc_atomic_uninit16(&channel->internal.refcnt);
+ silc_rwlock_free(channel->internal.lock);
silc_schedule_task_del_by_context(conn->client->schedule, channel);
silc_free(channel);
}
/* 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,
silc_id_render(new_id, SILC_ID_CHANNEL)));
/* Update the ID */
+ 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 client */
+
+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_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 */
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)
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;
}
}
+/* 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 */
projects / silc.git / blobdiff