lib/silcskr/silcskr.c

   1 /*
   2
   3   silcskr.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2005 - 2007 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
  20 #include "silc.h"
  21 #include "silcskr.h"
  22
  23 /************************** Types and definitions ***************************/
  24
  25 /* Search constraints */
  26 typedef enum {
  27   SILC_SKR_FIND_PKCS_TYPE,
  28   SILC_SKR_FIND_USERNAME,
  29   SILC_SKR_FIND_HOST,
  30   SILC_SKR_FIND_REALNAME,
  31   SILC_SKR_FIND_EMAIL,
  32   SILC_SKR_FIND_ORG,
  33   SILC_SKR_FIND_COUNTRY,
  34   SILC_SKR_FIND_PUBLIC_KEY,
  35   SILC_SKR_FIND_CONTEXT,
  36   SILC_SKR_FIND_USAGE,          /* Never added as key specific */
  37 } SilcSKRFindType;
  38
  39 /* Hash table key context */
  40 typedef struct {
  41   SilcSKRFindType type;         /* Type of key */
  42   void *data;                   /* Hash table key */
  43 } *SilcSKREntry, SilcSKREntryStruct;
  44
  45 /* Foreach user context when finding entries from hash table */
  46 typedef struct {
  47   SilcDList list;
  48   void *key_context;
  49   SilcSKRKeyUsage usage;
  50 } SilcSKRFindForeach;
  51
  52 #if defined(SILC_DEBUG)
  53 static const char *find_name[] = {
  54   "PKCS TYPE ",
  55   "USERNAME  ",
  56   "HOST      ",
  57   "REALNAME  ",
  58   "EMAIL     ",
  59   "ORG       ",
  60   "COUNTRY   ",
  61   "PUBLIC KEY",
  62   "CONTEXT   ",
  63   "USAGE     ",
  64   NULL
  65 };
  66 #endif /* SILC_DEBUG */
  67
  68 /************************ Static utility functions **************************/
  69
  70 #if defined(SILC_DEBUG)
  71
  72 /* Returns search constraint string */
  73
  74 static void silc_skr_type_string(SilcSKRFindType type, void *data,
  75                                  char *retbuf, SilcUInt32 retbuf_size)
  76 {
  77   switch (type) {
  78   case SILC_SKR_FIND_PKCS_TYPE:
  79   case SILC_SKR_FIND_USAGE:
  80     silc_snprintf(retbuf, retbuf_size, "[%s] [%d]", find_name[type],
  81                   (int)SILC_PTR_TO_32(data));
  82     break;
  83
  84   case SILC_SKR_FIND_PUBLIC_KEY:
  85   case SILC_SKR_FIND_CONTEXT:
  86     silc_snprintf(retbuf, retbuf_size, "[%s] [%p]", find_name[type], data);
  87     break;
  88
  89   default:
  90     silc_snprintf(retbuf, retbuf_size, "[%s] [%s]", find_name[type],
  91                   (char *)data);
  92   }
  93 }
  94 #endif /* SILC_DEBUG */
  95
  96 /* Hash table destructor for search constraints */
  97
  98 static void silc_skr_find_destructor(void *key, void *context,
  99                                      void *user_context)
 100 {
 101   SilcSKRFindType type = SILC_PTR_TO_32(key);
 102   SilcPKCSType pkcs_type = SILC_PTR_TO_32(user_context);
 103
 104   switch (type) {
 105   case SILC_SKR_FIND_PKCS_TYPE:
 106   case SILC_SKR_FIND_USAGE:
 107   case SILC_SKR_FIND_CONTEXT:
 108     break;
 109
 110   case SILC_SKR_FIND_PUBLIC_KEY:
 111     silc_pkcs_public_key_free(context);
 112     break;
 113
 114   default:
 115     /* In SILC Public key all entries are referenced from the public key
 116        so don't free them.  This test is valid only when removing key
 117        from the repository. */
 118     if (pkcs_type == SILC_PKCS_SILC)
 119       break;
 120
 121     silc_free(context);
 122   }
 123 }
 124
 125 /* Hash table destructor for key entries */
 126
 127 static void silc_skr_destructor(void *key, void *context, void *user_context)
 128 {
 129   SilcSKREntry type = key;
 130   SilcSKRKeyInternal entry = context;
 131   SilcPKCSType pkcs_type = silc_pkcs_get_type(entry->key.key);
 132
 133   /* Destroy search data, except for SILC_SKR_FIND_PUBLIC_KEY because it
 134      shares same context with the key entry. */
 135   if (SILC_PTR_TO_32(type->type) != SILC_SKR_FIND_PUBLIC_KEY)
 136     silc_skr_find_destructor(SILC_32_TO_PTR(type->type), type->data,
 137                              SILC_32_TO_PTR(pkcs_type));
 138   silc_free(type);
 139
 140   /* Destroy key */
 141   entry->refcnt--;
 142   if (entry->refcnt > 0)
 143     return;
 144
 145   SILC_LOG_DEBUG(("Freeing public key %p", entry->key.key));
 146
 147   silc_pkcs_public_key_free(entry->key.key);
 148   silc_free(entry);
 149 }
 150
 151 /* Hash table hash function for key entries */
 152
 153 static SilcUInt32 silc_skr_hash(void *key, void *user_context)
 154 {
 155   SilcSKREntry type = key;
 156
 157   switch (type->type) {
 158   case SILC_SKR_FIND_PKCS_TYPE:
 159   case SILC_SKR_FIND_CONTEXT:
 160     return type->type + (type->type ^ SILC_PTR_TO_32(type->data));
 161     break;
 162
 163   case SILC_SKR_FIND_PUBLIC_KEY:
 164     return type->type + silc_hash_public_key(type->data, user_context);
 165     break;
 166
 167   default:
 168     break;
 169   }
 170
 171   return type->type + silc_hash_string(type->data, user_context);
 172 }
 173
 174 /* Hash table comparison function for key entries */
 175
 176 static SilcBool silc_skr_compare(void *key1, void *key2, void *user_context)
 177 {
 178   SilcSKREntry type1 = key1;
 179   SilcSKREntry type2 = key2;
 180
 181   if (type1->type != type2->type)
 182     return FALSE;
 183
 184   switch (type1->type) {
 185   case SILC_SKR_FIND_PKCS_TYPE:
 186   case SILC_SKR_FIND_CONTEXT:
 187     return type1->data == type2->data;
 188     break;
 189
 190   case SILC_SKR_FIND_PUBLIC_KEY:
 191     return silc_hash_public_key_compare(type1->data, type2->data,
 192                                         user_context);
 193     break;
 194
 195   default:
 196     break;
 197   }
 198
 199   return silc_utf8_strcasecmp((const char *)type1->data,
 200                               (const char *)type2->data);
 201 }
 202
 203 /* Foreach function for finding entries in the repository */
 204
 205 static void silc_skr_find_foreach(void *key, void *context,
 206                                   void *user_context)
 207 {
 208   SilcSKRFindForeach *f = user_context;
 209   SilcSKRKeyInternal k = context;
 210
 211   if (k) {
 212     /* If key context is present, it must match the context in the key.
 213        This is used only internally when adding keys, to check if the key
 214        is added with same context. */
 215     if (f->key_context && f->key_context != k->key.key_context)
 216       return;
 217
 218     /* Check for usage bits.  At least one usage bit must be set. */
 219     if (f->usage && k->key.usage && (f->usage & k->key.usage) == 0)
 220       return;
 221
 222     silc_dlist_add(f->list, k);
 223   }
 224 }
 225
 226 /* Finds entry from repository by search constraint type and data */
 227
 228 static SilcBool silc_skr_find_entry(SilcSKR skr,
 229                                     SilcSKRStatus *status,
 230                                     SilcSKRFindType type,
 231                                     void *type_data,
 232                                     SilcDList *results,
 233                                     void *key_context,
 234                                     SilcSKRKeyUsage usage)
 235 {
 236   SilcSKREntryStruct find;
 237   SilcSKRFindForeach f;
 238
 239   f.list = silc_dlist_init();
 240   if (!f.list) {
 241     *status |= SILC_SKR_NO_MEMORY;
 242     return FALSE;
 243   }
 244   f.key_context = key_context;
 245   f.usage = usage;
 246
 247   find.type = type;
 248   find.data = type_data;
 249
 250   silc_hash_table_find_foreach(skr->keys, (void *)&find,
 251                                silc_skr_find_foreach, &f);
 252
 253   if (!silc_dlist_count(f.list)) {
 254     *status |= SILC_SKR_NOT_FOUND;
 255     silc_dlist_uninit(f.list);
 256     return FALSE;
 257   }
 258
 259   if (results)
 260     *results = f.list;
 261   else
 262     silc_dlist_uninit(f.list);
 263
 264   return TRUE;
 265 }
 266
 267 /* Add a key by search constraint type to repository */
 268
 269 static SilcBool silc_skr_add_entry(SilcSKR skr, SilcSKRFindType type,
 270                                    void *type_data, SilcSKRKeyInternal key)
 271 {
 272   SilcSKREntry entry;
 273
 274 #if defined(SILC_DEBUG)
 275   char tmp[256];
 276   memset(tmp, 0, sizeof(tmp));
 277   silc_skr_type_string(type, type_data, tmp, sizeof(tmp) - 1);
 278   SILC_LOG_DEBUG(("Search constraint %s", tmp));
 279 #endif /* SILC_DEBUG */
 280
 281   entry = silc_calloc(1, sizeof(*entry));
 282   if (!entry)
 283     return FALSE;
 284
 285   entry->type = type;
 286   entry->data = type_data;
 287
 288   return silc_hash_table_add(skr->keys, entry, key);
 289 }
 290
 291 /* Delete a key by search constraint type from repository */
 292
 293 static SilcBool silc_skr_del_entry(SilcSKR skr, SilcSKRFindType type,
 294                                    void *type_data, SilcSKRKeyInternal key)
 295 {
 296   SilcSKREntryStruct entry;
 297
 298   if (!type_data)
 299     return FALSE;
 300
 301   entry.type = type;
 302   entry.data = type_data;
 303
 304   return silc_hash_table_del_by_context(skr->keys, &entry, key);
 305 }
 306
 307 /* This performs AND operation.  Any entry already in `results' that is not
 308    in `list' will be removed from `results'. */
 309
 310 static SilcBool silc_skr_results_and(SilcDList list, SilcSKRStatus *status,
 311                                      SilcDList *results)
 312 {
 313   SilcSKRKeyInternal entry, r;
 314
 315   if (*results == NULL) {
 316     *results = silc_dlist_init();
 317     if (*results == NULL) {
 318       *status |= SILC_SKR_NO_MEMORY;
 319       return FALSE;
 320     }
 321   }
 322
 323   /* If results is empty, just add all entries from list to results */
 324   if (!silc_dlist_count(*results)) {
 325     silc_dlist_start(list);
 326     while ((entry = silc_dlist_get(list)) != SILC_LIST_END)
 327       silc_dlist_add(*results, entry);
 328
 329     return TRUE;
 330   }
 331
 332   silc_dlist_start(*results);
 333   while ((entry = silc_dlist_get(*results)) != SILC_LIST_END) {
 334
 335     /* Check if this entry is in list  */
 336     silc_dlist_start(list);
 337     while ((r = silc_dlist_get(list)) != SILC_LIST_END) {
 338       if (r == entry)
 339         break;
 340     }
 341     if (r != SILC_LIST_END)
 342       continue;
 343
 344     /* Remove from results */
 345     silc_dlist_del(*results, entry);
 346   }
 347
 348   /* If results became empty, we did not find any key */
 349   if (!silc_dlist_count(*results)) {
 350     SILC_LOG_DEBUG(("Not all search constraints found"));
 351     *status |= SILC_SKR_NOT_FOUND;
 352     return FALSE;
 353   }
 354
 355   return TRUE;
 356 }
 357
 358
 359 /***************************** SILC Public Key ******************************/
 360
 361 /* Add SILC style public key to repository */
 362
 363 static SilcSKRStatus silc_skr_add_silc(SilcSKR skr,
 364                                        SilcPublicKey public_key,
 365                                        SilcSKRKeyUsage usage,
 366                                        void *key_context,
 367                                        SilcSKRKey *return_key)
 368 {
 369   SilcSKRKeyInternal key;
 370   SilcSKRStatus status = SILC_SKR_ERROR;
 371   SilcPublicKeyIdentifier ident;
 372   SilcSILCPublicKey silc_pubkey;
 373 #if defined(SILC_DEBUG)
 374   char tmp[256];
 375 #endif /* SILC_DEBUG */
 376
 377   /* Get the SILC public key */
 378   silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC, public_key);
 379   ident = &silc_pubkey->identifier;
 380
 381   SILC_LOG_DEBUG(("Adding SILC public key %p [%s], context %p",
 382                   public_key, ident->username, key_context));
 383
 384   silc_mutex_lock(skr->lock);
 385
 386   /* Check that this key hasn't been added already */
 387   if (silc_skr_find_entry(skr, &status, SILC_SKR_FIND_PUBLIC_KEY,
 388                           public_key, NULL, key_context, 0)) {
 389     silc_mutex_unlock(skr->lock);
 390     SILC_LOG_DEBUG(("Key already added"));
 391     return status | SILC_SKR_ALREADY_EXIST;
 392   }
 393
 394   /* Allocate key entry */
 395   key = silc_calloc(1, sizeof(*key));
 396   if (!key) {
 397     silc_mutex_unlock(skr->lock);
 398     return status | SILC_SKR_NO_MEMORY;
 399   }
 400
 401   key->key.usage = usage;
 402   key->key.key = public_key;
 403   key->key.key_context = key_context;
 404
 405 #if defined(SILC_DEBUG)
 406   silc_skr_type_string(SILC_SKR_FIND_USAGE, SILC_32_TO_PTR(usage),
 407                        tmp, sizeof(tmp) - 1);
 408   SILC_LOG_DEBUG((" Search constraint %s", tmp));
 409 #endif /* SILC_DEBUG */
 410
 411   /* Add key specifics */
 412
 413   if (!silc_skr_add_entry(skr, SILC_SKR_FIND_PUBLIC_KEY,
 414                           public_key, key))
 415     goto err;
 416   key->refcnt++;
 417
 418   if (!silc_skr_add_entry(skr, SILC_SKR_FIND_PKCS_TYPE,
 419                           SILC_32_TO_PTR(SILC_PKCS_SILC), key))
 420     goto err;
 421   key->refcnt++;
 422
 423   if (ident->username) {
 424     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_USERNAME,
 425                             ident->username, key))
 426       goto err;
 427     key->refcnt++;
 428   }
 429
 430   if (ident->host) {
 431     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_HOST,
 432                             ident->host, key))
 433       goto err;
 434     key->refcnt++;
 435   }
 436
 437   if (ident->realname) {
 438     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_REALNAME,
 439                             ident->realname, key))
 440       goto err;
 441     key->refcnt++;
 442   }
 443
 444   if (ident->email) {
 445     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_EMAIL,
 446                             ident->email, key))
 447       goto err;
 448     key->refcnt++;
 449   }
 450
 451   if (ident->org) {
 452     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_ORG,
 453                             ident->org, key))
 454       goto err;
 455     key->refcnt++;
 456   }
 457
 458   if (ident->country) {
 459     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_COUNTRY,
 460                             ident->country, key))
 461       goto err;
 462     key->refcnt++;
 463   }
 464
 465   if (key_context) {
 466     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_CONTEXT,
 467                             key_context, key))
 468       goto err;
 469     key->refcnt++;
 470   }
 471
 472   silc_mutex_unlock(skr->lock);
 473
 474   if (return_key)
 475     *return_key = (SilcSKRKey)key;
 476
 477   return SILC_SKR_OK;
 478
 479  err:
 480   silc_mutex_unlock(skr->lock);
 481   return status;
 482 }
 483
 484 /* Add SILC style public key to repository, and only the public key, not
 485    other details from the key. */
 486
 487 static SilcSKRStatus silc_skr_add_silc_simple(SilcSKR skr,
 488                                               SilcPublicKey public_key,
 489                                               SilcSKRKeyUsage usage,
 490                                               void *key_context,
 491                                               SilcSKRKey *return_key)
 492 {
 493   SilcSKRKeyInternal key;
 494   SilcSKRStatus status = SILC_SKR_ERROR;
 495 #if defined(SILC_DEBUG)
 496   char tmp[256];
 497 #endif /* SILC_DEBUG */
 498
 499   SILC_LOG_DEBUG(("Adding SILC public key"));
 500
 501   silc_mutex_lock(skr->lock);
 502
 503   /* Check that this key hasn't been added already */
 504   if (silc_skr_find_entry(skr, &status, SILC_SKR_FIND_PUBLIC_KEY,
 505                           public_key, NULL, key_context, 0)) {
 506     silc_mutex_unlock(skr->lock);
 507     SILC_LOG_DEBUG(("Key already added"));
 508     return status | SILC_SKR_ALREADY_EXIST;
 509   }
 510
 511   /* Allocate key entry */
 512   key = silc_calloc(1, sizeof(*key));
 513   if (!key) {
 514     silc_mutex_unlock(skr->lock);
 515     return status | SILC_SKR_NO_MEMORY;
 516   }
 517
 518   key->key.usage = usage;
 519   key->key.key = public_key;
 520   key->key.key_context = key_context;
 521
 522 #if defined(SILC_DEBUG)
 523   silc_skr_type_string(SILC_SKR_FIND_USAGE, SILC_32_TO_PTR(usage),
 524                        tmp, sizeof(tmp) - 1);
 525   SILC_LOG_DEBUG(("Search cons %s", tmp));
 526 #endif /* SILC_DEBUG */
 527
 528   /* Add key specifics */
 529
 530   if (!silc_skr_add_entry(skr, SILC_SKR_FIND_PUBLIC_KEY,
 531                           public_key, key))
 532     goto err;
 533   key->refcnt++;
 534
 535   if (key_context) {
 536     if (!silc_skr_add_entry(skr, SILC_SKR_FIND_CONTEXT,
 537                             key_context, key))
 538       goto err;
 539     key->refcnt++;
 540   }
 541
 542   silc_mutex_unlock(skr->lock);
 543
 544   if (return_key)
 545     *return_key = (SilcSKRKey)key;
 546
 547   return SILC_SKR_OK;
 548
 549  err:
 550   silc_mutex_unlock(skr->lock);
 551   return status;
 552 }
 553
 554 /* Deletes SILC public key from repository */
 555
 556 static SilcSKRStatus silc_skr_del_silc_public_key(SilcSKR skr,
 557                                                   SilcPublicKey public_key,
 558                                                   void *key_context)
 559 {
 560   SilcSKRStatus status = SILC_SKR_ERROR;
 561   SilcPublicKeyIdentifier ident;
 562   SilcSILCPublicKey silc_pubkey;
 563   SilcSKRKeyInternal key;
 564   SilcDList entry;
 565
 566   /* Get the SILC public key */
 567   silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC, public_key);
 568   ident = &silc_pubkey->identifier;
 569
 570   SILC_LOG_DEBUG(("Deleting SILC public key [%s]", ident->username));
 571
 572   silc_mutex_lock(skr->lock);
 573
 574   /* Check that this key exists */
 575   if (!silc_skr_find_entry(skr, &status, SILC_SKR_FIND_PUBLIC_KEY,
 576                            public_key, &entry, key_context, 0)) {
 577     silc_mutex_unlock(skr->lock);
 578     SILC_LOG_DEBUG(("Key does not exist"));
 579     return status | SILC_SKR_NOT_FOUND;
 580   }
 581
 582   silc_dlist_start(entry);
 583   key = silc_dlist_get(entry);
 584   silc_dlist_uninit(entry);
 585
 586   silc_skr_del_entry(skr, SILC_SKR_FIND_PUBLIC_KEY, public_key, key);
 587   silc_skr_del_entry(skr, SILC_SKR_FIND_PKCS_TYPE,
 588                      SILC_32_TO_PTR(SILC_PKCS_SILC), key);
 589   silc_skr_del_entry(skr, SILC_SKR_FIND_USERNAME, ident->username, key);
 590   silc_skr_del_entry(skr, SILC_SKR_FIND_HOST, ident->host, key);
 591   silc_skr_del_entry(skr, SILC_SKR_FIND_REALNAME, ident->realname, key);
 592   silc_skr_del_entry(skr, SILC_SKR_FIND_EMAIL, ident->email, key);
 593   silc_skr_del_entry(skr, SILC_SKR_FIND_ORG, ident->org, key);
 594   silc_skr_del_entry(skr, SILC_SKR_FIND_COUNTRY, ident->country, key);
 595   silc_skr_del_entry(skr, SILC_SKR_FIND_CONTEXT, key_context, key);
 596
 597   silc_mutex_unlock(skr->lock);
 598
 599   return SILC_SKR_OK;
 600 }
 601
 602
 603 /**************************** Key Repository API ****************************/
 604
 605 /* Allocate key repository */
 606
 607 SilcSKR silc_skr_alloc(void)
 608 {
 609   SilcSKR skr;
 610
 611   skr = silc_calloc(1, sizeof(*skr));
 612   if (!skr)
 613     return NULL;
 614
 615   if (!silc_skr_init(skr)) {
 616     silc_skr_free(skr);
 617     return NULL;
 618   }
 619
 620   return skr;
 621 }
 622
 623 /* Free key repository */
 624
 625 void silc_skr_free(SilcSKR skr)
 626 {
 627   silc_skr_uninit(skr);
 628   silc_free(skr);
 629 }
 630
 631 /* Initializes key repository */
 632
 633 SilcBool silc_skr_init(SilcSKR skr)
 634 {
 635   if (!silc_mutex_alloc(&skr->lock))
 636     return FALSE;
 637
 638   skr->keys = silc_hash_table_alloc(0, silc_skr_hash, NULL,
 639                                     silc_skr_compare, NULL,
 640                                     silc_skr_destructor, NULL, TRUE);
 641   if (!skr->keys)
 642     return FALSE;
 643
 644   return TRUE;
 645 }
 646
 647 /* Uninitializes key repository */
 648
 649 void silc_skr_uninit(SilcSKR skr)
 650 {
 651   if (skr->keys)
 652     silc_hash_table_free(skr->keys);
 653   silc_mutex_free(skr->lock);
 654 }
 655
 656 /* Adds public key to key repository */
 657
 658 SilcSKRStatus silc_skr_add_public_key(SilcSKR skr,
 659                                       SilcPublicKey public_key,
 660                                       SilcSKRKeyUsage usage,
 661                                       void *key_context,
 662                                       SilcSKRKey *return_key)
 663 {
 664   SilcPKCSType type;
 665
 666   if (!public_key)
 667     return SILC_SKR_ERROR;
 668
 669   type = silc_pkcs_get_type(public_key);
 670
 671   SILC_LOG_DEBUG(("Adding public key %p to repository", public_key));
 672
 673   switch (type) {
 674
 675   case SILC_PKCS_SILC:
 676     return silc_skr_add_silc(skr, public_key, usage, key_context, return_key);
 677     break;
 678
 679   default:
 680     break;
 681   }
 682
 683   return SILC_SKR_ERROR;
 684 }
 685
 686 /* Adds public key to repository. */
 687
 688 SilcSKRStatus silc_skr_add_public_key_simple(SilcSKR skr,
 689                                              SilcPublicKey public_key,
 690                                              SilcSKRKeyUsage usage,
 691                                              void *key_context,
 692                                              SilcSKRKey *return_key)
 693 {
 694   SilcPKCSType type;
 695
 696   if (!public_key)
 697     return SILC_SKR_ERROR;
 698
 699   type = silc_pkcs_get_type(public_key);
 700
 701   SILC_LOG_DEBUG(("Adding public key %p to repository", public_key));
 702
 703   switch (type) {
 704
 705   case SILC_PKCS_SILC:
 706     return silc_skr_add_silc_simple(skr, public_key, usage, key_context,
 707                                     return_key);
 708     break;
 709
 710   default:
 711     break;
 712   }
 713
 714   return SILC_SKR_ERROR;
 715 }
 716
 717 /* Remove key from repository */
 718
 719 SilcSKRStatus silc_skr_del_public_key(SilcSKR skr,
 720                                       SilcPublicKey public_key,
 721                                       void *key_context)
 722 {
 723   SilcPKCSType type;
 724
 725   if (!public_key)
 726     return SILC_SKR_ERROR;
 727
 728   type = silc_pkcs_get_type(public_key);
 729
 730   SILC_LOG_DEBUG(("Deleting public key %p from repository", public_key));
 731
 732   switch (type) {
 733
 734   case SILC_PKCS_SILC:
 735     return silc_skr_del_silc_public_key(skr, public_key, key_context);
 736     break;
 737
 738   default:
 739     break;
 740   }
 741
 742   return SILC_SKR_ERROR;
 743 }
 744
 745 /* Reference key */
 746
 747 void silc_skr_ref_public_key(SilcSKR skr, SilcSKRKey key)
 748 {
 749   SilcSKRKeyInternal k = (SilcSKRKeyInternal)key;
 750
 751   silc_mutex_lock(skr->lock);
 752   SILC_LOG_DEBUG(("SKR key %p ref %d -> %d", k->refcnt, k->refcnt + 1));
 753   k->refcnt++;
 754   silc_mutex_unlock(skr->lock);
 755 }
 756
 757 /* Release key reference. */
 758
 759 void silc_skr_unref_public_key(SilcSKR skr, SilcSKRKey key)
 760 {
 761   SilcSKRKeyInternal k = (SilcSKRKeyInternal)key;
 762
 763   silc_mutex_lock(skr->lock);
 764
 765   SILC_LOG_DEBUG(("SKR key %p ref %d -> %d", k->refcnt, k->refcnt - 1));
 766   k->refcnt--;
 767
 768   if (k->refcnt == 0) {
 769     /* If reference is zero, the key has been removed from the repository
 770        already.  Just destroy the public key. */
 771     silc_pkcs_public_key_free(key->key);
 772     silc_free(key);
 773   }
 774
 775   silc_mutex_unlock(skr->lock);
 776 }
 777
 778
 779 /************************** Search Constraints API **************************/
 780
 781 /* Allocate search constraints */
 782
 783 SilcSKRFind silc_skr_find_alloc(void)
 784 {
 785   SilcSKRFind find;
 786
 787   find = silc_calloc(1, sizeof(*find));
 788   if (!find)
 789     return NULL;
 790
 791   find->constr = silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL,
 792                                        silc_skr_find_destructor, NULL, TRUE);
 793   if (!find->constr) {
 794     silc_skr_find_free(find);
 795     return NULL;
 796   }
 797
 798   return find;
 799 }
 800
 801 /* Free search constraints */
 802
 803 void silc_skr_find_free(SilcSKRFind find)
 804 {
 805   if (find->constr)
 806     silc_hash_table_free(find->constr);
 807   silc_free(find);
 808 }
 809
 810 SilcBool silc_skr_find_set_pkcs_type(SilcSKRFind find, SilcPKCSType type)
 811 {
 812   return silc_hash_table_add(find->constr,
 813                              SILC_32_TO_PTR(SILC_SKR_FIND_PKCS_TYPE),
 814                              SILC_32_TO_PTR(type));
 815 }
 816
 817 SilcBool silc_skr_find_set_username(SilcSKRFind find, const char *username)
 818 {
 819   void *c = silc_memdup(username, strlen(username));
 820   if (!c)
 821     return FALSE;
 822   return silc_hash_table_add(find->constr,
 823                              SILC_32_TO_PTR(SILC_SKR_FIND_USERNAME), c);
 824 }
 825
 826 SilcBool silc_skr_find_set_host(SilcSKRFind find, const char *host)
 827 {
 828   void *c = silc_memdup(host, strlen(host));
 829   if (!c)
 830     return FALSE;
 831   return silc_hash_table_add(find->constr,
 832                              SILC_32_TO_PTR(SILC_SKR_FIND_HOST), c);
 833 }
 834
 835 SilcBool silc_skr_find_set_realname(SilcSKRFind find, const char *realname)
 836 {
 837   void *c = silc_memdup(realname, strlen(realname));
 838   if (!c)
 839     return FALSE;
 840   return silc_hash_table_add(find->constr,
 841                              SILC_32_TO_PTR(SILC_SKR_FIND_REALNAME), c);
 842 }
 843
 844 SilcBool silc_skr_find_set_email(SilcSKRFind find, const char *email)
 845 {
 846   void *c = silc_memdup(email, strlen(email));
 847   if (!c)
 848     return FALSE;
 849   return silc_hash_table_add(find->constr,
 850                              SILC_32_TO_PTR(SILC_SKR_FIND_EMAIL), c);
 851 }
 852
 853 SilcBool silc_skr_find_set_org(SilcSKRFind find, const char *org)
 854 {
 855   void *c = silc_memdup(org, strlen(org));
 856   if (!c)
 857     return FALSE;
 858   return silc_hash_table_add(find->constr,
 859                              SILC_32_TO_PTR(SILC_SKR_FIND_ORG), c);
 860 }
 861
 862 SilcBool silc_skr_find_set_country(SilcSKRFind find, const char *country)
 863 {
 864   void *c = silc_memdup(country, strlen(country));
 865   if (!c)
 866     return FALSE;
 867   return silc_hash_table_add(find->constr,
 868                              SILC_32_TO_PTR(SILC_SKR_FIND_COUNTRY), c);
 869 }
 870
 871 SilcBool silc_skr_find_set_public_key(SilcSKRFind find,
 872                                       SilcPublicKey public_key)
 873 {
 874   SilcPublicKey pk = silc_pkcs_public_key_copy(public_key);
 875   if (!pk)
 876     return FALSE;
 877   return silc_hash_table_add(find->constr,
 878                              SILC_32_TO_PTR(SILC_SKR_FIND_PUBLIC_KEY), pk);
 879 }
 880
 881 SilcBool silc_skr_find_set_context(SilcSKRFind find, void *context)
 882 {
 883   if (!context)
 884     return TRUE;
 885   return silc_hash_table_add(find->constr,
 886                              SILC_32_TO_PTR(SILC_SKR_FIND_CONTEXT), context);
 887 }
 888
 889 SilcBool silc_skr_find_set_usage(SilcSKRFind find, SilcSKRKeyUsage usage)
 890 {
 891   if (!usage)
 892     return TRUE;
 893   return silc_hash_table_add(find->constr,
 894                              SILC_32_TO_PTR(SILC_SKR_FIND_USAGE),
 895                              SILC_32_TO_PTR(usage));
 896 }
 897
 898 /******************************** Search API ********************************/
 899
 900 /* Finds key(s) by the set search constraints.  The callback will be called
 901    once keys has been found. */
 902 /* This is now synchronous function but may later change async */
 903
 904 SilcAsyncOperation silc_skr_find(SilcSKR skr, SilcSchedule schedule,
 905                                  SilcSKRFind find,
 906                                  SilcSKRFindCallback callback,
 907                                  void *callback_context)
 908 {
 909   SilcSKRStatus status = SILC_SKR_ERROR;
 910   SilcHashTableList htl;
 911   SilcDList list, results = NULL;
 912   void *type, *ctx, *usage = NULL;
 913 #if defined(SILC_DEBUG)
 914   char tmp[256];
 915 #endif /* SILC_DEBUG */
 916
 917   SILC_LOG_DEBUG(("Finding key from repository"));
 918
 919   if (!find || !callback)
 920     return NULL;
 921
 922   silc_mutex_lock(skr->lock);
 923
 924   /* Get usage bits, if searching by them */
 925   silc_hash_table_find(find->constr, SILC_32_TO_PTR(SILC_SKR_FIND_USAGE),
 926                        NULL, &usage);
 927
 928 #if defined(SILC_DEBUG)
 929   if (usage) {
 930     memset(tmp, 0, sizeof(tmp));
 931     silc_skr_type_string(SILC_SKR_FIND_USAGE, usage, tmp, sizeof(tmp) - 1);
 932     SILC_LOG_DEBUG(("Finding key by %s", tmp));
 933   }
 934 #endif /* SILC_DEBUG */
 935
 936   silc_hash_table_list(find->constr, &htl);
 937   while (silc_hash_table_get(&htl, &type, &ctx)) {
 938
 939     /* SILC_SKR_FIND_USAGE is handled separately while searching the keys. */
 940     if ((SilcSKRFindType)SILC_32_TO_PTR(type) == SILC_SKR_FIND_USAGE)
 941       continue;
 942
 943 #if defined(SILC_DEBUG)
 944     memset(tmp, 0, sizeof(tmp));
 945     silc_skr_type_string((SilcSKRFindType)SILC_32_TO_PTR(type),
 946                          ctx, tmp, sizeof(tmp) - 1);
 947     SILC_LOG_DEBUG(("Finding key by %s", tmp));
 948 #endif /* SILC_DEBUG */
 949
 950     /* Find entries by this search constraint */
 951     if (!silc_skr_find_entry(skr, &status,
 952                              (SilcSKRFindType)SILC_32_TO_PTR(type),
 953                              ctx, &list, NULL, SILC_PTR_TO_32(usage))) {
 954       SILC_LOG_DEBUG(("Not found"));
 955       if (results) {
 956         silc_dlist_uninit(results);
 957         results = NULL;
 958       }
 959       break;
 960     }
 961
 962     /* For now, our logic rule is AND.  All constraints must be found
 963        to find the key.  Later OR might be added also. */
 964     if (!silc_skr_results_and(list, &status, &results)) {
 965       SILC_LOG_DEBUG(("Not found"));
 966       if (results) {
 967         silc_dlist_uninit(results);
 968         results = NULL;
 969       }
 970       silc_dlist_uninit(list);
 971       break;
 972     }
 973
 974     silc_dlist_uninit(list);
 975   }
 976   silc_hash_table_list_reset(&htl);
 977
 978   silc_mutex_unlock(skr->lock);
 979
 980   /* Return results */
 981   if (!results) {
 982     callback(skr, find, status, NULL, callback_context);
 983   } else {
 984     silc_dlist_start(results);
 985     callback(skr, find, SILC_SKR_OK, results, callback_context);
 986   }
 987
 988   return NULL;
 989 }