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