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