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