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