g10/keydb.c

   1 /* keydb.c - key database dispatcher
   2  * Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19  * USA.
  20  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <assert.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31
  32 #include "gpg.h"
  33 #include "util.h"
  34 #include "options.h"
  35 #include "main.h" /*try_make_homedir ()*/
  36 #include "packet.h"
  37 #include "keyring.h"
  38 #include "keydb.h"
  39 #include "i18n.h"
  40
  41 static int active_handles;
  42
  43 typedef enum {
  44     KEYDB_RESOURCE_TYPE_NONE = 0,
  45     KEYDB_RESOURCE_TYPE_KEYRING
  46 } KeydbResourceType;
  47 #define MAX_KEYDB_RESOURCES 40
  48
  49 struct resource_item {
  50   KeydbResourceType type;
  51   union {
  52     KEYRING_HANDLE kr;
  53   } u;
  54   void *token;
  55   int secret;
  56 };
  57
  58 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
  59 static int used_resources;
  60 static void *primary_keyring=NULL;
  61
  62 struct keydb_handle {
  63   int locked;
  64   int found;
  65   int current;
  66   int used; /* items in active */
  67   struct resource_item active[MAX_KEYDB_RESOURCES];
  68 };
  69
  70
  71 static int lock_all (KEYDB_HANDLE hd);
  72 static void unlock_all (KEYDB_HANDLE hd);
  73
  74
  75 /* Handle the creation of a keyring if it does not yet exist.  Take
  76    into acount that other processes might have the keyring already
  77    locked.  This lock check does not work if the directory itself is
  78    not yet available. */
  79 static int
  80 maybe_create_keyring (char *filename, int force)
  81 {
  82   DOTLOCK lockhd = NULL;
  83   IOBUF iobuf;
  84   int rc;
  85   mode_t oldmask;
  86   char *last_slash_in_filename;
  87
  88   /* A quick test whether the filename already exists. */
  89   if (!access (filename, F_OK))
  90     return 0;
  91
  92   /* If we don't want to create a new file at all, there is no need to
  93      go any further - bail out right here.  */
  94   if (!force)
  95     return gpg_error (GPG_ERR_ENOENT);
  96
  97   /* First of all we try to create the home directory.  Note, that we
  98      don't do any locking here because any sane application of gpg
  99      would create the home directory by itself and not rely on gpg's
 100      tricky auto-creation which is anyway only done for some home
 101      directory name patterns. */
 102   last_slash_in_filename = strrchr (filename, DIRSEP_C);
 103   *last_slash_in_filename = 0;
 104   if (access(filename, F_OK))
 105     {
 106       static int tried;
 107
 108       if (!tried)
 109         {
 110           tried = 1;
 111           try_make_homedir (filename);
 112         }
 113       if (access (filename, F_OK))
 114         {
 115           rc = gpg_error_from_errno (errno);
 116           *last_slash_in_filename = DIRSEP_C;
 117           goto leave;
 118         }
 119     }
 120   *last_slash_in_filename = DIRSEP_C;
 121
 122
 123   /* To avoid races with other instances of gpg trying to create or
 124      update the keyring (it is removed during an update for a short
 125      time), we do the next stuff in a locked state. */
 126   lockhd = create_dotlock (filename);
 127   if (!lockhd)
 128     {
 129       /* A reason for this to fail is that the directory is not
 130          writable. However, this whole locking stuff does not make
 131          sense if this is the case. An empty non-writable directory
 132          with no keyring is not really useful at all. */
 133       if (opt.verbose)
 134         log_info ("can't allocate lock for `%s'\n", filename );
 135
 136       if (!force)
 137         return gpg_error (GPG_ERR_ENOENT);
 138       else
 139         return gpg_error (GPG_ERR_GENERAL);
 140     }
 141
 142   if ( make_dotlock (lockhd, -1) )
 143     {
 144       /* This is something bad.  Probably a stale lockfile.  */
 145       log_info ("can't lock `%s'\n", filename );
 146       rc = G10ERR_GENERAL;
 147       goto leave;
 148     }
 149
 150   /* Now the real test while we are locked. */
 151   if (!access(filename, F_OK))
 152     {
 153       rc = 0;  /* Okay, we may access the file now.  */
 154       goto leave;
 155     }
 156
 157   /* The file does not yet exist, create it now. */
 158   oldmask = umask (077);
 159   if (is_secured_filename (filename))
 160     {
 161       iobuf = NULL;
 162       errno = EPERM;
 163     }
 164   else
 165     iobuf = iobuf_create (filename);
 166   umask (oldmask);
 167   if (!iobuf)
 168     {
 169       rc = gpg_error_from_errno (errno);
 170       log_error ( _("error creating keyring `%s': %s\n"),
 171                   filename, strerror(errno));
 172       goto leave;
 173     }
 174
 175   if (!opt.quiet)
 176     log_info (_("keyring `%s' created\n"), filename);
 177
 178   iobuf_close (iobuf);
 179   /* Must invalidate that ugly cache */
 180   iobuf_ioctl (NULL, 2, 0, filename);
 181   rc = 0;
 182
 183  leave:
 184   if (lockhd)
 185     {
 186       release_dotlock (lockhd);
 187       destroy_dotlock (lockhd);
 188     }
 189   return rc;
 190 }
 191
 192
 193 /*
 194  * Register a resource (which currently may only be a keyring file).
 195  * The first keyring which is added by this function is
 196  * created if it does not exist.
 197  * Note: this function may be called before secure memory is
 198  * available.
 199  * Flag 1 == force
 200  * Flag 2 == mark resource as primary
 201  * Flag 4 == This is a default resources
 202  */
 203 int
 204 keydb_add_resource (const char *url, int flags, int secret)
 205 {
 206     static int any_secret, any_public;
 207     const char *resname = url;
 208     char *filename = NULL;
 209     int force=(flags&1);
 210     int rc = 0;
 211     KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
 212     void *token;
 213
 214     /* Do we have an URL?
 215      *  gnupg-ring:filename  := this is a plain keyring
 216      *  filename := See what is is, but create as plain keyring.
 217      */
 218     if (strlen (resname) > 11) {
 219         if (!strncmp( resname, "gnupg-ring:", 11) ) {
 220             rt = KEYDB_RESOURCE_TYPE_KEYRING;
 221             resname += 11;
 222         }
 223 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
 224         else if (strchr (resname, ':')) {
 225             log_error ("invalid key resource URL `%s'\n", url );
 226             rc = G10ERR_GENERAL;
 227             goto leave;
 228         }
 229 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
 230     }
 231
 232     if (*resname != DIRSEP_C ) { /* do tilde expansion etc */
 233         if (strchr(resname, DIRSEP_C) )
 234             filename = make_filename (resname, NULL);
 235         else
 236             filename = make_filename (opt.homedir, resname, NULL);
 237     }
 238     else
 239         filename = xstrdup (resname);
 240
 241     if (!force)
 242         force = secret? !any_secret : !any_public;
 243
 244     /* see whether we can determine the filetype */
 245     if (rt == KEYDB_RESOURCE_TYPE_NONE) {
 246         FILE *fp = fopen( filename, "rb" );
 247
 248         if (fp) {
 249             u32 magic;
 250
 251             if (fread( &magic, 4, 1, fp) == 1 ) {
 252                 if (magic == 0x13579ace || magic == 0xce9a5713)
 253                     ; /* GDBM magic - no more support */
 254                 else
 255                     rt = KEYDB_RESOURCE_TYPE_KEYRING;
 256             }
 257             else /* maybe empty: assume ring */
 258                 rt = KEYDB_RESOURCE_TYPE_KEYRING;
 259             fclose( fp );
 260         }
 261         else /* no file yet: create ring */
 262             rt = KEYDB_RESOURCE_TYPE_KEYRING;
 263     }
 264
 265     switch (rt) {
 266       case KEYDB_RESOURCE_TYPE_NONE:
 267         log_error ("unknown type of key resource `%s'\n", url );
 268         rc = G10ERR_GENERAL;
 269         goto leave;
 270
 271       case KEYDB_RESOURCE_TYPE_KEYRING:
 272         rc = maybe_create_keyring (filename, force);
 273         if (rc)
 274           goto leave;
 275
 276         if(keyring_register_filename (filename, secret, &token))
 277           {
 278             if (used_resources >= MAX_KEYDB_RESOURCES)
 279               rc = G10ERR_RESOURCE_LIMIT;
 280             else
 281               {
 282                 if(flags&2)
 283                   primary_keyring=token;
 284                 all_resources[used_resources].type = rt;
 285                 all_resources[used_resources].u.kr = NULL; /* Not used here */
 286                 all_resources[used_resources].token = token;
 287                 all_resources[used_resources].secret = secret;
 288                 used_resources++;
 289               }
 290           }
 291         else
 292           {
 293             /* This keyring was already registered, so ignore it.
 294                However, we can still mark it as primary even if it was
 295                already registered. */
 296             if(flags&2)
 297               primary_keyring=token;
 298           }
 299         break;
 300
 301       default:
 302         log_error ("resource type of `%s' not supported\n", url);
 303         rc = G10ERR_GENERAL;
 304         goto leave;
 305     }
 306
 307     /* fixme: check directory permissions and print a warning */
 308
 309   leave:
 310     if (rc)
 311       {
 312         /* Secret keyrings are not required in all cases.  To avoid
 313            having gpg return failure we use log_info here if the
 314            rewsource is a secret one and marked as default
 315            resource.  */
 316         if ((flags&4) && secret)
 317           log_info (_("keyblock resource `%s': %s\n"),
 318                     filename, g10_errstr(rc));
 319         else
 320           log_error (_("keyblock resource `%s': %s\n"),
 321                      filename, g10_errstr(rc));
 322       }
 323     else if (secret)
 324         any_secret = 1;
 325     else
 326         any_public = 1;
 327     xfree (filename);
 328     return rc;
 329 }
 330
 331
 332
 333
 334 KEYDB_HANDLE
 335 keydb_new (int secret)
 336 {
 337   KEYDB_HANDLE hd;
 338   int i, j;
 339
 340   hd = xmalloc_clear (sizeof *hd);
 341   hd->found = -1;
 342
 343   assert (used_resources <= MAX_KEYDB_RESOURCES);
 344   for (i=j=0; i < used_resources; i++)
 345     {
 346       if (!all_resources[i].secret != !secret)
 347         continue;
 348       switch (all_resources[i].type)
 349         {
 350         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
 351           break;
 352         case KEYDB_RESOURCE_TYPE_KEYRING:
 353           hd->active[j].type   = all_resources[i].type;
 354           hd->active[j].token  = all_resources[i].token;
 355           hd->active[j].secret = all_resources[i].secret;
 356           hd->active[j].u.kr = keyring_new (all_resources[i].token, secret);
 357           if (!hd->active[j].u.kr) {
 358             xfree (hd);
 359             return NULL; /* fixme: release all previously allocated handles*/
 360           }
 361           j++;
 362           break;
 363         }
 364     }
 365   hd->used = j;
 366
 367   active_handles++;
 368   return hd;
 369 }
 370
 371 void
 372 keydb_release (KEYDB_HANDLE hd)
 373 {
 374     int i;
 375
 376     if (!hd)
 377         return;
 378     assert (active_handles > 0);
 379     active_handles--;
 380
 381     unlock_all (hd);
 382     for (i=0; i < hd->used; i++) {
 383         switch (hd->active[i].type) {
 384           case KEYDB_RESOURCE_TYPE_NONE:
 385             break;
 386           case KEYDB_RESOURCE_TYPE_KEYRING:
 387             keyring_release (hd->active[i].u.kr);
 388             break;
 389         }
 390     }
 391
 392     xfree (hd);
 393 }
 394
 395
 396 /*
 397  * Return the name of the current resource.  This is function first
 398  * looks for the last found found, then for the current search
 399  * position, and last returns the first available resource.  The
 400  * returned string is only valid as long as the handle exists.  This
 401  * function does only return NULL if no handle is specified, in all
 402  * other error cases an empty string is returned.
 403  */
 404 const char *
 405 keydb_get_resource_name (KEYDB_HANDLE hd)
 406 {
 407     int idx;
 408     const char *s = NULL;
 409
 410     if (!hd)
 411         return NULL;
 412
 413     if ( hd->found >= 0 && hd->found < hd->used)
 414         idx = hd->found;
 415     else if ( hd->current >= 0 && hd->current < hd->used)
 416         idx = hd->current;
 417     else
 418         idx = 0;
 419
 420     switch (hd->active[idx].type) {
 421       case KEYDB_RESOURCE_TYPE_NONE:
 422         s = NULL;
 423         break;
 424       case KEYDB_RESOURCE_TYPE_KEYRING:
 425         s = keyring_get_resource_name (hd->active[idx].u.kr);
 426         break;
 427     }
 428
 429     return s? s: "";
 430 }
 431
 432
 433
 434 static int
 435 lock_all (KEYDB_HANDLE hd)
 436 {
 437     int i, rc = 0;
 438
 439     for (i=0; !rc && i < hd->used; i++) {
 440         switch (hd->active[i].type) {
 441           case KEYDB_RESOURCE_TYPE_NONE:
 442             break;
 443           case KEYDB_RESOURCE_TYPE_KEYRING:
 444             rc = keyring_lock (hd->active[i].u.kr, 1);
 445             break;
 446         }
 447     }
 448
 449     if (rc) {
 450         /* revert the already set locks */
 451         for (i--; i >= 0; i--) {
 452             switch (hd->active[i].type) {
 453               case KEYDB_RESOURCE_TYPE_NONE:
 454                 break;
 455               case KEYDB_RESOURCE_TYPE_KEYRING:
 456                 keyring_lock (hd->active[i].u.kr, 0);
 457                 break;
 458             }
 459         }
 460     }
 461     else
 462         hd->locked = 1;
 463
 464     return rc;
 465 }
 466
 467 static void
 468 unlock_all (KEYDB_HANDLE hd)
 469 {
 470     int i;
 471
 472     if (!hd->locked)
 473         return;
 474
 475     for (i=hd->used-1; i >= 0; i--) {
 476         switch (hd->active[i].type) {
 477           case KEYDB_RESOURCE_TYPE_NONE:
 478             break;
 479           case KEYDB_RESOURCE_TYPE_KEYRING:
 480             keyring_lock (hd->active[i].u.kr, 0);
 481             break;
 482         }
 483     }
 484     hd->locked = 0;
 485 }
 486
 487
 488 /*
 489  * Return the last found keyring.  Caller must free it.
 490  * The returned keyblock has the kbode flag bit 0 set for the node with
 491  * the public key used to locate the keyblock or flag bit 1 set for
 492  * the user ID node.
 493  */
 494 int
 495 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
 496 {
 497     int rc = 0;
 498
 499     if (!hd)
 500         return G10ERR_INV_ARG;
 501
 502     if ( hd->found < 0 || hd->found >= hd->used)
 503         return -1; /* nothing found */
 504
 505     switch (hd->active[hd->found].type) {
 506       case KEYDB_RESOURCE_TYPE_NONE:
 507         rc = G10ERR_GENERAL; /* oops */
 508         break;
 509       case KEYDB_RESOURCE_TYPE_KEYRING:
 510         rc = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
 511         break;
 512     }
 513
 514     return rc;
 515 }
 516
 517 /*
 518  * update the current keyblock with KB
 519  */
 520 int
 521 keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
 522 {
 523     int rc = 0;
 524
 525     if (!hd)
 526         return G10ERR_INV_ARG;
 527
 528     if ( hd->found < 0 || hd->found >= hd->used)
 529         return -1; /* nothing found */
 530
 531     if( opt.dry_run )
 532         return 0;
 533
 534     rc = lock_all (hd);
 535     if (rc)
 536         return rc;
 537
 538     switch (hd->active[hd->found].type) {
 539       case KEYDB_RESOURCE_TYPE_NONE:
 540         rc = G10ERR_GENERAL; /* oops */
 541         break;
 542       case KEYDB_RESOURCE_TYPE_KEYRING:
 543         rc = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
 544         break;
 545     }
 546
 547     unlock_all (hd);
 548     return rc;
 549 }
 550
 551
 552 /*
 553  * Insert a new KB into one of the resources.
 554  */
 555 int
 556 keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
 557 {
 558     int rc = -1;
 559     int idx;
 560
 561     if (!hd)
 562         return G10ERR_INV_ARG;
 563
 564     if( opt.dry_run )
 565         return 0;
 566
 567     if ( hd->found >= 0 && hd->found < hd->used)
 568         idx = hd->found;
 569     else if ( hd->current >= 0 && hd->current < hd->used)
 570         idx = hd->current;
 571     else
 572         return G10ERR_GENERAL;
 573
 574     rc = lock_all (hd);
 575     if (rc)
 576         return rc;
 577
 578     switch (hd->active[idx].type) {
 579       case KEYDB_RESOURCE_TYPE_NONE:
 580         rc = G10ERR_GENERAL; /* oops */
 581         break;
 582       case KEYDB_RESOURCE_TYPE_KEYRING:
 583         rc = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
 584         break;
 585     }
 586
 587     unlock_all (hd);
 588     return rc;
 589 }
 590
 591
 592 /*
 593  * The current keyblock will be deleted.
 594  */
 595 int
 596 keydb_delete_keyblock (KEYDB_HANDLE hd)
 597 {
 598     int rc = -1;
 599
 600     if (!hd)
 601         return G10ERR_INV_ARG;
 602
 603     if ( hd->found < 0 || hd->found >= hd->used)
 604         return -1; /* nothing found */
 605
 606     if( opt.dry_run )
 607         return 0;
 608
 609     rc = lock_all (hd);
 610     if (rc)
 611         return rc;
 612
 613     switch (hd->active[hd->found].type) {
 614       case KEYDB_RESOURCE_TYPE_NONE:
 615         rc = G10ERR_GENERAL; /* oops */
 616         break;
 617       case KEYDB_RESOURCE_TYPE_KEYRING:
 618         rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
 619         break;
 620     }
 621
 622     unlock_all (hd);
 623     return rc;
 624 }
 625
 626 \f
 627 /*
 628  * Locate the default writable key resource, so that the next
 629  * operation (which is only relevant for inserts) will be done on this
 630  * resource.
 631  */
 632 int
 633 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
 634 {
 635   int rc;
 636
 637   if (!hd)
 638     return G10ERR_INV_ARG;
 639
 640   rc = keydb_search_reset (hd); /* this does reset hd->current */
 641   if (rc)
 642     return rc;
 643
 644   /* If we have a primary set, try that one first */
 645   if(primary_keyring)
 646     {
 647       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
 648         {
 649           if(hd->active[hd->current].token==primary_keyring)
 650             {
 651               if(keyring_is_writable (hd->active[hd->current].token))
 652                 return 0;
 653               else
 654                 break;
 655             }
 656         }
 657
 658       rc = keydb_search_reset (hd); /* this does reset hd->current */
 659       if (rc)
 660         return rc;
 661     }
 662
 663   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
 664     {
 665       switch (hd->active[hd->current].type)
 666         {
 667         case KEYDB_RESOURCE_TYPE_NONE:
 668           BUG();
 669           break;
 670         case KEYDB_RESOURCE_TYPE_KEYRING:
 671           if (keyring_is_writable (hd->active[hd->current].token))
 672             return 0; /* found (hd->current is set to it) */
 673           break;
 674         }
 675     }
 676
 677   return -1;
 678 }
 679
 680 /*
 681  * Rebuild the caches of all key resources.
 682  */
 683 void
 684 keydb_rebuild_caches (int noisy)
 685 {
 686   int i, rc;
 687
 688   for (i=0; i < used_resources; i++)
 689     {
 690       if (all_resources[i].secret)
 691         continue;
 692       switch (all_resources[i].type)
 693         {
 694         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
 695           break;
 696         case KEYDB_RESOURCE_TYPE_KEYRING:
 697           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
 698           if (rc)
 699             log_error (_("failed to rebuild keyring cache: %s\n"),
 700                        g10_errstr (rc));
 701           break;
 702         }
 703     }
 704 }
 705
 706
 707
 708 /*
 709  * Start the next search on this handle right at the beginning
 710  */
 711 int
 712 keydb_search_reset (KEYDB_HANDLE hd)
 713 {
 714     int i, rc = 0;
 715
 716     if (!hd)
 717         return G10ERR_INV_ARG;
 718
 719     hd->current = 0;
 720     hd->found = -1;
 721     /* and reset all resources */
 722     for (i=0; !rc && i < hd->used; i++) {
 723         switch (hd->active[i].type) {
 724           case KEYDB_RESOURCE_TYPE_NONE:
 725             break;
 726           case KEYDB_RESOURCE_TYPE_KEYRING:
 727             rc = keyring_search_reset (hd->active[i].u.kr);
 728             break;
 729         }
 730     }
 731     return rc;
 732 }
 733
 734
 735 /*
 736  * Search through all keydb resources, starting at the current position,
 737  * for a keyblock which contains one of the keys described in the DESC array.
 738  */
 739 int
 740 keydb_search2 (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
 741                size_t ndesc, size_t *descindex)
 742 {
 743     int rc = -1;
 744
 745     if (!hd)
 746         return G10ERR_INV_ARG;
 747
 748     while (rc == -1 && hd->current >= 0 && hd->current < hd->used) {
 749         switch (hd->active[hd->current].type) {
 750           case KEYDB_RESOURCE_TYPE_NONE:
 751             BUG(); /* we should never see it here */
 752             break;
 753           case KEYDB_RESOURCE_TYPE_KEYRING:
 754             rc = keyring_search (hd->active[hd->current].u.kr, desc,
 755                                  ndesc, descindex);
 756             break;
 757         }
 758         if (rc == -1) /* EOF -> switch to next resource */
 759             hd->current++;
 760         else if (!rc)
 761             hd->found = hd->current;
 762     }
 763
 764     return rc;
 765 }
 766
 767 int
 768 keydb_search_first (KEYDB_HANDLE hd)
 769 {
 770     KEYDB_SEARCH_DESC desc;
 771
 772     memset (&desc, 0, sizeof desc);
 773     desc.mode = KEYDB_SEARCH_MODE_FIRST;
 774     return keydb_search (hd, &desc, 1);
 775 }
 776
 777 int
 778 keydb_search_next (KEYDB_HANDLE hd)
 779 {
 780     KEYDB_SEARCH_DESC desc;
 781
 782     memset (&desc, 0, sizeof desc);
 783     desc.mode = KEYDB_SEARCH_MODE_NEXT;
 784     return keydb_search (hd, &desc, 1);
 785 }
 786
 787 int
 788 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
 789 {
 790     KEYDB_SEARCH_DESC desc;
 791
 792     memset (&desc, 0, sizeof desc);
 793     desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
 794     desc.u.kid[0] = kid[0];
 795     desc.u.kid[1] = kid[1];
 796     return keydb_search (hd, &desc, 1);
 797 }
 798
 799 int
 800 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
 801 {
 802     KEYDB_SEARCH_DESC desc;
 803
 804     memset (&desc, 0, sizeof desc);
 805     desc.mode = KEYDB_SEARCH_MODE_FPR;
 806     memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
 807     return keydb_search (hd, &desc, 1);
 808 }