gpg: Change parse_packet to take a context.
[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   struct parse_packet_ctx_s parsectx;
1160   PACKET *pkt;
1161   kbnode_t keyblock = NULL;
1162   kbnode_t node, *tail;
1163   int in_cert, save_mode;
1164   u32 n_sigs;
1165   int pk_count, uid_count;
1166
1167   *r_keyblock = NULL;
1168
1169   pkt = xtrymalloc (sizeof *pkt);
1170   if (!pkt)
1171     return gpg_error_from_syserror ();
1172   init_packet (pkt);
1173   init_parse_packet (&parsectx, iobuf);
1174   save_mode = set_packet_list_mode (0);
1175   in_cert = 0;
1176   n_sigs = 0;
1177   tail = NULL;
1178   pk_count = uid_count = 0;
1179   while ((err = parse_packet (&parsectx, pkt)) != -1)
1180     {
1181       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
1182         {
1183           free_packet (pkt);
1184           init_packet (pkt);
1185           continue;
1186         }
1187       if (err)
1188         {
1189           log_error ("parse_keyblock_image: read error: %s\n",
1190                      gpg_strerror (err));
1191           err = gpg_error (GPG_ERR_INV_KEYRING);
1192           break;
1193         }
1194
1195       /* Filter allowed packets.  */
1196       switch (pkt->pkttype)
1197         {
1198         case PKT_PUBLIC_KEY:
1199         case PKT_PUBLIC_SUBKEY:
1200         case PKT_SECRET_KEY:
1201         case PKT_SECRET_SUBKEY:
1202         case PKT_USER_ID:
1203         case PKT_ATTRIBUTE:
1204         case PKT_SIGNATURE:
1205           break; /* Allowed per RFC.  */
1206
1207         default:
1208           /* Note that can't allow ring trust packets here and some of
1209              the other GPG specific packets don't make sense either.  */
1210           log_error ("skipped packet of type %d in keybox\n",
1211                      (int)pkt->pkttype);
1212           free_packet(pkt);
1213           init_packet(pkt);
1214           continue;
1215         }
1216
1217       /* Other sanity checks.  */
1218       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
1219         {
1220           log_error ("parse_keyblock_image: first packet in a keybox blob "
1221                      "is not a public key packet\n");
1222           err = gpg_error (GPG_ERR_INV_KEYRING);
1223           break;
1224         }
1225       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
1226                       || pkt->pkttype == PKT_SECRET_KEY))
1227         {
1228           log_error ("parse_keyblock_image: "
1229                      "multiple keyblocks in a keybox blob\n");
1230           err = gpg_error (GPG_ERR_INV_KEYRING);
1231           break;
1232         }
1233       in_cert = 1;
1234
1235       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
1236         {
1237           PKT_signature *sig = pkt->pkt.signature;
1238
1239           n_sigs++;
1240           if (n_sigs > sigstatus[0])
1241             {
1242               log_error ("parse_keyblock_image: "
1243                          "more signatures than found in the meta data\n");
1244               err = gpg_error (GPG_ERR_INV_KEYRING);
1245               break;
1246
1247             }
1248           if (sigstatus[n_sigs])
1249             {
1250               sig->flags.checked = 1;
1251               if (sigstatus[n_sigs] == 1 )
1252                 ; /* missing key */
1253               else if (sigstatus[n_sigs] == 2 )
1254                 ; /* bad signature */
1255               else if (sigstatus[n_sigs] < 0x10000000)
1256                 ; /* bad flag */
1257               else
1258                 {
1259                   sig->flags.valid = 1;
1260                   /* Fixme: Shall we set the expired flag here?  */
1261                 }
1262             }
1263         }
1264
1265       node = new_kbnode (pkt);
1266
1267       switch (pkt->pkttype)
1268         {
1269         case PKT_PUBLIC_KEY:
1270         case PKT_PUBLIC_SUBKEY:
1271         case PKT_SECRET_KEY:
1272         case PKT_SECRET_SUBKEY:
1273           if (++pk_count == pk_no)
1274             node->flag |= 1;
1275           break;
1276
1277         case PKT_USER_ID:
1278           if (++uid_count == uid_no)
1279             node->flag |= 2;
1280           break;
1281
1282         default:
1283           break;
1284         }
1285
1286       if (!keyblock)
1287         keyblock = node;
1288       else
1289         *tail = node;
1290       tail = &node->next;
1291       pkt = xtrymalloc (sizeof *pkt);
1292       if (!pkt)
1293         {
1294           err = gpg_error_from_syserror ();
1295           break;
1296         }
1297       init_packet (pkt);
1298     }
1299   set_packet_list_mode (save_mode);
1300
1301   if (err == -1 && keyblock)
1302     err = 0; /* Got the entire keyblock.  */
1303
1304   if (!err && sigstatus && n_sigs != sigstatus[0])
1305     {
1306       log_error ("parse_keyblock_image: signature count does not match\n");
1307       err = gpg_error (GPG_ERR_INV_KEYRING);
1308     }
1309
1310   if (err)
1311     release_kbnode (keyblock);
1312   else
1313     *r_keyblock = keyblock;
1314   free_packet (pkt);
1315   xfree (pkt);
1316   return err;
1317 }
1318
1319
1320 /* Return the keyblock last found by keydb_search() in *RET_KB.
1321  *
1322  * On success, the function returns 0 and the caller must free *RET_KB
1323  * using release_kbnode().  Otherwise, the function returns an error
1324  * code.
1325  *
1326  * The returned keyblock has the kbnode flag bit 0 set for the node
1327  * with the public key used to locate the keyblock or flag bit 1 set
1328  * for the user ID node.  */
1329 gpg_error_t
1330 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
1331 {
1332   gpg_error_t err = 0;
1333
1334   *ret_kb = NULL;
1335
1336   if (!hd)
1337     return gpg_error (GPG_ERR_INV_ARG);
1338
1339   if (DBG_CLOCK)
1340     log_clock ("keydb_get_keybock enter");
1341
1342   if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
1343     {
1344       err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
1345       if (err)
1346         {
1347           log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
1348           keyblock_cache_clear (hd);
1349         }
1350       else
1351         {
1352           err = parse_keyblock_image (hd->keyblock_cache.iobuf,
1353                                       hd->keyblock_cache.pk_no,
1354                                       hd->keyblock_cache.uid_no,
1355                                       hd->keyblock_cache.sigstatus,
1356                                       ret_kb);
1357           if (err)
1358             keyblock_cache_clear (hd);
1359           if (DBG_CLOCK)
1360             log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1361                        : "keydb_get_keyblock leave (cached)");
1362           return err;
1363         }
1364     }
1365
1366   if (hd->found < 0 || hd->found >= hd->used)
1367     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1368
1369   switch (hd->active[hd->found].type)
1370     {
1371     case KEYDB_RESOURCE_TYPE_NONE:
1372       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1373       break;
1374     case KEYDB_RESOURCE_TYPE_KEYRING:
1375       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1376       break;
1377     case KEYDB_RESOURCE_TYPE_KEYBOX:
1378       {
1379         iobuf_t iobuf;
1380         u32 *sigstatus;
1381         int pk_no, uid_no;
1382
1383         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1384                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1385         if (!err)
1386           {
1387             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1388                                         ret_kb);
1389             if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1390               {
1391                 hd->keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1392                 hd->keyblock_cache.sigstatus = sigstatus;
1393                 hd->keyblock_cache.iobuf     = iobuf;
1394                 hd->keyblock_cache.pk_no     = pk_no;
1395                 hd->keyblock_cache.uid_no    = uid_no;
1396               }
1397             else
1398               {
1399                 xfree (sigstatus);
1400                 iobuf_close (iobuf);
1401               }
1402           }
1403       }
1404       break;
1405     }
1406
1407   if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1408     keyblock_cache_clear (hd);
1409
1410   if (DBG_CLOCK)
1411     log_clock (err? "keydb_get_keyblock leave (failed)"
1412                : "keydb_get_keyblock leave");
1413   return err;
1414 }
1415
1416
1417 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1418    only then stores a new iobuf object at R_IOBUF and a signature
1419    status vecotor at R_SIGSTATUS.  */
1420 static gpg_error_t
1421 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1422 {
1423   gpg_error_t err;
1424   iobuf_t iobuf;
1425   kbnode_t kbctx, node;
1426   u32 n_sigs;
1427   u32 *sigstatus;
1428
1429   *r_iobuf = NULL;
1430   if (r_sigstatus)
1431     *r_sigstatus = NULL;
1432
1433   /* Allocate a vector for the signature cache.  This is an array of
1434      u32 values with the first value giving the number of elements to
1435      follow and each element descriping the cache status of the
1436      signature.  */
1437   if (r_sigstatus)
1438     {
1439       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1440         if (node->pkt->pkttype == PKT_SIGNATURE)
1441           n_sigs++;
1442       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1443       if (!sigstatus)
1444         return gpg_error_from_syserror ();
1445     }
1446   else
1447     sigstatus = NULL;
1448
1449   iobuf = iobuf_temp ();
1450   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1451     {
1452       /* Make sure to use only packets valid on a keyblock.  */
1453       switch (node->pkt->pkttype)
1454         {
1455         case PKT_PUBLIC_KEY:
1456         case PKT_PUBLIC_SUBKEY:
1457         case PKT_SIGNATURE:
1458         case PKT_USER_ID:
1459         case PKT_ATTRIBUTE:
1460           /* Note that we don't want the ring trust packets.  They are
1461              not useful. */
1462           break;
1463         default:
1464           continue;
1465         }
1466
1467       err = build_packet (iobuf, node->pkt);
1468       if (err)
1469         {
1470           iobuf_close (iobuf);
1471           return err;
1472         }
1473
1474       /* Build signature status vector.  */
1475       if (node->pkt->pkttype == PKT_SIGNATURE)
1476         {
1477           PKT_signature *sig = node->pkt->pkt.signature;
1478
1479           n_sigs++;
1480           /* Fixme: Detect the "missing key" status.  */
1481           if (sig->flags.checked && sigstatus)
1482             {
1483               if (sig->flags.valid)
1484                 {
1485                   if (!sig->expiredate)
1486                     sigstatus[n_sigs] = 0xffffffff;
1487                   else if (sig->expiredate < 0x1000000)
1488                     sigstatus[n_sigs] = 0x10000000;
1489                   else
1490                     sigstatus[n_sigs] = sig->expiredate;
1491                 }
1492               else
1493                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1494             }
1495         }
1496     }
1497   if (sigstatus)
1498     sigstatus[0] = n_sigs;
1499
1500   *r_iobuf = iobuf;
1501   if (r_sigstatus)
1502     *r_sigstatus = sigstatus;
1503   return 0;
1504 }
1505
1506
1507 /* Update the keyblock KB (i.e., extract the fingerprint and find the
1508  * corresponding keyblock in the keyring).
1509  *
1510  * This doesn't do anything if --dry-run was specified.
1511  *
1512  * Returns 0 on success.  Otherwise, it returns an error code.  Note:
1513  * if there isn't a keyblock in the keyring corresponding to KB, then
1514  * this function returns GPG_ERR_VALUE_NOT_FOUND.
1515  *
1516  * This function selects the matching record and modifies the current
1517  * file position to point to the record just after the selected entry.
1518  * Thus, if you do a subsequent search using HD, you should first do a
1519  * keydb_search_reset.  Further, if the selected record is important,
1520  * you should use keydb_push_found_state and keydb_pop_found_state to
1521  * save and restore it.  */
1522 gpg_error_t
1523 keydb_update_keyblock (ctrl_t ctrl, KEYDB_HANDLE hd, kbnode_t kb)
1524 {
1525   gpg_error_t err;
1526   PKT_public_key *pk;
1527   KEYDB_SEARCH_DESC desc;
1528   size_t len;
1529
1530   log_assert (kb);
1531   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1532   pk = kb->pkt->pkt.public_key;
1533
1534   if (!hd)
1535     return gpg_error (GPG_ERR_INV_ARG);
1536
1537   kid_not_found_flush ();
1538   keyblock_cache_clear (hd);
1539
1540   if (opt.dry_run)
1541     return 0;
1542
1543   err = lock_all (hd);
1544   if (err)
1545     return err;
1546
1547 #ifdef USE_TOFU
1548   tofu_notice_key_changed (ctrl, kb);
1549 #endif
1550
1551   memset (&desc, 0, sizeof (desc));
1552   fingerprint_from_pk (pk, desc.u.fpr, &len);
1553   if (len == 20)
1554     desc.mode = KEYDB_SEARCH_MODE_FPR20;
1555   else
1556     log_bug ("%s: Unsupported key length: %zu\n", __func__, len);
1557
1558   keydb_search_reset (hd);
1559   err = keydb_search (hd, &desc, 1, NULL);
1560   if (err)
1561     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1562   log_assert (hd->found >= 0 && hd->found < hd->used);
1563
1564   switch (hd->active[hd->found].type)
1565     {
1566     case KEYDB_RESOURCE_TYPE_NONE:
1567       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1568       break;
1569     case KEYDB_RESOURCE_TYPE_KEYRING:
1570       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1571       break;
1572     case KEYDB_RESOURCE_TYPE_KEYBOX:
1573       {
1574         iobuf_t iobuf;
1575
1576         err = build_keyblock_image (kb, &iobuf, NULL);
1577         if (!err)
1578           {
1579             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1580                                           iobuf_get_temp_buffer (iobuf),
1581                                           iobuf_get_temp_length (iobuf));
1582             iobuf_close (iobuf);
1583           }
1584       }
1585       break;
1586     }
1587
1588   unlock_all (hd);
1589   return err;
1590 }
1591
1592
1593 /* Insert a keyblock into one of the underlying keyrings or keyboxes.
1594  *
1595  * Be default, the keyring / keybox from which the last search result
1596  * came is used.  If there was no previous search result (or
1597  * keydb_search_reset was called), then the keyring / keybox where the
1598  * next search would start is used (i.e., the current file position).
1599  *
1600  * Note: this doesn't do anything if --dry-run was specified.
1601  *
1602  * Returns 0 on success.  Otherwise, it returns an error code.  */
1603 gpg_error_t
1604 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1605 {
1606   gpg_error_t err;
1607   int idx;
1608
1609   if (!hd)
1610     return gpg_error (GPG_ERR_INV_ARG);
1611
1612   kid_not_found_flush ();
1613   keyblock_cache_clear (hd);
1614
1615   if (opt.dry_run)
1616     return 0;
1617
1618   if (hd->found >= 0 && hd->found < hd->used)
1619     idx = hd->found;
1620   else if (hd->current >= 0 && hd->current < hd->used)
1621     idx = hd->current;
1622   else
1623     return gpg_error (GPG_ERR_GENERAL);
1624
1625   err = lock_all (hd);
1626   if (err)
1627     return err;
1628
1629   switch (hd->active[idx].type)
1630     {
1631     case KEYDB_RESOURCE_TYPE_NONE:
1632       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1633       break;
1634     case KEYDB_RESOURCE_TYPE_KEYRING:
1635       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1636       break;
1637     case KEYDB_RESOURCE_TYPE_KEYBOX:
1638       { /* We need to turn our kbnode_t list of packets into a proper
1639            keyblock first.  This is required by the OpenPGP key parser
1640            included in the keybox code.  Eventually we can change this
1641            kludge to have the caller pass the image.  */
1642         iobuf_t iobuf;
1643         u32 *sigstatus;
1644
1645         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1646         if (!err)
1647           {
1648             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1649                                           iobuf_get_temp_buffer (iobuf),
1650                                           iobuf_get_temp_length (iobuf),
1651                                           sigstatus);
1652             xfree (sigstatus);
1653             iobuf_close (iobuf);
1654           }
1655       }
1656       break;
1657     }
1658
1659   unlock_all (hd);
1660   return err;
1661 }
1662
1663
1664 /* Delete the currently selected keyblock.  If you haven't done a
1665  * search yet on this database handle (or called keydb_search_reset),
1666  * then this will return an error.
1667  *
1668  * Returns 0 on success or an error code, if an error occurs.  */
1669 gpg_error_t
1670 keydb_delete_keyblock (KEYDB_HANDLE hd)
1671 {
1672   gpg_error_t rc;
1673
1674   if (!hd)
1675     return gpg_error (GPG_ERR_INV_ARG);
1676
1677   kid_not_found_flush ();
1678   keyblock_cache_clear (hd);
1679
1680   if (hd->found < 0 || hd->found >= hd->used)
1681     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1682
1683   if (opt.dry_run)
1684     return 0;
1685
1686   rc = lock_all (hd);
1687   if (rc)
1688     return rc;
1689
1690   switch (hd->active[hd->found].type)
1691     {
1692     case KEYDB_RESOURCE_TYPE_NONE:
1693       rc = gpg_error (GPG_ERR_GENERAL);
1694       break;
1695     case KEYDB_RESOURCE_TYPE_KEYRING:
1696       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1697       break;
1698     case KEYDB_RESOURCE_TYPE_KEYBOX:
1699       rc = keybox_delete (hd->active[hd->found].u.kb);
1700       break;
1701     }
1702
1703   unlock_all (hd);
1704   return rc;
1705 }
1706
1707
1708 \f
1709 /* A database may consists of multiple keyrings / key boxes.  This
1710  * sets the "file position" to the start of the first keyring / key
1711  * box that is writable (i.e., doesn't have the read-only flag set).
1712  *
1713  * This first tries the primary keyring (the last keyring (not
1714  * keybox!) added using keydb_add_resource() and with
1715  * KEYDB_RESOURCE_FLAG_PRIMARY set).  If that is not writable, then it
1716  * tries the keyrings / keyboxes in the order in which they were
1717  * added.  */
1718 gpg_error_t
1719 keydb_locate_writable (KEYDB_HANDLE hd)
1720 {
1721   gpg_error_t rc;
1722
1723   if (!hd)
1724     return GPG_ERR_INV_ARG;
1725
1726   rc = keydb_search_reset (hd); /* this does reset hd->current */
1727   if (rc)
1728     return rc;
1729
1730   /* If we have a primary set, try that one first */
1731   if (primary_keydb)
1732     {
1733       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1734         {
1735           if(hd->active[hd->current].token == primary_keydb)
1736             {
1737               if(keyring_is_writable (hd->active[hd->current].token))
1738                 return 0;
1739               else
1740                 break;
1741             }
1742         }
1743
1744       rc = keydb_search_reset (hd); /* this does reset hd->current */
1745       if (rc)
1746         return rc;
1747     }
1748
1749   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1750     {
1751       switch (hd->active[hd->current].type)
1752         {
1753         case KEYDB_RESOURCE_TYPE_NONE:
1754           BUG();
1755           break;
1756         case KEYDB_RESOURCE_TYPE_KEYRING:
1757           if (keyring_is_writable (hd->active[hd->current].token))
1758             return 0; /* found (hd->current is set to it) */
1759           break;
1760         case KEYDB_RESOURCE_TYPE_KEYBOX:
1761           if (keybox_is_writable (hd->active[hd->current].token))
1762             return 0; /* found (hd->current is set to it) */
1763           break;
1764         }
1765     }
1766
1767   return gpg_error (GPG_ERR_NOT_FOUND);
1768 }
1769
1770
1771 /* Rebuild the on-disk caches of all key resources.  */
1772 void
1773 keydb_rebuild_caches (int noisy)
1774 {
1775   int i, rc;
1776
1777   for (i=0; i < used_resources; i++)
1778     {
1779       if (!keyring_is_writable (all_resources[i].token))
1780         continue;
1781       switch (all_resources[i].type)
1782         {
1783         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1784           break;
1785         case KEYDB_RESOURCE_TYPE_KEYRING:
1786           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1787           if (rc)
1788             log_error (_("failed to rebuild keyring cache: %s\n"),
1789                        gpg_strerror (rc));
1790           break;
1791         case KEYDB_RESOURCE_TYPE_KEYBOX:
1792           /* N/A.  */
1793           break;
1794         }
1795     }
1796 }
1797
1798
1799 /* Return the number of skipped blocks (because they were to large to
1800    read from a keybox) since the last search reset.  */
1801 unsigned long
1802 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1803 {
1804   return hd ? hd->skipped_long_blobs : 0;
1805 }
1806
1807
1808 /* Clears the current search result and resets the handle's position
1809  * so that the next search starts at the beginning of the database
1810  * (the start of the first resource).
1811  *
1812  * Returns 0 on success and an error code if an error occurred.
1813  * (Currently, this function always returns 0 if HD is valid.)  */
1814 gpg_error_t
1815 keydb_search_reset (KEYDB_HANDLE hd)
1816 {
1817   gpg_error_t rc = 0;
1818   int i;
1819
1820   if (!hd)
1821     return gpg_error (GPG_ERR_INV_ARG);
1822
1823   keyblock_cache_clear (hd);
1824
1825   if (DBG_CLOCK)
1826     log_clock ("keydb_search_reset");
1827
1828   if (DBG_CACHE)
1829     log_debug ("keydb_search: reset  (hd=%p)", hd);
1830
1831   hd->skipped_long_blobs = 0;
1832   hd->current = 0;
1833   hd->found = -1;
1834   /* Now reset all resources.  */
1835   for (i=0; !rc && i < hd->used; i++)
1836     {
1837       switch (hd->active[i].type)
1838         {
1839         case KEYDB_RESOURCE_TYPE_NONE:
1840           break;
1841         case KEYDB_RESOURCE_TYPE_KEYRING:
1842           rc = keyring_search_reset (hd->active[i].u.kr);
1843           break;
1844         case KEYDB_RESOURCE_TYPE_KEYBOX:
1845           rc = keybox_search_reset (hd->active[i].u.kb);
1846           break;
1847         }
1848     }
1849   hd->is_reset = 1;
1850   return rc;
1851 }
1852
1853
1854 /* Search the database for keys matching the search description.  If
1855  * the DB contains any legacy keys, these are silently ignored.
1856  *
1857  * DESC is an array of search terms with NDESC entries.  The search
1858  * terms are or'd together.  That is, the next entry in the DB that
1859  * matches any of the descriptions will be returned.
1860  *
1861  * Note: this function resumes searching where the last search left
1862  * off (i.e., at the current file position).  If you want to search
1863  * from the start of the database, then you need to first call
1864  * keydb_search_reset().
1865  *
1866  * If no key matches the search description, returns
1867  * GPG_ERR_NOT_FOUND.  If there was a match, returns 0.  If an error
1868  * occurred, returns an error code.
1869  *
1870  * The returned key is considered to be selected and the raw data can,
1871  * for instance, be returned by calling keydb_get_keyblock().  */
1872 gpg_error_t
1873 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1874               size_t ndesc, size_t *descindex)
1875 {
1876   int i;
1877   gpg_error_t rc;
1878   int was_reset = hd->is_reset;
1879   /* If an entry is already in the cache, then don't add it again.  */
1880   int already_in_cache = 0;
1881
1882   if (descindex)
1883     *descindex = 0; /* Make sure it is always set on return.  */
1884
1885   if (!hd)
1886     return gpg_error (GPG_ERR_INV_ARG);
1887
1888   if (!any_registered)
1889     {
1890       write_status_error ("keydb_search", gpg_error (GPG_ERR_KEYRING_OPEN));
1891       return gpg_error (GPG_ERR_NOT_FOUND);
1892     }
1893
1894   if (DBG_CLOCK)
1895     log_clock ("keydb_search enter");
1896
1897   if (DBG_LOOKUP)
1898     {
1899       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
1900       for (i = 0; i < ndesc; i ++)
1901         {
1902           char *t = keydb_search_desc_dump (&desc[i]);
1903           log_debug ("%s   %d: %s\n", __func__, i, t);
1904           xfree (t);
1905         }
1906     }
1907
1908
1909   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1910       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1911     {
1912       if (DBG_CLOCK)
1913         log_clock ("keydb_search leave (not found, cached)");
1914       return gpg_error (GPG_ERR_NOT_FOUND);
1915     }
1916
1917   /* NB: If one of the exact search modes below is used in a loop to
1918      walk over all keys (with the same fingerprint) the caching must
1919      have been disabled for the handle.  */
1920   if (!hd->no_caching
1921       && ndesc == 1
1922       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1923           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1924       && hd->keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1925       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, 20)
1926       /* Make sure the current file position occurs before the cached
1927          result to avoid an infinite loop.  */
1928       && (hd->current < hd->keyblock_cache.resource
1929           || (hd->current == hd->keyblock_cache.resource
1930               && (keybox_offset (hd->active[hd->current].u.kb)
1931                   <= hd->keyblock_cache.offset))))
1932     {
1933       /* (DESCINDEX is already set).  */
1934       if (DBG_CLOCK)
1935         log_clock ("keydb_search leave (cached)");
1936
1937       hd->current = hd->keyblock_cache.resource;
1938       /* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
1939          Seek just beyond that.  */
1940       keybox_seek (hd->active[hd->current].u.kb,
1941                    hd->keyblock_cache.offset + 1);
1942       return 0;
1943     }
1944
1945   rc = -1;
1946   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1947          && hd->current >= 0 && hd->current < hd->used)
1948     {
1949       if (DBG_LOOKUP)
1950         log_debug ("%s: searching %s (resource %d of %d)\n",
1951                    __func__,
1952                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1953                    ? "keyring"
1954                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1955                       ? "keybox" : "unknown type"),
1956                    hd->current, hd->used);
1957
1958        switch (hd->active[hd->current].type)
1959         {
1960         case KEYDB_RESOURCE_TYPE_NONE:
1961           BUG(); /* we should never see it here */
1962           break;
1963         case KEYDB_RESOURCE_TYPE_KEYRING:
1964           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1965                                ndesc, descindex, 1);
1966           break;
1967         case KEYDB_RESOURCE_TYPE_KEYBOX:
1968           do
1969             rc = keybox_search (hd->active[hd->current].u.kb, desc,
1970                                 ndesc, KEYBOX_BLOBTYPE_PGP,
1971                                 descindex, &hd->skipped_long_blobs);
1972           while (rc == GPG_ERR_LEGACY_KEY);
1973           break;
1974         }
1975
1976       if (DBG_LOOKUP)
1977         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1978                    __func__,
1979                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1980                    ? "keyring"
1981                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1982                       ? "keybox" : "unknown type"),
1983                    hd->current, hd->used,
1984                    rc == -1 ? "EOF" : gpg_strerror (rc));
1985
1986       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1987         {
1988           /* EOF -> switch to next resource */
1989           hd->current++;
1990         }
1991       else if (!rc)
1992         hd->found = hd->current;
1993     }
1994   hd->is_reset = 0;
1995
1996   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1997         ? gpg_error (GPG_ERR_NOT_FOUND)
1998         : rc);
1999
2000   keyblock_cache_clear (hd);
2001   if (!hd->no_caching
2002       && !rc
2003       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
2004                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
2005       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
2006     {
2007       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
2008       hd->keyblock_cache.resource = hd->current;
2009       /* The current offset is at the start of the next record.  Since
2010          a record is at least 1 byte, we just use offset - 1, which is
2011          within the record.  */
2012       hd->keyblock_cache.offset
2013         = keybox_offset (hd->active[hd->current].u.kb) - 1;
2014       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, 20);
2015     }
2016
2017   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
2018       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
2019       && !already_in_cache)
2020     kid_not_found_insert (desc[0].u.kid);
2021
2022   if (DBG_CLOCK)
2023     log_clock (rc? "keydb_search leave (not found)"
2024                  : "keydb_search leave (found)");
2025   return rc;
2026 }
2027
2028
2029 /* Return the first non-legacy key in the database.
2030  *
2031  * If you want the very first key in the database, you can directly
2032  * call keydb_search with the search description
2033  *  KEYDB_SEARCH_MODE_FIRST.  */
2034 gpg_error_t
2035 keydb_search_first (KEYDB_HANDLE hd)
2036 {
2037   gpg_error_t err;
2038   KEYDB_SEARCH_DESC desc;
2039
2040   err = keydb_search_reset (hd);
2041   if (err)
2042     return err;
2043
2044   memset (&desc, 0, sizeof desc);
2045   desc.mode = KEYDB_SEARCH_MODE_FIRST;
2046   return keydb_search (hd, &desc, 1, NULL);
2047 }
2048
2049
2050 /* Return the next key (not the next matching key!).
2051  *
2052  * Unlike calling keydb_search with KEYDB_SEARCH_MODE_NEXT, this
2053  * function silently skips legacy keys.  */
2054 gpg_error_t
2055 keydb_search_next (KEYDB_HANDLE hd)
2056 {
2057   KEYDB_SEARCH_DESC desc;
2058
2059   memset (&desc, 0, sizeof desc);
2060   desc.mode = KEYDB_SEARCH_MODE_NEXT;
2061   return keydb_search (hd, &desc, 1, NULL);
2062 }
2063
2064
2065 /* This is a convenience function for searching for keys with a long
2066  * key id.
2067  *
2068  * Note: this function resumes searching where the last search left
2069  * off.  If you want to search the whole database, then you need to
2070  * first call keydb_search_reset().  */
2071 gpg_error_t
2072 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
2073 {
2074   KEYDB_SEARCH_DESC desc;
2075
2076   memset (&desc, 0, sizeof desc);
2077   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
2078   desc.u.kid[0] = kid[0];
2079   desc.u.kid[1] = kid[1];
2080   return keydb_search (hd, &desc, 1, NULL);
2081 }
2082
2083
2084 /* This is a convenience function for searching for keys with a long
2085  * (20 byte) fingerprint.
2086  *
2087  * Note: this function resumes searching where the last search left
2088  * off.  If you want to search the whole database, then you need to
2089  * first call keydb_search_reset().  */
2090 gpg_error_t
2091 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
2092 {
2093   KEYDB_SEARCH_DESC desc;
2094
2095   memset (&desc, 0, sizeof desc);
2096   desc.mode = KEYDB_SEARCH_MODE_FPR;
2097   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
2098   return keydb_search (hd, &desc, 1, NULL);
2099 }