gpg: Fix TOCTTOU when updating keyblocks.
[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 \f
537 gpg_error_t
538 keydb_add_resource (const char *url, unsigned int flags)
539 {
540   /* Whether we have successfully registered a resource.  */
541   static int any_registered;
542   /* The file named by the URL (i.e., without the prototype).  */
543   const char *resname = url;
544
545   char *filename = NULL;
546   int create;
547   int read_only = !!(flags&KEYDB_RESOURCE_FLAG_READONLY);
548   int is_default = !!(flags&KEYDB_RESOURCE_FLAG_DEFAULT);
549   int is_gpgvdef = !!(flags&KEYDB_RESOURCE_FLAG_GPGVDEF);
550   int rc = 0;
551   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
552   void *token;
553
554   /* Create the resource if it is the first registered one.  */
555   create = (!read_only && !any_registered);
556
557   if (strlen (resname) > 11 && !strncmp( resname, "gnupg-ring:", 11) )
558     {
559       rt = KEYDB_RESOURCE_TYPE_KEYRING;
560       resname += 11;
561     }
562   else if (strlen (resname) > 10 && !strncmp (resname, "gnupg-kbx:", 10) )
563     {
564       rt = KEYDB_RESOURCE_TYPE_KEYBOX;
565       resname += 10;
566     }
567 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
568   else if (strchr (resname, ':'))
569     {
570       log_error ("invalid key resource URL '%s'\n", url );
571       rc = gpg_error (GPG_ERR_GENERAL);
572       goto leave;
573     }
574 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
575
576   if (*resname != DIRSEP_C
577 #ifdef HAVE_W32_SYSTEM
578       && *resname != '/'  /* Fixme: does not handle drive letters.  */
579 #endif
580         )
581     {
582       /* Do tilde expansion etc. */
583       if (strchr (resname, DIRSEP_C)
584 #ifdef HAVE_W32_SYSTEM
585           || strchr (resname, '/')  /* Windows also accepts this.  */
586 #endif
587           )
588         filename = make_filename (resname, NULL);
589       else
590         filename = make_filename (opt.homedir, resname, NULL);
591     }
592   else
593     filename = xstrdup (resname);
594
595   /* See whether we can determine the filetype.  */
596   if (rt == KEYDB_RESOURCE_TYPE_NONE)
597     {
598       int found, openpgp_flag;
599       int pass = 0;
600       size_t filenamelen;
601
602     check_again:
603       filenamelen = strlen (filename);
604       rt = rt_from_file (filename, &found, &openpgp_flag);
605       if (found)
606         {
607           /* The file exists and we have the resource type in RT.
608
609              Now let us check whether in addition to the "pubring.gpg"
610              a "pubring.kbx with openpgp keys exists.  This is so that
611              GPG 2.1 will use an existing "pubring.kbx" by default iff
612              that file has been created or used by 2.1.  This check is
613              needed because after creation or use of the kbx file with
614              2.1 an older version of gpg may have created a new
615              pubring.gpg for its own use.  */
616           if (!pass && is_default && rt == KEYDB_RESOURCE_TYPE_KEYRING
617               && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
618             {
619               strcpy (filename+filenamelen-4, ".kbx");
620               if ((rt_from_file (filename, &found, &openpgp_flag)
621                    == KEYDB_RESOURCE_TYPE_KEYBOX) && found && openpgp_flag)
622                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
623               else /* Restore filename */
624                 strcpy (filename+filenamelen-4, ".gpg");
625             }
626         }
627       else if (!pass && is_gpgvdef
628                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".kbx"))
629         {
630           /* Not found but gpgv's default "trustedkeys.kbx" file has
631              been requested.  We did not found it so now check whether
632              a "trustedkeys.gpg" file exists and use that instead.  */
633           KeydbResourceType rttmp;
634
635           strcpy (filename+filenamelen-4, ".gpg");
636           rttmp = rt_from_file (filename, &found, &openpgp_flag);
637           if (found
638               && ((rttmp == KEYDB_RESOURCE_TYPE_KEYBOX && openpgp_flag)
639                   || (rttmp == KEYDB_RESOURCE_TYPE_KEYRING)))
640             rt = rttmp;
641           else /* Restore filename */
642             strcpy (filename+filenamelen-4, ".kbx");
643         }
644       else if (!pass
645                && is_default && create
646                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
647         {
648           /* The file does not exist, the default resource has been
649              requested, the file shall be created, and the file has a
650              ".gpg" suffix.  Change the suffix to ".kbx" and try once
651              more.  This way we achieve that we open an existing
652              ".gpg" keyring, but create a new keybox file with an
653              ".kbx" suffix.  */
654           strcpy (filename+filenamelen-4, ".kbx");
655           pass++;
656           goto check_again;
657         }
658       else /* No file yet: create keybox. */
659         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
660     }
661
662   switch (rt)
663     {
664     case KEYDB_RESOURCE_TYPE_NONE:
665       log_error ("unknown type of key resource '%s'\n", url );
666       rc = gpg_error (GPG_ERR_GENERAL);
667       goto leave;
668
669     case KEYDB_RESOURCE_TYPE_KEYRING:
670       rc = maybe_create_keyring_or_box (filename, 0, create);
671       if (rc)
672         goto leave;
673
674       if (keyring_register_filename (filename, read_only, &token))
675         {
676           if (used_resources >= MAX_KEYDB_RESOURCES)
677             rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
678           else
679             {
680               if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
681                 primary_keyring = token;
682               all_resources[used_resources].type = rt;
683               all_resources[used_resources].u.kr = NULL; /* Not used here */
684               all_resources[used_resources].token = token;
685               used_resources++;
686             }
687         }
688       else
689         {
690           /* This keyring was already registered, so ignore it.
691              However, we can still mark it as primary even if it was
692              already registered.  */
693           if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
694             primary_keyring = token;
695         }
696       break;
697
698     case KEYDB_RESOURCE_TYPE_KEYBOX:
699       {
700         rc = maybe_create_keyring_or_box (filename, 1, create);
701         if (rc)
702           goto leave;
703
704         /* FIXME: How do we register a read-only keybox?  */
705         token = keybox_register_file (filename, 0);
706         if (token)
707           {
708             if (used_resources >= MAX_KEYDB_RESOURCES)
709               rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
710             else
711               {
712                 /* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
713                 /*   primary_keyring = token; */
714                 all_resources[used_resources].type = rt;
715                 all_resources[used_resources].u.kb = NULL; /* Not used here */
716                 all_resources[used_resources].token = token;
717
718                 /* FIXME: Do a compress run if needed and no other
719                    user is currently using the keybox. */
720
721                 used_resources++;
722               }
723           }
724         else
725           {
726             /* Already registered.  We will mark it as the primary key
727                if requested.  */
728             /* FIXME: How to do that?  Change the keybox interface?  */
729             /* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
730             /*   primary_keyring = token; */
731           }
732       }
733       break;
734
735       default:
736         log_error ("resource type of '%s' not supported\n", url);
737         rc = gpg_error (GPG_ERR_GENERAL);
738         goto leave;
739     }
740
741   /* fixme: check directory permissions and print a warning */
742
743  leave:
744   if (rc)
745     log_error (_("keyblock resource '%s': %s\n"), filename, gpg_strerror (rc));
746   else
747     any_registered = 1;
748   xfree (filename);
749   return rc;
750 }
751
752
753 void
754 keydb_dump_stats (void)
755 {
756   if (kid_not_found_cache_count)
757     log_info ("keydb: kid_not_found_cache: total: %u\n",
758               kid_not_found_cache_count);
759 }
760
761
762 /* Create a new database handle.  A database handle is similar to a
763    file handle: it contains a local file position.  This is used when
764    searching: subsequent searches resume where the previous search
765    left off.  To rewind the position, use keydb_search_reset().  This
766    function returns NULL on error, sets ERRNO, and prints an error
767    diagnostic. */
768 KEYDB_HANDLE
769 keydb_new (void)
770 {
771   KEYDB_HANDLE hd;
772   int i, j;
773   int die = 0;
774   int reterrno;
775
776   if (DBG_CLOCK)
777     log_clock ("keydb_new");
778
779   hd = xtrycalloc (1, sizeof *hd);
780   if (!hd)
781     goto leave;
782   hd->found = -1;
783   hd->saved_found = -1;
784   hd->is_reset = 1;
785
786   assert (used_resources <= MAX_KEYDB_RESOURCES);
787   for (i=j=0; ! die && i < used_resources; i++)
788     {
789       switch (all_resources[i].type)
790         {
791         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
792           break;
793         case KEYDB_RESOURCE_TYPE_KEYRING:
794           hd->active[j].type   = all_resources[i].type;
795           hd->active[j].token  = all_resources[i].token;
796           hd->active[j].u.kr = keyring_new (all_resources[i].token);
797           if (!hd->active[j].u.kr)
798             {
799               reterrno = errno;
800               die = 1;
801             }
802           j++;
803           break;
804         case KEYDB_RESOURCE_TYPE_KEYBOX:
805           hd->active[j].type   = all_resources[i].type;
806           hd->active[j].token  = all_resources[i].token;
807           hd->active[j].u.kb   = keybox_new_openpgp (all_resources[i].token, 0);
808           if (!hd->active[j].u.kb)
809             {
810               reterrno = errno;
811               die = 1;
812             }
813           j++;
814           break;
815         }
816     }
817   hd->used = j;
818
819   active_handles++;
820
821   if (die)
822     {
823       keydb_release (hd);
824       gpg_err_set_errno (reterrno);
825       hd = NULL;
826     }
827
828  leave:
829   if (!hd)
830     log_error (_("error opening key DB: %s\n"),
831                gpg_strerror (gpg_error_from_syserror()));
832
833   return hd;
834 }
835
836
837 void
838 keydb_release (KEYDB_HANDLE hd)
839 {
840   int i;
841
842   if (!hd)
843     return;
844   assert (active_handles > 0);
845   active_handles--;
846
847   unlock_all (hd);
848   for (i=0; i < hd->used; i++)
849     {
850       switch (hd->active[i].type)
851         {
852         case KEYDB_RESOURCE_TYPE_NONE:
853           break;
854         case KEYDB_RESOURCE_TYPE_KEYRING:
855           keyring_release (hd->active[i].u.kr);
856           break;
857         case KEYDB_RESOURCE_TYPE_KEYBOX:
858           keybox_release (hd->active[i].u.kb);
859           break;
860         }
861     }
862
863   xfree (hd);
864 }
865
866
867 void
868 keydb_disable_caching (KEYDB_HANDLE hd)
869 {
870   if (hd)
871     hd->no_caching = 1;
872 }
873
874
875 const char *
876 keydb_get_resource_name (KEYDB_HANDLE hd)
877 {
878   int idx;
879   const char *s = NULL;
880
881   if (!hd)
882     return NULL;
883
884   if ( hd->found >= 0 && hd->found < hd->used)
885     idx = hd->found;
886   else if ( hd->current >= 0 && hd->current < hd->used)
887     idx = hd->current;
888   else
889     idx = 0;
890
891   switch (hd->active[idx].type)
892     {
893     case KEYDB_RESOURCE_TYPE_NONE:
894       s = NULL;
895       break;
896     case KEYDB_RESOURCE_TYPE_KEYRING:
897       s = keyring_get_resource_name (hd->active[idx].u.kr);
898       break;
899     case KEYDB_RESOURCE_TYPE_KEYBOX:
900       s = keybox_get_resource_name (hd->active[idx].u.kb);
901       break;
902     }
903
904   return s? s: "";
905 }
906
907
908
909 static int
910 lock_all (KEYDB_HANDLE hd)
911 {
912   int i, rc = 0;
913
914   /* Fixme: This locking scheme may lead to a deadlock if the resources
915      are not added in the same order by all processes.  We are
916      currently only allowing one resource so it is not a problem.
917      [Oops: Who claimed the latter]
918
919      To fix this we need to use a lock file to protect lock_all.  */
920
921   for (i=0; !rc && i < hd->used; i++)
922     {
923       switch (hd->active[i].type)
924         {
925         case KEYDB_RESOURCE_TYPE_NONE:
926           break;
927         case KEYDB_RESOURCE_TYPE_KEYRING:
928           rc = keyring_lock (hd->active[i].u.kr, 1);
929           break;
930         case KEYDB_RESOURCE_TYPE_KEYBOX:
931           rc = keybox_lock (hd->active[i].u.kb, 1);
932           break;
933         }
934     }
935
936   if (rc)
937     {
938       /* Revert the already taken locks.  */
939       for (i--; i >= 0; i--)
940         {
941           switch (hd->active[i].type)
942             {
943             case KEYDB_RESOURCE_TYPE_NONE:
944               break;
945             case KEYDB_RESOURCE_TYPE_KEYRING:
946               keyring_lock (hd->active[i].u.kr, 0);
947               break;
948             case KEYDB_RESOURCE_TYPE_KEYBOX:
949               rc = keybox_lock (hd->active[i].u.kb, 0);
950               break;
951             }
952         }
953     }
954   else
955     hd->locked = 1;
956
957   return rc;
958 }
959
960
961 static void
962 unlock_all (KEYDB_HANDLE hd)
963 {
964   int i;
965
966   if (!hd->locked)
967     return;
968
969   for (i=hd->used-1; i >= 0; i--)
970     {
971       switch (hd->active[i].type)
972         {
973         case KEYDB_RESOURCE_TYPE_NONE:
974           break;
975         case KEYDB_RESOURCE_TYPE_KEYRING:
976           keyring_lock (hd->active[i].u.kr, 0);
977           break;
978         case KEYDB_RESOURCE_TYPE_KEYBOX:
979           keybox_lock (hd->active[i].u.kb, 0);
980           break;
981         }
982     }
983   hd->locked = 0;
984 }
985
986
987 \f
988 void
989 keydb_push_found_state (KEYDB_HANDLE hd)
990 {
991   if (!hd)
992     return;
993
994   if (hd->found < 0 || hd->found >= hd->used)
995     {
996       hd->saved_found = -1;
997       return;
998     }
999
1000   switch (hd->active[hd->found].type)
1001     {
1002     case KEYDB_RESOURCE_TYPE_NONE:
1003       break;
1004     case KEYDB_RESOURCE_TYPE_KEYRING:
1005       keyring_push_found_state (hd->active[hd->found].u.kr);
1006       break;
1007     case KEYDB_RESOURCE_TYPE_KEYBOX:
1008       keybox_push_found_state (hd->active[hd->found].u.kb);
1009       break;
1010     }
1011
1012   hd->saved_found = hd->found;
1013   hd->found = -1;
1014 }
1015
1016
1017 void
1018 keydb_pop_found_state (KEYDB_HANDLE hd)
1019 {
1020   if (!hd)
1021     return;
1022
1023   hd->found = hd->saved_found;
1024   hd->saved_found = -1;
1025   if (hd->found < 0 || hd->found >= hd->used)
1026     return;
1027
1028   switch (hd->active[hd->found].type)
1029     {
1030     case KEYDB_RESOURCE_TYPE_NONE:
1031       break;
1032     case KEYDB_RESOURCE_TYPE_KEYRING:
1033       keyring_pop_found_state (hd->active[hd->found].u.kr);
1034       break;
1035     case KEYDB_RESOURCE_TYPE_KEYBOX:
1036       keybox_pop_found_state (hd->active[hd->found].u.kb);
1037       break;
1038     }
1039 }
1040
1041
1042 \f
1043 static gpg_error_t
1044 parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
1045                       const u32 *sigstatus, kbnode_t *r_keyblock)
1046 {
1047   gpg_error_t err;
1048   PACKET *pkt;
1049   kbnode_t keyblock = NULL;
1050   kbnode_t node, *tail;
1051   int in_cert, save_mode;
1052   u32 n_sigs;
1053   int pk_count, uid_count;
1054
1055   *r_keyblock = NULL;
1056
1057   pkt = xtrymalloc (sizeof *pkt);
1058   if (!pkt)
1059     return gpg_error_from_syserror ();
1060   init_packet (pkt);
1061   save_mode = set_packet_list_mode (0);
1062   in_cert = 0;
1063   n_sigs = 0;
1064   tail = NULL;
1065   pk_count = uid_count = 0;
1066   while ((err = parse_packet (iobuf, pkt)) != -1)
1067     {
1068       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
1069         {
1070           free_packet (pkt);
1071           init_packet (pkt);
1072           continue;
1073         }
1074       if (err)
1075         {
1076           log_error ("parse_keyblock_image: read error: %s\n",
1077                      gpg_strerror (err));
1078           err = gpg_error (GPG_ERR_INV_KEYRING);
1079           break;
1080         }
1081
1082       /* Filter allowed packets.  */
1083       switch (pkt->pkttype)
1084         {
1085         case PKT_PUBLIC_KEY:
1086         case PKT_PUBLIC_SUBKEY:
1087         case PKT_SECRET_KEY:
1088         case PKT_SECRET_SUBKEY:
1089         case PKT_USER_ID:
1090         case PKT_ATTRIBUTE:
1091         case PKT_SIGNATURE:
1092           break; /* Allowed per RFC.  */
1093
1094         default:
1095           /* Note that can't allow ring trust packets here and some of
1096              the other GPG specific packets don't make sense either.  */
1097           log_error ("skipped packet of type %d in keybox\n",
1098                      (int)pkt->pkttype);
1099           free_packet(pkt);
1100           init_packet(pkt);
1101           continue;
1102         }
1103
1104       /* Other sanity checks.  */
1105       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
1106         {
1107           log_error ("parse_keyblock_image: first packet in a keybox blob "
1108                      "is not a public key packet\n");
1109           err = gpg_error (GPG_ERR_INV_KEYRING);
1110           break;
1111         }
1112       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
1113                       || pkt->pkttype == PKT_SECRET_KEY))
1114         {
1115           log_error ("parse_keyblock_image: "
1116                      "multiple keyblocks in a keybox blob\n");
1117           err = gpg_error (GPG_ERR_INV_KEYRING);
1118           break;
1119         }
1120       in_cert = 1;
1121
1122       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
1123         {
1124           PKT_signature *sig = pkt->pkt.signature;
1125
1126           n_sigs++;
1127           if (n_sigs > sigstatus[0])
1128             {
1129               log_error ("parse_keyblock_image: "
1130                          "more signatures than found in the meta data\n");
1131               err = gpg_error (GPG_ERR_INV_KEYRING);
1132               break;
1133
1134             }
1135           if (sigstatus[n_sigs])
1136             {
1137               sig->flags.checked = 1;
1138               if (sigstatus[n_sigs] == 1 )
1139                 ; /* missing key */
1140               else if (sigstatus[n_sigs] == 2 )
1141                 ; /* bad signature */
1142               else if (sigstatus[n_sigs] < 0x10000000)
1143                 ; /* bad flag */
1144               else
1145                 {
1146                   sig->flags.valid = 1;
1147                   /* Fixme: Shall we set the expired flag here?  */
1148                 }
1149             }
1150         }
1151
1152       node = new_kbnode (pkt);
1153
1154       switch (pkt->pkttype)
1155         {
1156         case PKT_PUBLIC_KEY:
1157         case PKT_PUBLIC_SUBKEY:
1158         case PKT_SECRET_KEY:
1159         case PKT_SECRET_SUBKEY:
1160           if (++pk_count == pk_no)
1161             node->flag |= 1;
1162           break;
1163
1164         case PKT_USER_ID:
1165           if (++uid_count == uid_no)
1166             node->flag |= 2;
1167           break;
1168
1169         default:
1170           break;
1171         }
1172
1173       if (!keyblock)
1174         keyblock = node;
1175       else
1176         *tail = node;
1177       tail = &node->next;
1178       pkt = xtrymalloc (sizeof *pkt);
1179       if (!pkt)
1180         {
1181           err = gpg_error_from_syserror ();
1182           break;
1183         }
1184       init_packet (pkt);
1185     }
1186   set_packet_list_mode (save_mode);
1187
1188   if (err == -1 && keyblock)
1189     err = 0; /* Got the entire keyblock.  */
1190
1191   if (!err && sigstatus && n_sigs != sigstatus[0])
1192     {
1193       log_error ("parse_keyblock_image: signature count does not match\n");
1194       err = gpg_error (GPG_ERR_INV_KEYRING);
1195     }
1196
1197   if (err)
1198     release_kbnode (keyblock);
1199   else
1200     *r_keyblock = keyblock;
1201   free_packet (pkt);
1202   xfree (pkt);
1203   return err;
1204 }
1205
1206
1207 gpg_error_t
1208 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
1209 {
1210   gpg_error_t err = 0;
1211
1212   *ret_kb = NULL;
1213
1214   if (!hd)
1215     return gpg_error (GPG_ERR_INV_ARG);
1216
1217   if (DBG_CLOCK)
1218     log_clock ("keydb_get_keybock enter");
1219
1220   if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
1221     {
1222       err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
1223       if (err)
1224         {
1225           log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
1226           keyblock_cache_clear (hd);
1227         }
1228       else
1229         {
1230           err = parse_keyblock_image (hd->keyblock_cache.iobuf,
1231                                       hd->keyblock_cache.pk_no,
1232                                       hd->keyblock_cache.uid_no,
1233                                       hd->keyblock_cache.sigstatus,
1234                                       ret_kb);
1235           if (err)
1236             keyblock_cache_clear (hd);
1237           if (DBG_CLOCK)
1238             log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1239                        : "keydb_get_keyblock leave (cached)");
1240           return err;
1241         }
1242     }
1243
1244   if (hd->found < 0 || hd->found >= hd->used)
1245     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1246
1247   switch (hd->active[hd->found].type)
1248     {
1249     case KEYDB_RESOURCE_TYPE_NONE:
1250       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1251       break;
1252     case KEYDB_RESOURCE_TYPE_KEYRING:
1253       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1254       break;
1255     case KEYDB_RESOURCE_TYPE_KEYBOX:
1256       {
1257         iobuf_t iobuf;
1258         u32 *sigstatus;
1259         int pk_no, uid_no;
1260
1261         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1262                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1263         if (!err)
1264           {
1265             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1266                                         ret_kb);
1267             if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1268               {
1269                 hd->keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1270                 hd->keyblock_cache.sigstatus = sigstatus;
1271                 hd->keyblock_cache.iobuf     = iobuf;
1272                 hd->keyblock_cache.pk_no     = pk_no;
1273                 hd->keyblock_cache.uid_no    = uid_no;
1274               }
1275             else
1276               {
1277                 xfree (sigstatus);
1278                 iobuf_close (iobuf);
1279               }
1280           }
1281       }
1282       break;
1283     }
1284
1285   if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1286     keyblock_cache_clear (hd);
1287
1288   if (DBG_CLOCK)
1289     log_clock (err? "keydb_get_keyblock leave (failed)"
1290                : "keydb_get_keyblock leave");
1291   return err;
1292 }
1293
1294
1295 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1296    only then stores a new iobuf object at R_IOBUF and a signature
1297    status vecotor at R_SIGSTATUS.  */
1298 static gpg_error_t
1299 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1300 {
1301   gpg_error_t err;
1302   iobuf_t iobuf;
1303   kbnode_t kbctx, node;
1304   u32 n_sigs;
1305   u32 *sigstatus;
1306
1307   *r_iobuf = NULL;
1308   if (r_sigstatus)
1309     *r_sigstatus = NULL;
1310
1311   /* Allocate a vector for the signature cache.  This is an array of
1312      u32 values with the first value giving the number of elements to
1313      follow and each element descriping the cache status of the
1314      signature.  */
1315   if (r_sigstatus)
1316     {
1317       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1318         if (node->pkt->pkttype == PKT_SIGNATURE)
1319           n_sigs++;
1320       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1321       if (!sigstatus)
1322         return gpg_error_from_syserror ();
1323     }
1324   else
1325     sigstatus = NULL;
1326
1327   iobuf = iobuf_temp ();
1328   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1329     {
1330       /* Make sure to use only packets valid on a keyblock.  */
1331       switch (node->pkt->pkttype)
1332         {
1333         case PKT_PUBLIC_KEY:
1334         case PKT_PUBLIC_SUBKEY:
1335         case PKT_SIGNATURE:
1336         case PKT_USER_ID:
1337         case PKT_ATTRIBUTE:
1338           /* Note that we don't want the ring trust packets.  They are
1339              not useful. */
1340           break;
1341         default:
1342           continue;
1343         }
1344
1345       err = build_packet (iobuf, node->pkt);
1346       if (err)
1347         {
1348           iobuf_close (iobuf);
1349           return err;
1350         }
1351
1352       /* Build signature status vector.  */
1353       if (node->pkt->pkttype == PKT_SIGNATURE)
1354         {
1355           PKT_signature *sig = node->pkt->pkt.signature;
1356
1357           n_sigs++;
1358           /* Fixme: Detect the "missing key" status.  */
1359           if (sig->flags.checked && sigstatus)
1360             {
1361               if (sig->flags.valid)
1362                 {
1363                   if (!sig->expiredate)
1364                     sigstatus[n_sigs] = 0xffffffff;
1365                   else if (sig->expiredate < 0x1000000)
1366                     sigstatus[n_sigs] = 0x10000000;
1367                   else
1368                     sigstatus[n_sigs] = sig->expiredate;
1369                 }
1370               else
1371                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1372             }
1373         }
1374     }
1375   if (sigstatus)
1376     sigstatus[0] = n_sigs;
1377
1378   *r_iobuf = iobuf;
1379   if (r_sigstatus)
1380     *r_sigstatus = sigstatus;
1381   return 0;
1382 }
1383
1384
1385 gpg_error_t
1386 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1387 {
1388   gpg_error_t err;
1389   PKT_public_key *pk = kb->pkt->pkt.public_key;
1390   KEYDB_SEARCH_DESC desc;
1391   size_t len;
1392
1393   assert (kb);
1394   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1395
1396   if (!hd)
1397     return gpg_error (GPG_ERR_INV_ARG);
1398
1399   kid_not_found_flush ();
1400   keyblock_cache_clear (hd);
1401
1402   if (opt.dry_run)
1403     return 0;
1404
1405   err = lock_all (hd);
1406   if (err)
1407     return err;
1408
1409   memset (&desc, 0, sizeof (desc));
1410   fingerprint_from_pk (pk, desc.u.fpr, &len);
1411   if (len == 20)
1412     desc.mode = KEYDB_SEARCH_MODE_FPR20;
1413   else
1414     log_bug ("%s: Unsupported key length: %zd\n", __func__, len);
1415
1416   keydb_search_reset (hd);
1417   err = keydb_search (hd, &desc, 1, NULL);
1418   if (err)
1419     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1420   assert (hd->found >= 0 && hd->found < hd->used);
1421
1422   switch (hd->active[hd->found].type)
1423     {
1424     case KEYDB_RESOURCE_TYPE_NONE:
1425       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1426       break;
1427     case KEYDB_RESOURCE_TYPE_KEYRING:
1428       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1429       break;
1430     case KEYDB_RESOURCE_TYPE_KEYBOX:
1431       {
1432         iobuf_t iobuf;
1433
1434         err = build_keyblock_image (kb, &iobuf, NULL);
1435         if (!err)
1436           {
1437             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1438                                           iobuf_get_temp_buffer (iobuf),
1439                                           iobuf_get_temp_length (iobuf));
1440             iobuf_close (iobuf);
1441           }
1442       }
1443       break;
1444     }
1445
1446   unlock_all (hd);
1447   return err;
1448 }
1449
1450
1451 gpg_error_t
1452 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1453 {
1454   gpg_error_t err;
1455   int idx;
1456
1457   if (!hd)
1458     return gpg_error (GPG_ERR_INV_ARG);
1459
1460   kid_not_found_flush ();
1461   keyblock_cache_clear (hd);
1462
1463   if (opt.dry_run)
1464     return 0;
1465
1466   if (hd->found >= 0 && hd->found < hd->used)
1467     idx = hd->found;
1468   else if (hd->current >= 0 && hd->current < hd->used)
1469     idx = hd->current;
1470   else
1471     return gpg_error (GPG_ERR_GENERAL);
1472
1473   err = lock_all (hd);
1474   if (err)
1475     return err;
1476
1477   switch (hd->active[idx].type)
1478     {
1479     case KEYDB_RESOURCE_TYPE_NONE:
1480       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1481       break;
1482     case KEYDB_RESOURCE_TYPE_KEYRING:
1483       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1484       break;
1485     case KEYDB_RESOURCE_TYPE_KEYBOX:
1486       { /* We need to turn our kbnode_t list of packets into a proper
1487            keyblock first.  This is required by the OpenPGP key parser
1488            included in the keybox code.  Eventually we can change this
1489            kludge to have the caller pass the image.  */
1490         iobuf_t iobuf;
1491         u32 *sigstatus;
1492
1493         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1494         if (!err)
1495           {
1496             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1497                                           iobuf_get_temp_buffer (iobuf),
1498                                           iobuf_get_temp_length (iobuf),
1499                                           sigstatus);
1500             xfree (sigstatus);
1501             iobuf_close (iobuf);
1502           }
1503       }
1504       break;
1505     }
1506
1507   unlock_all (hd);
1508   return err;
1509 }
1510
1511
1512 gpg_error_t
1513 keydb_delete_keyblock (KEYDB_HANDLE hd)
1514 {
1515   gpg_error_t rc;
1516
1517   if (!hd)
1518     return gpg_error (GPG_ERR_INV_ARG);
1519
1520   kid_not_found_flush ();
1521   keyblock_cache_clear (hd);
1522
1523   if (hd->found < 0 || hd->found >= hd->used)
1524     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1525
1526   if (opt.dry_run)
1527     return 0;
1528
1529   rc = lock_all (hd);
1530   if (rc)
1531     return rc;
1532
1533   switch (hd->active[hd->found].type)
1534     {
1535     case KEYDB_RESOURCE_TYPE_NONE:
1536       rc = gpg_error (GPG_ERR_GENERAL);
1537       break;
1538     case KEYDB_RESOURCE_TYPE_KEYRING:
1539       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1540       break;
1541     case KEYDB_RESOURCE_TYPE_KEYBOX:
1542       rc = keybox_delete (hd->active[hd->found].u.kb);
1543       break;
1544     }
1545
1546   unlock_all (hd);
1547   return rc;
1548 }
1549
1550
1551 \f
1552 gpg_error_t
1553 keydb_locate_writable (KEYDB_HANDLE hd)
1554 {
1555   gpg_error_t rc;
1556
1557   if (!hd)
1558     return GPG_ERR_INV_ARG;
1559
1560   rc = keydb_search_reset (hd); /* this does reset hd->current */
1561   if (rc)
1562     return rc;
1563
1564   /* If we have a primary set, try that one first */
1565   if (primary_keyring)
1566     {
1567       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1568         {
1569           if(hd->active[hd->current].token==primary_keyring)
1570             {
1571               if(keyring_is_writable (hd->active[hd->current].token))
1572                 return 0;
1573               else
1574                 break;
1575             }
1576         }
1577
1578       rc = keydb_search_reset (hd); /* this does reset hd->current */
1579       if (rc)
1580         return rc;
1581     }
1582
1583   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1584     {
1585       switch (hd->active[hd->current].type)
1586         {
1587         case KEYDB_RESOURCE_TYPE_NONE:
1588           BUG();
1589           break;
1590         case KEYDB_RESOURCE_TYPE_KEYRING:
1591           if (keyring_is_writable (hd->active[hd->current].token))
1592             return 0; /* found (hd->current is set to it) */
1593           break;
1594         case KEYDB_RESOURCE_TYPE_KEYBOX:
1595           if (keybox_is_writable (hd->active[hd->current].token))
1596             return 0; /* found (hd->current is set to it) */
1597           break;
1598         }
1599     }
1600
1601   return gpg_error (GPG_ERR_NOT_FOUND);
1602 }
1603
1604 void
1605 keydb_rebuild_caches (int noisy)
1606 {
1607   int i, rc;
1608
1609   for (i=0; i < used_resources; i++)
1610     {
1611       if (!keyring_is_writable (all_resources[i].token))
1612         continue;
1613       switch (all_resources[i].type)
1614         {
1615         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1616           break;
1617         case KEYDB_RESOURCE_TYPE_KEYRING:
1618           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1619           if (rc)
1620             log_error (_("failed to rebuild keyring cache: %s\n"),
1621                        gpg_strerror (rc));
1622           break;
1623         case KEYDB_RESOURCE_TYPE_KEYBOX:
1624           /* N/A.  */
1625           break;
1626         }
1627     }
1628 }
1629
1630
1631 unsigned long
1632 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1633 {
1634   return hd ? hd->skipped_long_blobs : 0;
1635 }
1636
1637
1638 gpg_error_t
1639 keydb_search_reset (KEYDB_HANDLE hd)
1640 {
1641   gpg_error_t rc = 0;
1642   int i;
1643
1644   if (!hd)
1645     return gpg_error (GPG_ERR_INV_ARG);
1646
1647   keyblock_cache_clear (hd);
1648
1649   if (DBG_CLOCK)
1650     log_clock ("keydb_search_reset");
1651
1652   if (DBG_CACHE)
1653     log_debug ("keydb_search: reset  (hd=%p)", hd);
1654
1655   hd->skipped_long_blobs = 0;
1656   hd->current = 0;
1657   hd->found = -1;
1658   /* Now reset all resources.  */
1659   for (i=0; !rc && i < hd->used; i++)
1660     {
1661       switch (hd->active[i].type)
1662         {
1663         case KEYDB_RESOURCE_TYPE_NONE:
1664           break;
1665         case KEYDB_RESOURCE_TYPE_KEYRING:
1666           rc = keyring_search_reset (hd->active[i].u.kr);
1667           break;
1668         case KEYDB_RESOURCE_TYPE_KEYBOX:
1669           rc = keybox_search_reset (hd->active[i].u.kb);
1670           break;
1671         }
1672     }
1673   hd->is_reset = 1;
1674   return rc;
1675 }
1676
1677
1678 gpg_error_t
1679 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1680               size_t ndesc, size_t *descindex)
1681 {
1682   int i;
1683   gpg_error_t rc;
1684   int was_reset = hd->is_reset;
1685   /* If an entry is already in the cache, then don't add it again.  */
1686   int already_in_cache = 0;
1687
1688   if (descindex)
1689     *descindex = 0; /* Make sure it is always set on return.  */
1690
1691   if (!hd)
1692     return gpg_error (GPG_ERR_INV_ARG);
1693
1694   if (DBG_CLOCK)
1695     log_clock ("keydb_search enter");
1696
1697   if (DBG_LOOKUP)
1698     {
1699       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
1700       for (i = 0; i < ndesc; i ++)
1701         {
1702           char *t = keydb_search_desc_dump (&desc[i]);
1703           log_debug ("%s   %d: %s\n", __func__, i, t);
1704           xfree (t);
1705         }
1706     }
1707
1708
1709   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1710       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1711     {
1712       if (DBG_CLOCK)
1713         log_clock ("keydb_search leave (not found, cached)");
1714       return gpg_error (GPG_ERR_NOT_FOUND);
1715     }
1716
1717   /* NB: If one of the exact search modes below is used in a loop to
1718      walk over all keys (with the same fingerprint) the caching must
1719      have been disabled for the handle.  */
1720   if (!hd->no_caching
1721       && ndesc == 1
1722       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1723           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1724       && hd->keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1725       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, 20)
1726       /* Make sure the current file position occurs before the cached
1727          result to avoid an infinite loop.  */
1728       && (hd->current < hd->keyblock_cache.resource
1729           || (hd->current == hd->keyblock_cache.resource
1730               && (keybox_offset (hd->active[hd->current].u.kb)
1731                   <= hd->keyblock_cache.offset))))
1732     {
1733       /* (DESCINDEX is already set).  */
1734       if (DBG_CLOCK)
1735         log_clock ("keydb_search leave (cached)");
1736
1737       hd->current = hd->keyblock_cache.resource;
1738       /* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
1739          Seek just beyond that.  */
1740       keybox_seek (hd->active[hd->current].u.kb,
1741                    hd->keyblock_cache.offset + 1);
1742       return 0;
1743     }
1744
1745   rc = -1;
1746   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1747          && hd->current >= 0 && hd->current < hd->used)
1748     {
1749       if (DBG_LOOKUP)
1750         log_debug ("%s: searching %s (resource %d of %d)\n",
1751                    __func__,
1752                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1753                    ? "keyring"
1754                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1755                       ? "keybox" : "unknown type"),
1756                    hd->current, hd->used);
1757
1758        switch (hd->active[hd->current].type)
1759         {
1760         case KEYDB_RESOURCE_TYPE_NONE:
1761           BUG(); /* we should never see it here */
1762           break;
1763         case KEYDB_RESOURCE_TYPE_KEYRING:
1764           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1765                                ndesc, descindex, 1);
1766           break;
1767         case KEYDB_RESOURCE_TYPE_KEYBOX:
1768           do
1769             rc = keybox_search (hd->active[hd->current].u.kb, desc,
1770                                 ndesc, KEYBOX_BLOBTYPE_PGP,
1771                                 descindex, &hd->skipped_long_blobs);
1772           while (rc == GPG_ERR_LEGACY_KEY);
1773           break;
1774         }
1775
1776       if (DBG_LOOKUP)
1777         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1778                    __func__,
1779                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1780                    ? "keyring"
1781                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1782                       ? "keybox" : "unknown type"),
1783                    hd->current, hd->used,
1784                    rc == -1 ? "EOF" : gpg_strerror (rc));
1785
1786       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1787         {
1788           /* EOF -> switch to next resource */
1789           hd->current++;
1790         }
1791       else if (!rc)
1792         hd->found = hd->current;
1793     }
1794   hd->is_reset = 0;
1795
1796   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1797         ? gpg_error (GPG_ERR_NOT_FOUND)
1798         : rc);
1799
1800   keyblock_cache_clear (hd);
1801   if (!hd->no_caching
1802       && !rc
1803       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1804                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1805       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
1806     {
1807       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1808       hd->keyblock_cache.resource = hd->current;
1809       /* The current offset is at the start of the next record.  Since
1810          a record is at least 1 byte, we just use offset - 1, which is
1811          within the record.  */
1812       hd->keyblock_cache.offset
1813         = keybox_offset (hd->active[hd->current].u.kb) - 1;
1814       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, 20);
1815     }
1816
1817   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
1818       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
1819       && !already_in_cache)
1820     kid_not_found_insert (desc[0].u.kid);
1821
1822   if (DBG_CLOCK)
1823     log_clock (rc? "keydb_search leave (not found)"
1824                  : "keydb_search leave (found)");
1825   return rc;
1826 }
1827
1828
1829 gpg_error_t
1830 keydb_search_first (KEYDB_HANDLE hd)
1831 {
1832   gpg_error_t err;
1833   KEYDB_SEARCH_DESC desc;
1834
1835   err = keydb_search_reset (hd);
1836   if (err)
1837     return err;
1838
1839   memset (&desc, 0, sizeof desc);
1840   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1841   return keydb_search (hd, &desc, 1, NULL);
1842 }
1843
1844
1845 gpg_error_t
1846 keydb_search_next (KEYDB_HANDLE hd)
1847 {
1848   KEYDB_SEARCH_DESC desc;
1849
1850   memset (&desc, 0, sizeof desc);
1851   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1852   return keydb_search (hd, &desc, 1, NULL);
1853 }
1854
1855 gpg_error_t
1856 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1857 {
1858   KEYDB_SEARCH_DESC desc;
1859
1860   memset (&desc, 0, sizeof desc);
1861   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1862   desc.u.kid[0] = kid[0];
1863   desc.u.kid[1] = kid[1];
1864   return keydb_search (hd, &desc, 1, NULL);
1865 }
1866
1867 gpg_error_t
1868 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1869 {
1870   KEYDB_SEARCH_DESC desc;
1871
1872   memset (&desc, 0, sizeof desc);
1873   desc.mode = KEYDB_SEARCH_MODE_FPR;
1874   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1875   return keydb_search (hd, &desc, 1, NULL);
1876 }