lib/silcapputil/silcidcache.c

   1 /*
   2
   3   silcidcache.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2000 - 2006 Pekka Riikonen
   8
   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.
  12
  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.
  17
  18 */
  19 /* $Id$ */
  20
  21 #include "silc.h"
  22 #include "silcidcache.h"
  23
  24 /************************** Types and definitions ***************************/
  25
  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 */
  34 };
  35
  36
  37 /************************ Static utility functions **************************/
  38
  39 /* Callback that is called by the hash table routine when traversing
  40    entries in the hash table. */
  41
  42 static void silc_idcache_get_all_foreach(void *key, void *context,
  43                                          void *user_context)
  44 {
  45   SilcList *list = user_context;
  46   if (!context)
  47     return;
  48   silc_list_add(*list, context);
  49 }
  50
  51 /* Cache entry destructor */
  52
  53 static void silc_idcache_destructor(SilcIDCache cache,
  54                                     SilcIDCacheEntry entry,
  55                                     void *app_context)
  56 {
  57   if (cache->destructor)
  58     cache->destructor(cache, entry, cache->destructor, app_context);
  59
  60   memset(entry, 'F', sizeof(*entry));
  61   silc_free(entry);
  62 }
  63
  64
  65 /****************************** Public API **********************************/
  66
  67 /* Allocates new ID cache object. */
  68
  69 SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
  70                                SilcIDCacheDestructor destructor,
  71                                void *destructor_context)
  72 {
  73   SilcIDCache cache;
  74
  75   SILC_LOG_DEBUG(("Allocating new cache"));
  76
  77   cache = silc_calloc(1, sizeof(*cache));
  78   if (!cache)
  79     return NULL;
  80
  81   cache->id_table = silc_hash_table_alloc(count, silc_hash_id,
  82                                           SILC_32_TO_PTR(id_type),
  83                                           silc_hash_id_compare,
  84                                           SILC_32_TO_PTR(id_type),
  85                                           NULL, NULL, TRUE);
  86   cache->name_table = silc_hash_table_alloc(count, silc_hash_utf8_string, NULL,
  87                                             silc_hash_utf8_compare, NULL,
  88                                             NULL, NULL, TRUE);
  89   cache->context_table = silc_hash_table_alloc(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;
  94
  95   if (!cache->id_table || !cache->name_table || !cache->context_table) {
  96     if (cache->id_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);
 102     silc_free(cache);
 103     return NULL;
 104   }
 105
 106   return cache;
 107 }
 108
 109 /* Frees ID cache object and cache entries */
 110
 111 void silc_idcache_free(SilcIDCache cache)
 112 {
 113   silc_hash_table_free(cache->id_table);
 114   silc_hash_table_free(cache->name_table);
 115   silc_hash_table_free(cache->context_table);
 116   silc_free(cache);
 117 }
 118
 119 /* Add new entry to cache */
 120
 121 SilcIDCacheEntry
 122 silc_idcache_add(SilcIDCache cache, char *name, void *id, void *context)
 123 {
 124   SilcIDCacheEntry c;
 125
 126   if (!id)
 127     return NULL;
 128
 129   /* Allocate new cache entry */
 130   c = silc_calloc(1, sizeof(*c));
 131   if (!c)
 132     return NULL;
 133
 134   c->id = id;
 135   c->name = name;
 136   c->context = context;
 137
 138   SILC_LOG_DEBUG(("Adding cache entry %p", c));
 139
 140   /* Add the new entry to the hash tables */
 141
 142   if (id) {
 143     if (silc_idcache_find_by_id_one(cache, id, NULL)) {
 144       SILC_LOG_ERROR(("Attempted to add same ID twice to ID Cache"));
 145       goto err;
 146     }
 147     if (!silc_hash_table_add(cache->id_table, id, c))
 148       goto err;
 149   }
 150   if (name)
 151     if (!silc_hash_table_add(cache->name_table, name, c))
 152       goto err;
 153   if (context)
 154     if (!silc_hash_table_add(cache->context_table, context, c))
 155       goto err;
 156
 157   return c;
 158
 159  err:
 160   if (c->name)
 161     silc_hash_table_del_by_context(cache->name_table, c->name, c);
 162   if (c->context)
 163     silc_hash_table_del_by_context(cache->context_table, c->context, c);
 164   if (c->id)
 165     silc_hash_table_del_by_context(cache->id_table, c->id, c);
 166   silc_free(c);
 167
 168   return NULL;
 169 }
 170
 171 /* Delete cache entry from cache. */
 172
 173 SilcBool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry entry,
 174                           void *app_context)
 175 {
 176   SilcBool ret = FALSE;
 177
 178   SILC_LOG_DEBUG(("Deleting cache entry %p", entry));
 179
 180   if (entry->name)
 181     ret = silc_hash_table_del_by_context(cache->name_table, entry->name,
 182                                          entry);
 183   if (entry->context)
 184     ret = silc_hash_table_del_by_context(cache->context_table, entry->context,
 185                                          entry);
 186   if (entry->id)
 187     ret = silc_hash_table_del_by_context(cache->id_table, entry->id,
 188                                          entry);
 189
 190   if (ret)
 191     silc_idcache_destructor(cache, entry, app_context);
 192
 193   return ret;
 194 }
 195
 196 /* Deletes ID cache entry by ID. */
 197
 198 SilcBool silc_idcache_del_by_id(SilcIDCache cache, void *id,
 199                                 void *app_context)
 200 {
 201   SilcIDCacheEntry c;
 202
 203   if (!silc_hash_table_find(cache->id_table, id, NULL, (void **)&c))
 204     return FALSE;
 205
 206   return silc_idcache_del(cache, c, app_context);
 207 }
 208
 209 /* Deletes ID cache entry by context. */
 210
 211 SilcBool silc_idcache_del_by_context(SilcIDCache cache, void *context,
 212                                      void *app_context)
 213 {
 214   SilcIDCacheEntry c;
 215
 216   if (!silc_hash_table_find(cache->context_table, context, NULL, (void **)&c))
 217     return FALSE;
 218
 219   return silc_idcache_del(cache, c, app_context);
 220 }
 221
 222 /* Update entry */
 223
 224 SilcBool silc_idcache_update(SilcIDCache cache, SilcIDCacheEntry entry,
 225                              void *old_id, void *new_id,
 226                              char *old_name, char *new_name)
 227 {
 228   if (old_id && new_id) {
 229     if (!silc_hash_table_del_by_context(cache->id_table, old_id, entry))
 230       return FALSE;
 231
 232     if (cache->id_type == SILC_ID_CLIENT)
 233       *(SilcClientID *)entry->id = *(SilcClientID *)new_id;
 234     if (cache->id_type == SILC_ID_SERVER)
 235       *(SilcServerID *)entry->id = *(SilcServerID *)new_id;
 236     if (cache->id_type == SILC_ID_CHANNEL)
 237       *(SilcChannelID *)entry->id = *(SilcChannelID *)new_id;
 238
 239     if (!silc_hash_table_add(cache->id_table, entry->id, entry))
 240       return FALSE;
 241   }
 242
 243   if (old_name && new_name) {
 244     if (!silc_hash_table_del_by_context(cache->name_table, old_name, entry))
 245       return FALSE;
 246
 247     entry->name = new_name;
 248
 249     if (!silc_hash_table_add(cache->name_table, entry->name, entry))
 250       return FALSE;
 251   }
 252
 253   return TRUE;
 254 }
 255
 256 /* Returns all cache entrys from the ID cache to the `ret' ID Cache List. */
 257
 258 SilcBool silc_idcache_get_all(SilcIDCache cache, SilcList *ret_list)
 259 {
 260   if (!ret_list)
 261     return FALSE;
 262
 263   if (!silc_hash_table_count(cache->id_table))
 264     return FALSE;
 265
 266   silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach,
 267                           ret_list);
 268
 269   if (!silc_list_count(*ret_list))
 270     return FALSE;
 271
 272   return TRUE;
 273 }
 274
 275 /* Find ID Cache entry by ID. May return multiple entries. */
 276
 277 SilcBool silc_idcache_find_by_id(SilcIDCache cache, void *id,
 278                                  SilcList *ret_list)
 279 {
 280   if (!ret_list)
 281     return FALSE;
 282
 283   if (!silc_hash_table_count(cache->id_table))
 284     return FALSE;
 285
 286   silc_hash_table_find_foreach(cache->id_table, id,
 287                                silc_idcache_get_all_foreach, ret_list);
 288
 289   if (!silc_list_count(*ret_list))
 290     return FALSE;
 291
 292   return TRUE;
 293 }
 294
 295 /* Find one specific ID entry.  Compare full IDs */
 296
 297 SilcBool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
 298                                      SilcIDCacheEntry *ret)
 299 {
 300   return silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)ret,
 301                                   NULL, NULL,
 302                                   silc_hash_id_compare_full,
 303                                   SILC_32_TO_PTR(cache->id_type));
 304 }
 305
 306 /* Finds cache entry by context. */
 307
 308 SilcBool silc_idcache_find_by_context(SilcIDCache cache, void *context,
 309                                       SilcIDCacheEntry *ret)
 310 {
 311   return silc_hash_table_find(cache->context_table, context, NULL,
 312                               (void *)ret);
 313 }
 314
 315 /* Find ID Cache entry by name. Returns list of cache entries. */
 316
 317 SilcBool silc_idcache_find_by_name(SilcIDCache cache, char *name,
 318                                    SilcList *ret_list)
 319 {
 320   if (!ret_list)
 321     return FALSE;
 322
 323   if (!silc_hash_table_count(cache->name_table))
 324     return FALSE;
 325
 326   silc_hash_table_find_foreach(cache->name_table, name,
 327                                silc_idcache_get_all_foreach, ret_list);
 328
 329   if (!silc_list_count(*ret_list))
 330     return FALSE;
 331
 332   return TRUE;
 333 }
 334
 335 /* Find ID Cache entry by name. Returns one cache entry. */
 336
 337 SilcBool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
 338                                        SilcIDCacheEntry *ret)
 339 {
 340   return silc_hash_table_find(cache->name_table, name, NULL, (void *)ret);
 341 }