2150a927aeacca1253697f47f3ab14f3fb763d17
[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;
1390   KEYDB_SEARCH_DESC desc;
1391   size_t len;
1392
1393   assert (kb);
1394   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1395   pk = kb->pkt->pkt.public_key;
1396
1397   if (!hd)
1398     return gpg_error (GPG_ERR_INV_ARG);
1399
1400   kid_not_found_flush ();
1401   keyblock_cache_clear (hd);
1402
1403   if (opt.dry_run)
1404     return 0;
1405
1406   err = lock_all (hd);
1407   if (err)
1408     return err;
1409
1410   memset (&desc, 0, sizeof (desc));
1411   fingerprint_from_pk (pk, desc.u.fpr, &len);
1412   if (len == 20)
1413     desc.mode = KEYDB_SEARCH_MODE_FPR20;
1414   else
1415     log_bug ("%s: Unsupported key length: %zu\n", __func__, len);
1416
1417   keydb_search_reset (hd);
1418   err = keydb_search (hd, &desc, 1, NULL);
1419   if (err)
1420     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1421   assert (hd->found >= 0 && hd->found < hd->used);
1422
1423   switch (hd->active[hd->found].type)
1424     {
1425     case KEYDB_RESOURCE_TYPE_NONE:
1426       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1427       break;
1428     case KEYDB_RESOURCE_TYPE_KEYRING:
1429       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1430       break;
1431     case KEYDB_RESOURCE_TYPE_KEYBOX:
1432       {
1433         iobuf_t iobuf;
1434
1435         err = build_keyblock_image (kb, &iobuf, NULL);
1436         if (!err)
1437           {
1438             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1439                                           iobuf_get_temp_buffer (iobuf),
1440                                           iobuf_get_temp_length (iobuf));
1441             iobuf_close (iobuf);
1442           }
1443       }
1444       break;
1445     }
1446
1447   unlock_all (hd);
1448   return err;
1449 }
1450
1451
1452 gpg_error_t
1453 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1454 {
1455   gpg_error_t err;
1456   int idx;
1457
1458   if (!hd)
1459     return gpg_error (GPG_ERR_INV_ARG);
1460
1461   kid_not_found_flush ();
1462   keyblock_cache_clear (hd);
1463
1464   if (opt.dry_run)
1465     return 0;
1466
1467   if (hd->found >= 0 && hd->found < hd->used)
1468     idx = hd->found;
1469   else if (hd->current >= 0 && hd->current < hd->used)
1470     idx = hd->current;
1471   else
1472     return gpg_error (GPG_ERR_GENERAL);
1473
1474   err = lock_all (hd);
1475   if (err)
1476     return err;
1477
1478   switch (hd->active[idx].type)
1479     {
1480     case KEYDB_RESOURCE_TYPE_NONE:
1481       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1482       break;
1483     case KEYDB_RESOURCE_TYPE_KEYRING:
1484       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1485       break;
1486     case KEYDB_RESOURCE_TYPE_KEYBOX:
1487       { /* We need to turn our kbnode_t list of packets into a proper
1488            keyblock first.  This is required by the OpenPGP key parser
1489            included in the keybox code.  Eventually we can change this
1490            kludge to have the caller pass the image.  */
1491         iobuf_t iobuf;
1492         u32 *sigstatus;
1493
1494         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1495         if (!err)
1496           {
1497             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1498                                           iobuf_get_temp_buffer (iobuf),
1499                                           iobuf_get_temp_length (iobuf),
1500                                           sigstatus);
1501             xfree (sigstatus);
1502             iobuf_close (iobuf);
1503           }
1504       }
1505       break;
1506     }
1507
1508   unlock_all (hd);
1509   return err;
1510 }
1511
1512
1513 gpg_error_t
1514 keydb_delete_keyblock (KEYDB_HANDLE hd)
1515 {
1516   gpg_error_t rc;
1517
1518   if (!hd)
1519     return gpg_error (GPG_ERR_INV_ARG);
1520
1521   kid_not_found_flush ();
1522   keyblock_cache_clear (hd);
1523
1524   if (hd->found < 0 || hd->found >= hd->used)
1525     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1526
1527   if (opt.dry_run)
1528     return 0;
1529
1530   rc = lock_all (hd);
1531   if (rc)
1532     return rc;
1533
1534   switch (hd->active[hd->found].type)
1535     {
1536     case KEYDB_RESOURCE_TYPE_NONE:
1537       rc = gpg_error (GPG_ERR_GENERAL);
1538       break;
1539     case KEYDB_RESOURCE_TYPE_KEYRING:
1540       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1541       break;
1542     case KEYDB_RESOURCE_TYPE_KEYBOX:
1543       rc = keybox_delete (hd->active[hd->found].u.kb);
1544       break;
1545     }
1546
1547   unlock_all (hd);
1548   return rc;
1549 }
1550
1551
1552 \f
1553 gpg_error_t
1554 keydb_locate_writable (KEYDB_HANDLE hd)
1555 {
1556   gpg_error_t rc;
1557
1558   if (!hd)
1559     return GPG_ERR_INV_ARG;
1560
1561   rc = keydb_search_reset (hd); /* this does reset hd->current */
1562   if (rc)
1563     return rc;
1564
1565   /* If we have a primary set, try that one first */
1566   if (primary_keyring)
1567     {
1568       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1569         {
1570           if(hd->active[hd->current].token==primary_keyring)
1571             {
1572               if(keyring_is_writable (hd->active[hd->current].token))
1573                 return 0;
1574               else
1575                 break;
1576             }
1577         }
1578
1579       rc = keydb_search_reset (hd); /* this does reset hd->current */
1580       if (rc)
1581         return rc;
1582     }
1583
1584   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1585     {
1586       switch (hd->active[hd->current].type)
1587         {
1588         case KEYDB_RESOURCE_TYPE_NONE:
1589           BUG();
1590           break;
1591         case KEYDB_RESOURCE_TYPE_KEYRING:
1592           if (keyring_is_writable (hd->active[hd->current].token))
1593             return 0; /* found (hd->current is set to it) */
1594           break;
1595         case KEYDB_RESOURCE_TYPE_KEYBOX:
1596           if (keybox_is_writable (hd->active[hd->current].token))
1597             return 0; /* found (hd->current is set to it) */
1598           break;
1599         }
1600     }
1601
1602   return gpg_error (GPG_ERR_NOT_FOUND);
1603 }
1604
1605 void
1606 keydb_rebuild_caches (int noisy)
1607 {
1608   int i, rc;
1609
1610   for (i=0; i < used_resources; i++)
1611     {
1612       if (!keyring_is_writable (all_resources[i].token))
1613         continue;
1614       switch (all_resources[i].type)
1615         {
1616         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1617           break;
1618         case KEYDB_RESOURCE_TYPE_KEYRING:
1619           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1620           if (rc)
1621             log_error (_("failed to rebuild keyring cache: %s\n"),
1622                        gpg_strerror (rc));
1623           break;
1624         case KEYDB_RESOURCE_TYPE_KEYBOX:
1625           /* N/A.  */
1626           break;
1627         }
1628     }
1629 }
1630
1631
1632 unsigned long
1633 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1634 {
1635   return hd ? hd->skipped_long_blobs : 0;
1636 }
1637
1638
1639 gpg_error_t
1640 keydb_search_reset (KEYDB_HANDLE hd)
1641 {
1642   gpg_error_t rc = 0;
1643   int i;
1644
1645   if (!hd)
1646     return gpg_error (GPG_ERR_INV_ARG);
1647
1648   keyblock_cache_clear (hd);
1649
1650   if (DBG_CLOCK)
1651     log_clock ("keydb_search_reset");
1652
1653   if (DBG_CACHE)
1654     log_debug ("keydb_search: reset  (hd=%p)", hd);
1655
1656   hd->skipped_long_blobs = 0;
1657   hd->current = 0;
1658   hd->found = -1;
1659   /* Now reset all resources.  */
1660   for (i=0; !rc && i < hd->used; i++)
1661     {
1662       switch (hd->active[i].type)
1663         {
1664         case KEYDB_RESOURCE_TYPE_NONE:
1665           break;
1666         case KEYDB_RESOURCE_TYPE_KEYRING:
1667           rc = keyring_search_reset (hd->active[i].u.kr);
1668           break;
1669         case KEYDB_RESOURCE_TYPE_KEYBOX:
1670           rc = keybox_search_reset (hd->active[i].u.kb);
1671           break;
1672         }
1673     }
1674   hd->is_reset = 1;
1675   return rc;
1676 }
1677
1678
1679 gpg_error_t
1680 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1681               size_t ndesc, size_t *descindex)
1682 {
1683   int i;
1684   gpg_error_t rc;
1685   int was_reset = hd->is_reset;
1686   /* If an entry is already in the cache, then don't add it again.  */
1687   int already_in_cache = 0;
1688
1689   if (descindex)
1690     *descindex = 0; /* Make sure it is always set on return.  */
1691
1692   if (!hd)
1693     return gpg_error (GPG_ERR_INV_ARG);
1694
1695   if (DBG_CLOCK)
1696     log_clock ("keydb_search enter");
1697
1698   if (DBG_LOOKUP)
1699     {
1700       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
1701       for (i = 0; i < ndesc; i ++)
1702         {
1703           char *t = keydb_search_desc_dump (&desc[i]);
1704           log_debug ("%s   %d: %s\n", __func__, i, t);
1705           xfree (t);
1706         }
1707     }
1708
1709
1710   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1711       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1712     {
1713       if (DBG_CLOCK)
1714         log_clock ("keydb_search leave (not found, cached)");
1715       return gpg_error (GPG_ERR_NOT_FOUND);
1716     }
1717
1718   /* NB: If one of the exact search modes below is used in a loop to
1719      walk over all keys (with the same fingerprint) the caching must
1720      have been disabled for the handle.  */
1721   if (!hd->no_caching
1722       && ndesc == 1
1723       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1724           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1725       && hd->keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1726       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, 20)
1727       /* Make sure the current file position occurs before the cached
1728          result to avoid an infinite loop.  */
1729       && (hd->current < hd->keyblock_cache.resource
1730           || (hd->current == hd->keyblock_cache.resource
1731               && (keybox_offset (hd->active[hd->current].u.kb)
1732                   <= hd->keyblock_cache.offset))))
1733     {
1734       /* (DESCINDEX is already set).  */
1735       if (DBG_CLOCK)
1736         log_clock ("keydb_search leave (cached)");
1737
1738       hd->current = hd->keyblock_cache.resource;
1739       /* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
1740          Seek just beyond that.  */
1741       keybox_seek (hd->active[hd->current].u.kb,
1742                    hd->keyblock_cache.offset + 1);
1743       return 0;
1744     }
1745
1746   rc = -1;
1747   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1748          && hd->current >= 0 && hd->current < hd->used)
1749     {
1750       if (DBG_LOOKUP)
1751         log_debug ("%s: searching %s (resource %d of %d)\n",
1752                    __func__,
1753                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1754                    ? "keyring"
1755                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1756                       ? "keybox" : "unknown type"),
1757                    hd->current, hd->used);
1758
1759        switch (hd->active[hd->current].type)
1760         {
1761         case KEYDB_RESOURCE_TYPE_NONE:
1762           BUG(); /* we should never see it here */
1763           break;
1764         case KEYDB_RESOURCE_TYPE_KEYRING:
1765           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1766                                ndesc, descindex, 1);
1767           break;
1768         case KEYDB_RESOURCE_TYPE_KEYBOX:
1769           do
1770             rc = keybox_search (hd->active[hd->current].u.kb, desc,
1771                                 ndesc, KEYBOX_BLOBTYPE_PGP,
1772                                 descindex, &hd->skipped_long_blobs);
1773           while (rc == GPG_ERR_LEGACY_KEY);
1774           break;
1775         }
1776
1777       if (DBG_LOOKUP)
1778         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1779                    __func__,
1780                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1781                    ? "keyring"
1782                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1783                       ? "keybox" : "unknown type"),
1784                    hd->current, hd->used,
1785                    rc == -1 ? "EOF" : gpg_strerror (rc));
1786
1787       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1788         {
1789           /* EOF -> switch to next resource */
1790           hd->current++;
1791         }
1792       else if (!rc)
1793         hd->found = hd->current;
1794     }
1795   hd->is_reset = 0;
1796
1797   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1798         ? gpg_error (GPG_ERR_NOT_FOUND)
1799         : rc);
1800
1801   keyblock_cache_clear (hd);
1802   if (!hd->no_caching
1803       && !rc
1804       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1805                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1806       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
1807     {
1808       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1809       hd->keyblock_cache.resource = hd->current;
1810       /* The current offset is at the start of the next record.  Since
1811          a record is at least 1 byte, we just use offset - 1, which is
1812          within the record.  */
1813       hd->keyblock_cache.offset
1814         = keybox_offset (hd->active[hd->current].u.kb) - 1;
1815       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, 20);
1816     }
1817
1818   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
1819       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
1820       && !already_in_cache)
1821     kid_not_found_insert (desc[0].u.kid);
1822
1823   if (DBG_CLOCK)
1824     log_clock (rc? "keydb_search leave (not found)"
1825                  : "keydb_search leave (found)");
1826   return rc;
1827 }
1828
1829
1830 gpg_error_t
1831 keydb_search_first (KEYDB_HANDLE hd)
1832 {
1833   gpg_error_t err;
1834   KEYDB_SEARCH_DESC desc;
1835
1836   err = keydb_search_reset (hd);
1837   if (err)
1838     return err;
1839
1840   memset (&desc, 0, sizeof desc);
1841   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1842   return keydb_search (hd, &desc, 1, NULL);
1843 }
1844
1845
1846 gpg_error_t
1847 keydb_search_next (KEYDB_HANDLE hd)
1848 {
1849   KEYDB_SEARCH_DESC desc;
1850
1851   memset (&desc, 0, sizeof desc);
1852   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1853   return keydb_search (hd, &desc, 1, NULL);
1854 }
1855
1856 gpg_error_t
1857 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1858 {
1859   KEYDB_SEARCH_DESC desc;
1860
1861   memset (&desc, 0, sizeof desc);
1862   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1863   desc.u.kid[0] = kid[0];
1864   desc.u.kid[1] = kid[1];
1865   return keydb_search (hd, &desc, 1, NULL);
1866 }
1867
1868 gpg_error_t
1869 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1870 {
1871   KEYDB_SEARCH_DESC desc;
1872
1873   memset (&desc, 0, sizeof desc);
1874   desc.mode = KEYDB_SEARCH_MODE_FPR;
1875   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1876   return keydb_search (hd, &desc, 1, NULL);
1877 }