*/
/* $Id$ */
-#include "silcincludes.h"
+#include "silc.h"
#include "silcidcache.h"
-/* Static prototypes */
-static void silc_idcache_destructor(void *key, void *context,
- void *user_context);
-static SilcIDCacheList silc_idcache_list_alloc();
-static void silc_idcache_list_add(SilcIDCacheList list,
- SilcIDCacheEntry cache);
+/************************** Types and definitions ***************************/
-/*
- SILC ID Cache object.
-
- This is context for the ID cache system. This includes all the cache
- entries and other internal data. This is read-only object and not
- visible outside this cache system.
-
- Fields are as follows:
-
- SilcHashTable id_table
-
- Hash table using the ID as the key.
-
- SilcHashTable name_table
-
- Hash table using the name as the key.
+/* ID Cache context */
+struct SilcIDCacheStruct {
+ SilcHashTable id_table; /* ID hash table */
+ SilcHashTable name_table; /* Name hash table */
+ SilcHashTable context_table; /* Context hash table */
+ SilcIDCacheDestructor destructor; /* Entry destructor */
+ void *context; /* Destructor context */
+ SilcIdType id_type; /* Type of ID cache */
+};
- SilcHashTable context_table
- Hash table using the context as the key.
+/************************ Static utility functions **************************/
- SilcIDCacheDestructor destructor
+/* Callback that is called by the hash table routine when traversing
+ entries in the hash table. */
- Destructor callback that is called when an cache entry expires or is
- purged from the ID cache. The application must not free cache entry
- because the library will do it automatically. The appliation, however,
- is responsible of freeing any data in the entry.
+static void silc_idcache_get_all_foreach(void *key, void *context,
+ void *user_context)
+{
+ SilcList *list = user_context;
+ if (!context)
+ return;
+ silc_list_add(*list, context);
+}
- SilcIdType id_type
+/* Cache entry destructor */
- Indicates the type of the ID's this cache holds.
+static void silc_idcache_destructor(SilcIDCache cache,
+ SilcIDCacheEntry entry,
+ void *app_context)
+{
+ if (cache->destructor)
+ cache->destructor(cache, entry, cache->destructor, app_context);
-*/
-struct SilcIDCacheStruct {
- SilcHashTable id_table;
- SilcHashTable name_table;
- SilcHashTable context_table;
- SilcIDCacheDestructor destructor;
- void *context;
- SilcIdType type;
- unsigned int delete_id : 1;
- unsigned int delete_name : 1;
-};
+ memset(entry, 'F', sizeof(*entry));
+ silc_free(entry);
+}
-/*
- ID Cache list.
- This is returned when searching the cache. Enumeration functions are
- provided to traverse the list; actually this is used as table not as
- list. :)
+/****************************** Public API **********************************/
- By default the found cache entries are saved into the static cache
- table to provide access without reallocation. However, if the static
- table is full, rest of the cache entries are dynamically allocated
- into `cache_dyn' table. Traversing functions automatically handles
- these situations.
-
-*/
-struct SilcIDCacheListStruct {
- SilcIDCacheEntry cache[128];
- SilcIDCacheEntry *cache_dyn;
- SilcUInt32 cache_dyn_count;
- SilcUInt32 cache_count;
- SilcUInt32 pos;
- bool dyn;
-};
-
-/* Allocates new ID cache object. The initial amount of allocated entries
- can be sent as argument. If `count' is 0 the system uses default values.
- The `id_type' defines the types of the ID's that will be saved to the
- cache. */
+/* Allocates new ID cache object. */
SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
SilcIDCacheDestructor destructor,
- void *destructor_context,
- bool delete_id, bool delete_name)
+ void *destructor_context)
{
SilcIDCache cache;
cache = silc_calloc(1, sizeof(*cache));
if (!cache)
return NULL;
+
cache->id_table = silc_hash_table_alloc(count, silc_hash_id,
SILC_32_TO_PTR(id_type),
silc_hash_id_compare,
SILC_32_TO_PTR(id_type),
- silc_idcache_destructor,
- cache, TRUE);
+ NULL, NULL, TRUE);
cache->name_table = silc_hash_table_alloc(count, silc_hash_utf8_string, NULL,
silc_hash_utf8_compare, NULL,
NULL, NULL, TRUE);
NULL, NULL, NULL, NULL, TRUE);
cache->destructor = destructor;
cache->context = destructor_context;
- cache->type = id_type;
- cache->delete_id = delete_id;
- cache->delete_name = delete_name;
+ cache->id_type = id_type;
if (!cache->id_table || !cache->name_table || !cache->context_table) {
if (cache->id_table)
void silc_idcache_free(SilcIDCache cache)
{
- if (cache) {
- silc_hash_table_free(cache->id_table);
- silc_hash_table_free(cache->name_table);
- silc_hash_table_free(cache->context_table);
- silc_free(cache);
- }
+ silc_hash_table_free(cache->id_table);
+ silc_hash_table_free(cache->name_table);
+ silc_hash_table_free(cache->context_table);
+ silc_free(cache);
}
-/* Add new entry to the cache. Returns TRUE if the entry was added and
- FALSE if it could not be added. The `name' is the name associated with
- the ID, the `id' the actual ID and the `context' a used specific context.
- If the `expire' is TRUE the entry expires in default time and if FALSE
- the entry never expires from the cache. */
+/* Add new entry to cache */
-bool silc_idcache_add(SilcIDCache cache, char *name, void *id,
- void *context, int expire, SilcIDCacheEntry *ret)
+SilcIDCacheEntry
+silc_idcache_add(SilcIDCache cache, char *name, void *id, void *context)
{
SilcIDCacheEntry c;
- SILC_LOG_DEBUG(("Adding cache entry"));
+ if (!id)
+ return NULL;
/* Allocate new cache entry */
c = silc_calloc(1, sizeof(*c));
if (!c)
- return FALSE;
+ return NULL;
+
c->id = id;
c->name = name;
- c->expire = expire;
c->context = context;
+ SILC_LOG_DEBUG(("Adding cache entry %p", c));
+
/* Add the new entry to the hash tables */
- if (id)
- silc_hash_table_add(cache->id_table, id, c);
+ if (id) {
+ if (silc_idcache_find_by_id_one(cache, id, NULL)) {
+ SILC_LOG_ERROR(("Attempted to add same ID twice to ID Cache"));
+ goto err;
+ }
+ if (!silc_hash_table_add(cache->id_table, id, c))
+ goto err;
+ }
if (name)
- silc_hash_table_add(cache->name_table, name, c);
+ if (!silc_hash_table_add(cache->name_table, name, c))
+ goto err;
if (context)
- silc_hash_table_add(cache->context_table, context, c);
+ if (!silc_hash_table_add(cache->context_table, context, c))
+ goto err;
- if (ret)
- *ret = c;
+ return c;
- return TRUE;
-}
-
-/* Destructor for the ID Cache entry */
+ err:
+ if (c->name)
+ silc_hash_table_del_by_context(cache->name_table, c->name, c);
+ if (c->context)
+ silc_hash_table_del_by_context(cache->context_table, c->context, c);
+ if (c->id)
+ silc_hash_table_del_by_context(cache->id_table, c->id, c);
+ silc_free(c);
-static void silc_idcache_destructor(void *key, void *context,
- void *user_context)
-{
- SilcIDCacheEntry c = context;
- if (c) {
- SilcIDCache cache = user_context;
- if (cache) {
- if (cache->delete_id)
- silc_free(c->id);
- if (cache->delete_name)
- silc_free(c->name);
- }
- memset(c, 'F', sizeof(*c));
- silc_free(c);
- }
+ return NULL;
}
/* Delete cache entry from cache. */
-bool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry old)
+SilcBool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry entry,
+ void *app_context)
{
- bool ret = FALSE;
-
- SILC_LOG_DEBUG(("Deleting cache entry"));
-
- if (old->name)
- ret = silc_hash_table_del_by_context(cache->name_table, old->name, old);
- if (old->context)
- ret = silc_hash_table_del(cache->context_table, old->context);
- if (old->id)
- ret = silc_hash_table_del(cache->id_table, old->id);
- else {
- silc_idcache_destructor(NULL, old, NULL);
- ret = TRUE;
- }
-
- return ret;
-}
+ SilcBool ret = FALSE;
-/* Deletes ID cache entry by ID. */
+ SILC_LOG_DEBUG(("Deleting cache entry %p", entry));
-bool silc_idcache_del_by_id(SilcIDCache cache, void *id)
-{
- SilcIDCacheEntry c;
+ if (entry->name)
+ ret = silc_hash_table_del_by_context(cache->name_table, entry->name,
+ entry);
+ if (entry->context)
+ ret = silc_hash_table_del_by_context(cache->context_table, entry->context,
+ entry);
+ if (entry->id)
+ ret = silc_hash_table_del_by_context(cache->id_table, entry->id,
+ entry);
- if (!silc_hash_table_find(cache->id_table, id, NULL, (void *)&c))
- return FALSE;
+ if (ret)
+ silc_idcache_destructor(cache, entry, app_context);
- return silc_idcache_del(cache, c);
+ return ret;
}
-/* Same as above but with specific hash and comparison functions. If the
- functions are NULL then default values are used. */
+/* Deletes ID cache entry by ID. */
-bool silc_idcache_del_by_id_ext(SilcIDCache cache, void *id,
- SilcHashFunction hash,
- void *hash_context,
- SilcHashCompare compare,
- void *compare_context)
+SilcBool silc_idcache_del_by_id(SilcIDCache cache, void *id,
+ void *app_context)
{
SilcIDCacheEntry c;
- bool ret = FALSE;
-
- SILC_LOG_DEBUG(("Deleting cache entry"));
- if (!silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)&c,
- hash, hash_context, compare,
- compare_context))
+ if (!silc_hash_table_find(cache->id_table, id, NULL, (void **)&c))
return FALSE;
- if (c->name)
- ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
- if (c->context)
- ret = silc_hash_table_del(cache->context_table, c->context);
- if (c->id)
- ret = silc_hash_table_del_ext(cache->id_table, c->id, hash,
- hash_context, compare, compare_context,
- NULL, NULL);
- return ret;
+ return silc_idcache_del(cache, c, app_context);
}
/* Deletes ID cache entry by context. */
-bool silc_idcache_del_by_context(SilcIDCache cache, void *context)
+SilcBool silc_idcache_del_by_context(SilcIDCache cache, void *context,
+ void *app_context)
{
SilcIDCacheEntry c;
- bool ret = FALSE;
- SILC_LOG_DEBUG(("Deleting cache entry"));
-
- if (!silc_hash_table_find(cache->context_table, context, NULL, (void *)&c))
+ if (!silc_hash_table_find(cache->context_table, context, NULL, (void **)&c))
return FALSE;
- if (c->name)
- ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
- if (c->context)
- ret = silc_hash_table_del(cache->context_table, c->context);
- if (c->id)
- ret = silc_hash_table_del_by_context(cache->id_table, c->id, c);
- else {
- silc_idcache_destructor(NULL, c, NULL);
- ret = TRUE;
- }
-
- return ret;
+ return silc_idcache_del(cache, c, app_context);
}
-/* Deletes all ID entries from cache. Free's memory as well. */
-
-bool silc_idcache_del_all(SilcIDCache cache)
-{
- silc_hash_table_free(cache->id_table);
- silc_hash_table_free(cache->name_table);
- silc_hash_table_free(cache->context_table);
-
- return TRUE;
-}
+/* Update entry */
-static void silc_idcache_destructor_dummy(void *key, void *context,
- void *user_context)
+SilcBool silc_idcache_update(SilcIDCache cache, SilcIDCacheEntry entry,
+ void *old_id, void *new_id,
+ char *old_name, char *new_name)
{
- /* Dummy - nothing */
-}
+ if (old_id && new_id) {
+ if (!silc_hash_table_del_by_context(cache->id_table, old_id, entry))
+ return FALSE;
-/* Foreach callback fro silc_idcache_purge. */
+ entry->id = new_id;
-static void silc_idcache_purge_foreach(void *key, void *context,
- void *user_context)
-{
- SilcIDCache cache = (SilcIDCache)user_context;
- SilcUInt32 curtime = time(NULL);
- SilcIDCacheEntry c = (SilcIDCacheEntry)context;
- bool ret = FALSE;
-
- if (!context)
- return;
-
- if (c->expire && c->expire < curtime) {
- /* Remove the entry from the hash tables */
- if (c->name)
- ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
- if (c->context)
- ret = silc_hash_table_del(cache->context_table, c->context);
- if (c->id)
- ret =
- silc_hash_table_del_by_context_ext(cache->id_table, c->id, c,
- NULL, NULL, NULL, NULL,
- silc_idcache_destructor_dummy,
- NULL);
- if (ret == TRUE) {
- /* Call the destructor */
- if (cache->destructor)
- cache->destructor(cache, c, cache->context);
-
- /* Free the entry, it has been deleted from the hash tables */
- silc_idcache_destructor(NULL, c, NULL);
- }
+ if (!silc_hash_table_add(cache->id_table, entry->id, entry))
+ return FALSE;
}
-}
-
-/* Purges the cache by removing expired cache entires. Note that this
- may be very slow operation. */
-
-bool silc_idcache_purge(SilcIDCache cache)
-{
- silc_hash_table_foreach(cache->id_table, silc_idcache_purge_foreach, cache);
- return TRUE;
-}
-/* Purges the specific entry by context. */
+ if (old_name && new_name) {
+ if (!silc_hash_table_del_by_context(cache->name_table, old_name, entry))
+ return FALSE;
-bool silc_idcache_purge_by_context(SilcIDCache cache, void *context)
-{
- SilcIDCacheEntry c;
- bool ret = FALSE;
-
- if (!silc_hash_table_find(cache->context_table, context, NULL,
- (void *)&c))
- return FALSE;
+ entry->name = new_name;
- /* Remove the entry from the hash tables */
- if (c->name)
- ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
- if (c->context)
- ret = silc_hash_table_del(cache->context_table, c->context);
- if (c->id)
- ret =
- silc_hash_table_del_by_context_ext(cache->id_table, c->id, c,
- NULL, NULL, NULL, NULL,
- silc_idcache_destructor_dummy, NULL);
- if (ret == TRUE) {
- /* Call the destructor */
- if (cache->destructor)
- cache->destructor(cache, c, cache->context);
-
- /* Free the entry, it has been deleted from the hash tables */
- silc_idcache_destructor(NULL, c, NULL);
+ if (!silc_hash_table_add(cache->name_table, entry->name, entry))
+ return FALSE;
}
- return ret;
-}
-
-/* Callback that is called by the hash table routine when traversing
- entrys in the hash table. */
-
-static void silc_idcache_get_all_foreach(void *key, void *context,
- void *user_context)
-{
- SilcIDCacheList list = (SilcIDCacheList)user_context;
- if (!context)
- return;
- silc_idcache_list_add(list, (SilcIDCacheEntry)context);
+ return TRUE;
}
/* Returns all cache entrys from the ID cache to the `ret' ID Cache List. */
-bool silc_idcache_get_all(SilcIDCache cache, SilcIDCacheList *ret)
+SilcBool silc_idcache_get_all(SilcIDCache cache, SilcList *ret_list)
{
- SilcIDCacheList list;
-
- if (!ret)
- return TRUE;
-
- list = silc_idcache_list_alloc();
- if (!list)
+ if (!ret_list)
return FALSE;
- silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach, list);
- if (silc_idcache_list_count(list) == 0) {
- silc_idcache_list_free(list);
+ if (!silc_hash_table_count(cache->id_table))
return FALSE;
- }
- *ret = list;
+ silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach,
+ ret_list);
+
+ if (!silc_list_count(*ret_list))
+ return FALSE;
return TRUE;
}
/* Find ID Cache entry by ID. May return multiple entries. */
-bool silc_idcache_find_by_id(SilcIDCache cache, void *id,
- SilcIDCacheList *ret)
+SilcBool silc_idcache_find_by_id(SilcIDCache cache, void *id,
+ SilcList *ret_list)
{
- SilcIDCacheList list;
-
- list = silc_idcache_list_alloc();
- if (!list)
+ if (!ret_list)
return FALSE;
- if (!ret)
- return TRUE;
+ if (!silc_hash_table_count(cache->id_table))
+ return FALSE;
silc_hash_table_find_foreach(cache->id_table, id,
- silc_idcache_get_all_foreach, list);
+ silc_idcache_get_all_foreach, ret_list);
- if (silc_idcache_list_count(list) == 0) {
- silc_idcache_list_free(list);
+ if (!silc_list_count(*ret_list))
return FALSE;
- }
-
- *ret = list;
return TRUE;
}
-/* Find specific ID with specific hash function and comparison functions.
- If `hash' is NULL then the default hash funtion is used and if `compare'
- is NULL default comparison function is used. */
+/* Find one specific ID entry. Compare full IDs */
-bool silc_idcache_find_by_id_one_ext(SilcIDCache cache, void *id,
- SilcHashFunction hash,
- void *hash_context,
- SilcHashCompare compare,
- void *compare_context,
+SilcBool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
SilcIDCacheEntry *ret)
{
return silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)ret,
- hash, hash_context, compare,
- compare_context);
-}
-
-/* Find one specific ID entry. */
-
-bool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
- SilcIDCacheEntry *ret)
-{
- return silc_hash_table_find(cache->id_table, id, NULL, (void *)ret);
+ NULL, NULL,
+ silc_hash_id_compare_full,
+ SILC_32_TO_PTR(cache->id_type));
}
/* Finds cache entry by context. */
-bool silc_idcache_find_by_context(SilcIDCache cache, void *context,
- SilcIDCacheEntry *ret)
+SilcBool silc_idcache_find_by_context(SilcIDCache cache, void *context,
+ SilcIDCacheEntry *ret)
{
return silc_hash_table_find(cache->context_table, context, NULL,
(void *)ret);
/* Find ID Cache entry by name. Returns list of cache entries. */
-bool silc_idcache_find_by_name(SilcIDCache cache, char *name,
- SilcIDCacheList *ret)
+SilcBool silc_idcache_find_by_name(SilcIDCache cache, char *name,
+ SilcList *ret_list)
{
- SilcIDCacheList list;
-
- list = silc_idcache_list_alloc();
- if (!list)
+ if (!ret_list)
return FALSE;
- if (!ret)
- return TRUE;
+ if (!silc_hash_table_count(cache->name_table))
+ return FALSE;
silc_hash_table_find_foreach(cache->name_table, name,
- silc_idcache_get_all_foreach, list);
+ silc_idcache_get_all_foreach, ret_list);
- if (silc_idcache_list_count(list) == 0) {
- silc_idcache_list_free(list);
+ if (!silc_list_count(*ret_list))
return FALSE;
- }
-
- *ret = list;
return TRUE;
}
/* Find ID Cache entry by name. Returns one cache entry. */
-bool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
- SilcIDCacheEntry *ret)
+SilcBool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
+ SilcIDCacheEntry *ret)
{
- if (!silc_hash_table_find(cache->name_table, name, NULL, (void *)ret))
- return FALSE;
-
- return TRUE;
-}
-
-/* Allocates ID cache list. */
-
-static SilcIDCacheList silc_idcache_list_alloc()
-{
- SilcIDCacheList list;
-
- list = silc_calloc(1, sizeof(*list));
- if (!list)
- return FALSE;
-
- return list;
-}
-
-/* Adds cache entry to the ID cache list. If needed reallocates memory
- for the list. */
-
-static void silc_idcache_list_add(SilcIDCacheList list, SilcIDCacheEntry cache)
-{
- int i;
-
- /* Try to add to static cache */
- if (!list->cache_dyn_count)
- for (i = 0; i < (sizeof(list->cache) / sizeof(list->cache[0])); i++) {
- if (!list->cache[i]) {
- list->cache[i] = cache;
- list->cache_count++;
- return;
- }
- }
-
- /* Static cache is full, allocate dynamic cache */
- for (i = 0; i < list->cache_dyn_count; i++) {
- if (!list->cache_dyn[i]) {
- list->cache_dyn[i] = cache;
- list->cache_count++;
- break;
- }
- }
-
- if (i >= list->cache_dyn_count) {
- int k;
-
- i = list->cache_dyn_count;
- list->cache_dyn = silc_realloc(list->cache_dyn,
- sizeof(*list->cache_dyn) * (i + 5));
- if (!list->cache_dyn)
- return;
-
- /* NULL the reallocated area */
- for (k = i; k < (i + 5); k++)
- list->cache_dyn[k] = NULL;
-
- list->cache_dyn[i] = cache;
- list->cache_count++;
- list->cache_dyn_count += 5;
- }
-}
-
-/* Returns number of cache entries in the ID cache list. */
-
-int silc_idcache_list_count(SilcIDCacheList list)
-{
- return list->cache_count;
-}
-
-/* Returns first entry from the ID cache list. */
-
-bool silc_idcache_list_first(SilcIDCacheList list, SilcIDCacheEntry *ret)
-{
- list->pos = 0;
-
- if (!list->cache[list->pos])
- return FALSE;
-
- if (ret)
- *ret = list->cache[list->pos];
-
- return TRUE;
-}
-
-/* Returns next entry from the ID cache list. */
-
-bool silc_idcache_list_next(SilcIDCacheList list, SilcIDCacheEntry *ret)
-{
- list->pos++;
-
- if (!list->dyn &&
- list->pos >= (sizeof(list->cache) / sizeof(list->cache[0]))) {
- list->pos = 0;
- list->dyn = TRUE;
- }
-
- if (list->dyn && list->pos >= list->cache_dyn_count)
- return FALSE;
-
- if (!list->dyn && !list->cache[list->pos])
- return FALSE;
-
- if (list->dyn && !list->cache_dyn[list->pos])
- return FALSE;
-
- if (ret) {
- if (!list->dyn)
- *ret = list->cache[list->pos];
- else
- *ret = list->cache_dyn[list->pos];
- }
-
- return TRUE;
-}
-
-/* Frees ID cache list. User must free the list object returned by
- any of the searching functions. */
-
-void silc_idcache_list_free(SilcIDCacheList list)
-{
- if (list) {
- if (list->cache_dyn)
- silc_free(list->cache_dyn);
- silc_free(list);
- }
+ return silc_hash_table_find(cache->name_table, name, NULL, (void *)ret);
}
projects / silc.git / blobdiff