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
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,
+static void silc_idcache_list_add(SilcIDCacheList list,
SilcIDCacheEntry cache);
/*
SilcIdType type;
};
-/*
+/*
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. :)
*/
struct SilcIDCacheListStruct {
- SilcIDCacheEntry cache[64];
+ SilcIDCacheEntry cache[128];
SilcIDCacheEntry *cache_dyn;
SilcUInt32 cache_dyn_count;
SilcUInt32 cache_count;
};
/* 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.
+ 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. */
SILC_LOG_DEBUG(("Allocating new cache"));
cache = silc_calloc(1, sizeof(*cache));
- cache->id_table = silc_hash_table_alloc(count, silc_hash_id,
+ if (!cache)
+ return NULL;
+ cache->id_table = silc_hash_table_alloc(count, silc_hash_id,
(void *)(SilcUInt32)id_type,
- silc_hash_id_compare,
- (void *)(SilcUInt32)id_type,
- silc_idcache_destructor, NULL,
- FALSE);
+ silc_hash_id_compare,
+ (void *)(SilcUInt32)id_type,
+ silc_idcache_destructor, NULL, TRUE);
cache->name_table = silc_hash_table_alloc(count, silc_hash_string, NULL,
- silc_hash_string_compare, NULL,
- NULL, NULL, FALSE);
+ silc_hash_string_compare, NULL,
+ NULL, NULL, TRUE);
cache->context_table = silc_hash_table_alloc(count, silc_hash_ptr, NULL,
- NULL, NULL, NULL, NULL, FALSE);
+ NULL, NULL, NULL, NULL, TRUE);
cache->destructor = destructor;
cache->type = id_type;
+ if (!cache->id_table || !cache->name_table || !cache->context_table) {
+ if (cache->id_table)
+ silc_hash_table_free(cache->id_table);
+ if (cache->name_table)
+ silc_hash_table_free(cache->name_table);
+ if (cache->context_table)
+ silc_hash_table_free(cache->context_table);
+ silc_free(cache);
+ return NULL;
+ }
+
return cache;
}
If the `expire' is TRUE the entry expires in default time and if FALSE
the entry never expires from the cache. */
-bool silc_idcache_add(SilcIDCache cache, char *name, void *id,
+bool silc_idcache_add(SilcIDCache cache, char *name, void *id,
void *context, int expire, SilcIDCacheEntry *ret)
{
SilcIDCacheEntry c;
/* Allocate new cache entry */
c = silc_calloc(1, sizeof(*c));
+ if (!c)
+ return FALSE;
c->id = id;
c->name = name;
c->expire = expire;
if (context)
silc_hash_table_add(cache->context_table, context, c);
- /* See whether we have time to rehash the tables */
- if ((silc_hash_table_count(cache->id_table) / 2) >
- silc_hash_table_size(cache->id_table)) {
- silc_hash_table_rehash(cache->id_table, 0);
- silc_hash_table_rehash(cache->name_table, 0);
- silc_hash_table_rehash(cache->context_table, 0);
- }
-
if (ret)
*ret = c;
static void silc_idcache_destructor(void *key, void *context,
void *user_context)
{
- silc_free(context);
+ SilcIDCacheEntry c = context;
+ if (c) {
+ memset(c, 'F', sizeof(*c));
+ silc_free(c);
+ }
}
/* Delete cache entry from cache. */
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_free(old);
+ else {
+ silc_idcache_destructor(NULL, old, NULL);
+ ret = TRUE;
+ }
return ret;
}
functions are NULL then default values are used. */
bool silc_idcache_del_by_id_ext(SilcIDCache cache, void *id,
- SilcHashFunction hash,
+ SilcHashFunction hash,
void *hash_context,
- SilcHashCompare compare,
+ SilcHashCompare compare,
void *compare_context)
{
SilcIDCacheEntry c;
SILC_LOG_DEBUG(("Deleting cache entry"));
if (!silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)&c,
- hash, hash_context, compare,
+ hash, hash_context, compare,
compare_context))
return FALSE;
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_free(c);
+ else {
+ silc_idcache_destructor(NULL, c, NULL);
+ ret = TRUE;
+ }
return ret;
}
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)
- silc_hash_table_del_by_context(cache->name_table, c->name, c);
+ ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
if (c->context)
- silc_hash_table_del(cache->context_table, c->context);
+ ret = silc_hash_table_del(cache->context_table, c->context);
if (c->id)
- silc_hash_table_del_by_context_ext(cache->id_table, c->id, c,
- NULL, NULL, NULL, NULL,
- silc_idcache_destructor_dummy, NULL);
-
- /* Call the destructor */
- if (cache->destructor)
- cache->destructor(cache, c);
-
- /* Free the entry, it has been deleted from the hash tables */
- silc_free(c);
+ 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);
+
+ /* Free the entry, it has been deleted from the hash tables */
+ silc_idcache_destructor(NULL, c, NULL);
+ }
}
}
SilcIDCacheEntry c;
bool ret = FALSE;
- if (!silc_hash_table_find(cache->context_table, context, NULL,
+ if (!silc_hash_table_find(cache->context_table, context, NULL,
(void *)&c))
return FALSE;
if (c->id)
ret =
silc_hash_table_del_by_context_ext(cache->id_table, c->id, c,
- NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL,
silc_idcache_destructor_dummy, NULL);
-
- /* Call the destructor */
- if (cache->destructor)
- cache->destructor(cache, c);
+ if (ret == TRUE) {
+ /* Call the destructor */
+ if (cache->destructor)
+ cache->destructor(cache, c);
- /* Free the entry, it has been deleted from the hash tables */
- silc_free(c);
+ /* Free the entry, it has been deleted from the hash tables */
+ silc_idcache_destructor(NULL, c, NULL);
+ }
return ret;
}
void *user_context)
{
SilcIDCacheList list = (SilcIDCacheList)user_context;
+ if (!context)
+ return;
silc_idcache_list_add(list, (SilcIDCacheEntry)context);
}
return TRUE;
list = silc_idcache_list_alloc();
+ if (!list)
+ return FALSE;
silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach, list);
if (silc_idcache_list_count(list) == 0) {
/* Find ID Cache entry by ID. May return multiple entries. */
-bool silc_idcache_find_by_id(SilcIDCache cache, void *id,
+bool silc_idcache_find_by_id(SilcIDCache cache, void *id,
SilcIDCacheList *ret)
{
SilcIDCacheList list;
list = silc_idcache_list_alloc();
+ if (!list)
+ return FALSE;
if (!ret)
return TRUE;
If `hash' is NULL then the default hash funtion is used and if `compare'
is NULL default comparison function is used. */
-bool silc_idcache_find_by_id_one_ext(SilcIDCache cache, void *id,
- SilcHashFunction hash,
+bool silc_idcache_find_by_id_one_ext(SilcIDCache cache, void *id,
+ SilcHashFunction hash,
void *hash_context,
- SilcHashCompare compare,
+ SilcHashCompare compare,
void *compare_context,
SilcIDCacheEntry *ret)
{
return silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)ret,
- hash, hash_context, compare,
+ hash, hash_context, compare,
compare_context);
}
/* Find one specific ID entry. */
-bool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
+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);
/* Finds cache entry by context. */
-bool silc_idcache_find_by_context(SilcIDCache cache, void *context,
+bool silc_idcache_find_by_context(SilcIDCache cache, void *context,
SilcIDCacheEntry *ret)
{
- return silc_hash_table_find(cache->context_table, context, NULL,
+ return silc_hash_table_find(cache->context_table, context, NULL,
(void *)ret);
}
SilcIDCacheList list;
list = silc_idcache_list_alloc();
+ if (!list)
+ return FALSE;
if (!ret)
return TRUE;
- silc_hash_table_find_foreach(cache->name_table, name,
+ silc_hash_table_find_foreach(cache->name_table, name,
silc_idcache_get_all_foreach, list);
if (silc_idcache_list_count(list) == 0) {
SilcIDCacheList list;
list = silc_calloc(1, sizeof(*list));
+ if (!list)
+ return FALSE;
return list;
}
int k;
i = list->cache_dyn_count;
- list->cache_dyn = silc_realloc(list->cache_dyn,
+ 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++)
if (!list->cache[list->pos])
return FALSE;
-
+
if (ret)
*ret = list->cache[list->pos];
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;
}
projects / silc.git / blobdiff