idlist.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2001 Pekka Riikonen
+ Copyright (C) 1997 - 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
#include "serverincludes.h"
#include "idlist.h"
+#include "server_internal.h"
/******************************************************************************
data->psn_receive = idata->psn_receive;
data->hash = idata->hash;
data->public_key = idata->public_key;
+ memcpy(data->fingerprint, idata->fingerprint, sizeof(data->fingerprint));
data->rekey = idata->rekey;
data->last_receive = idata->last_receive;
data->last_sent = idata->last_sent;
silc_hmac_free(idata->hmac_send);
if (idata->hmac_receive)
silc_hmac_free(idata->hmac_receive);
+ if (idata->hash)
+ silc_hash_free(idata->hash);
if (idata->public_key)
silc_pkcs_public_key_free(idata->public_key);
+
+ idata->send_key = NULL;
+ idata->receive_key = NULL;
+ idata->rekey = NULL;
+ idata->hmac_send = NULL;
+ idata->hmac_receive = NULL;
+ idata->hash = NULL;
+ idata->public_key = NULL;
}
/* Purges ID cache */
{
SilcIDListPurge i = (SilcIDListPurge)context;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Purging cache"));
silc_idcache_purge(i->cache);
silc_schedule_task_add(i->schedule, 0,
silc_idlist_purge,
- (void *)i, 600, 0,
+ (void *)i, i->timeout, 0,
SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
}
server->connection = connection;
if (!silc_idcache_add(id_list->servers, server->server_name,
- (void *)server->id, (void *)server, FALSE)) {
+ (void *)server->id, (void *)server, 0, NULL)) {
silc_free(server);
return NULL;
}
server->id = new_id;
silc_idcache_add(id_list->servers, server->server_name, server->id,
- server, FALSE);
+ server, 0, NULL);
SILC_LOG_DEBUG(("Found"));
int silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry)
{
- SILC_LOG_DEBUG(("Start"));
-
if (entry) {
/* Remove from cache */
- if (entry->id)
- if (!silc_idcache_del_by_id(id_list->servers, (void *)entry->id))
- return FALSE;
+ if (!silc_idcache_del_by_context(id_list->servers, entry))
+ return FALSE;
+
+ SILC_LOG_DEBUG(("Deleting server %s", entry->server_name ?
+ entry->server_name : ""));
/* Free data */
silc_free(entry->server_name);
silc_free(entry->id);
+ silc_free(entry->server_info);
memset(entry, 'F', sizeof(*entry));
silc_free(entry);
SilcClientEntry
silc_idlist_add_client(SilcIDList id_list, char *nickname, char *username,
char *userinfo, SilcClientID *id,
- SilcServerEntry router, void *connection)
+ SilcServerEntry router, void *connection,
+ int expire)
{
SilcClientEntry client;
NULL, NULL, NULL, NULL, TRUE);
if (!silc_idcache_add(id_list->clients, nickname, (void *)client->id,
- (void *)client, FALSE)) {
+ (void *)client, expire, NULL)) {
silc_hash_table_free(client->channels);
silc_free(client);
return NULL;
if (entry) {
/* Remove from cache */
- if (entry->id)
- if (!silc_idcache_del_by_context(id_list->clients, entry))
- return FALSE;
+ if (!silc_idcache_del_by_context(id_list->clients, entry))
+ return FALSE;
+
+ assert(!silc_hash_table_count(entry->channels));
/* Free data */
silc_free(entry->nickname);
+ silc_free(entry->servername);
silc_free(entry->username);
silc_free(entry->userinfo);
silc_free(entry->id);
+ silc_hash_table_free(entry->channels);
memset(entry, 'F', sizeof(*entry));
silc_free(entry);
int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
char *server,
SilcClientEntry **clients,
- uint32 *clients_count)
+ SilcUInt32 *clients_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
SilcHash md5hash,
SilcClientEntry **clients,
- uint32 *clients_count)
+ SilcUInt32 *clients_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
unsigned char hash[32];
SilcClientID client_id;
+ char nick[128 + 1];
SILC_LOG_DEBUG(("Start"));
- silc_hash_make(md5hash, nickname, strlen(nickname), hash);
+ memset(nick, 0, sizeof(nick));
+ silc_to_lower(nickname, nick, sizeof(nick) - 1);
+ silc_hash_make(md5hash, nick, strlen(nick), hash);
/* As the Client ID is hashed in the ID cache by hashing only the hash
from the Client ID, we can do a lookup with only the hash not the
/* Replaces old Client ID with new one */
SilcClientEntry
-silc_idlist_replace_client_id(SilcIDList id_list, SilcClientID *old_id,
- SilcClientID *new_id)
+silc_idlist_replace_client_id(SilcServer server,
+ SilcIDList id_list, SilcClientID *old_id,
+ SilcClientID *new_id, const char *nickname)
{
SilcIDCacheEntry id_cache = NULL;
SilcClientEntry client;
/* Remove the old entry and add a new one */
- silc_idcache_del_by_context(id_list->clients, client);
+ if (!silc_idcache_del_by_context(id_list->clients, client))
+ return NULL;
+
+ /* Check if anyone is watching old nickname */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_check_watcher_list(server, client, nickname,
+ SILC_NOTIFY_TYPE_NICK_CHANGE);
silc_free(client->id);
+ silc_free(client->nickname);
client->id = new_id;
+ client->nickname = nickname ? strdup(nickname) : NULL;
+
+ /* Check if anyone is watching new nickname */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_check_watcher_list(server, client, nickname,
+ SILC_NOTIFY_TYPE_NICK_CHANGE);
- silc_idcache_add(id_list->clients, NULL, client->id, client, FALSE);
+ if (!silc_idcache_add(id_list->clients, client->nickname, client->id,
+ client, 0, NULL))
+ return NULL;
SILC_LOG_DEBUG(("Replaced"));
{
SilcClientEntry client;
- SILC_LOG_DEBUG(("Start"));
-
client = (SilcClientEntry)entry->context;
if (client) {
- if (client->nickname)
- silc_free(client->nickname);
- if (client->username)
- silc_free(client->username);
- if (client->userinfo)
- silc_free(client->userinfo);
- if (client->id)
- silc_free(client->id);
-
- memset(client, 'F', sizeof(*client));
+ silc_free(client->nickname);
+ silc_free(client->username);
+ silc_free(client->userinfo);
+ silc_free(client->id);
+ silc_hash_table_free(client->channels);
+
+ memset(client, 'A', sizeof(*client));
silc_free(client);
}
}
SilcChannelEntry
silc_idlist_add_channel(SilcIDList id_list, char *channel_name, int mode,
SilcChannelID *id, SilcServerEntry router,
- SilcCipher channel_key, SilcHmac hmac)
+ SilcCipher channel_key, SilcHmac hmac,
+ int expire)
{
SilcChannelEntry channel;
- SILC_LOG_DEBUG(("Adding new channel entry"));
+ SILC_LOG_DEBUG(("Adding new channel %s", channel_name));
channel = silc_calloc(1, sizeof(*channel));
channel->channel_name = channel_name;
channel->router = router;
channel->channel_key = channel_key;
channel->hmac = hmac;
- channel->created = time(0);
+ channel->created = channel->updated = time(0);
if (!channel->hmac)
if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
silc_free(channel);
NULL, NULL, NULL, TRUE);
if (!silc_idcache_add(id_list->channels, channel->channel_name,
- (void *)channel->id, (void *)channel, FALSE)) {
+ (void *)channel->id, (void *)channel, expire, NULL)) {
silc_hmac_free(channel->hmac);
silc_hash_table_free(channel->user_list);
silc_free(channel);
{
SilcChannelClientEntry chl = (SilcChannelClientEntry)context;
+ SILC_LOG_DEBUG(("Removing client %s from channel %s",
+ chl->client->nickname ? chl->client->nickname :
+ (unsigned char *)"", chl->channel->channel_name));
+
/* 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(chl->client->channels, chl->channel);
int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry)
{
- SILC_LOG_DEBUG(("Start"));
-
if (entry) {
/* Remove from cache */
- if (entry->id)
- if (!silc_idcache_del_by_id(id_list->channels, (void *)entry->id))
- return FALSE;
+ if (!silc_idcache_del_by_context(id_list->channels, entry))
+ return FALSE;
+
+ SILC_LOG_DEBUG(("Deleting channel %s", entry->channel_name));
+
+ /* 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(entry->user_list, silc_idlist_del_channel_foreach,
+ NULL);
+ silc_hash_table_free(entry->user_list);
/* Free data */
silc_free(entry->channel_name);
silc_free(entry->key);
}
silc_free(entry->cipher);
+ if (entry->hmac)
+ silc_hmac_free(entry->hmac);
silc_free(entry->hmac_name);
silc_free(entry->rekey);
-
- /* 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(entry->user_list, silc_idlist_del_channel_foreach,
- NULL);
- silc_hash_table_free(entry->user_list);
+ if (entry->founder_key)
+ silc_pkcs_public_key_free(entry->founder_key);
memset(entry, 'F', sizeof(*entry));
silc_free(entry);
{
SilcIDCacheEntry id_cache = NULL;
- SILC_LOG_DEBUG(("Channel by name"));
+ SILC_LOG_DEBUG(("Channel by name %s", name));
if (!silc_idcache_find_by_name_one(id_list->channels, name, &id_cache))
return NULL;
SILC_LOG_DEBUG(("Found"));
+ /* Touch channel */
+ ((SilcChannelEntry)id_cache->context)->updated = time(NULL);
+
return id_cache->context;
}
SILC_LOG_DEBUG(("Found"));
+ /* Touch channel */
+ channel->updated = time(NULL);
+
return channel;
}
channel->id = new_id;
silc_idcache_add(id_list->channels, channel->channel_name, channel->id,
- channel, FALSE);
+ channel, 0, NULL);
SILC_LOG_DEBUG(("Replaced"));
+ /* Touch channel */
+ channel->updated = time(NULL);
+
return channel;
}
SilcChannelEntry *
silc_idlist_get_channels(SilcIDList id_list, SilcChannelID *channel_id,
- uint32 *channels_count)
+ SilcUInt32 *channels_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;