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