SilcIDListData data = (SilcIDListData)entry;
data->send_key = idata->send_key;
data->receive_key = idata->receive_key;
+ data->hash = idata->hash;
data->hmac = idata->hmac;
data->hmac_key = idata->hmac_key;
data->hmac_key_len = idata->hmac_key_len;
- data->pkcs = idata->pkcs;
data->public_key = idata->public_key;
data->last_receive = idata->last_receive;
data->last_sent = idata->last_sent;
memset(idata->hmac_key, 0, idata->hmac_key_len);
silc_free(idata->hmac_key);
}
- if (idata->pkcs)
- silc_pkcs_free(idata->pkcs);
if (idata->public_key)
silc_pkcs_public_key_free(idata->public_key);
}
+/* Purges ID cache */
+
+SILC_TASK_CALLBACK_GLOBAL(silc_idlist_purge)
+{
+ SilcIDListPurge i = (SilcIDListPurge)context;
+
+ SILC_LOG_DEBUG(("Start"));
+
+ silc_idcache_purge(i->cache);
+ silc_task_register(i->timeout_queue, 0,
+ silc_idlist_purge,
+ (void *)i, 600, 0,
+ SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
+}
+
/******************************************************************************
Server entry functions
server->router = router;
server->connection = connection;
- if (!silc_idcache_add(id_list->servers, server->server_name, SILC_ID_SERVER,
- (void *)server->id, (void *)server, TRUE)) {
+ if (!silc_idcache_add(id_list->servers, server->server_name,
+ server->server_name ? strlen(server->server_name) : 0,
+ SILC_ID_SERVER, (void *)server->id,
+ (void *)server, TRUE, FALSE)) {
silc_free(server);
return NULL;
}
if (ret_entry)
*ret_entry = id_cache;
+ SILC_LOG_DEBUG(("Found"));
+
return server;
}
server = (SilcServerEntry)id_cache->context;
sock = (SilcSocketConnection)server->connection;
- if (sock && (!strcmp(sock->hostname, hostname) ||
- !strcmp(sock->ip, hostname)) && sock->port == port)
+ if (sock && ((sock->hostname && !strcmp(sock->hostname, hostname)) ||
+ (sock->ip && !strcmp(sock->ip, hostname)))
+ && sock->port == port)
break;
id_cache = NULL;
server->id = new_id;
id_cache->id = (void *)new_id;
+ SILC_LOG_DEBUG(("Found"));
+
return server;
}
/* Removes and free's server entry from ID list */
-void silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry)
+int silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry)
{
if (entry) {
/* Remove from cache */
if (entry->id)
- silc_idcache_del_by_id(id_list->servers, SILC_ID_SERVER,
- (void *)entry->id);
+ if (!silc_idcache_del_by_id(id_list->servers, SILC_ID_SERVER,
+ (void *)entry->id))
+ return FALSE;
/* Free data */
if (entry->server_name)
memset(entry, 'F', sizeof(*entry));
silc_free(entry);
+ return TRUE;
}
+
+ return FALSE;
}
/******************************************************************************
SilcClientEntry
silc_idlist_add_client(SilcIDList id_list, unsigned char *nickname,
- char *username, char *userinfo, SilcClientID *id,
+ unsigned int nickname_len, char *username,
+ char *userinfo, SilcClientID *id,
SilcServerEntry router, void *connection)
{
SilcClientEntry client;
silc_list_init(client->channels, struct SilcChannelClientEntryStruct,
client_list);
- if (!silc_idcache_add(id_list->clients, nickname, SILC_ID_CLIENT,
- (void *)client->id, (void *)client, TRUE)) {
+ if (!silc_idcache_add(id_list->clients, nickname, nickname_len,
+ SILC_ID_CLIENT, (void *)client->id,
+ (void *)client, TRUE, FALSE)) {
silc_free(client);
return NULL;
}
/* Returns all clients matching requested nickname. Number of clients is
returned to `clients_count'. Caller must free the returned table. */
-SilcClientEntry *
-silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
- char *server, unsigned int *clients_count)
+int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
+ char *server,
+ SilcClientEntry **clients,
+ unsigned int *clients_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
- SilcClientEntry *clients;
int i;
+ SILC_LOG_DEBUG(("Start"));
+
if (!silc_idcache_find_by_data(id_list->clients, nickname, &list))
- return NULL;
+ return FALSE;
- clients = silc_calloc(silc_idcache_list_count(list), sizeof(*clients));
+ *clients = silc_realloc(*clients,
+ (silc_idcache_list_count(list) + *clients_count) *
+ sizeof(**clients));
i = 0;
silc_idcache_list_first(list, &id_cache);
- clients[i++] = (SilcClientEntry)id_cache->context;
+ (*clients)[i++] = (SilcClientEntry)id_cache->context;
while (silc_idcache_list_next(list, &id_cache))
- clients[i++] = (SilcClientEntry)id_cache->context;
+ (*clients)[i++] = (SilcClientEntry)id_cache->context;
silc_idcache_list_free(list);
- if (clients_count)
- *clients_count = i;
+ *clients_count += i;
- return clients;
+ return TRUE;
}
/* Returns all clients matching requested nickname. Number of clients is
returned to `clients_count'. Caller must free the returned table. */
-
-SilcClientEntry *
-silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
- SilcHash md5hash,
- unsigned int *clients_count)
+/* XXX This actually checks the data, which can be hash of the nickname
+ but is not if the client is local client. Global client on global
+ list may have hash. Thus, this is not fully reliable function.
+ Instead this should probably check the hash from the list of client ID's. */
+
+int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
+ SilcHash md5hash,
+ SilcClientEntry **clients,
+ unsigned int *clients_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
- SilcClientEntry *clients;
unsigned char hash[32];
int i;
+ SILC_LOG_DEBUG(("Start"));
+
silc_hash_make(md5hash, nickname, strlen(nickname), hash);
if (!silc_idcache_find_by_data(id_list->clients, hash, &list))
- return NULL;
+ return FALSE;
- clients = silc_calloc(silc_idcache_list_count(list), sizeof(*clients));
+ *clients = silc_realloc(*clients,
+ (silc_idcache_list_count(list) + *clients_count) *
+ sizeof(**clients));
i = 0;
silc_idcache_list_first(list, &id_cache);
- clients[i++] = (SilcClientEntry)id_cache->context;
+ (*clients)[i++] = (SilcClientEntry)id_cache->context;
while (silc_idcache_list_next(list, &id_cache))
- clients[i++] = (SilcClientEntry)id_cache->context;
+ (*clients)[i++] = (SilcClientEntry)id_cache->context;
silc_idcache_list_free(list);
- if (clients_count)
- *clients_count = i;
+ *clients_count += i;
- return clients;
-}
-
-/* Finds client entry by nickname. */
-
-SilcClientEntry
-silc_idlist_find_client_by_nickname(SilcIDList id_list, char *nickname,
- char *server, SilcIDCacheEntry *ret_entry)
-{
- SilcIDCacheList list = NULL;
- SilcIDCacheEntry id_cache = NULL;
- SilcClientEntry client = NULL;
-
- SILC_LOG_DEBUG(("Client by nickname"));
-
- if (server) {
- if (!silc_idcache_find_by_data(id_list->clients, nickname, &list))
- return NULL;
-
-#if 0
- while (silc_idcache_list_next(list, &id_cache)) {
- client = (SilcClientEntry)id_cache->context;
-
- if (!strcmp(server, XXX, strlen(server)))
- break;
-
- client = NULL;
- }
-#endif
-
- silc_idcache_list_free(list);
-
- if (!client)
- return NULL;
- } else {
- if (!silc_idcache_find_by_data_one(id_list->clients, nickname, &id_cache))
- return NULL;
-
- client = (SilcClientEntry)id_cache->context;
-
- if (ret_entry)
- *ret_entry = id_cache;
- }
-
- SILC_LOG_DEBUG(("Found"));
-
- return client;
+ return TRUE;
}
/* Finds client by nickname hash. */
return client;
}
+/* Client cache entry destructor that is called when the cache is purged. */
+
+void silc_idlist_client_destructor(SilcIDCache cache,
+ SilcIDCacheEntry entry)
+{
+ 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);
+ }
+}
/******************************************************************************
channel_list);
if (!silc_idcache_add(id_list->channels, channel->channel_name,
- SILC_ID_CHANNEL, (void *)channel->id,
- (void *)channel, TRUE)) {
+ channel->channel_name ? strlen(channel->channel_name) :
+ 0, SILC_ID_CHANNEL,
+ (void *)channel->id, (void *)channel, TRUE, FALSE)) {
silc_free(channel);
return NULL;
}
memset(entry->key, 0, entry->key_len / 8);
silc_free(entry->key);
}
+ if (entry->cipher)
+ silc_free(entry->cipher);
+ if (entry->hmac_name)
+ silc_free(entry->hmac_name);
+ if (entry->rekey)
+ silc_free(entry->rekey);
/* Free all data, free also any reference from the client's channel
list since they share the same memory. */
channel->id = new_id;
id_cache->id = (void *)new_id;
+ SILC_LOG_DEBUG(("Replaced"));
+
return channel;
}
+
+/* Returns channels from the ID list. If the `channel_id' is NULL then
+ all channels are returned. */
+
+SilcChannelEntry *
+silc_idlist_get_channels(SilcIDList id_list, SilcChannelID *channel_id,
+ unsigned int *channels_count)
+{
+ SilcIDCacheList list = NULL;
+ SilcIDCacheEntry id_cache = NULL;
+ SilcChannelEntry *channels;
+ int i;
+
+ SILC_LOG_DEBUG(("Start"));
+
+ if (!silc_idcache_find_by_id(id_list->channels, channel_id ? channel_id :
+ SILC_ID_CACHE_ANY, SILC_ID_CHANNEL, &list))
+ return NULL;
+
+ channels = silc_calloc(silc_idcache_list_count(list), sizeof(*channels));
+
+ i = 0;
+ silc_idcache_list_first(list, &id_cache);
+ channels[i++] = (SilcChannelEntry)id_cache->context;
+
+ while (silc_idcache_list_next(list, &id_cache))
+ channels[i++] = (SilcChannelEntry)id_cache->context;
+
+ silc_idcache_list_free(list);
+
+ if (channels_count)
+ *channels_count = i;
+
+ return channels;
+}
projects / silc.git / blobdiff