5 Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
7 Copyright (C) 2000 - 2001 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
22 #include "silcincludes.h"
23 #include "silcidcache.h"
25 /* Static prototypes */
26 static void silc_idcache_destructor(void *key, void *context,
28 static SilcIDCacheList silc_idcache_list_alloc();
29 static void silc_idcache_list_add(SilcIDCacheList list,
30 SilcIDCacheEntry cache);
35 This is context for the ID cache system. This includes all the cache
36 entries and other internal data. This is read-only object and not
37 visible outside this cache system.
39 Fields are as follows:
41 SilcHashTable id_table
43 Hash table using the ID as the key.
45 SilcHashTable name_table
47 Hash table using the name as the key.
49 SilcHashTable context_table
51 Hash table using the context as the key.
53 SilcIDCacheDestructor destructor
55 Destructor callback that is called when an cache entry expires or is
56 purged from the ID cache. The application must not free cache entry
57 because the library will do it automatically. The appliation, however,
58 is responsible of freeing any data in the entry.
62 Indicates the type of the ID's this cache holds.
65 struct SilcIDCacheStruct {
66 SilcHashTable id_table;
67 SilcHashTable name_table;
68 SilcHashTable context_table;
69 SilcIDCacheDestructor destructor;
76 This is returned when searching the cache. Enumeration functions are
77 provided to traverse the list; actually this is used as table not as
80 By default the found cache entries are saved into the static cache
81 table to provide access without reallocation. However, if the static
82 table is full, rest of the cache entries are dynamically allocated
83 into `cache_dyn' table. Traversing functions automatically handles
87 struct SilcIDCacheListStruct {
88 SilcIDCacheEntry cache[128];
89 SilcIDCacheEntry *cache_dyn;
90 SilcUInt32 cache_dyn_count;
91 SilcUInt32 cache_count;
96 /* Allocates new ID cache object. The initial amount of allocated entries
97 can be sent as argument. If `count' is 0 the system uses default values.
98 The `id_type' defines the types of the ID's that will be saved to the
101 SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
102 SilcIDCacheDestructor destructor)
106 SILC_LOG_DEBUG(("Allocating new cache"));
108 cache = silc_calloc(1, sizeof(*cache));
111 cache->id_table = silc_hash_table_alloc(count, silc_hash_id,
112 (void *)(SilcUInt32)id_type,
113 silc_hash_id_compare,
114 (void *)(SilcUInt32)id_type,
115 silc_idcache_destructor, NULL, TRUE);
116 cache->name_table = silc_hash_table_alloc(count, silc_hash_string, NULL,
117 silc_hash_string_compare, NULL,
119 cache->context_table = silc_hash_table_alloc(count, silc_hash_ptr, NULL,
120 NULL, NULL, NULL, NULL, TRUE);
121 cache->destructor = destructor;
122 cache->type = id_type;
124 if (!cache->id_table || !cache->name_table || !cache->context_table) {
126 silc_hash_table_free(cache->id_table);
127 if (cache->name_table)
128 silc_hash_table_free(cache->name_table);
129 if (cache->context_table)
130 silc_hash_table_free(cache->context_table);
138 /* Frees ID cache object and cache entries */
140 void silc_idcache_free(SilcIDCache cache)
143 silc_hash_table_free(cache->id_table);
144 silc_hash_table_free(cache->name_table);
145 silc_hash_table_free(cache->context_table);
150 /* Add new entry to the cache. Returns TRUE if the entry was added and
151 FALSE if it could not be added. The `name' is the name associated with
152 the ID, the `id' the actual ID and the `context' a used specific context.
153 If the `expire' is TRUE the entry expires in default time and if FALSE
154 the entry never expires from the cache. */
156 bool silc_idcache_add(SilcIDCache cache, char *name, void *id,
157 void *context, int expire, SilcIDCacheEntry *ret)
161 SILC_LOG_DEBUG(("Adding cache entry"));
163 /* Allocate new cache entry */
164 c = silc_calloc(1, sizeof(*c));
170 c->context = context;
172 /* Add the new entry to the hash tables */
175 silc_hash_table_add(cache->id_table, id, c);
177 silc_hash_table_add(cache->name_table, name, c);
179 silc_hash_table_add(cache->context_table, context, c);
187 /* Destructor for the ID Cache entry */
189 static void silc_idcache_destructor(void *key, void *context,
192 SilcIDCacheEntry c = context;
194 memset(c, 'F', sizeof(*c));
199 /* Delete cache entry from cache. */
201 bool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry old)
205 SILC_LOG_DEBUG(("Deleting cache entry"));
208 ret = silc_hash_table_del_by_context(cache->name_table, old->name, old);
210 ret = silc_hash_table_del(cache->context_table, old->context);
212 ret = silc_hash_table_del(cache->id_table, old->id);
214 silc_idcache_destructor(NULL, old, NULL);
219 /* Deletes ID cache entry by ID. */
221 bool silc_idcache_del_by_id(SilcIDCache cache, void *id)
225 if (!silc_hash_table_find(cache->id_table, id, NULL, (void *)&c))
228 return silc_idcache_del(cache, c);
231 /* Same as above but with specific hash and comparison functions. If the
232 functions are NULL then default values are used. */
234 bool silc_idcache_del_by_id_ext(SilcIDCache cache, void *id,
235 SilcHashFunction hash,
237 SilcHashCompare compare,
238 void *compare_context)
243 SILC_LOG_DEBUG(("Deleting cache entry"));
245 if (!silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)&c,
246 hash, hash_context, compare,
251 ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
253 ret = silc_hash_table_del(cache->context_table, c->context);
255 ret = silc_hash_table_del_ext(cache->id_table, c->id, hash,
256 hash_context, compare, compare_context,
262 /* Deletes ID cache entry by context. */
264 bool silc_idcache_del_by_context(SilcIDCache cache, void *context)
269 SILC_LOG_DEBUG(("Deleting cache entry"));
271 if (!silc_hash_table_find(cache->context_table, context, NULL, (void *)&c))
275 ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
277 ret = silc_hash_table_del(cache->context_table, c->context);
279 ret = silc_hash_table_del_by_context(cache->id_table, c->id, c);
281 silc_idcache_destructor(NULL, c, NULL);
286 /* Deletes all ID entries from cache. Free's memory as well. */
288 bool silc_idcache_del_all(SilcIDCache cache)
290 silc_hash_table_free(cache->id_table);
291 silc_hash_table_free(cache->name_table);
292 silc_hash_table_free(cache->context_table);
297 static void silc_idcache_destructor_dummy(void *key, void *context,
300 /* Dummy - nothing */
303 /* Foreach callback fro silc_idcache_purge. */
305 static void silc_idcache_purge_foreach(void *key, void *context,
308 SilcIDCache cache = (SilcIDCache)user_context;
309 SilcUInt32 curtime = time(NULL);
310 SilcIDCacheEntry c = (SilcIDCacheEntry)context;
316 if (c->expire && c->expire < curtime) {
317 /* Remove the entry from the hash tables */
319 ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
321 ret = silc_hash_table_del(cache->context_table, c->context);
324 silc_hash_table_del_by_context_ext(cache->id_table, c->id, c,
325 NULL, NULL, NULL, NULL,
326 silc_idcache_destructor_dummy,
329 /* Call the destructor */
330 if (cache->destructor)
331 cache->destructor(cache, c);
333 /* Free the entry, it has been deleted from the hash tables */
334 silc_idcache_destructor(NULL, c, NULL);
339 /* Purges the cache by removing expired cache entires. Note that this
340 may be very slow operation. */
342 bool silc_idcache_purge(SilcIDCache cache)
344 silc_hash_table_foreach(cache->id_table, silc_idcache_purge_foreach, cache);
348 /* Purges the specific entry by context. */
350 bool silc_idcache_purge_by_context(SilcIDCache cache, void *context)
355 if (!silc_hash_table_find(cache->context_table, context, NULL,
359 /* Remove the entry from the hash tables */
361 ret = silc_hash_table_del_by_context(cache->name_table, c->name, c);
363 ret = silc_hash_table_del(cache->context_table, c->context);
366 silc_hash_table_del_by_context_ext(cache->id_table, c->id, c,
367 NULL, NULL, NULL, NULL,
368 silc_idcache_destructor_dummy, NULL);
370 /* Call the destructor */
371 if (cache->destructor)
372 cache->destructor(cache, c);
374 /* Free the entry, it has been deleted from the hash tables */
375 silc_idcache_destructor(NULL, c, NULL);
381 /* Callback that is called by the hash table routine when traversing
382 entrys in the hash table. */
384 static void silc_idcache_get_all_foreach(void *key, void *context,
387 SilcIDCacheList list = (SilcIDCacheList)user_context;
390 silc_idcache_list_add(list, (SilcIDCacheEntry)context);
393 /* Returns all cache entrys from the ID cache to the `ret' ID Cache List. */
395 bool silc_idcache_get_all(SilcIDCache cache, SilcIDCacheList *ret)
397 SilcIDCacheList list;
402 list = silc_idcache_list_alloc();
405 silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach, list);
407 if (silc_idcache_list_count(list) == 0) {
408 silc_idcache_list_free(list);
417 /* Find ID Cache entry by ID. May return multiple entries. */
419 bool silc_idcache_find_by_id(SilcIDCache cache, void *id,
420 SilcIDCacheList *ret)
422 SilcIDCacheList list;
424 list = silc_idcache_list_alloc();
431 silc_hash_table_find_foreach(cache->id_table, id,
432 silc_idcache_get_all_foreach, list);
434 if (silc_idcache_list_count(list) == 0) {
435 silc_idcache_list_free(list);
444 /* Find specific ID with specific hash function and comparison functions.
445 If `hash' is NULL then the default hash funtion is used and if `compare'
446 is NULL default comparison function is used. */
448 bool silc_idcache_find_by_id_one_ext(SilcIDCache cache, void *id,
449 SilcHashFunction hash,
451 SilcHashCompare compare,
452 void *compare_context,
453 SilcIDCacheEntry *ret)
455 return silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)ret,
456 hash, hash_context, compare,
460 /* Find one specific ID entry. */
462 bool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
463 SilcIDCacheEntry *ret)
465 return silc_hash_table_find(cache->id_table, id, NULL, (void *)ret);
468 /* Finds cache entry by context. */
470 bool silc_idcache_find_by_context(SilcIDCache cache, void *context,
471 SilcIDCacheEntry *ret)
473 return silc_hash_table_find(cache->context_table, context, NULL,
477 /* Find ID Cache entry by name. Returns list of cache entries. */
479 bool silc_idcache_find_by_name(SilcIDCache cache, char *name,
480 SilcIDCacheList *ret)
482 SilcIDCacheList list;
484 list = silc_idcache_list_alloc();
491 silc_hash_table_find_foreach(cache->name_table, name,
492 silc_idcache_get_all_foreach, list);
494 if (silc_idcache_list_count(list) == 0) {
495 silc_idcache_list_free(list);
504 /* Find ID Cache entry by name. Returns one cache entry. */
506 bool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
507 SilcIDCacheEntry *ret)
509 if (!silc_hash_table_find(cache->name_table, name, NULL, (void *)ret))
515 /* Allocates ID cache list. */
517 static SilcIDCacheList silc_idcache_list_alloc()
519 SilcIDCacheList list;
521 list = silc_calloc(1, sizeof(*list));
528 /* Adds cache entry to the ID cache list. If needed reallocates memory
531 static void silc_idcache_list_add(SilcIDCacheList list, SilcIDCacheEntry cache)
535 /* Try to add to static cache */
536 if (!list->cache_dyn_count)
537 for (i = 0; i < (sizeof(list->cache) / sizeof(list->cache[0])); i++) {
538 if (!list->cache[i]) {
539 list->cache[i] = cache;
545 /* Static cache is full, allocate dynamic cache */
546 for (i = 0; i < list->cache_dyn_count; i++) {
547 if (!list->cache_dyn[i]) {
548 list->cache_dyn[i] = cache;
554 if (i >= list->cache_dyn_count) {
557 i = list->cache_dyn_count;
558 list->cache_dyn = silc_realloc(list->cache_dyn,
559 sizeof(*list->cache_dyn) * (i + 5));
560 if (!list->cache_dyn)
563 /* NULL the reallocated area */
564 for (k = i; k < (i + 5); k++)
565 list->cache_dyn[k] = NULL;
567 list->cache_dyn[i] = cache;
569 list->cache_dyn_count += 5;
573 /* Returns number of cache entries in the ID cache list. */
575 int silc_idcache_list_count(SilcIDCacheList list)
577 return list->cache_count;
580 /* Returns first entry from the ID cache list. */
582 bool silc_idcache_list_first(SilcIDCacheList list, SilcIDCacheEntry *ret)
586 if (!list->cache[list->pos])
590 *ret = list->cache[list->pos];
595 /* Returns next entry from the ID cache list. */
597 bool silc_idcache_list_next(SilcIDCacheList list, SilcIDCacheEntry *ret)
602 list->pos >= (sizeof(list->cache) / sizeof(list->cache[0]))) {
607 if (list->dyn && list->pos >= list->cache_dyn_count)
610 if (!list->dyn && !list->cache[list->pos])
613 if (list->dyn && !list->cache_dyn[list->pos])
618 *ret = list->cache[list->pos];
620 *ret = list->cache_dyn[list->pos];
626 /* Frees ID cache list. User must free the list object returned by
627 any of the searching functions. */
629 void silc_idcache_list_free(SilcIDCacheList list)
633 silc_free(list->cache_dyn);