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