X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=apps%2Fsilcd%2Fidlist.c;h=f762787fe80af56f9e921192b0bb14947bafccce;hp=5f04a26fd691c81ce893bf4a0d34d1128d4b8de2;hb=e5d8d3db6caa344b3d419b884556c21b15e7d123;hpb=0f9738ce962b8498bbed0a75d5fb6fa127e3577f

diff --git a/apps/silcd/idlist.c b/apps/silcd/idlist.c
index 5f04a26f..f762787f 100644
--- a/apps/silcd/idlist.c
+++ b/apps/silcd/idlist.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
 
-  Copyright (C) 1997 - 2000 Pekka Riikonen
+  Copyright (C) 1997 - 2001 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
@@ -17,384 +17,761 @@
   GNU General Public License for more details.
 
 */
-/*
- * $Id$
- * $Log$
- * Revision 1.1.1.1  2000/06/27 11:36:56  priikone
- * 	Importet from internal CVS/Added Log headers.
- *
- *
- */
+/* $Id$ */
 
 #include "serverincludes.h"
 #include "idlist.h"
 
-/* Adds a new server to the list. The pointer sent as argument is allocated
-   and returned. */
+/******************************************************************************
+
+                             Common functions
+
+******************************************************************************/
+
+/* This function is used to add keys and stuff to common ID entry data
+   structure. */
 
-void silc_idlist_add_server(SilcServerList **list, 
-			    char *server_name, int server_type,
-			    SilcServerID *id, SilcServerList *router,
-			    SilcCipher send_key, SilcCipher receive_key,
-			    SilcPKCS public_key, SilcHmac hmac, 
-			    SilcServerList **new_idlist)
+void silc_idlist_add_data(void *entry, SilcIDListData idata)
 {
-  SilcServerList *last, *idlist;
+  SilcIDListData data = (SilcIDListData)entry;
+  data->send_key = idata->send_key;
+  data->receive_key = idata->receive_key;
+  data->rekey = idata->rekey;
+  data->hash = idata->hash;
+  data->hmac_send = idata->hmac_send;
+  data->hmac_receive = idata->hmac_receive;
+  data->public_key = idata->public_key;
+  data->last_receive = idata->last_receive;
+  data->last_sent = idata->last_sent;
+  data->status = idata->status;
+
+  data->created = time(0);	/* Update creation time */
+}
 
-  SILC_LOG_DEBUG(("Adding new server to id list"));
+/* Free's all data in the common ID entry data structure. */
 
