5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 2000 - 2007 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; version 2 of the License.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
22 #include "silcidcache.h"
24 /************************** Types and definitions ***************************/
26 /* ID Cache context */
27 struct SilcIDCacheStruct {
28 SilcHashTable id_table; /* ID hash table */
29 SilcHashTable name_table; /* Name hash table */
30 SilcHashTable context_table; /* Context hash table */
31 SilcIDCacheDestructor destructor; /* Entry destructor */
32 void *context; /* Destructor context */
33 SilcIdType id_type; /* Type of ID cache */
37 /************************ Static utility functions **************************/
39 /* Callback that is called by the hash table routine when traversing
40 entries in the hash table. */
42 static void silc_idcache_get_all_foreach(void *key, void *context,
45 SilcList *list = user_context;
48 silc_list_add(*list, context);
51 /* Cache entry destructor */
53 static void silc_idcache_destructor(SilcIDCache cache,
54 SilcIDCacheEntry entry,
57 if (cache->destructor)
58 cache->destructor(cache, entry, cache->destructor, app_context);
60 memset(entry, 'F', sizeof(*entry));
65 /****************************** Public API **********************************/
67 /* Allocates new ID cache object. */
69 SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
70 SilcIDCacheDestructor destructor,
71 void *destructor_context)
75 SILC_LOG_DEBUG(("Allocating new cache"));
77 cache = silc_calloc(1, sizeof(*cache));
81 cache->id_table = silc_hash_table_alloc(NULL, count, silc_hash_id,
82 SILC_32_TO_PTR(id_type),
84 SILC_32_TO_PTR(id_type),
86 cache->name_table = silc_hash_table_alloc(NULL, count, silc_hash_utf8_string,
87 NULL, silc_hash_utf8_compare, NULL,
89 cache->context_table = silc_hash_table_alloc(NULL, count, silc_hash_ptr, NULL,
90 NULL, NULL, NULL, NULL, TRUE);
91 cache->destructor = destructor;
92 cache->context = destructor_context;
93 cache->id_type = id_type;
95 if (!cache->id_table || !cache->name_table || !cache->context_table) {
97 silc_hash_table_free(cache->id_table);
98 if (cache->name_table)
99 silc_hash_table_free(cache->name_table);
100 if (cache->context_table)
101 silc_hash_table_free(cache->context_table);
109 /* Frees ID cache object and cache entries */
111 void silc_idcache_free(SilcIDCache cache)
113 silc_hash_table_free(cache->id_table);
114 silc_hash_table_free(cache->name_table);
115 silc_hash_table_free(cache->context_table);
119 /* Add new entry to cache */
122 silc_idcache_add(SilcIDCache cache, char *name, void *id, void *context)
128 if (!name && !id && !context)
131 /* Allocate new cache entry */
132 c = silc_calloc(1, sizeof(*c));
138 c->context = context;
140 SILC_LOG_DEBUG(("Adding cache entry %p", c));
143 /* See if this entry is added already to cache */
144 if (silc_idcache_find_by_id_one(cache, id, NULL)) {
145 SILC_LOG_ERROR(("Attempted to add same ID twice to ID Cache, id %s",
146 silc_id_render(id, cache->id_type)));
152 /* Add the new entry to the hash tables */
154 if (!silc_hash_table_add(cache->id_table, id, c))
157 if (!silc_hash_table_add(cache->name_table, name, c))
160 if (!silc_hash_table_add(cache->context_table, context, c))
167 silc_hash_table_del_by_context(cache->name_table, c->name, c);
169 silc_hash_table_del_by_context(cache->context_table, c->context, c);
171 silc_hash_table_del_by_context(cache->id_table, c->id, c);
177 /* Delete cache entry from cache. */
179 SilcBool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry entry,
182 SilcBool ret = FALSE;
187 SILC_LOG_DEBUG(("Deleting cache entry %p", entry));
190 ret = silc_hash_table_del_by_context(cache->name_table, entry->name,
193 ret = silc_hash_table_del_by_context(cache->context_table, entry->context,
196 ret = silc_hash_table_del_by_context(cache->id_table, entry->id,
200 silc_idcache_destructor(cache, entry, app_context);
205 /* Deletes ID cache entry by ID. */
207 SilcBool silc_idcache_del_by_id(SilcIDCache cache, void *id,
215 if (!silc_hash_table_find(cache->id_table, id, NULL, (void *)&c))
218 return silc_idcache_del(cache, c, app_context);
221 /* Deletes ID cache entry by context. */
223 SilcBool silc_idcache_del_by_context(SilcIDCache cache, void *context,
231 if (!silc_hash_table_find(cache->context_table, context, NULL, (void *)&c))
234 return silc_idcache_del(cache, c, app_context);
239 SilcBool silc_idcache_update(SilcIDCache cache, SilcIDCacheEntry entry,
240 void *new_id, char *new_name,
241 SilcBool free_old_name)
248 if (!silc_hash_table_del_by_context(cache->id_table, entry->id, entry))
251 if (cache->id_type == SILC_ID_CLIENT)
252 *(SilcClientID *)entry->id = *(SilcClientID *)new_id;
253 if (cache->id_type == SILC_ID_SERVER)
254 *(SilcServerID *)entry->id = *(SilcServerID *)new_id;
255 if (cache->id_type == SILC_ID_CHANNEL)
256 *(SilcChannelID *)entry->id = *(SilcChannelID *)new_id;
261 if (!silc_hash_table_add(cache->id_table, entry->id, entry))
267 if (!silc_hash_table_del_by_context(cache->name_table, entry->name,
272 silc_free(entry->name);
273 entry->name = new_name;
275 if (!silc_hash_table_add(cache->name_table, entry->name, entry))
282 /* Update entry by context */
284 SilcBool silc_idcache_update_by_context(SilcIDCache cache, void *context,
285 void *new_id, char *new_name,
286 SilcBool free_old_name)
293 if (!silc_hash_table_find(cache->context_table, context, NULL, (void *)&c))
296 return silc_idcache_update(cache, c, new_id, new_name, free_old_name);
299 /* Move entry to another cache */
301 SilcBool silc_idcache_move(SilcIDCache from_cache, SilcIDCache to_cache,
302 SilcIDCacheEntry entry)
306 SILC_LOG_DEBUG(("Moving entry %p from %p cache to %p cache", entry,
307 from_cache, to_cache));
309 if (!from_cache || !to_cache || !entry)
312 if (from_cache->id_type != to_cache->id_type) {
313 SILC_LOG_ERROR(("Incompatible ID caches, cannot move entry"));
317 if (entry->context) {
318 if (!silc_hash_table_find(from_cache->context_table, entry->context,
321 } else if (entry->name) {
322 if (!silc_hash_table_find(from_cache->name_table, entry->name,
325 } else if (entry->id) {
326 if (!silc_hash_table_find(from_cache->id_table, entry->id,
336 /* See if this entry is added already to cache */
337 if (c->id && silc_idcache_find_by_id_one(to_cache, c->id, NULL)) {
338 SILC_LOG_ERROR(("Attempted to add same ID twice to ID Cache, id %s",
339 silc_id_render(c->id, to_cache->id_type)));
344 /* Remove from original cache */
346 silc_hash_table_del_by_context(from_cache->name_table, c->name, c);
348 silc_hash_table_del_by_context(from_cache->context_table, c->context, c);
350 silc_hash_table_del_by_context(from_cache->id_table, c->id, c);
352 /* Move to the other cache */
354 silc_hash_table_add(to_cache->id_table, c->id, c);
356 silc_hash_table_add(to_cache->name_table, c->name, c);
358 silc_hash_table_add(to_cache->context_table, c->context, c);
363 /* Returns all cache entrys from the ID cache to the `ret' ID Cache List. */
365 SilcBool silc_idcache_get_all(SilcIDCache cache, SilcList *ret_list)
367 if (!cache || !ret_list)
370 if (!silc_hash_table_count(cache->id_table))
373 silc_list_init(*ret_list, struct SilcIDCacheEntryStruct, next);
374 silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach,
377 if (!silc_list_count(*ret_list))
383 /* Find ID Cache entry by ID. May return multiple entries. */
385 SilcBool silc_idcache_find_by_id(SilcIDCache cache, void *id,
388 if (!cache || !ret_list)
391 if (!silc_hash_table_count(cache->id_table))
394 silc_list_init(*ret_list, struct SilcIDCacheEntryStruct, next);
395 silc_hash_table_find_foreach(cache->id_table, id,
396 silc_idcache_get_all_foreach, ret_list);
398 if (!silc_list_count(*ret_list))
404 /* Find one specific ID entry. Compare full IDs */
406 SilcBool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
407 SilcIDCacheEntry *ret)
411 return silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)ret,
413 silc_hash_id_compare_full,
414 SILC_32_TO_PTR(cache->id_type));
417 /* Finds cache entry by context. */
419 SilcBool silc_idcache_find_by_context(SilcIDCache cache, void *context,
420 SilcIDCacheEntry *ret)
424 return silc_hash_table_find(cache->context_table, context, NULL,
428 /* Find ID Cache entry by name. Returns list of cache entries. */
430 SilcBool silc_idcache_find_by_name(SilcIDCache cache, char *name,
433 if (!cache || !ret_list)
436 if (!silc_hash_table_count(cache->name_table))
439 silc_list_init(*ret_list, struct SilcIDCacheEntryStruct, next);
440 silc_hash_table_find_foreach(cache->name_table, name,
441 silc_idcache_get_all_foreach, ret_list);
443 if (!silc_list_count(*ret_list))
449 /* Find ID Cache entry by name. Returns one cache entry. */
451 SilcBool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
452 SilcIDCacheEntry *ret)
456 return silc_hash_table_find(cache->name_table, name, NULL, (void *)ret);