X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=apps%2Fsilcd%2Fidlist.c;h=621c4c4ffccc8600c8db86416e5c3bf5b9b7c40c;hb=c257b555225193e54d85daf541d29578b3c93882;hp=86b603179b036ce579ec3329c0d1f5b8dff85fff;hpb=4d58526a59b7310e9e11a2cca02fb955ab1732b4;p=silc.git diff --git a/apps/silcd/idlist.c b/apps/silcd/idlist.c index 86b60317..621c4c4f 100644 --- a/apps/silcd/idlist.c +++ b/apps/silcd/idlist.c @@ -2,15 +2,15 @@ idlist.c - Author: Pekka Riikonen + Author: Pekka Riikonen - Copyright (C) 1997 - 2001 Pekka Riikonen + Copyright (C) 1997 - 2005 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 the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -21,6 +21,7 @@ #include "serverincludes.h" #include "idlist.h" +#include "server_internal.h" /****************************************************************************** @@ -36,14 +37,19 @@ void silc_idlist_add_data(void *entry, SilcIDListData idata) SilcIDListData data = (SilcIDListData)entry; data->send_key = idata->send_key; data->receive_key = idata->receive_key; - data->hmac = idata->hmac; - data->hmac_key = idata->hmac_key; - data->hmac_key_len = idata->hmac_key_len; - data->pkcs = idata->pkcs; + data->hmac_send = idata->hmac_send; + data->hmac_receive = idata->hmac_receive; + data->psn_send = idata->psn_send; + 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; - data->registered = idata->registered; + data->status = idata->status; + + data->created = time(0); /* Update creation time */ } /* Free's all data in the common ID entry data structure. */ @@ -55,16 +61,44 @@ void silc_idlist_del_data(void *entry) silc_cipher_free(idata->send_key); if (idata->receive_key) silc_cipher_free(idata->receive_key); - if (idata->hmac) - silc_hmac_free(idata->hmac); - if (idata->hmac_key) { - memset(idata->hmac_key, 0, idata->hmac_key_len); - silc_free(idata->hmac_key); + if (idata->rekey) { + if (idata->rekey->send_enc_key) { + memset(idata->rekey->send_enc_key, 0, idata->rekey->enc_key_len); + silc_free(idata->rekey->send_enc_key); + } + silc_free(idata->rekey); } - if (idata->pkcs) - silc_pkcs_free(idata->pkcs); + if (idata->hmac_send) + 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 */ + +SILC_TASK_CALLBACK_GLOBAL(silc_idlist_purge) +{ + SilcServer server = app_context; + SilcIDListPurge i = (SilcIDListPurge)context; + + SILC_LOG_DEBUG(("Purging cache")); + + silc_idcache_purge(i->cache); + silc_schedule_task_add(server->schedule, 0, silc_idlist_purge, + (void *)i, i->timeout, 0, + SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW); } /****************************************************************************** @@ -78,16 +112,25 @@ void silc_idlist_del_data(void *entry) when new server connects to us. We also add ourselves to cache with this function. */ -SilcServerEntry -silc_idlist_add_server(SilcIDList id_list, +SilcServerEntry +silc_idlist_add_server(SilcIDList id_list, char *server_name, int server_type, SilcServerID *id, SilcServerEntry router, void *connection) { SilcServerEntry server; + char *server_namec = NULL; SILC_LOG_DEBUG(("Adding new server entry")); + /* Normalize name. This is cached, original is in server context. */ + if (server_name) { + server_namec = silc_identifier_check(server_name, strlen(server_name), + SILC_STRING_UTF8, 256, NULL); + if (!server_namec) + return NULL; + } + server = silc_calloc(1, sizeof(*server)); server->server_name = server_name; server->server_type = server_type; @@ -95,9 +138,10 @@ silc_idlist_add_server(SilcIDList id_list, 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, FALSE)) { + if (!silc_idcache_add(id_list->servers, server_namec, + (void *)server->id, (void *)server, 0, NULL)) { silc_free(server); + silc_free(server_namec); return NULL; } @@ -108,7 +152,7 @@ silc_idlist_add_server(SilcIDList id_list, SilcServerEntry silc_idlist_find_server_by_id(SilcIDList id_list, SilcServerID *id, - SilcIDCacheEntry *ret_entry) + bool registered, SilcIDCacheEntry *ret_entry) { SilcIDCacheEntry id_cache = NULL; SilcServerEntry server; @@ -119,37 +163,49 @@ silc_idlist_find_server_by_id(SilcIDList id_list, SilcServerID *id, SILC_LOG_DEBUG(("Server ID (%s)", silc_id_render(id, SILC_ID_SERVER))); - if (!silc_idcache_find_by_id_one(id_list->servers, (void *)id, - SILC_ID_SERVER, &id_cache)) + if (!silc_idcache_find_by_id_one(id_list->servers, (void *)id, + &id_cache)) return NULL; server = (SilcServerEntry)id_cache->context; + if (server && registered && + !(server->data.status & SILC_IDLIST_STATUS_REGISTERED)) + return NULL; + if (ret_entry) *ret_entry = id_cache; + SILC_LOG_DEBUG(("Found")); + return server; } -/* Find server by name */ +/* Find server by name. The 'name' must be normalized already. */ SilcServerEntry silc_idlist_find_server_by_name(SilcIDList id_list, char *name, - SilcIDCacheEntry *ret_entry) + bool registered, SilcIDCacheEntry *ret_entry) { SilcIDCacheEntry id_cache = NULL; SilcServerEntry server; SILC_LOG_DEBUG(("Server by name `%s'", name)); - if (!silc_idcache_find_by_data_one(id_list->servers, name, &id_cache)) + if (!silc_idcache_find_by_name_one(id_list->servers, name, &id_cache)) return NULL; server = (SilcServerEntry)id_cache->context; - + + if (server && registered && + !(server->data.status & SILC_IDLIST_STATUS_REGISTERED)) + return NULL; + if (ret_entry) *ret_entry = id_cache; + SILC_LOG_DEBUG(("Found")); + return server; } @@ -157,17 +213,17 @@ silc_idlist_find_server_by_name(SilcIDList id_list, char *name, SilcServerEntry silc_idlist_find_server_by_conn(SilcIDList id_list, char *hostname, - int port, SilcIDCacheEntry *ret_entry) + int port, bool registered, + SilcIDCacheEntry *ret_entry) { SilcIDCacheList list = NULL; SilcIDCacheEntry id_cache = NULL; SilcServerEntry server = NULL; SilcSocketConnection sock; - + SILC_LOG_DEBUG(("Server by hostname %s and port %d", hostname, port)); - if (!silc_idcache_find_by_id(id_list->servers, SILC_ID_CACHE_ANY, - SILC_ID_SERVER, &list)) + if (!silc_idcache_get_all(id_list->servers, &list)) return NULL; if (!silc_idcache_list_first(list, &id_cache)) { @@ -178,9 +234,10 @@ silc_idlist_find_server_by_conn(SilcIDList id_list, char *hostname, while (id_cache) { 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 && !strcasecmp(sock->hostname, hostname)) || + (sock->ip && !strcasecmp(sock->ip, hostname))) + && server->id->port == SILC_SWAB_16(port)) break; id_cache = NULL; @@ -189,9 +246,13 @@ silc_idlist_find_server_by_conn(SilcIDList id_list, char *hostname, if (!silc_idcache_list_next(list, &id_cache)) break; } - + silc_idcache_list_free(list); + if (server && registered && + !(server->data.status & SILC_IDLIST_STATUS_REGISTERED)) + return NULL; + if (ret_entry) *ret_entry = id_cache; @@ -200,7 +261,7 @@ silc_idlist_find_server_by_conn(SilcIDList id_list, char *hostname, return server; } -/* Replaces old Server ID with new one */ +/* Replaces old Server ID with new one */ SilcServerEntry silc_idlist_replace_server_id(SilcIDList id_list, SilcServerID *old_id, @@ -208,43 +269,61 @@ silc_idlist_replace_server_id(SilcIDList id_list, SilcServerID *old_id, { SilcIDCacheEntry id_cache = NULL; SilcServerEntry server; + char *name; if (!old_id || !new_id) return NULL; SILC_LOG_DEBUG(("Replacing Server ID")); - if (!silc_idcache_find_by_id_one(id_list->servers, (void *)old_id, - SILC_ID_SERVER, &id_cache)) + if (!silc_idcache_find_by_id_one(id_list->servers, (void *)old_id, + &id_cache)) return NULL; server = (SilcServerEntry)id_cache->context; + name = strdup(id_cache->name); + + /* Remove the old entry and add a new one */ + + silc_idcache_del_by_id(id_list->servers, (void *)server->id); + silc_free(server->id); server->id = new_id; - id_cache->id = (void *)new_id; + + silc_idcache_add(id_list->servers, name, server->id, server, 0, NULL); + + 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_context(id_list->servers, entry)) { + SILC_LOG_DEBUG(("Unknown server, did not delete")); + return FALSE; + } + + SILC_LOG_DEBUG(("Deleting server %s id %s", entry->server_name ? + entry->server_name : "", + entry->id ? + silc_id_render(entry->id, SILC_ID_SERVER) : "")); /* Free data */ - if (entry->server_name) - silc_free(entry->server_name); - if (entry->id) - silc_free(entry->id); + silc_free(entry->server_name); + silc_free(entry->id); + silc_free(entry->server_info); memset(entry, 'F', sizeof(*entry)); silc_free(entry); + return TRUE; } + + return FALSE; } /****************************************************************************** @@ -263,27 +342,57 @@ void silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry) to be directly connected local client and `router' must be NULL. */ SilcClientEntry -silc_idlist_add_client(SilcIDList id_list, unsigned char *nickname, - char *username, char *userinfo, SilcClientID *id, - SilcServerEntry router, void *connection) +silc_idlist_add_client(SilcIDList id_list, char *nickname, char *username, + char *userinfo, SilcClientID *id, + SilcServerEntry router, void *connection, + int expire) { SilcClientEntry client; + char *nicknamec = NULL; SILC_LOG_DEBUG(("Adding new client entry")); + /* Normalize name. This is cached, original is in client context. */ + if (nickname) { + nicknamec = silc_identifier_check(nickname, strlen(nickname), + SILC_STRING_UTF8, 128, NULL); + if (!nicknamec) + return NULL; + } + + /* Check username. */ + if (username) { + char *u = NULL, *h = NULL; + silc_parse_userfqdn(username, &u, &h); + if (!u) + return NULL; + if (!silc_identifier_verify(u, strlen(u), SILC_STRING_UTF8, 128)) { + silc_free(u); + silc_free(h); + return NULL; + } + if (h && !silc_identifier_verify(h, strlen(h), SILC_STRING_UTF8, 256)) { + silc_free(u); + silc_free(h); + return NULL; + } + } + client = silc_calloc(1, sizeof(*client)); client->nickname = nickname; - client->username = username; + client->username = username ? strdup(username) : NULL; client->userinfo = userinfo; client->id = id; client->router = router; client->connection = connection; - silc_list_init(client->channels, struct SilcChannelClientEntryStruct, - client_list); + client->channels = silc_hash_table_alloc(3, silc_hash_ptr, NULL, + NULL, NULL, NULL, NULL, TRUE); - if (!silc_idcache_add(id_list->clients, nickname, SILC_ID_CLIENT, - (void *)client->id, (void *)client, TRUE, FALSE)) { + if (!silc_idcache_add(id_list->clients, nicknamec, (void *)client->id, + (void *)client, expire, NULL)) { + silc_hash_table_free(client->channels); silc_free(client); + silc_free(nicknamec); return NULL; } @@ -295,22 +404,24 @@ silc_idlist_add_client(SilcIDList id_list, unsigned char *nickname, int silc_idlist_del_client(SilcIDList id_list, SilcClientEntry entry) { + SILC_LOG_DEBUG(("Start")); + if (entry) { - /* Remove from cache */ - if (entry->id) - if (!silc_idcache_del_by_id(id_list->clients, SILC_ID_CLIENT, - (void *)entry->id)) - return FALSE; + /* Remove from cache. Destructor callback deletes stuff. */ + if (!silc_idcache_del_by_context(id_list->clients, entry)) { + SILC_LOG_DEBUG(("Unknown client, did not delete")); + return FALSE; + } - /* Free data */ - if (entry->nickname) - silc_free(entry->nickname); - if (entry->username) - silc_free(entry->username); - if (entry->userinfo) - silc_free(entry->userinfo); - if (entry->id) - silc_free(entry->id); + assert(!silc_hash_table_count(entry->channels)); + + silc_free(entry->nickname); + silc_free(entry->servername); + silc_free(entry->username); + silc_free(entry->userinfo); + silc_free(entry->id); + silc_free(entry->attrs); + silc_hash_table_free(entry->channels); memset(entry, 'F', sizeof(*entry)); silc_free(entry); @@ -321,172 +432,111 @@ int silc_idlist_del_client(SilcIDList id_list, SilcClientEntry entry) return FALSE; } -/* Returns all clients matching requested nickname. Number of clients is - returned to `clients_count'. Caller must free the returned table. */ +/* ID Cache destructor */ -SilcClientEntry * -silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname, - char *server, unsigned int *clients_count) +void silc_idlist_client_destructor(SilcIDCache cache, + SilcIDCacheEntry entry) { - SilcIDCacheList list = NULL; - SilcIDCacheEntry id_cache = NULL; - SilcClientEntry *clients; - int i; - - if (!silc_idcache_find_by_data(id_list->clients, nickname, &list)) - return NULL; - - clients = silc_calloc(silc_idcache_list_count(list), sizeof(*clients)); - - i = 0; - silc_idcache_list_first(list, &id_cache); - clients[i++] = (SilcClientEntry)id_cache->context; - - while (silc_idcache_list_next(list, &id_cache)) - clients[i++] = (SilcClientEntry)id_cache->context; - - silc_idcache_list_free(list); - - if (clients_count) - *clients_count = i; + SilcClientEntry client; - return clients; + client = (SilcClientEntry)entry->context; + if (client) { + assert(!silc_hash_table_count(client->channels)); + silc_free(client->nickname); + silc_free(client->servername); + silc_free(client->username); + silc_free(client->userinfo); + silc_free(client->id); + silc_free(client->attrs); + silc_hash_table_free(client->channels); + + memset(client, 'A', sizeof(*client)); + silc_free(client); + } } /* Returns all clients matching requested nickname. Number of clients is - returned to `clients_count'. Caller must free the returned table. */ + returned to `clients_count'. Caller must free the returned table. + The 'nickname' must be normalized already. */ -SilcClientEntry * -silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname, - SilcHash md5hash, - unsigned int *clients_count) +int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname, + char *server, + SilcClientEntry **clients, + SilcUInt32 *clients_count) { SilcIDCacheList list = NULL; SilcIDCacheEntry id_cache = NULL; - SilcClientEntry *clients; - unsigned char hash[32]; - int i; - silc_hash_make(md5hash, nickname, strlen(nickname), hash); + SILC_LOG_DEBUG(("Start")); - if (!silc_idcache_find_by_data(id_list->clients, hash, &list)) - return NULL; + if (!silc_idcache_find_by_name(id_list->clients, nickname, &list)) + 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)[(*clients_count)++] = (SilcClientEntry)id_cache->context; while (silc_idcache_list_next(list, &id_cache)) - clients[i++] = (SilcClientEntry)id_cache->context; - + (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context; silc_idcache_list_free(list); - - if (clients_count) - *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); + SILC_LOG_DEBUG(("Found total %d clients", *clients_count)); - 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. */ +/* Returns all clients matching requested nickname hash. Number of clients + is returned to `clients_count'. Caller must free the returned table. + The 'nickname' must be normalized already. */ -SilcClientEntry -silc_idlist_find_client_by_hash(SilcIDList id_list, char *nickname, - SilcHash md5hash, SilcIDCacheEntry *ret_entry) +int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname, + SilcHash md5hash, + SilcClientEntry **clients, + SilcUInt32 *clients_count) { SilcIDCacheList list = NULL; SilcIDCacheEntry id_cache = NULL; - SilcClientEntry client = NULL; unsigned char hash[32]; + SilcClientID client_id; - SILC_LOG_DEBUG(("Client by hash")); + SILC_LOG_DEBUG(("Start")); silc_hash_make(md5hash, nickname, strlen(nickname), hash); - if (!silc_idcache_find_by_id(id_list->clients, SILC_ID_CACHE_ANY, - SILC_ID_CLIENT, &list)) - return NULL; + /* 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 + other parts of the ID and get all the clients with that hash, ie. + with that nickname, as the hash is from the nickname. */ + memset(&client_id, 0, sizeof(client_id)); + memcpy(&client_id.hash, hash, sizeof(client_id.hash)); + if (!silc_idcache_find_by_id(id_list->clients, &client_id, &list)) + return FALSE; - if (!silc_idcache_list_first(list, &id_cache)) { - silc_idcache_list_free(list); - return NULL; - } + *clients = silc_realloc(*clients, + (silc_idcache_list_count(list) + *clients_count) * + sizeof(**clients)); - while (id_cache) { - client = (SilcClientEntry)id_cache->context; - - if (client && !SILC_ID_COMPARE_HASH(client->id, hash)) - break; + silc_idcache_list_first(list, &id_cache); + (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context; - id_cache = NULL; - client = NULL; + while (silc_idcache_list_next(list, &id_cache)) + (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context; - if (!silc_idcache_list_next(list, &id_cache)) - break; - } - silc_idcache_list_free(list); - if (ret_entry) - *ret_entry = id_cache; - - SILC_LOG_DEBUG(("Found")); + SILC_LOG_DEBUG(("Found total %d clients", *clients_count)); - return client; + return TRUE; } /* Finds client by Client ID */ SilcClientEntry silc_idlist_find_client_by_id(SilcIDList id_list, SilcClientID *id, - SilcIDCacheEntry *ret_entry) + bool registered, SilcIDCacheEntry *ret_entry) { SilcIDCacheEntry id_cache = NULL; SilcClientEntry client; @@ -494,15 +544,25 @@ silc_idlist_find_client_by_id(SilcIDList id_list, SilcClientID *id, if (!id) return NULL; - SILC_LOG_DEBUG(("Client ID (%s)", + SILC_LOG_DEBUG(("Client ID (%s)", silc_id_render(id, SILC_ID_CLIENT))); - if (!silc_idcache_find_by_id_one(id_list->clients, (void *)id, - SILC_ID_CLIENT, &id_cache)) + /* Do extended search since the normal ID comparison function for + Client ID's compares only the hash from the Client ID and not the + entire ID. The silc_hash_client_id_compare compares the entire + Client ID as we want to find one specific Client ID. */ + if (!silc_idcache_find_by_id_one_ext(id_list->clients, (void *)id, + NULL, NULL, + silc_hash_client_id_compare, NULL, + &id_cache)) return NULL; client = (SilcClientEntry)id_cache->context; + if (client && registered && + !(client->data.status & SILC_IDLIST_STATUS_REGISTERED)) + return NULL; + if (ret_entry) *ret_entry = id_cache; @@ -514,64 +574,68 @@ silc_idlist_find_client_by_id(SilcIDList id_list, SilcClientID *id, /* 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; + char *nicknamec = NULL; if (!old_id || !new_id) return NULL; SILC_LOG_DEBUG(("Replacing Client ID")); - if (!silc_idcache_find_by_id_one(id_list->clients, (void *)old_id, - SILC_ID_CLIENT, &id_cache)) + /* Normalize name. This is cached, original is in client context. */ + if (nickname) { + nicknamec = silc_identifier_check(nickname, strlen(nickname), + SILC_STRING_UTF8, 128, NULL); + if (!nicknamec) + return NULL; + } + + /* Do extended search since the normal ID comparison function for + Client ID's compares only the hash from the Client ID and not the + entire ID. The silc_hash_client_id_compare compares the entire + Client ID as we want to find one specific Client ID. */ + if (!silc_idcache_find_by_id_one_ext(id_list->clients, (void *)old_id, + NULL, NULL, + silc_hash_client_id_compare, NULL, + &id_cache)) return NULL; client = (SilcClientEntry)id_cache->context; + + /* Remove the old entry and add a new one */ + + 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; - id_cache->id = (void *)new_id; - - /* If the old ID Cache data was the hash value of the old Client ID - replace it with the hash of new Client ID */ - if (id_cache->data && !SILC_ID_COMPARE_HASH(old_id, id_cache->data)) { - silc_free(id_cache->data); - id_cache->data = silc_calloc(sizeof(new_id->hash), sizeof(unsigned char)); - memcpy(id_cache->data, new_id->hash, sizeof(new_id->hash)); - silc_idcache_sort_by_data(id_list->clients); - } + 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); + + if (!silc_idcache_add(id_list->clients, nicknamec, client->id, + client, 0, NULL)) + return NULL; SILC_LOG_DEBUG(("Replaced")); 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); - } -} /****************************************************************************** @@ -585,9 +649,21 @@ void silc_idlist_client_destructor(SilcIDCache cache, 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; + char *channel_namec = NULL; + + SILC_LOG_DEBUG(("Adding new channel %s", channel_name)); + + /* Normalize name. This is cached, original is in client context. */ + if (channel_name) { + channel_namec = silc_channel_name_check(channel_name, strlen(channel_name), + SILC_STRING_UTF8, 256, NULL); + if (!channel_namec) + return NULL; + } channel = silc_calloc(1, sizeof(*channel)); channel->channel_name = channel_name; @@ -596,60 +672,91 @@ silc_idlist_add_channel(SilcIDList id_list, char *channel_name, int mode, channel->router = router; channel->channel_key = channel_key; channel->hmac = hmac; + channel->created = channel->updated = time(0); if (!channel->hmac) - if (!silc_hmac_alloc("hmac-sha1-96", NULL, &channel->hmac)) { + if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) { silc_free(channel); return NULL; } - silc_list_init(channel->user_list, struct SilcChannelClientEntryStruct, - channel_list); + channel->user_list = silc_hash_table_alloc(3, silc_hash_ptr, NULL, NULL, + NULL, NULL, NULL, TRUE); - if (!silc_idcache_add(id_list->channels, channel->channel_name, - SILC_ID_CHANNEL, (void *)channel->id, - (void *)channel, TRUE, FALSE)) { + if (!silc_idcache_add(id_list->channels, channel_namec, + (void *)channel->id, (void *)channel, expire, NULL)) { + silc_hmac_free(channel->hmac); + silc_hash_table_free(channel->user_list); silc_free(channel); + silc_free(channel_namec); return NULL; } return channel; } +/* Foreach callbcak to free all users from the channel when deleting a + channel entry. */ + +static void silc_idlist_del_channel_foreach(void *key, void *context, + void *user_context) +{ + 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); + silc_free(chl); +} + /* Free channel entry. This free's everything. */ int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry) { if (entry) { - SilcChannelClientEntry chl; - /* Remove from cache */ - if (entry->id) - if (!silc_idcache_del_by_id(id_list->channels, SILC_ID_CHANNEL, - (void *)entry->id)) - return FALSE; + if (!silc_idcache_del_by_context(id_list->channels, entry)) { + SILC_LOG_DEBUG(("Unknown channel, did not delete")); + 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 */ - if (entry->channel_name) - silc_free(entry->channel_name); - if (entry->id) - silc_free(entry->id); - if (entry->topic) - silc_free(entry->topic); + silc_free(entry->channel_name); + silc_free(entry->id); + silc_free(entry->topic); + + if (entry->invite_list) + silc_hash_table_free(entry->invite_list); + if (entry->ban_list) + silc_hash_table_free(entry->ban_list); + if (entry->channel_key) silc_cipher_free(entry->channel_key); if (entry->key) { memset(entry->key, 0, entry->key_len / 8); silc_free(entry->key); } - - /* Free all data, free also any reference from the client's channel - list since they share the same memory. */ - silc_list_start(entry->user_list); - while ((chl = silc_list_get(entry->user_list)) != SILC_LIST_END) { - silc_list_del(chl->client->channels, chl); - silc_list_del(entry->user_list, chl); - silc_free(chl); - } + silc_free(entry->cipher); + if (entry->hmac) + silc_hmac_free(entry->hmac); + silc_free(entry->hmac_name); + silc_free(entry->rekey); + if (entry->founder_key) + silc_pkcs_public_key_free(entry->founder_key); + if (entry->channel_pubkeys) + silc_hash_table_free(entry->channel_pubkeys); memset(entry, 'F', sizeof(*entry)); silc_free(entry); @@ -660,36 +767,28 @@ int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry) } /* Finds channel by channel name. Channel names are unique and they - are not case-sensitive. */ + are not case-sensitive. The 'name' must be normalized already. */ SilcChannelEntry silc_idlist_find_channel_by_name(SilcIDList id_list, char *name, SilcIDCacheEntry *ret_entry) { - SilcIDCacheList list = NULL; SilcIDCacheEntry id_cache = NULL; - SilcChannelEntry channel; - SILC_LOG_DEBUG(("Channel by name")); + SILC_LOG_DEBUG(("Channel by name %s", name)); - if (!silc_idcache_find_by_data_loose(id_list->channels, name, &list)) + if (!silc_idcache_find_by_name_one(id_list->channels, name, &id_cache)) return NULL; - - if (!silc_idcache_list_first(list, &id_cache)) { - silc_idcache_list_free(list); - return NULL; - } - - channel = (SilcChannelEntry)id_cache->context; if (ret_entry) *ret_entry = id_cache; - silc_idcache_list_free(list); - SILC_LOG_DEBUG(("Found")); - return channel; + /* Touch channel */ + ((SilcChannelEntry)id_cache->context)->updated = time(NULL); + + return id_cache->context; } /* Finds channel by Channel ID. */ @@ -707,8 +806,7 @@ silc_idlist_find_channel_by_id(SilcIDList id_list, SilcChannelID *id, SILC_LOG_DEBUG(("Channel ID (%s)", silc_id_render(id, SILC_ID_CHANNEL))); - if (!silc_idcache_find_by_id_one(id_list->channels, (void *)id, - SILC_ID_CHANNEL, &id_cache)) + if (!silc_idcache_find_by_id_one(id_list->channels, (void *)id, &id_cache)) return NULL; channel = (SilcChannelEntry)id_cache->context; @@ -718,6 +816,9 @@ silc_idlist_find_channel_by_id(SilcIDList id_list, SilcChannelID *id, SILC_LOG_DEBUG(("Found")); + /* Touch channel */ + channel->updated = time(NULL); + return channel; } @@ -730,20 +831,76 @@ silc_idlist_replace_channel_id(SilcIDList id_list, SilcChannelID *old_id, { SilcIDCacheEntry id_cache = NULL; SilcChannelEntry channel; + char *name; if (!old_id || !new_id) return NULL; SILC_LOG_DEBUG(("Replacing Channel ID")); - if (!silc_idcache_find_by_id_one(id_list->channels, (void *)old_id, - SILC_ID_CHANNEL, &id_cache)) + if (!silc_idcache_find_by_id_one(id_list->channels, (void *)old_id, + &id_cache)) return NULL; channel = (SilcChannelEntry)id_cache->context; + name = strdup(id_cache->name); + + /* Remove the old entry and add a new one */ + + silc_idcache_del_by_id(id_list->channels, (void *)channel->id); + silc_free(channel->id); channel->id = new_id; - id_cache->id = (void *)new_id; + + silc_idcache_add(id_list->channels, name, channel->id, channel, 0, NULL); + + SILC_LOG_DEBUG(("Replaced")); + + /* Touch channel */ + channel->updated = time(NULL); 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, + SilcUInt32 *channels_count) +{ + SilcIDCacheList list = NULL; + SilcIDCacheEntry id_cache = NULL; + SilcChannelEntry *channels = NULL; + int i = 0; + + SILC_LOG_DEBUG(("Start")); + + if (!channel_id) { + if (!silc_idcache_get_all(id_list->channels, &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); + } else { + if (!silc_idcache_find_by_id_one(id_list->channels, channel_id, &id_cache)) + return NULL; + + i = 1; + channels = silc_calloc(1, sizeof(*channels)); + channels[0] = (SilcChannelEntry)id_cache->context; + } + + if (channels_count) + *channels_count = i; + + return channels; +}