-  idlist = silc_calloc(1, sizeof(*idlist));
-  if (idlist == NULL) {
-    SILC_LOG_ERROR(("Could not allocate new server list object"));
-    *new_idlist = NULL;
-    return;
+void silc_idlist_del_data(void *entry)
+{
+  SilcIDListData idata = (SilcIDListData)entry;
+  if (idata->send_key)
+    silc_cipher_free(idata->send_key);
+  if (idata->receive_key)
+    silc_cipher_free(idata->receive_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->hmac_send)		/* Same as idata->hmac_receive */
+    silc_hmac_free(idata->hmac_send);
+  if (idata->public_key)
+    silc_pkcs_public_key_free(idata->public_key);
+}
 
-  /* Set the pointers */
-  idlist->server_name = server_name;
-  idlist->server_type = server_type;
-  idlist->id = id;
-  idlist->router = router;
-  idlist->send_key = send_key;
-  idlist->receive_key = receive_key;
-  idlist->public_key = public_key;
-  idlist->hmac = hmac;
-  idlist->next = idlist;
-  idlist->prev = idlist;
-
-  /* First on the list? */
-  if (!*list) {
-    *list = idlist;
-    *new_idlist = idlist;
-    return;
-  }
+/* Purges ID cache */
+
+SILC_TASK_CALLBACK_GLOBAL(silc_idlist_purge)
+{
+  SilcIDListPurge i = (SilcIDListPurge)context;
 
-  /* Add it to the list */
-  last = (*list)->prev;
-  last->next = idlist;
-  (*list)->prev = idlist;
-  idlist->next = (*list);
-  idlist->prev = last;
+  SILC_LOG_DEBUG(("Start"));
 
-  if (new_idlist)
-    *new_idlist = idlist;
+  silc_idcache_purge(i->cache);
+  silc_schedule_task_add(i->schedule, 0, 
+			 silc_idlist_purge,
+			 (void *)i, 600, 0,
+			 SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
 }
 
-/* Adds a new client to the client list. This is called when new client 
-   connection is accepted to the server. This adds all the relevant data 
-   about the client and session with it to the list. This list is 
-   referenced for example when sending message to the client. */
-
-void silc_idlist_add_client(SilcClientList **list, char *nickname,
-			    char *username, char *userinfo,
-			    SilcClientID *id, SilcServerList *router,
-			    SilcCipher send_key, SilcCipher receive_key,
-			    SilcPKCS public_key, SilcHmac hmac, 
-			    SilcClientList **new_idlist)
+/******************************************************************************
+
+                          Server entry functions
+
+******************************************************************************/
+
+/* Add new server entry. This adds the new server entry to ID cache and
+   returns the allocated entry object or NULL on error. This is called
+   when new server connects to us. We also add ourselves to cache with
+   this function. */
+
+SilcServerEntry 
+silc_idlist_add_server(SilcIDList id_list, 
+		       char *server_name, int server_type,
+		       SilcServerID *id, SilcServerEntry router,
+		       void *connection)
 {
-  SilcClientList *last, *idlist;
+  SilcServerEntry server;
 
-  SILC_LOG_DEBUG(("Adding new client to id list"));
+  SILC_LOG_DEBUG(("Adding new server entry"));
 
-  idlist = silc_calloc(1, sizeof(*idlist));
-  if (idlist == NULL) {
-    SILC_LOG_ERROR(("Could not allocate new client list object"));
-    return;
-  }
+  server = silc_calloc(1, sizeof(*server));
+  server->server_name = server_name;
+  server->server_type = server_type;
+  server->id = id;
+  server->router = router;
+  server->connection = connection;
 
-  /* Set the pointers */
-  idlist->nickname = nickname;
-  idlist->username = username;
-  idlist->userinfo = userinfo;
-  idlist->id = id;
-  idlist->router = router;
-  idlist->send_key = send_key;
-  idlist->receive_key = receive_key;
-  idlist->public_key = public_key;
-  idlist->hmac = hmac;
-  idlist->next = idlist;
-  idlist->prev = idlist;
-
-  /* First on the list? */
-  if (!(*list)) {
-    *list = idlist;
-    if (new_idlist)
-      *new_idlist = idlist;
-    return;
+  if (!silc_idcache_add(id_list->servers, server->server_name, 
+			(void *)server->id, (void *)server, FALSE)) {
+    silc_free(server);
+    return NULL;
   }
 
-  /* Add it to the list */
-  last = (*list)->prev;
-  last->next = idlist;
-  (*list)->prev = idlist;
-  idlist->next = *list;
-  idlist->prev = last;
-
-  if (new_idlist)
-    *new_idlist = idlist;
+  return server;
 }
 
-/* Free client entry.  This free's everything. */
+/* Finds server by Server ID */
 
-void silc_idlist_del_client(SilcClientList **list, SilcClientList *entry)
+SilcServerEntry
+silc_idlist_find_server_by_id(SilcIDList id_list, SilcServerID *id,
+			      bool registered, SilcIDCacheEntry *ret_entry)
 {
-  if (entry) {
-    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);
-    if (entry->send_key)
-      silc_cipher_free(entry->send_key);
-    if (entry->receive_key)
-      silc_cipher_free(entry->receive_key);
-    if (entry->public_key)
-      silc_pkcs_free(entry->public_key);
-    if (entry->hmac)
-      silc_hmac_free(entry->hmac);
-    if (entry->hmac_key) {
-      memset(entry->hmac_key, 0, entry->hmac_key_len);
-      silc_free(entry->hmac_key);
-    }
+  SilcIDCacheEntry id_cache = NULL;
+  SilcServerEntry server;
 
-    /* Last one in list? */
-    if (*list == entry && entry->next == entry) {
-      *list = NULL;
-      silc_free(entry);
-      return;
-    }
+  if (!id)
+    return NULL;
 
-    /* At the start of list? */
-    if (*list == entry && entry->next != entry) {
-      *list = entry->next;
-      entry->next->prev = entry->prev;
-      entry->prev->next = *list;
-      silc_free(entry);
-      return;
-    }
+  SILC_LOG_DEBUG(("Server ID (%s)",
+		  silc_id_render(id, SILC_ID_SERVER)));
 
-    /* Remove from list */
-    entry->prev->next = entry->next;
-    entry->next->prev = entry->prev;
-    silc_free(entry);
-    return;
-  }
+  if (!silc_idcache_find_by_id_one(id_list->servers, (void *)id, 
+				   &id_cache))
+    return NULL;
+
+  server = (SilcServerEntry)id_cache->context;
+
+  if (ret_entry)
+    *ret_entry = id_cache;
+
+  if (server && registered && 
+      !(server->data.status & SILC_IDLIST_STATUS_REGISTERED))
+    return NULL;
+
+  SILC_LOG_DEBUG(("Found"));
+
+  return server;
 }
 
-SilcClientList *
-silc_idlist_find_client_by_nickname(SilcClientList *list,
-				    char *nickname,
-				    char *server)
+/* Find server by name */
+
+SilcServerEntry
+silc_idlist_find_server_by_name(SilcIDList id_list, char *name,
+				bool registered, SilcIDCacheEntry *ret_entry)
 {
-  SilcClientList *first, *entry;
+  SilcIDCacheEntry id_cache = NULL;
+  SilcServerEntry server;
+
+  SILC_LOG_DEBUG(("Server by name `%s'", name));
+
+  if (!silc_idcache_find_by_name_one(id_list->servers, name, &id_cache))
+    return NULL;
 
-  SILC_LOG_DEBUG(("Finding client by nickname"));
+  server = (SilcServerEntry)id_cache->context;
+  
+  if (ret_entry)
+    *ret_entry = id_cache;
+
+  if (server && registered &&
+      !(server->data.status & SILC_IDLIST_STATUS_REGISTERED))
+    return NULL;
+
+  SILC_LOG_DEBUG(("Found"));
+
+  return server;
+}
 
-  if (!list)
+/* Find server by connection parameters, hostname and port */
+
+SilcServerEntry
+silc_idlist_find_server_by_conn(SilcIDList id_list, char *hostname,
+				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_get_all(id_list->servers, &list))
     return NULL;
 
-  first = entry = list;
-  if (!strcmp(entry->nickname, nickname)) {
-    SILC_LOG_DEBUG(("Found"));
-    return entry;
+  if (!silc_idcache_list_first(list, &id_cache)) {
+    silc_idcache_list_free(list);
+    return NULL;
   }
-  entry = entry->next;
 
-  while(entry != first) {
-    if (!strcmp(entry->nickname, nickname)) {
-      SILC_LOG_DEBUG(("Found"));
-      return entry;
-    }
+  while (id_cache) {
+    server = (SilcServerEntry)id_cache->context;
+    sock = (SilcSocketConnection)server->connection;
+    
+    if (sock && ((sock->hostname && !strcasecmp(sock->hostname, hostname)) ||
+		 (sock->ip && !strcasecmp(sock->ip, hostname)))
+	&& sock->port == port)
+      break;
+
+    id_cache = NULL;
+    server = NULL;
 
-    entry = entry->next;
+    if (!silc_idcache_list_next(list, &id_cache))
+      break;
   }
+  
+  silc_idcache_list_free(list);
 
-  return NULL;
+  if (ret_entry)
+    *ret_entry = id_cache;
+
+  if (server && registered &&
+      !(server->data.status & SILC_IDLIST_STATUS_REGISTERED))
+    return NULL;
+
+  SILC_LOG_DEBUG(("Found"));
+
+  return server;
 }
 
-SilcClientList *
-silc_idlist_find_client_by_hash(SilcClientList *list,
-				char *nickname, SilcHash md5hash)
+/* Replaces old Server ID with new one */ 
+
+SilcServerEntry
+silc_idlist_replace_server_id(SilcIDList id_list, SilcServerID *old_id,
+			      SilcServerID *new_id)
 {
-  SilcClientList *first, *entry;
-  unsigned char hash[16];
+  SilcIDCacheEntry id_cache = NULL;
+  SilcServerEntry server;
+
+  if (!old_id || !new_id)
+    return NULL;
 
-  SILC_LOG_DEBUG(("Finding client by nickname hash"));
+  SILC_LOG_DEBUG(("Replacing Server ID"));
 
-  if (!list)
+  if (!silc_idcache_find_by_id_one(id_list->servers, (void *)old_id, 
+				   &id_cache))
     return NULL;
 
-  /* Make hash of the nickname */
-  silc_hash_make(md5hash, nickname, strlen(nickname), hash);
+  server = (SilcServerEntry)id_cache->context;
 
-  first = entry = list;
-  if (entry && !SILC_ID_COMPARE_HASH(entry->id, hash)) {
-    SILC_LOG_DEBUG(("Found"));
-    return entry;
-  }
-  entry = entry->next;
+  /* Remove the old entry and add a new one */
 
-  while(entry != first) {
-    if (entry && !SILC_ID_COMPARE_HASH(entry->id, hash)) {
-      SILC_LOG_DEBUG(("Found"));
-      return entry;
-    }
+  silc_idcache_del_by_id(id_list->servers, (void *)server->id);
 
-    entry = entry->next;
-  }
+  silc_free(server->id);
+  server->id = new_id;
+
+  silc_idcache_add(id_list->servers, server->server_name, server->id, 
+		   server, FALSE);
 
-  return NULL;
+  SILC_LOG_DEBUG(("Found"));
+
+  return server;
 }
 
-SilcClientList *
-silc_idlist_find_client_by_id(SilcClientList *list, SilcClientID *id)
+/* Removes and free's server entry from ID list */
+
+int silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry)
 {
-  SilcClientList *first, *entry;
+  SILC_LOG_DEBUG(("Start"));
 
-  SILC_LOG_DEBUG(("Finding client by Client ID"));
+  if (entry) {
+    /* Remove from cache */
+    if (entry->id)
+      if (!silc_idcache_del_by_id(id_list->servers, (void *)entry->id))
+	return FALSE;
 
-  if (!list)
-    return NULL;
+    /* Free data */
+    silc_free(entry->server_name);
+    silc_free(entry->id);
 
-  first = entry = list;
-  if (entry && !SILC_ID_CLIENT_COMPARE(entry->id, id)) {
-    SILC_LOG_DEBUG(("Found"));
-    return entry;
+    memset(entry, 'F', sizeof(*entry));
+    silc_free(entry);
+    return TRUE;
   }
-  entry = entry->next;
 
-  while(entry != first) {
-    if (entry && !SILC_ID_CLIENT_COMPARE(entry->id, id)) {
-      SILC_LOG_DEBUG(("Found"));
-      return entry;
-    }
+  return FALSE;
+}
+
+/******************************************************************************
+
+                          Client entry functions
+
+******************************************************************************/
+
+/* Add new client entry. This adds the client entry to ID cache system
+   and returns the allocated client entry or NULL on error.  This is
+   called when new client connection is accepted to the server. If The
+   `router' is provided then the all server routines assume that the client
+   is not directly connected local client but it has router set and is
+   remote.  If this is the case then `connection' must be NULL.  If, on the
+   other hand, the `connection' is provided then the client is assumed
+   to be directly connected local client and `router' must be NULL. */
 
-    entry = entry->next;
+SilcClientEntry
+silc_idlist_add_client(SilcIDList id_list, char *nickname, char *username, 
+		       char *userinfo, SilcClientID *id, 
+		       SilcServerEntry router, void *connection)
+{
+  SilcClientEntry client;
+
+  SILC_LOG_DEBUG(("Adding new client entry"));
+
+  client = silc_calloc(1, sizeof(*client));
+  client->nickname = nickname;
+  client->username = username;
+  client->userinfo = userinfo;
+  client->id = id;
+  client->router = router;
+  client->connection = connection;
+  client->channels = silc_hash_table_alloc(3, silc_hash_ptr, NULL,
+					   NULL, NULL, NULL, NULL, TRUE);
+
+  if (!silc_idcache_add(id_list->clients, nickname, (void *)client->id, 
+			(void *)client, FALSE)) {
+    silc_hash_table_free(client->channels);
+    silc_free(client);
+    return NULL;
   }
 
-  return NULL;
+  return client;
 }
 
-/* Adds new channel to the list. */
+/* Free client entry. This free's everything and removes the entry
+   from ID cache. Call silc_idlist_del_data before calling this one. */
 
-void silc_idlist_add_channel(SilcChannelList **list, 
-			     char *channel_name, int mode,
-			     SilcChannelID *id, SilcServerList *router,
-			     SilcCipher channel_key,
-			     SilcChannelList **new_idlist)
+int silc_idlist_del_client(SilcIDList id_list, SilcClientEntry entry)
 {
-  SilcChannelList *last, *idlist;
+  SILC_LOG_DEBUG(("Start"));
+
+  if (entry) {
+    /* Remove from cache */
+    if (entry->id)
+      if (!silc_idcache_del_by_context(id_list->clients, entry))
+	return FALSE;
 
-  SILC_LOG_DEBUG(("Adding new channel to id list"));
+    /* Free data */
+    silc_free(entry->nickname);
+    silc_free(entry->username);
+    silc_free(entry->userinfo);
+    silc_free(entry->id);
 
-  idlist = silc_calloc(1, sizeof(*idlist));
-  if (idlist == NULL) {
-    SILC_LOG_ERROR(("Could not allocate new channel list object"));
-    return;
-  }
+    memset(entry, 'F', sizeof(*entry));
+    silc_free(entry);
 
-  /* Set the pointers */
-  idlist->channel_name = channel_name;
-  idlist->mode = mode;
-  idlist->id = id;
-  idlist->router = router;
-  idlist->channel_key = channel_key;
-  idlist->next = idlist;
-  idlist->prev = idlist;
-
-  /* First on the list? */
-  if (!*list) {
-    *list = idlist;
-    if (new_idlist)
-      *new_idlist = idlist;
-    return;
+    return TRUE;
   }
 
-  /* Add it to the list */
-  last = (*list)->prev;
-  last->next = idlist;
-  (*list)->prev = idlist;
-  idlist->next = (*list);
-  idlist->prev = last;
+  return FALSE;
+}
+
+/* Returns all clients matching requested nickname. Number of clients is
+   returned to `clients_count'. Caller must free the returned table. */
+
+int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
+					char *server, 
+					SilcClientEntry **clients,
+					uint32 *clients_count)
+{
+  SilcIDCacheList list = NULL;
+  SilcIDCacheEntry id_cache = NULL;
+
+  SILC_LOG_DEBUG(("Start"));
+
+  if (!silc_idcache_find_by_name(id_list->clients, nickname, &list))
+    return FALSE;
+
+  *clients = silc_realloc(*clients, 
+			  (silc_idcache_list_count(list) + *clients_count) * 
+			  sizeof(**clients));
+
+  silc_idcache_list_first(list, &id_cache);
+  (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context;
+
+  while (silc_idcache_list_next(list, &id_cache))
+    (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context;
+  
+  silc_idcache_list_free(list);
+  
+  SILC_LOG_DEBUG(("Found total %d clients", *clients_count));
+
+  return TRUE;
+}
+
+/* Returns all clients matching requested nickname hash. Number of clients
+   is returned to `clients_count'. Caller must free the returned table. */
+
+int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
+				    SilcHash md5hash,
+				    SilcClientEntry **clients,
+				    uint32 *clients_count)
+{
+  SilcIDCacheList list = NULL;
+  SilcIDCacheEntry id_cache = NULL;
+  unsigned char hash[32];
+  SilcClientID client_id;
+
+  SILC_LOG_DEBUG(("Start"));
 
-  if (new_idlist)
-    *new_idlist = idlist;
+  silc_hash_make(md5hash, nickname, strlen(nickname), 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
+     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;
+
+  *clients = silc_realloc(*clients, 
+			  (silc_idcache_list_count(list) + *clients_count) * 
+			  sizeof(**clients));
+
+  silc_idcache_list_first(list, &id_cache);
+  (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context;
+
+  while (silc_idcache_list_next(list, &id_cache))
+    (*clients)[(*clients_count)++] = (SilcClientEntry)id_cache->context;
+  
+  silc_idcache_list_free(list);
+  
+  SILC_LOG_DEBUG(("Found total %d clients", *clients_count));
+
+  return TRUE;
 }
 
-SilcChannelList *
-silc_idlist_find_channel_by_id(SilcChannelList *list, SilcChannelID *id)
+/* Finds client by Client ID */
+
+SilcClientEntry
+silc_idlist_find_client_by_id(SilcIDList id_list, SilcClientID *id,
+			      bool registered, SilcIDCacheEntry *ret_entry)
 {
-  SilcChannelList *first, *entry;
+  SilcIDCacheEntry id_cache = NULL;
+  SilcClientEntry client;
+
+  if (!id)
+    return NULL;
+
+  SILC_LOG_DEBUG(("Client ID (%s)", 
+		  silc_id_render(id, SILC_ID_CLIENT)));
+
+  /* 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 (ret_entry)
+    *ret_entry = id_cache;
+
+  if (client && registered &&
+      !(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
+    return NULL;
+
+  SILC_LOG_DEBUG(("Found"));
+
+  return client;
+}
+
+/* Replaces old Client ID with new one */
+
+SilcClientEntry
+silc_idlist_replace_client_id(SilcIDList id_list, SilcClientID *old_id,
+			      SilcClientID *new_id)
+{
+  SilcIDCacheEntry id_cache = NULL;
+  SilcClientEntry client;
+
+  if (!old_id || !new_id)
+    return NULL;
 
-  SILC_LOG_DEBUG(("Finding channel by Channel ID"));
+  SILC_LOG_DEBUG(("Replacing Client ID"));
 
-  if (!list)
+  /* 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;
 
-  first = entry = list;
-  if (entry && !SILC_ID_CHANNEL_COMPARE(entry->id, id)) {
-    SILC_LOG_DEBUG(("Found"));
-    return entry;
+  client = (SilcClientEntry)id_cache->context;
+
+  /* Remove the old entry and add a new one */
+
+  silc_idcache_del_by_context(id_list->clients, client);
+
+  silc_free(client->id);
+  client->id = new_id;
+
+  silc_idcache_add(id_list->clients, NULL, client->id, client, FALSE);
+
+  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);
   }
-  entry = entry->next;
+}
+
+/******************************************************************************
 
-  while(entry != first) {
-    if (entry && !SILC_ID_CHANNEL_COMPARE(entry->id, id)) {
-      SILC_LOG_DEBUG(("Found"));
-      return entry;
+                          Channel entry functions
+
+******************************************************************************/
+
+/* Add new channel entry. This add the new channel entry to the ID cache
+   system and returns the allocated entry or NULL on error. */
+
+SilcChannelEntry
+silc_idlist_add_channel(SilcIDList id_list, char *channel_name, int mode,
+			SilcChannelID *id, SilcServerEntry router,
+			SilcCipher channel_key, SilcHmac hmac)
+{
+  SilcChannelEntry channel;
+
+  SILC_LOG_DEBUG(("Adding new channel entry"));
+
+  channel = silc_calloc(1, sizeof(*channel));
+  channel->channel_name = channel_name;
+  channel->mode = mode;
+  channel->id = id;
+  channel->router = router;
+  channel->channel_key = channel_key;
+  channel->hmac = hmac;
+  channel->created = time(0);
+  if (!channel->hmac)
+    if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
+      silc_free(channel);
+      return NULL;
     }
 
-    entry = entry->next;
+  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, 
+			(void *)channel->id, (void *)channel, FALSE)) {
+    silc_hmac_free(channel->hmac);
+    silc_hash_table_free(channel->user_list);
+    silc_free(channel);
+    return NULL;
   }
 
-  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;
+
+  /* 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. */
 
-void silc_idlist_del_channel(SilcChannelList **list, SilcChannelList *entry)
+int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry)
 {
+  SILC_LOG_DEBUG(("Start"));
+
   if (entry) {
-    if (entry->channel_name)
-      silc_free(entry->channel_name);
+    /* Remove from cache */
     if (entry->id)
-      silc_free(entry->id);
-    if (entry->topic)
-      silc_free(entry->topic);
+      if (!silc_idcache_del_by_id(id_list->channels, (void *)entry->id))
+	return FALSE;
+
+    /* Free data */
+    silc_free(entry->channel_name);
+    silc_free(entry->id);
+    silc_free(entry->topic);
     if (entry->channel_key)
       silc_cipher_free(entry->channel_key);
     if (entry->key) {
-      memset(entry->key, 0, entry->key_len);
+      memset(entry->key, 0, entry->key_len / 8);
       silc_free(entry->key);
     }
-    memset(entry->iv, 0, sizeof(entry->iv));
+    silc_free(entry->cipher);
+    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);
+
+    memset(entry, 'F', sizeof(*entry));
+    silc_free(entry);
+    return TRUE;
+  }
 
-    if (entry->user_list_count)
-      silc_free(entry->user_list);
+  return FALSE;
+}
 
-    /* Last one in list? */
-    if (*list == entry && entry->next == entry) {
-      *list = NULL;
-      silc_free(entry);
-      return;
-    }
+/* Finds channel by channel name. Channel names are unique and they
+   are not case-sensitive. */
 
-    /* At the start of list? */
-    if (*list == entry && entry->next != entry) {
-      *list = entry->next;
-      entry->next->prev = entry->prev;
-      entry->prev->next = *list;
-      silc_free(entry);
-      return;
-    }
+SilcChannelEntry
+silc_idlist_find_channel_by_name(SilcIDList id_list, char *name,
+				 SilcIDCacheEntry *ret_entry)
+{
+  SilcIDCacheEntry id_cache = NULL;
 
-    /* Remove from list */
-    entry->prev->next = entry->next;
-    entry->next->prev = entry->prev;
-    silc_free(entry);
-    return;
+  SILC_LOG_DEBUG(("Channel by name"));
+
+  if (!silc_idcache_find_by_name_one(id_list->channels, name, &id_cache))
+    return NULL;
+
+  if (ret_entry)
+    *ret_entry = id_cache;
+
+  SILC_LOG_DEBUG(("Found"));
+
+  return id_cache->context;
+}
+
+/* Finds channel by Channel ID. */
+
+SilcChannelEntry
+silc_idlist_find_channel_by_id(SilcIDList id_list, SilcChannelID *id,
+			       SilcIDCacheEntry *ret_entry)
+{
+  SilcIDCacheEntry id_cache = NULL;
+  SilcChannelEntry channel;
+
+  if (!id)
+    return NULL;
+
+  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, &id_cache))
+    return NULL;
+
+  channel = (SilcChannelEntry)id_cache->context;
+
+  if (ret_entry)
+    *ret_entry = id_cache;
+
+  SILC_LOG_DEBUG(("Found"));
+
+  return channel;
+}
+
+/* Replaces old Channel ID with new one. This is done when router forces
+   normal server to change Channel ID. */
+
+SilcChannelEntry
+silc_idlist_replace_channel_id(SilcIDList id_list, SilcChannelID *old_id,
+			       SilcChannelID *new_id)
+{
+  SilcIDCacheEntry id_cache = NULL;
+  SilcChannelEntry channel;
+
+  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, 
+				   &id_cache))
+    return NULL;
+
+  channel = (SilcChannelEntry)id_cache->context;
+
+  /* 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;
+
+  silc_idcache_add(id_list->channels, channel->channel_name, channel->id, 
+		   channel, FALSE);
+
+  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,
+			 uint32 *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;
 }