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