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