g10: Fix memory leaks.
[gnupg.git] / g10 / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001-2013 Free Software Foundation, Inc.
3  * Coyrright (C) 2001-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <unistd.h>
29
30 #include "gpg.h"
31 #include "util.h"
32 #include "options.h"
33 #include "main.h" /*try_make_homedir ()*/
34 #include "packet.h"
35 #include "keyring.h"
36 #include "../kbx/keybox.h"
37 #include "keydb.h"
38 #include "i18n.h"
39
40 static int active_handles;
41
42 typedef enum
43   {
44     KEYDB_RESOURCE_TYPE_NONE = 0,
45     KEYDB_RESOURCE_TYPE_KEYRING,
46     KEYDB_RESOURCE_TYPE_KEYBOX
47   } KeydbResourceType;
48 #define MAX_KEYDB_RESOURCES 40
49
50 struct resource_item
51 {
52   KeydbResourceType type;
53   union {
54     KEYRING_HANDLE kr;
55     KEYBOX_HANDLE kb;
56   } u;
57   void *token;
58 };
59
60 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
61 static int used_resources;
62
63 /* A pointer used to check for the primary key database by comparing
64    to the struct resource_item's TOKEN.  */
65 static void *primary_keydb;
66
67
68 /* This is a simple cache used to return the last result of a
69    successful fingerprint search.  This works only for keybox resources
70    because (due to lack of a copy_keyblock function) we need to store
71    an image of the keyblock which is fortunately instantly available
72    for keyboxes.  */
73 enum keyblock_cache_states {
74   KEYBLOCK_CACHE_EMPTY,
75   KEYBLOCK_CACHE_PREPARED,
76   KEYBLOCK_CACHE_FILLED
77 };
78
79 struct keyblock_cache {
80   enum keyblock_cache_states state;
81   byte fpr[MAX_FINGERPRINT_LEN];
82   iobuf_t iobuf; /* Image of the keyblock.  */
83   u32 *sigstatus;
84   int pk_no;
85   int uid_no;
86   /* Offset of the record in the keybox.  */
87   int resource;
88   off_t offset;
89 };
90
91
92 struct keydb_handle
93 {
94   /* When we locked all of the resources in ACTIVE (using keyring_lock
95      / keybox_lock, as appropriate).  */
96   int locked;
97
98   /* The index into ACTIVE of the resources in which the last search
99      result was found.  Initially -1.  */
100   int found;
101
102   /* Initially -1 (invalid).  This is used to save a search result and
103      later restore it as the selected result.  */
104   int saved_found;
105
106   /* The number of skipped long blobs since the last search
107      (keydb_search_reset).  */
108   unsigned long skipped_long_blobs;
109
110   /* If set, this disables the use of the keyblock cache.  */
111   int no_caching;
112
113   /* Whether the next search will be from the beginning of the
114      database (and thus consider all records).  */
115   int is_reset;
116
117   /* The "file position."  In our case, this is index of the current
118      resource in ACTIVE.  */
119   int current;
120
121   /* The number of resources in ACTIVE.  */
122   int used;
123
124   /* Cache of the last found and parsed key block (only used for
125      keyboxes, not keyrings).  */
126   struct keyblock_cache keyblock_cache;
127
128   /* Copy of ALL_RESOURCES when keydb_new is called.  */
129   struct resource_item active[MAX_KEYDB_RESOURCES];
130 };
131
132 /* Looking up keys is expensive.  To hide the cost, we cache whether
133    keys exist in the key database.  Then, if we know a key does not
134    exist, we don't have to spend time looking it up.  This
135    particularly helps the --list-sigs and --check-sigs commands.
136
137    The cache stores the results in a hash using separate chaining.
138    Concretely: we use the LSB of the keyid to index the hash table and
139    each bucket consists of a linked list of entries.  An entry
140    consists of the 64-bit key id.  If a key id is not in the cache,
141    then we don't know whether it is in the DB or not.
142
143    To simplify the cache consistency protocol, we simply flush the
144    whole cache whenever a key is inserted or updated.  */
145
146 #define KID_NOT_FOUND_CACHE_BUCKETS 256
147 static struct kid_not_found_cache_bucket *
148   kid_not_found_cache[KID_NOT_FOUND_CACHE_BUCKETS];
149
150 /* The total number of entries in the hash table.  */
151 static unsigned int kid_not_found_cache_count;
152
153 struct kid_not_found_cache_bucket
154 {
155   struct kid_not_found_cache_bucket *next;
156   u32 kid[2];
157 };
158
159
160 static int lock_all (KEYDB_HANDLE hd);
161 static void unlock_all (KEYDB_HANDLE hd);
162
163
164 /* Check whether the keyid KID is in key id is definitely not in the
165    database.
166
167    Returns:
168
169      0 - Indeterminate: the key id is not in the cache; we don't know
170          whether the key is in the database or not.  If you want a
171          definitive answer, you'll need to perform a lookup.
172
173      1 - There is definitely no key with this key id in the database.
174          We searched for a key with this key id previously, but we
175          didn't find it in the database.  */
176 static int
177 kid_not_found_p (u32 *kid)
178 {
179   struct kid_not_found_cache_bucket *k;
180
181   for (k = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS]; k; k = k->next)
182     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
183       {
184         if (DBG_CACHE)
185           log_debug ("keydb: kid_not_found_p (%08lx%08lx) => not in DB\n",
186                      (ulong)kid[0], (ulong)kid[1]);
187         return 1;
188       }
189
190   if (DBG_CACHE)
191     log_debug ("keydb: kid_not_found_p (%08lx%08lx) => indeterminate\n",
192                (ulong)kid[0], (ulong)kid[1]);
193   return 0;
194 }
195
196
197 /* Insert the keyid KID into the kid_not_found_cache.  FOUND is whether
198    the key is in the key database or not.
199
200    Note this function does not check whether the key id is already in
201    the cache.  As such, kid_not_found_p() should be called first.  */
202 static void
203 kid_not_found_insert (u32 *kid)
204 {
205   struct kid_not_found_cache_bucket *k;
206
207   if (DBG_CACHE)
208     log_debug ("keydb: kid_not_found_insert (%08lx%08lx)\n",
209                (ulong)kid[0], (ulong)kid[1]);
210   k = xmalloc (sizeof *k);
211   k->kid[0] = kid[0];
212   k->kid[1] = kid[1];
213   k->next = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS];
214   kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS] = k;
215   kid_not_found_cache_count++;
216 }
217
218
219 /* Flush the kid not found cache.  */
220 static void
221 kid_not_found_flush (void)
222 {
223   struct kid_not_found_cache_bucket *k, *knext;
224   int i;
225
226   if (DBG_CACHE)
227     log_debug ("keydb: kid_not_found_flush\n");
228
229   if (!kid_not_found_cache_count)
230     return;
231
232   for (i=0; i < DIM(kid_not_found_cache); i++)
233     {
234       for (k = kid_not_found_cache[i]; k; k = knext)
235         {
236           knext = k->next;
237           xfree (k);
238         }
239       kid_not_found_cache[i] = NULL;
240     }
241   kid_not_found_cache_count = 0;
242 }
243
244
245 static void
246 keyblock_cache_clear (struct keydb_handle *hd)
247 {
248   hd->keyblock_cache.state = KEYBLOCK_CACHE_EMPTY;
249   xfree (hd->keyblock_cache.sigstatus);
250   hd->keyblock_cache.sigstatus = NULL;
251   iobuf_close (hd->keyblock_cache.iobuf);
252   hd->keyblock_cache.iobuf = NULL;
253   hd->keyblock_cache.resource = -1;
254   hd->keyblock_cache.offset = -1;
255 }
256
257
258 /* Handle the creation of a keyring or a keybox if it does not yet
259    exist.  Take into account that other processes might have the
260    keyring/keybox already locked.  This lock check does not work if
261    the directory itself is not yet available.  If IS_BOX is true the
262    filename is expected to refer to a keybox.  If FORCE_CREATE is true
263    the keyring or keybox will be created.
264
265    Return 0 if it is okay to access the specified file.  */
266 static gpg_error_t
267 maybe_create_keyring_or_box (char *filename, int is_box, int force_create)
268 {
269   dotlock_t lockhd = NULL;
270   IOBUF iobuf;
271   int rc;
272   mode_t oldmask;
273   char *last_slash_in_filename;
274   char *bak_fname = NULL;
275   char *tmp_fname = NULL;
276   int save_slash;
277
278   /* A quick test whether the filename already exists. */
279   if (!access (filename, F_OK))
280     return 0;
281
282   /* If we don't want to create a new file at all, there is no need to
283      go any further - bail out right here.  */
284   if (!force_create)
285     return gpg_error (GPG_ERR_ENOENT);
286
287   /* First of all we try to create the home directory.  Note, that we
288      don't do any locking here because any sane application of gpg
289      would create the home directory by itself and not rely on gpg's
290      tricky auto-creation which is anyway only done for certain home
291      directory name pattern. */
292   last_slash_in_filename = strrchr (filename, DIRSEP_C);
293 #if HAVE_W32_SYSTEM
294   {
295     /* Windows may either have a slash or a backslash.  Take care of it.  */
296     char *p = strrchr (filename, '/');
297     if (!last_slash_in_filename || p > last_slash_in_filename)
298       last_slash_in_filename = p;
299   }
300 #endif /*HAVE_W32_SYSTEM*/
301   if (!last_slash_in_filename)
302     return gpg_error (GPG_ERR_ENOENT);  /* No slash at all - should
303                                            not happen though.  */
304   save_slash = *last_slash_in_filename;
305   *last_slash_in_filename = 0;
306   if (access(filename, F_OK))
307     {
308       static int tried;
309
310       if (!tried)
311         {
312           tried = 1;
313           try_make_homedir (filename);
314         }
315       if (access (filename, F_OK))
316         {
317           rc = gpg_error_from_syserror ();
318           *last_slash_in_filename = save_slash;
319           goto leave;
320         }
321     }
322   *last_slash_in_filename = save_slash;
323
324   /* To avoid races with other instances of gpg trying to create or
325      update the keyring (it is removed during an update for a short
326      time), we do the next stuff in a locked state. */
327   lockhd = dotlock_create (filename, 0);
328   if (!lockhd)
329     {
330       rc = gpg_error_from_syserror ();
331       /* A reason for this to fail is that the directory is not
332          writable. However, this whole locking stuff does not make
333          sense if this is the case. An empty non-writable directory
334          with no keyring is not really useful at all. */
335       if (opt.verbose)
336         log_info ("can't allocate lock for '%s': %s\n",
337                   filename, gpg_strerror (rc));
338
339       if (!force_create)
340         return gpg_error (GPG_ERR_ENOENT);  /* Won't happen.  */
341       else
342         return rc;
343     }
344
345   if ( dotlock_take (lockhd, -1) )
346     {
347       rc = gpg_error_from_syserror ();
348       /* This is something bad.  Probably a stale lockfile.  */
349       log_info ("can't lock '%s': %s\n", filename, gpg_strerror (rc));
350       goto leave;
351     }
352
353   /* Now the real test while we are locked. */
354
355   /* Gpg either uses pubring.gpg or pubring.kbx and thus different
356    * lock files.  Now, when one gpg process is updating a pubring.gpg
357    * and thus holding the corresponding lock, a second gpg process may
358    * get to here at the time between the two rename operation used by
359    * the first process to update pubring.gpg.  The lock taken above
360    * may not protect the second process if it tries to create a
361    * pubring.kbx file which would be protected by a different lock
362    * file.
363    *
364    * We can detect this case by checking that the two temporary files
365    * used by the update code exist at the same time.  In that case we
366    * do not create a new file but act as if FORCE_CREATE has not been
367    * given.  Obviously there is a race between our two checks but the
368    * worst thing is that we won't create a new file, which is better
369    * than to accidentally creating one.  */
370   rc = keybox_tmp_names (filename, is_box, &bak_fname, &tmp_fname);
371   if (rc)
372     goto leave;
373
374   if (!access (filename, F_OK))
375     {
376       rc = 0;  /* Okay, we may access the file now.  */
377       goto leave;
378     }
379   if (!access (bak_fname, F_OK) && !access (tmp_fname, F_OK))
380     {
381       /* Very likely another process is updating a pubring.gpg and we
382          should not create a pubring.kbx.  */
383       rc = gpg_error (GPG_ERR_ENOENT);
384       goto leave;
385     }
386
387
388   /* The file does not yet exist, create it now. */
389   oldmask = umask (077);
390   if (is_secured_filename (filename))
391     {
392       iobuf = NULL;
393       gpg_err_set_errno (EPERM);
394     }
395   else
396     iobuf = iobuf_create (filename, 0);
397   umask (oldmask);
398   if (!iobuf)
399     {
400       rc = gpg_error_from_syserror ();
401       if (is_box)
402         log_error (_("error creating keybox '%s': %s\n"),
403                    filename, gpg_strerror (rc));
404       else
405         log_error (_("error creating keyring '%s': %s\n"),
406                    filename, gpg_strerror (rc));
407       goto leave;
408     }
409
410   iobuf_close (iobuf);
411   /* Must invalidate that ugly cache */
412   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, filename);
413
414   /* Make sure that at least one record is in a new keybox file, so
415      that the detection magic will work the next time it is used.  */
416   if (is_box)
417     {
418       FILE *fp = fopen (filename, "w");
419       if (!fp)
420         rc = gpg_error_from_syserror ();
421       else
422         {
423           rc = _keybox_write_header_blob (fp, 1);
424           fclose (fp);
425         }
426       if (rc)
427         {
428           if (is_box)
429             log_error (_("error creating keybox '%s': %s\n"),
430                        filename, gpg_strerror (rc));
431           else
432             log_error (_("error creating keyring '%s': %s\n"),
433                        filename, gpg_strerror (rc));
434           goto leave;
435         }
436     }
437
438   if (!opt.quiet)
439     {
440       if (is_box)
441         log_info (_("keybox '%s' created\n"), filename);
442       else
443         log_info (_("keyring '%s' created\n"), filename);
444     }
445
446   rc = 0;
447
448  leave:
449   if (lockhd)
450     {
451       dotlock_release (lockhd);
452       dotlock_destroy (lockhd);
453     }
454   xfree (bak_fname);
455   xfree (tmp_fname);
456   return rc;
457 }
458
459
460 /* Helper for keydb_add_resource.  Opens FILENAME to figure out the
461    resource type.
462
463    Returns the specified file's likely type.  If the file does not
464    exist, returns KEYDB_RESOURCE_TYPE_NONE and sets *R_FOUND to 0.
465    Otherwise, tries to figure out the file's type.  This is either
466    KEYDB_RESOURCE_TYPE_KEYBOX, KEYDB_RESOURCE_TYPE_KEYRING or
467    KEYDB_RESOURCE_TYPE_KEYNONE.  If the file is a keybox and it has
468    the OpenPGP flag set, then R_OPENPGP is also set.  */
469 static KeydbResourceType
470 rt_from_file (const char *filename, int *r_found, int *r_openpgp)
471 {
472   u32 magic;
473   unsigned char verbuf[4];
474   FILE *fp;
475   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
476
477   *r_found = *r_openpgp = 0;
478   fp = fopen (filename, "rb");
479   if (fp)
480     {
481       *r_found = 1;
482
483       if (fread (&magic, 4, 1, fp) == 1 )
484         {
485           if (magic == 0x13579ace || magic == 0xce9a5713)
486             ; /* GDBM magic - not anymore supported. */
487           else if (fread (&verbuf, 4, 1, fp) == 1
488                    && verbuf[0] == 1
489                    && fread (&magic, 4, 1, fp) == 1
490                    && !memcmp (&magic, "KBXf", 4))
491             {
492               if ((verbuf[3] & 0x02))
493                 *r_openpgp = 1;
494               rt = KEYDB_RESOURCE_TYPE_KEYBOX;
495             }
496           else
497             rt = KEYDB_RESOURCE_TYPE_KEYRING;
498         }
499       else /* Maybe empty: assume keyring. */
500         rt = KEYDB_RESOURCE_TYPE_KEYRING;
501
502       fclose (fp);
503     }
504
505   return rt;
506 }
507 \f
508 char *
509 keydb_search_desc_dump (struct keydb_search_desc *desc)
510 {
511   char b[MAX_FORMATTED_FINGERPRINT_LEN + 1];
512   char fpr[2 * MAX_FINGERPRINT_LEN + 1];
513
514   switch (desc->mode)
515     {
516     case KEYDB_SEARCH_MODE_EXACT:
517       return xasprintf ("EXACT: '%s'", desc->u.name);
518     case KEYDB_SEARCH_MODE_SUBSTR:
519       return xasprintf ("SUBSTR: '%s'", desc->u.name);
520     case KEYDB_SEARCH_MODE_MAIL:
521       return xasprintf ("MAIL: '%s'", desc->u.name);
522     case KEYDB_SEARCH_MODE_MAILSUB:
523       return xasprintf ("MAILSUB: '%s'", desc->u.name);
524     case KEYDB_SEARCH_MODE_MAILEND:
525       return xasprintf ("MAILEND: '%s'", desc->u.name);
526     case KEYDB_SEARCH_MODE_WORDS:
527       return xasprintf ("WORDS: '%s'", desc->u.name);
528     case KEYDB_SEARCH_MODE_SHORT_KID:
529       return xasprintf ("SHORT_KID: '%s'",
530                         format_keyid (desc->u.kid, KF_SHORT, b, sizeof (b)));
531     case KEYDB_SEARCH_MODE_LONG_KID:
532       return xasprintf ("LONG_KID: '%s'",
533                         format_keyid (desc->u.kid, KF_LONG, b, sizeof (b)));
534     case KEYDB_SEARCH_MODE_FPR16:
535       bin2hex (desc->u.fpr, 16, fpr);
536       return xasprintf ("FPR16: '%s'",
537                         format_hexfingerprint (fpr, b, sizeof (b)));
538     case KEYDB_SEARCH_MODE_FPR20:
539       bin2hex (desc->u.fpr, 20, fpr);
540       return xasprintf ("FPR20: '%s'",
541                         format_hexfingerprint (fpr, b, sizeof (b)));
542     case KEYDB_SEARCH_MODE_FPR:
543       bin2hex (desc->u.fpr, 20, fpr);
544       return xasprintf ("FPR: '%s'",
545                         format_hexfingerprint (fpr, b, sizeof (b)));
546     case KEYDB_SEARCH_MODE_ISSUER:
547       return xasprintf ("ISSUER: '%s'", desc->u.name);
548     case KEYDB_SEARCH_MODE_ISSUER_SN:
549       return xasprintf ("ISSUER_SN: '%*s'",
550                         (int) (desc->snlen == -1
551                                ? strlen (desc->sn) : desc->snlen),
552                         desc->sn);
553     case KEYDB_SEARCH_MODE_SN:
554       return xasprintf ("SN: '%*s'",
555                         (int) (desc->snlen == -1
556                                ? strlen (desc->sn) : desc->snlen),
557                         desc->sn);
558     case KEYDB_SEARCH_MODE_SUBJECT:
559       return xasprintf ("SUBJECT: '%s'", desc->u.name);
560     case KEYDB_SEARCH_MODE_KEYGRIP:
561       return xasprintf ("KEYGRIP: %s", desc->u.grip);
562     case KEYDB_SEARCH_MODE_FIRST:
563       return xasprintf ("FIRST");
564     case KEYDB_SEARCH_MODE_NEXT:
565       return xasprintf ("NEXT");
566     default:
567       return xasprintf ("Bad search mode (%d)", desc->mode);
568     }
569 }
570
571
572 \f
573 /* Register a resource (keyring or keybox).  The first keyring or
574  * keybox that is added using this function is created if it does not
575  * already exist and the KEYDB_RESOURCE_FLAG_READONLY is not set.
576  *
577  * FLAGS are a combination of the KEYDB_RESOURCE_FLAG_* constants.
578  *
579  * URL must have the following form:
580  *
581  *   gnupg-ring:filename  = plain keyring
582  *   gnupg-kbx:filename   = keybox file
583  *   filename             = check file's type (create as a plain keyring)
584  *
585  * Note: on systems with drive letters (Windows) invalid URLs (i.e.,
586  * those with an unrecognized part before the ':' such as "c:\...")
587  * will silently be treated as bare filenames.  On other systems, such
588  * URLs will cause this function to return GPG_ERR_GENERAL.
589  *
590  * If KEYDB_RESOURCE_FLAG_DEFAULT is set, the resource is a keyring
591  * and the file ends in ".gpg", then this function also checks if a
592  * file with the same name, but the extension ".kbx" exists, is a
593  * keybox and the OpenPGP flag is set.  If so, this function opens
594  * that resource instead.
595  *
596  * If the file is not found, KEYDB_RESOURCE_FLAG_GPGVDEF is set and
597  * the URL ends in ".kbx", then this function will try opening the
598  * same URL, but with the extension ".gpg".  If that file is a keybox
599  * with the OpenPGP flag set or it is a keyring, then we use that
600  * instead.
601  *
602  * If the file is not found, KEYDB_RESOURCE_FLAG_DEFAULT is set, the
603  * file should be created and the file's extension is ".gpg" then we
604  * replace the extension with ".kbx".
605  *
606  * If the KEYDB_RESOURCE_FLAG_PRIMARY is set and the resource is a
607  * keyring (not a keybox), then this resource is considered the
608  * primary resource.  This is used by keydb_locate_writable().  If
609  * another primary keyring is set, then that keyring is considered the
610  * primary.
611  *
612  * If KEYDB_RESOURCE_FLAG_READONLY is set and the resource is a
613  * keyring (not a keybox), then the keyring is marked as read only and
614  * operations just as keyring_insert_keyblock will return
615  * GPG_ERR_ACCESS.  */
616 gpg_error_t
617 keydb_add_resource (const char *url, unsigned int flags)
618 {
619   /* Whether we have successfully registered a resource.  */
620   static int any_registered;
621   /* The file named by the URL (i.e., without the prototype).  */
622   const char *resname = url;
623
624   char *filename = NULL;
625   int create;
626   int read_only = !!(flags&KEYDB_RESOURCE_FLAG_READONLY);
627   int is_default = !!(flags&KEYDB_RESOURCE_FLAG_DEFAULT);
628   int is_gpgvdef = !!(flags&KEYDB_RESOURCE_FLAG_GPGVDEF);
629   gpg_error_t err = 0;
630   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
631   void *token;
632
633   /* Create the resource if it is the first registered one.  */
634   create = (!read_only && !any_registered);
635
636   if (strlen (resname) > 11 && !strncmp( resname, "gnupg-ring:", 11) )
637     {
638       rt = KEYDB_RESOURCE_TYPE_KEYRING;
639       resname += 11;
640     }
641   else if (strlen (resname) > 10 && !strncmp (resname, "gnupg-kbx:", 10) )
642     {
643       rt = KEYDB_RESOURCE_TYPE_KEYBOX;
644       resname += 10;
645     }
646 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
647   else if (strchr (resname, ':'))
648     {
649       log_error ("invalid key resource URL '%s'\n", url );
650       err = gpg_error (GPG_ERR_GENERAL);
651       goto leave;
652     }
653 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
654
655   if (*resname != DIRSEP_C
656 #ifdef HAVE_W32_SYSTEM
657       && *resname != '/'  /* Fixme: does not handle drive letters.  */
658 #endif
659         )
660     {
661       /* Do tilde expansion etc. */
662       if (strchr (resname, DIRSEP_C)
663 #ifdef HAVE_W32_SYSTEM
664           || strchr (resname, '/')  /* Windows also accepts this.  */
665 #endif
666           )
667         filename = make_filename (resname, NULL);
668       else
669         filename = make_filename (gnupg_homedir (), resname, NULL);
670     }
671   else
672     filename = xstrdup (resname);
673
674   /* See whether we can determine the filetype.  */
675   if (rt == KEYDB_RESOURCE_TYPE_NONE)
676     {
677       int found, openpgp_flag;
678       int pass = 0;
679       size_t filenamelen;
680
681     check_again:
682       filenamelen = strlen (filename);
683       rt = rt_from_file (filename, &found, &openpgp_flag);
684       if (found)
685         {
686           /* The file exists and we have the resource type in RT.
687
688              Now let us check whether in addition to the "pubring.gpg"
689              a "pubring.kbx with openpgp keys exists.  This is so that
690              GPG 2.1 will use an existing "pubring.kbx" by default iff
691              that file has been created or used by 2.1.  This check is
692              needed because after creation or use of the kbx file with
693              2.1 an older version of gpg may have created a new
694              pubring.gpg for its own use.  */
695           if (!pass && is_default && rt == KEYDB_RESOURCE_TYPE_KEYRING
696               && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
697             {
698               strcpy (filename+filenamelen-4, ".kbx");
699               if ((rt_from_file (filename, &found, &openpgp_flag)
700                    == KEYDB_RESOURCE_TYPE_KEYBOX) && found && openpgp_flag)
701                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
702               else /* Restore filename */
703                 strcpy (filename+filenamelen-4, ".gpg");
704             }
705         }
706       else if (!pass && is_gpgvdef
707                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".kbx"))
708         {
709           /* Not found but gpgv's default "trustedkeys.kbx" file has
710              been requested.  We did not found it so now check whether
711              a "trustedkeys.gpg" file exists and use that instead.  */
712           KeydbResourceType rttmp;
713
714           strcpy (filename+filenamelen-4, ".gpg");
715           rttmp = rt_from_file (filename, &found, &openpgp_flag);
716           if (found
717               && ((rttmp == KEYDB_RESOURCE_TYPE_KEYBOX && openpgp_flag)
718                   || (rttmp == KEYDB_RESOURCE_TYPE_KEYRING)))
719             rt = rttmp;
720           else /* Restore filename */
721             strcpy (filename+filenamelen-4, ".kbx");
722         }
723       else if (!pass
724                && is_default && create
725                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
726         {
727           /* The file does not exist, the default resource has been
728              requested, the file shall be created, and the file has a
729              ".gpg" suffix.  Change the suffix to ".kbx" and try once
730              more.  This way we achieve that we open an existing
731              ".gpg" keyring, but create a new keybox file with an
732              ".kbx" suffix.  */
733           strcpy (filename+filenamelen-4, ".kbx");
734           pass++;
735           goto check_again;
736         }
737       else /* No file yet: create keybox. */
738         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
739     }
740
741   switch (rt)
742     {
743     case KEYDB_RESOURCE_TYPE_NONE:
744       log_error ("unknown type of key resource '%s'\n", url );
745       err = gpg_error (GPG_ERR_GENERAL);
746       goto leave;
747
748     case KEYDB_RESOURCE_TYPE_KEYRING:
749       err = maybe_create_keyring_or_box (filename, 0, create);
750       if (err)
751         goto leave;
752
753       if (keyring_register_filename (filename, read_only, &token))
754         {
755           if (used_resources >= MAX_KEYDB_RESOURCES)
756             err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
757           else
758             {
759               if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
760                 primary_keydb = token;
761               all_resources[used_resources].type = rt;
762               all_resources[used_resources].u.kr = NULL; /* Not used here */
763               all_resources[used_resources].token = token;
764               used_resources++;
765             }
766         }
767       else
768         {
769           /* This keyring was already registered, so ignore it.
770              However, we can still mark it as primary even if it was
771              already registered.  */
772           if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
773             primary_keydb = token;
774         }
775       break;
776
777     case KEYDB_RESOURCE_TYPE_KEYBOX:
778       {
779         err = maybe_create_keyring_or_box (filename, 1, create);
780         if (err)
781           goto leave;
782
783         err = keybox_register_file (filename, 0, &token);
784         if (!err)
785           {
786             if (used_resources >= MAX_KEYDB_RESOURCES)
787               err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
788             else
789               {
790                 if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
791                   primary_keydb = token;
792                 all_resources[used_resources].type = rt;
793                 all_resources[used_resources].u.kb = NULL; /* Not used here */
794                 all_resources[used_resources].token = token;
795
796                 /* FIXME: Do a compress run if needed and no other
797                    user is currently using the keybox. */
798
799                 used_resources++;
800               }
801           }
802         else if (gpg_err_code (err) == GPG_ERR_EEXIST)
803           {
804             /* Already registered.  We will mark it as the primary key
805                if requested.  */
806             if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
807               primary_keydb = token;
808           }
809       }
810       break;
811
812       default:
813         log_error ("resource type of '%s' not supported\n", url);
814         err = gpg_error (GPG_ERR_GENERAL);
815         goto leave;
816     }
817
818   /* fixme: check directory permissions and print a warning */
819
820  leave:
821   if (err)
822     log_error (_("keyblock resource '%s': %s\n"), filename, gpg_strerror (err));
823   else
824     any_registered = 1;
825   xfree (filename);
826   return err;
827 }
828
829
830 void
831 keydb_dump_stats (void)
832 {
833   if (kid_not_found_cache_count)
834     log_info ("keydb: kid_not_found_cache: total: %u\n",
835               kid_not_found_cache_count);
836 }
837
838
839 /* Create a new database handle.  A database handle is similar to a
840    file handle: it contains a local file position.  This is used when
841    searching: subsequent searches resume where the previous search
842    left off.  To rewind the position, use keydb_search_reset().  This
843    function returns NULL on error, sets ERRNO, and prints an error
844    diagnostic. */
845 KEYDB_HANDLE
846 keydb_new (void)
847 {
848   KEYDB_HANDLE hd;
849   int i, j;
850   int die = 0;
851   int reterrno;
852
853   if (DBG_CLOCK)
854     log_clock ("keydb_new");
855
856   hd = xtrycalloc (1, sizeof *hd);
857   if (!hd)
858     goto leave;
859   hd->found = -1;
860   hd->saved_found = -1;
861   hd->is_reset = 1;
862
863   log_assert (used_resources <= MAX_KEYDB_RESOURCES);
864   for (i=j=0; ! die && i < used_resources; i++)
865     {
866       switch (all_resources[i].type)
867         {
868         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
869           break;
870         case KEYDB_RESOURCE_TYPE_KEYRING:
871           hd->active[j].type   = all_resources[i].type;
872           hd->active[j].token  = all_resources[i].token;
873           hd->active[j].u.kr = keyring_new (all_resources[i].token);
874           if (!hd->active[j].u.kr)
875             {
876               reterrno = errno;
877               die = 1;
878             }
879           j++;
880           break;
881         case KEYDB_RESOURCE_TYPE_KEYBOX:
882           hd->active[j].type   = all_resources[i].type;
883           hd->active[j].token  = all_resources[i].token;
884           hd->active[j].u.kb   = keybox_new_openpgp (all_resources[i].token, 0);
885           if (!hd->active[j].u.kb)
886             {
887               reterrno = errno;
888               die = 1;
889             }
890           j++;
891           break;
892         }
893     }
894   hd->used = j;
895
896   active_handles++;
897
898   if (die)
899     {
900       keydb_release (hd);
901       gpg_err_set_errno (reterrno);
902       hd = NULL;
903     }
904
905  leave:
906   if (!hd)
907     log_error (_("error opening key DB: %s\n"),
908                gpg_strerror (gpg_error_from_syserror()));
909
910   return hd;
911 }
912
913
914 void
915 keydb_release (KEYDB_HANDLE hd)
916 {
917   int i;
918
919   if (!hd)
920     return;
921   log_assert (active_handles > 0);
922   active_handles--;
923
924   unlock_all (hd);
925   for (i=0; i < hd->used; i++)
926     {
927       switch (hd->active[i].type)
928         {
929         case KEYDB_RESOURCE_TYPE_NONE:
930           break;
931         case KEYDB_RESOURCE_TYPE_KEYRING:
932           keyring_release (hd->active[i].u.kr);
933           break;
934         case KEYDB_RESOURCE_TYPE_KEYBOX:
935           keybox_release (hd->active[i].u.kb);
936           break;
937         }
938     }
939
940   xfree (hd);
941 }
942
943
944 /* Set a flag on the handle to suppress use of cached results.  This
945  * is required for updating a keyring and for key listings.  Fixme:
946  * Using a new parameter for keydb_new might be a better solution.  */
947 void
948 keydb_disable_caching (KEYDB_HANDLE hd)
949 {
950   if (hd)
951     hd->no_caching = 1;
952 }
953
954
955 /* Return the file name of the resource in which the current search
956  * result was found or, if there is no search result, the filename of
957  * the current resource (i.e., the resource that the file position
958  * points to).  Note: the filename is not necessarily the URL used to
959  * open it!
960  *
961  * This function only returns NULL if no handle is specified, in all
962  * other error cases an empty string is returned.  */
963 const char *
964 keydb_get_resource_name (KEYDB_HANDLE hd)
965 {
966   int idx;
967   const char *s = NULL;
968
969   if (!hd)
970     return NULL;
971
972   if ( hd->found >= 0 && hd->found < hd->used)
973     idx = hd->found;
974   else if ( hd->current >= 0 && hd->current < hd->used)
975     idx = hd->current;
976   else
977     idx = 0;
978
979   switch (hd->active[idx].type)
980     {
981     case KEYDB_RESOURCE_TYPE_NONE:
982       s = NULL;
983       break;
984     case KEYDB_RESOURCE_TYPE_KEYRING:
985       s = keyring_get_resource_name (hd->active[idx].u.kr);
986       break;
987     case KEYDB_RESOURCE_TYPE_KEYBOX:
988       s = keybox_get_resource_name (hd->active[idx].u.kb);
989       break;
990     }
991
992   return s? s: "";
993 }
994
995
996
997 static int
998 lock_all (KEYDB_HANDLE hd)
999 {
1000   int i, rc = 0;
1001
1002   /* Fixme: This locking scheme may lead to a deadlock if the resources
1003      are not added in the same order by all processes.  We are
1004      currently only allowing one resource so it is not a problem.
1005      [Oops: Who claimed the latter]
1006
1007      To fix this we need to use a lock file to protect lock_all.  */
1008
1009   for (i=0; !rc && i < hd->used; i++)
1010     {
1011       switch (hd->active[i].type)
1012         {
1013         case KEYDB_RESOURCE_TYPE_NONE:
1014           break;
1015         case KEYDB_RESOURCE_TYPE_KEYRING:
1016           rc = keyring_lock (hd->active[i].u.kr, 1);
1017           break;
1018         case KEYDB_RESOURCE_TYPE_KEYBOX:
1019           rc = keybox_lock (hd->active[i].u.kb, 1);
1020           break;
1021         }
1022     }
1023
1024   if (rc)
1025     {
1026       /* Revert the already taken locks.  */
1027       for (i--; i >= 0; i--)
1028         {
1029           switch (hd->active[i].type)
1030             {
1031             case KEYDB_RESOURCE_TYPE_NONE:
1032               break;
1033             case KEYDB_RESOURCE_TYPE_KEYRING:
1034               keyring_lock (hd->active[i].u.kr, 0);
1035               break;
1036             case KEYDB_RESOURCE_TYPE_KEYBOX:
1037               keybox_lock (hd->active[i].u.kb, 0);
1038               break;
1039             }
1040         }
1041     }
1042   else
1043     hd->locked = 1;
1044
1045   return rc;
1046 }
1047
1048
1049 static void
1050 unlock_all (KEYDB_HANDLE hd)
1051 {
1052   int i;
1053
1054   if (!hd->locked)
1055     return;
1056
1057   for (i=hd->used-1; i >= 0; i--)
1058     {
1059       switch (hd->active[i].type)
1060         {
1061         case KEYDB_RESOURCE_TYPE_NONE:
1062           break;
1063         case KEYDB_RESOURCE_TYPE_KEYRING:
1064           keyring_lock (hd->active[i].u.kr, 0);
1065           break;
1066         case KEYDB_RESOURCE_TYPE_KEYBOX:
1067           keybox_lock (hd->active[i].u.kb, 0);
1068           break;
1069         }
1070     }
1071   hd->locked = 0;
1072 }
1073
1074
1075 \f
1076 /* Save the last found state and invalidate the current selection
1077  * (i.e., the entry selected by keydb_search() is invalidated and
1078  * something like keydb_get_keyblock() will return an error).  This
1079  * does not change the file position.  This makes it possible to do
1080  * something like:
1081  *
1082  *   keydb_search (hd, ...);  // Result 1.
1083  *   keydb_push_found_state (hd);
1084  *     keydb_search_reset (hd);
1085  *     keydb_search (hd, ...);  // Result 2.
1086  *   keydb_pop_found_state (hd);
1087  *   keydb_get_keyblock (hd, ...);  // -> Result 1.
1088  *
1089  * Note: it is only possible to save a single save state at a time.
1090  * In other words, the the save stack only has room for a single
1091  * instance of the state.  */
1092 void
1093 keydb_push_found_state (KEYDB_HANDLE hd)
1094 {
1095   if (!hd)
1096     return;
1097
1098   if (hd->found < 0 || hd->found >= hd->used)
1099     {
1100       hd->saved_found = -1;
1101       return;
1102     }
1103
1104   switch (hd->active[hd->found].type)
1105     {
1106     case KEYDB_RESOURCE_TYPE_NONE:
1107       break;
1108     case KEYDB_RESOURCE_TYPE_KEYRING:
1109       keyring_push_found_state (hd->active[hd->found].u.kr);
1110       break;
1111     case KEYDB_RESOURCE_TYPE_KEYBOX:
1112       keybox_push_found_state (hd->active[hd->found].u.kb);
1113       break;
1114     }
1115
1116   hd->saved_found = hd->found;
1117   hd->found = -1;
1118 }
1119
1120
1121 /* Restore the previous save state.  If the saved state is NULL or
1122    invalid, this is a NOP.  */
1123 void
1124 keydb_pop_found_state (KEYDB_HANDLE hd)
1125 {
1126   if (!hd)
1127     return;
1128
1129   hd->found = hd->saved_found;
1130   hd->saved_found = -1;
1131   if (hd->found < 0 || hd->found >= hd->used)
1132     return;
1133
1134   switch (hd->active[hd->found].type)
1135     {
1136     case KEYDB_RESOURCE_TYPE_NONE:
1137       break;
1138     case KEYDB_RESOURCE_TYPE_KEYRING:
1139       keyring_pop_found_state (hd->active[hd->found].u.kr);
1140       break;
1141     case KEYDB_RESOURCE_TYPE_KEYBOX:
1142       keybox_pop_found_state (hd->active[hd->found].u.kb);
1143       break;
1144     }
1145 }
1146
1147
1148 \f
1149 static gpg_error_t
1150 parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
1151                       const u32 *sigstatus, kbnode_t *r_keyblock)
1152 {
1153   gpg_error_t err;
1154   PACKET *pkt;
1155   kbnode_t keyblock = NULL;
1156   kbnode_t node, *tail;
1157   int in_cert, save_mode;
1158   u32 n_sigs;
1159   int pk_count, uid_count;
1160
1161   *r_keyblock = NULL;
1162
1163   pkt = xtrymalloc (sizeof *pkt);
1164   if (!pkt)
1165     return gpg_error_from_syserror ();
1166   init_packet (pkt);
1167   save_mode = set_packet_list_mode (0);
1168   in_cert = 0;
1169   n_sigs = 0;
1170   tail = NULL;
1171   pk_count = uid_count = 0;
1172   while ((err = parse_packet (iobuf, pkt)) != -1)
1173     {
1174       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
1175         {
1176           free_packet (pkt);
1177           init_packet (pkt);
1178           continue;
1179         }
1180       if (err)
1181         {
1182           log_error ("parse_keyblock_image: read error: %s\n",
1183                      gpg_strerror (err));
1184           err = gpg_error (GPG_ERR_INV_KEYRING);
1185           break;
1186         }
1187
1188       /* Filter allowed packets.  */
1189       switch (pkt->pkttype)
1190         {
1191         case PKT_PUBLIC_KEY:
1192         case PKT_PUBLIC_SUBKEY:
1193         case PKT_SECRET_KEY:
1194         case PKT_SECRET_SUBKEY:
1195         case PKT_USER_ID:
1196         case PKT_ATTRIBUTE:
1197         case PKT_SIGNATURE:
1198           break; /* Allowed per RFC.  */
1199
1200         default:
1201           /* Note that can't allow ring trust packets here and some of
1202              the other GPG specific packets don't make sense either.  */
1203           log_error ("skipped packet of type %d in keybox\n",
1204                      (int)pkt->pkttype);
1205           free_packet(pkt);
1206           init_packet(pkt);
1207           continue;
1208         }
1209
1210       /* Other sanity checks.  */
1211       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
1212         {
1213           log_error ("parse_keyblock_image: first packet in a keybox blob "
1214                      "is not a public key packet\n");
1215           err = gpg_error (GPG_ERR_INV_KEYRING);
1216           break;
1217         }
1218       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
1219                       || pkt->pkttype == PKT_SECRET_KEY))
1220         {
1221           log_error ("parse_keyblock_image: "
1222                      "multiple keyblocks in a keybox blob\n");
1223           err = gpg_error (GPG_ERR_INV_KEYRING);
1224           break;
1225         }
1226       in_cert = 1;
1227
1228       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
1229         {
1230           PKT_signature *sig = pkt->pkt.signature;
1231
1232           n_sigs++;
1233           if (n_sigs > sigstatus[0])
1234             {
1235               log_error ("parse_keyblock_image: "
1236                          "more signatures than found in the meta data\n");
1237               err = gpg_error (GPG_ERR_INV_KEYRING);
1238               break;
1239
1240             }
1241           if (sigstatus[n_sigs])
1242             {
1243               sig->flags.checked = 1;
1244               if (sigstatus[n_sigs] == 1 )
1245                 ; /* missing key */
1246               else if (sigstatus[n_sigs] == 2 )
1247                 ; /* bad signature */
1248               else if (sigstatus[n_sigs] < 0x10000000)
1249                 ; /* bad flag */
1250               else
1251                 {
1252                   sig->flags.valid = 1;
1253                   /* Fixme: Shall we set the expired flag here?  */
1254                 }
1255             }
1256         }
1257
1258       node = new_kbnode (pkt);
1259
1260       switch (pkt->pkttype)
1261         {
1262         case PKT_PUBLIC_KEY:
1263         case PKT_PUBLIC_SUBKEY:
1264         case PKT_SECRET_KEY:
1265         case PKT_SECRET_SUBKEY:
1266           if (++pk_count == pk_no)
1267             node->flag |= 1;
1268           break;
1269
1270         case PKT_USER_ID:
1271           if (++uid_count == uid_no)
1272             node->flag |= 2;
1273           break;
1274
1275         default:
1276           break;
1277         }
1278
1279       if (!keyblock)
1280         keyblock = node;
1281       else
1282         *tail = node;
1283       tail = &node->next;
1284       pkt = xtrymalloc (sizeof *pkt);
1285       if (!pkt)
1286         {
1287           err = gpg_error_from_syserror ();
1288           break;
1289         }
1290       init_packet (pkt);
1291     }
1292   set_packet_list_mode (save_mode);
1293
1294   if (err == -1 && keyblock)
1295     err = 0; /* Got the entire keyblock.  */
1296
1297   if (!err && sigstatus && n_sigs != sigstatus[0])
1298     {
1299       log_error ("parse_keyblock_image: signature count does not match\n");
1300       err = gpg_error (GPG_ERR_INV_KEYRING);
1301     }
1302
1303   if (err)
1304     release_kbnode (keyblock);
1305   else
1306     *r_keyblock = keyblock;
1307   free_packet (pkt);
1308   xfree (pkt);
1309   return err;
1310 }
1311
1312
1313 /* Return the keyblock last found by keydb_search() in *RET_KB.
1314  *
1315  * On success, the function returns 0 and the caller must free *RET_KB
1316  * using release_kbnode().  Otherwise, the function returns an error
1317  * code.
1318  *
1319  * The returned keyblock has the kbnode flag bit 0 set for the node
1320  * with the public key used to locate the keyblock or flag bit 1 set
1321  * for the user ID node.  */
1322 gpg_error_t
1323 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
1324 {
1325   gpg_error_t err = 0;
1326
1327   *ret_kb = NULL;
1328
1329   if (!hd)
1330     return gpg_error (GPG_ERR_INV_ARG);
1331
1332   if (DBG_CLOCK)
1333     log_clock ("keydb_get_keybock enter");
1334
1335   if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
1336     {
1337       err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
1338       if (err)
1339         {
1340           log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
1341           keyblock_cache_clear (hd);
1342         }
1343       else
1344         {
1345           err = parse_keyblock_image (hd->keyblock_cache.iobuf,
1346                                       hd->keyblock_cache.pk_no,
1347                                       hd->keyblock_cache.uid_no,
1348                                       hd->keyblock_cache.sigstatus,
1349                                       ret_kb);
1350           if (err)
1351             keyblock_cache_clear (hd);
1352           if (DBG_CLOCK)
1353             log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1354                        : "keydb_get_keyblock leave (cached)");
1355           return err;
1356         }
1357     }
1358
1359   if (hd->found < 0 || hd->found >= hd->used)
1360     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1361
1362   switch (hd->active[hd->found].type)
1363     {
1364     case KEYDB_RESOURCE_TYPE_NONE:
1365       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1366       break;
1367     case KEYDB_RESOURCE_TYPE_KEYRING:
1368       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1369       break;
1370     case KEYDB_RESOURCE_TYPE_KEYBOX:
1371       {
1372         iobuf_t iobuf;
1373         u32 *sigstatus;
1374         int pk_no, uid_no;
1375
1376         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1377                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1378         if (!err)
1379           {
1380             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1381                                         ret_kb);
1382             if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1383               {
1384                 hd->keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1385                 hd->keyblock_cache.sigstatus = sigstatus;
1386                 hd->keyblock_cache.iobuf     = iobuf;
1387                 hd->keyblock_cache.pk_no     = pk_no;
1388                 hd->keyblock_cache.uid_no    = uid_no;
1389               }
1390             xfree (sigstatus);
1391             iobuf_close (iobuf);
1392           }
1393       }
1394       break;
1395     }
1396
1397   if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1398     keyblock_cache_clear (hd);
1399
1400   if (DBG_CLOCK)
1401     log_clock (err? "keydb_get_keyblock leave (failed)"
1402                : "keydb_get_keyblock leave");
1403   return err;
1404 }
1405
1406
1407 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1408    only then stores a new iobuf object at R_IOBUF and a signature
1409    status vecotor at R_SIGSTATUS.  */
1410 static gpg_error_t
1411 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1412 {
1413   gpg_error_t err;
1414   iobuf_t iobuf;
1415   kbnode_t kbctx, node;
1416   u32 n_sigs;
1417   u32 *sigstatus;
1418
1419   *r_iobuf = NULL;
1420   if (r_sigstatus)
1421     *r_sigstatus = NULL;
1422
1423   /* Allocate a vector for the signature cache.  This is an array of
1424      u32 values with the first value giving the number of elements to
1425      follow and each element descriping the cache status of the
1426      signature.  */
1427   if (r_sigstatus)
1428     {
1429       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1430         if (node->pkt->pkttype == PKT_SIGNATURE)
1431           n_sigs++;
1432       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1433       if (!sigstatus)
1434         return gpg_error_from_syserror ();
1435     }
1436   else
1437     sigstatus = NULL;
1438
1439   iobuf = iobuf_temp ();
1440   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1441     {
1442       /* Make sure to use only packets valid on a keyblock.  */
1443       switch (node->pkt->pkttype)
1444         {
1445         case PKT_PUBLIC_KEY:
1446         case PKT_PUBLIC_SUBKEY:
1447         case PKT_SIGNATURE:
1448         case PKT_USER_ID:
1449         case PKT_ATTRIBUTE:
1450           /* Note that we don't want the ring trust packets.  They are
1451              not useful. */
1452           break;
1453         default:
1454           continue;
1455         }
1456
1457       err = build_packet (iobuf, node->pkt);
1458       if (err)
1459         {
1460           iobuf_close (iobuf);
1461           return err;
1462         }
1463
1464       /* Build signature status vector.  */
1465       if (node->pkt->pkttype == PKT_SIGNATURE)
1466         {
1467           PKT_signature *sig = node->pkt->pkt.signature;
1468
1469           n_sigs++;
1470           /* Fixme: Detect the "missing key" status.  */
1471           if (sig->flags.checked && sigstatus)
1472             {
1473               if (sig->flags.valid)
1474                 {
1475                   if (!sig->expiredate)
1476                     sigstatus[n_sigs] = 0xffffffff;
1477                   else if (sig->expiredate < 0x1000000)
1478                     sigstatus[n_sigs] = 0x10000000;
1479                   else
1480                     sigstatus[n_sigs] = sig->expiredate;
1481                 }
1482               else
1483                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1484             }
1485         }
1486     }
1487   if (sigstatus)
1488     sigstatus[0] = n_sigs;
1489
1490   *r_iobuf = iobuf;
1491   if (r_sigstatus)
1492     *r_sigstatus = sigstatus;
1493   return 0;
1494 }
1495
1496
1497 /* Update the keyblock KB (i.e., extract the fingerprint and find the
1498  * corresponding keyblock in the keyring).
1499  *
1500  * This doesn't do anything if --dry-run was specified.
1501  *
1502  * Returns 0 on success.  Otherwise, it returns an error code.  Note:
1503  * if there isn't a keyblock in the keyring corresponding to KB, then
1504  * this function returns GPG_ERR_VALUE_NOT_FOUND.
1505  *
1506  * This function selects the matching record and modifies the current
1507  * file position to point to the record just after the selected entry.
1508  * Thus, if you do a subsequent search using HD, you should first do a
1509  * keydb_search_reset.  Further, if the selected record is important,
1510  * you should use keydb_push_found_state and keydb_pop_found_state to
1511  * save and restore it.  */
1512 gpg_error_t
1513 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1514 {
1515   gpg_error_t err;
1516   PKT_public_key *pk;
1517   KEYDB_SEARCH_DESC desc;
1518   size_t len;
1519
1520   log_assert (kb);
1521   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1522   pk = kb->pkt->pkt.public_key;
1523
1524   if (!hd)
1525     return gpg_error (GPG_ERR_INV_ARG);
1526
1527   kid_not_found_flush ();
1528   keyblock_cache_clear (hd);
1529
1530   if (opt.dry_run)
1531     return 0;
1532
1533   err = lock_all (hd);
1534   if (err)
1535     return err;
1536
1537   memset (&desc, 0, sizeof (desc));
1538   fingerprint_from_pk (pk, desc.u.fpr, &len);
1539   if (len == 20)
1540     desc.mode = KEYDB_SEARCH_MODE_FPR20;
1541   else
1542     log_bug ("%s: Unsupported key length: %zu\n", __func__, len);
1543
1544   keydb_search_reset (hd);
1545   err = keydb_search (hd, &desc, 1, NULL);
1546   if (err)
1547     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1548   log_assert (hd->found >= 0 && hd->found < hd->used);
1549
1550   switch (hd->active[hd->found].type)
1551     {
1552     case KEYDB_RESOURCE_TYPE_NONE:
1553       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1554       break;
1555     case KEYDB_RESOURCE_TYPE_KEYRING:
1556       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1557       break;
1558     case KEYDB_RESOURCE_TYPE_KEYBOX:
1559       {
1560         iobuf_t iobuf;
1561
1562         err = build_keyblock_image (kb, &iobuf, NULL);
1563         if (!err)
1564           {
1565             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1566                                           iobuf_get_temp_buffer (iobuf),
1567                                           iobuf_get_temp_length (iobuf));
1568             iobuf_close (iobuf);
1569           }
1570       }
1571       break;
1572     }
1573
1574   unlock_all (hd);
1575   return err;
1576 }
1577
1578
1579 /* Insert a keyblock into one of the underlying keyrings or keyboxes.
1580  *
1581  * Be default, the keyring / keybox from which the last search result
1582  * came is used.  If there was no previous search result (or
1583  * keydb_search_reset was called), then the keyring / keybox where the
1584  * next search would start is used (i.e., the current file position).
1585  *
1586  * Note: this doesn't do anything if --dry-run was specified.
1587  *
1588  * Returns 0 on success.  Otherwise, it returns an error code.  */
1589 gpg_error_t
1590 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1591 {
1592   gpg_error_t err;
1593   int idx;
1594
1595   if (!hd)
1596     return gpg_error (GPG_ERR_INV_ARG);
1597
1598   kid_not_found_flush ();
1599   keyblock_cache_clear (hd);
1600
1601   if (opt.dry_run)
1602     return 0;
1603
1604   if (hd->found >= 0 && hd->found < hd->used)
1605     idx = hd->found;
1606   else if (hd->current >= 0 && hd->current < hd->used)
1607     idx = hd->current;
1608   else
1609     return gpg_error (GPG_ERR_GENERAL);
1610
1611   err = lock_all (hd);
1612   if (err)
1613     return err;
1614
1615   switch (hd->active[idx].type)
1616     {
1617     case KEYDB_RESOURCE_TYPE_NONE:
1618       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1619       break;
1620     case KEYDB_RESOURCE_TYPE_KEYRING:
1621       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1622       break;
1623     case KEYDB_RESOURCE_TYPE_KEYBOX:
1624       { /* We need to turn our kbnode_t list of packets into a proper
1625            keyblock first.  This is required by the OpenPGP key parser
1626            included in the keybox code.  Eventually we can change this
1627            kludge to have the caller pass the image.  */
1628         iobuf_t iobuf;
1629         u32 *sigstatus;
1630
1631         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1632         if (!err)
1633           {
1634             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1635                                           iobuf_get_temp_buffer (iobuf),
1636                                           iobuf_get_temp_length (iobuf),
1637                                           sigstatus);
1638             xfree (sigstatus);
1639             iobuf_close (iobuf);
1640           }
1641       }
1642       break;
1643     }
1644
1645   unlock_all (hd);
1646   return err;
1647 }
1648
1649
1650 /* Delete the currently selected keyblock.  If you haven't done a
1651  * search yet on this database handle (or called keydb_search_reset),
1652  * then this will return an error.
1653  *
1654  * Returns 0 on success or an error code, if an error occurs.  */
1655 gpg_error_t
1656 keydb_delete_keyblock (KEYDB_HANDLE hd)
1657 {
1658   gpg_error_t rc;
1659
1660   if (!hd)
1661     return gpg_error (GPG_ERR_INV_ARG);
1662
1663   kid_not_found_flush ();
1664   keyblock_cache_clear (hd);
1665
1666   if (hd->found < 0 || hd->found >= hd->used)
1667     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1668
1669   if (opt.dry_run)
1670     return 0;
1671
1672   rc = lock_all (hd);
1673   if (rc)
1674     return rc;
1675
1676   switch (hd->active[hd->found].type)
1677     {
1678     case KEYDB_RESOURCE_TYPE_NONE:
1679       rc = gpg_error (GPG_ERR_GENERAL);
1680       break;
1681     case KEYDB_RESOURCE_TYPE_KEYRING:
1682       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1683       break;
1684     case KEYDB_RESOURCE_TYPE_KEYBOX:
1685       rc = keybox_delete (hd->active[hd->found].u.kb);
1686       break;
1687     }
1688
1689   unlock_all (hd);
1690   return rc;
1691 }
1692
1693
1694 \f
1695 /* A database may consists of multiple keyrings / key boxes.  This
1696  * sets the "file position" to the start of the first keyring / key
1697  * box that is writable (i.e., doesn't have the read-only flag set).
1698  *
1699  * This first tries the primary keyring (the last keyring (not
1700  * keybox!) added using keydb_add_resource() and with
1701  * KEYDB_RESOURCE_FLAG_PRIMARY set).  If that is not writable, then it
1702  * tries the keyrings / keyboxes in the order in which they were
1703  * added.  */
1704 gpg_error_t
1705 keydb_locate_writable (KEYDB_HANDLE hd)
1706 {
1707   gpg_error_t rc;
1708
1709   if (!hd)
1710     return GPG_ERR_INV_ARG;
1711
1712   rc = keydb_search_reset (hd); /* this does reset hd->current */
1713   if (rc)
1714     return rc;
1715
1716   /* If we have a primary set, try that one first */
1717   if (primary_keydb)
1718     {
1719       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1720         {
1721           if(hd->active[hd->current].token == primary_keydb)
1722             {
1723               if(keyring_is_writable (hd->active[hd->current].token))
1724                 return 0;
1725               else
1726                 break;
1727             }
1728         }
1729
1730       rc = keydb_search_reset (hd); /* this does reset hd->current */
1731       if (rc)
1732         return rc;
1733     }
1734
1735   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1736     {
1737       switch (hd->active[hd->current].type)
1738         {
1739         case KEYDB_RESOURCE_TYPE_NONE:
1740           BUG();
1741           break;
1742         case KEYDB_RESOURCE_TYPE_KEYRING:
1743           if (keyring_is_writable (hd->active[hd->current].token))
1744             return 0; /* found (hd->current is set to it) */
1745           break;
1746         case KEYDB_RESOURCE_TYPE_KEYBOX:
1747           if (keybox_is_writable (hd->active[hd->current].token))
1748             return 0; /* found (hd->current is set to it) */
1749           break;
1750         }
1751     }
1752
1753   return gpg_error (GPG_ERR_NOT_FOUND);
1754 }
1755
1756
1757 /* Rebuild the on-disk caches of all key resources.  */
1758 void
1759 keydb_rebuild_caches (int noisy)
1760 {
1761   int i, rc;
1762
1763   for (i=0; i < used_resources; i++)
1764     {
1765       if (!keyring_is_writable (all_resources[i].token))
1766         continue;
1767       switch (all_resources[i].type)
1768         {
1769         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1770           break;
1771         case KEYDB_RESOURCE_TYPE_KEYRING:
1772           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1773           if (rc)
1774             log_error (_("failed to rebuild keyring cache: %s\n"),
1775                        gpg_strerror (rc));
1776           break;
1777         case KEYDB_RESOURCE_TYPE_KEYBOX:
1778           /* N/A.  */
1779           break;
1780         }
1781     }
1782 }
1783
1784
1785 /* Return the number of skipped blocks (because they were to large to
1786    read from a keybox) since the last search reset.  */
1787 unsigned long
1788 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1789 {
1790   return hd ? hd->skipped_long_blobs : 0;
1791 }
1792
1793
1794 /* Clears the current search result and resets the handle's position
1795  * so that the next search starts at the beginning of the database
1796  * (the start of the first resource).
1797  *
1798  * Returns 0 on success and an error code if an error occurred.
1799  * (Currently, this function always returns 0 if HD is valid.)  */
1800 gpg_error_t
1801 keydb_search_reset (KEYDB_HANDLE hd)
1802 {
1803   gpg_error_t rc = 0;
1804   int i;
1805
1806   if (!hd)
1807     return gpg_error (GPG_ERR_INV_ARG);
1808
1809   keyblock_cache_clear (hd);
1810
1811   if (DBG_CLOCK)
1812     log_clock ("keydb_search_reset");
1813
1814   if (DBG_CACHE)
1815     log_debug ("keydb_search: reset  (hd=%p)", hd);
1816
1817   hd->skipped_long_blobs = 0;
1818   hd->current = 0;
1819   hd->found = -1;
1820   /* Now reset all resources.  */
1821   for (i=0; !rc && i < hd->used; i++)
1822     {
1823       switch (hd->active[i].type)
1824         {
1825         case KEYDB_RESOURCE_TYPE_NONE:
1826           break;
1827         case KEYDB_RESOURCE_TYPE_KEYRING:
1828           rc = keyring_search_reset (hd->active[i].u.kr);
1829           break;
1830         case KEYDB_RESOURCE_TYPE_KEYBOX:
1831           rc = keybox_search_reset (hd->active[i].u.kb);
1832           break;
1833         }
1834     }
1835   hd->is_reset = 1;
1836   return rc;
1837 }
1838
1839
1840 /* Search the database for keys matching the search description.  If
1841  * the DB contains any legacy keys, these are silently ignored.
1842  *
1843  * DESC is an array of search terms with NDESC entries.  The search
1844  * terms are or'd together.  That is, the next entry in the DB that
1845  * matches any of the descriptions will be returned.
1846  *
1847  * Note: this function resumes searching where the last search left
1848  * off (i.e., at the current file position).  If you want to search
1849  * from the start of the database, then you need to first call
1850  * keydb_search_reset().
1851  *
1852  * If no key matches the search description, returns
1853  * GPG_ERR_NOT_FOUND.  If there was a match, returns 0.  If an error
1854  * occurred, returns an error code.
1855  *
1856  * The returned key is considered to be selected and the raw data can,
1857  * for instance, be returned by calling keydb_get_keyblock().  */
1858 gpg_error_t
1859 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1860               size_t ndesc, size_t *descindex)
1861 {
1862   int i;
1863   gpg_error_t rc;
1864   int was_reset = hd->is_reset;
1865   /* If an entry is already in the cache, then don't add it again.  */
1866   int already_in_cache = 0;
1867
1868   if (descindex)
1869     *descindex = 0; /* Make sure it is always set on return.  */
1870
1871   if (!hd)
1872     return gpg_error (GPG_ERR_INV_ARG);
1873
1874   if (DBG_CLOCK)
1875     log_clock ("keydb_search enter");
1876
1877   if (DBG_LOOKUP)
1878     {
1879       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
1880       for (i = 0; i < ndesc; i ++)
1881         {
1882           char *t = keydb_search_desc_dump (&desc[i]);
1883           log_debug ("%s   %d: %s\n", __func__, i, t);
1884           xfree (t);
1885         }
1886     }
1887
1888
1889   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1890       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1891     {
1892       if (DBG_CLOCK)
1893         log_clock ("keydb_search leave (not found, cached)");
1894       return gpg_error (GPG_ERR_NOT_FOUND);
1895     }
1896
1897   /* NB: If one of the exact search modes below is used in a loop to
1898      walk over all keys (with the same fingerprint) the caching must
1899      have been disabled for the handle.  */
1900   if (!hd->no_caching
1901       && ndesc == 1
1902       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1903           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1904       && hd->keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1905       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, 20)
1906       /* Make sure the current file position occurs before the cached
1907          result to avoid an infinite loop.  */
1908       && (hd->current < hd->keyblock_cache.resource
1909           || (hd->current == hd->keyblock_cache.resource
1910               && (keybox_offset (hd->active[hd->current].u.kb)
1911                   <= hd->keyblock_cache.offset))))
1912     {
1913       /* (DESCINDEX is already set).  */
1914       if (DBG_CLOCK)
1915         log_clock ("keydb_search leave (cached)");
1916
1917       hd->current = hd->keyblock_cache.resource;
1918       /* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
1919          Seek just beyond that.  */
1920       keybox_seek (hd->active[hd->current].u.kb,
1921                    hd->keyblock_cache.offset + 1);
1922       return 0;
1923     }
1924
1925   rc = -1;
1926   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1927          && hd->current >= 0 && hd->current < hd->used)
1928     {
1929       if (DBG_LOOKUP)
1930         log_debug ("%s: searching %s (resource %d of %d)\n",
1931                    __func__,
1932                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1933                    ? "keyring"
1934                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1935                       ? "keybox" : "unknown type"),
1936                    hd->current, hd->used);
1937
1938        switch (hd->active[hd->current].type)
1939         {
1940         case KEYDB_RESOURCE_TYPE_NONE:
1941           BUG(); /* we should never see it here */
1942           break;
1943         case KEYDB_RESOURCE_TYPE_KEYRING:
1944           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1945                                ndesc, descindex, 1);
1946           break;
1947         case KEYDB_RESOURCE_TYPE_KEYBOX:
1948           do
1949             rc = keybox_search (hd->active[hd->current].u.kb, desc,
1950                                 ndesc, KEYBOX_BLOBTYPE_PGP,
1951                                 descindex, &hd->skipped_long_blobs);
1952           while (rc == GPG_ERR_LEGACY_KEY);
1953           break;
1954         }
1955
1956       if (DBG_LOOKUP)
1957         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1958                    __func__,
1959                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1960                    ? "keyring"
1961                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1962                       ? "keybox" : "unknown type"),
1963                    hd->current, hd->used,
1964                    rc == -1 ? "EOF" : gpg_strerror (rc));
1965
1966       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1967         {
1968           /* EOF -> switch to next resource */
1969           hd->current++;
1970         }
1971       else if (!rc)
1972         hd->found = hd->current;
1973     }
1974   hd->is_reset = 0;
1975
1976   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1977         ? gpg_error (GPG_ERR_NOT_FOUND)
1978         : rc);
1979
1980   keyblock_cache_clear (hd);
1981   if (!hd->no_caching
1982       && !rc
1983       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1984                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1985       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
1986     {
1987       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1988       hd->keyblock_cache.resource = hd->current;
1989       /* The current offset is at the start of the next record.  Since
1990          a record is at least 1 byte, we just use offset - 1, which is
1991          within the record.  */
1992       hd->keyblock_cache.offset
1993         = keybox_offset (hd->active[hd->current].u.kb) - 1;
1994       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, 20);
1995     }
1996
1997   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
1998       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
1999       && !already_in_cache)
2000     kid_not_found_insert (desc[0].u.kid);
2001
2002   if (DBG_CLOCK)
2003     log_clock (rc? "keydb_search leave (not found)"
2004                  : "keydb_search leave (found)");
2005   return rc;
2006 }
2007
2008
2009 /* Return the first non-legacy key in the database.
2010  *
2011  * If you want the very first key in the database, you can directly
2012  * call keydb_search with the search description
2013  *  KEYDB_SEARCH_MODE_FIRST.  */
2014 gpg_error_t
2015 keydb_search_first (KEYDB_HANDLE hd)
2016 {
2017   gpg_error_t err;
2018   KEYDB_SEARCH_DESC desc;
2019
2020   err = keydb_search_reset (hd);
2021   if (err)
2022     return err;
2023
2024   memset (&desc, 0, sizeof desc);
2025   desc.mode = KEYDB_SEARCH_MODE_FIRST;
2026   return keydb_search (hd, &desc, 1, NULL);
2027 }
2028
2029
2030 /* Return the next key (not the next matching key!).
2031  *
2032  * Unlike calling keydb_search with KEYDB_SEARCH_MODE_NEXT, this
2033  * function silently skips legacy keys.  */
2034 gpg_error_t
2035 keydb_search_next (KEYDB_HANDLE hd)
2036 {
2037   KEYDB_SEARCH_DESC desc;
2038
2039   memset (&desc, 0, sizeof desc);
2040   desc.mode = KEYDB_SEARCH_MODE_NEXT;
2041   return keydb_search (hd, &desc, 1, NULL);
2042 }
2043
2044
2045 /* This is a convenience function for searching for keys with a long
2046  * key id.
2047  *
2048  * Note: this function resumes searching where the last search left
2049  * off.  If you want to search the whole database, then you need to
2050  * first call keydb_search_reset().  */
2051 gpg_error_t
2052 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
2053 {
2054   KEYDB_SEARCH_DESC desc;
2055
2056   memset (&desc, 0, sizeof desc);
2057   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
2058   desc.u.kid[0] = kid[0];
2059   desc.u.kid[1] = kid[1];
2060   return keydb_search (hd, &desc, 1, NULL);
2061 }
2062
2063
2064 /* This is a convenience function for searching for keys with a long
2065  * (20 byte) fingerprint.
2066  *
2067  * Note: this function resumes searching where the last search left
2068  * off.  If you want to search the whole database, then you need to
2069  * first call keydb_search_reset().  */
2070 gpg_error_t
2071 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
2072 {
2073   KEYDB_SEARCH_DESC desc;
2074
2075   memset (&desc, 0, sizeof desc);
2076   desc.mode = KEYDB_SEARCH_MODE_FPR;
2077   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
2078   return keydb_search (hd, &desc, 1, NULL);
2079 }