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