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