gpg: Take care of keydb_new returning NULL.
[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 /* Create a new database handle.  A database handle is similar to a
758    file handle: it contains a local file position.  This is used when
759    searching: subsequent searches resume where the previous search
760    left off.  To rewind the position, use keydb_search_reset().  This
761    function returns NULL on error, sets ERRNO, and prints an error
762    diagnostic. */
763 KEYDB_HANDLE
764 keydb_new (void)
765 {
766   KEYDB_HANDLE hd;
767   int i, j;
768   int die = 0;
769   int reterrno;
770
771   if (DBG_CLOCK)
772     log_clock ("keydb_new");
773
774   hd = xtrycalloc (1, sizeof *hd);
775   if (!hd)
776     goto leave;
777   hd->found = -1;
778   hd->saved_found = -1;
779   hd->is_reset = 1;
780
781   assert (used_resources <= MAX_KEYDB_RESOURCES);
782   for (i=j=0; ! die && i < used_resources; i++)
783     {
784       switch (all_resources[i].type)
785         {
786         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
787           break;
788         case KEYDB_RESOURCE_TYPE_KEYRING:
789           hd->active[j].type   = all_resources[i].type;
790           hd->active[j].token  = all_resources[i].token;
791           hd->active[j].u.kr = keyring_new (all_resources[i].token);
792           if (!hd->active[j].u.kr)
793             {
794               reterrno = errno;
795               die = 1;
796             }
797           j++;
798           break;
799         case KEYDB_RESOURCE_TYPE_KEYBOX:
800           hd->active[j].type   = all_resources[i].type;
801           hd->active[j].token  = all_resources[i].token;
802           hd->active[j].u.kb   = keybox_new_openpgp (all_resources[i].token, 0);
803           if (!hd->active[j].u.kb)
804             {
805               reterrno = errno;
806               die = 1;
807             }
808           j++;
809           break;
810         }
811     }
812   hd->used = j;
813
814   active_handles++;
815
816   if (die)
817     {
818       keydb_release (hd);
819       gpg_err_set_errno (reterrno);
820       hd = NULL;
821     }
822
823  leave:
824   if (!hd)
825     log_error (_("error opening key DB: %s\n"),
826                gpg_strerror (gpg_error_from_syserror()));
827
828   return hd;
829 }
830
831
832 void
833 keydb_release (KEYDB_HANDLE hd)
834 {
835   int i;
836
837   if (!hd)
838     return;
839   assert (active_handles > 0);
840   active_handles--;
841
842   unlock_all (hd);
843   for (i=0; i < hd->used; i++)
844     {
845       switch (hd->active[i].type)
846         {
847         case KEYDB_RESOURCE_TYPE_NONE:
848           break;
849         case KEYDB_RESOURCE_TYPE_KEYRING:
850           keyring_release (hd->active[i].u.kr);
851           break;
852         case KEYDB_RESOURCE_TYPE_KEYBOX:
853           keybox_release (hd->active[i].u.kb);
854           break;
855         }
856     }
857
858   xfree (hd);
859 }
860
861
862 void
863 keydb_disable_caching (KEYDB_HANDLE hd)
864 {
865   if (hd)
866     hd->no_caching = 1;
867 }
868
869
870 const char *
871 keydb_get_resource_name (KEYDB_HANDLE hd)
872 {
873   int idx;
874   const char *s = NULL;
875
876   if (!hd)
877     return NULL;
878
879   if ( hd->found >= 0 && hd->found < hd->used)
880     idx = hd->found;
881   else if ( hd->current >= 0 && hd->current < hd->used)
882     idx = hd->current;
883   else
884     idx = 0;
885
886   switch (hd->active[idx].type)
887     {
888     case KEYDB_RESOURCE_TYPE_NONE:
889       s = NULL;
890       break;
891     case KEYDB_RESOURCE_TYPE_KEYRING:
892       s = keyring_get_resource_name (hd->active[idx].u.kr);
893       break;
894     case KEYDB_RESOURCE_TYPE_KEYBOX:
895       s = keybox_get_resource_name (hd->active[idx].u.kb);
896       break;
897     }
898
899   return s? s: "";
900 }
901
902
903
904 static int
905 lock_all (KEYDB_HANDLE hd)
906 {
907   int i, rc = 0;
908
909   /* Fixme: This locking scheme may lead to a deadlock if the resources
910      are not added in the same order by all processes.  We are
911      currently only allowing one resource so it is not a problem.
912      [Oops: Who claimed the latter]
913
914      To fix this we need to use a lock file to protect lock_all.  */
915
916   for (i=0; !rc && i < hd->used; i++)
917     {
918       switch (hd->active[i].type)
919         {
920         case KEYDB_RESOURCE_TYPE_NONE:
921           break;
922         case KEYDB_RESOURCE_TYPE_KEYRING:
923           rc = keyring_lock (hd->active[i].u.kr, 1);
924           break;
925         case KEYDB_RESOURCE_TYPE_KEYBOX:
926           rc = keybox_lock (hd->active[i].u.kb, 1);
927           break;
928         }
929     }
930
931   if (rc)
932     {
933       /* Revert the already taken locks.  */
934       for (i--; i >= 0; i--)
935         {
936           switch (hd->active[i].type)
937             {
938             case KEYDB_RESOURCE_TYPE_NONE:
939               break;
940             case KEYDB_RESOURCE_TYPE_KEYRING:
941               keyring_lock (hd->active[i].u.kr, 0);
942               break;
943             case KEYDB_RESOURCE_TYPE_KEYBOX:
944               rc = keybox_lock (hd->active[i].u.kb, 0);
945               break;
946             }
947         }
948     }
949   else
950     hd->locked = 1;
951
952   return rc;
953 }
954
955
956 static void
957 unlock_all (KEYDB_HANDLE hd)
958 {
959   int i;
960
961   if (!hd->locked)
962     return;
963
964   for (i=hd->used-1; i >= 0; i--)
965     {
966       switch (hd->active[i].type)
967         {
968         case KEYDB_RESOURCE_TYPE_NONE:
969           break;
970         case KEYDB_RESOURCE_TYPE_KEYRING:
971           keyring_lock (hd->active[i].u.kr, 0);
972           break;
973         case KEYDB_RESOURCE_TYPE_KEYBOX:
974           keybox_lock (hd->active[i].u.kb, 0);
975           break;
976         }
977     }
978   hd->locked = 0;
979 }
980
981
982 \f
983 void
984 keydb_push_found_state (KEYDB_HANDLE hd)
985 {
986   if (!hd)
987     return;
988
989   if (hd->found < 0 || hd->found >= hd->used)
990     {
991       hd->saved_found = -1;
992       return;
993     }
994
995   switch (hd->active[hd->found].type)
996     {
997     case KEYDB_RESOURCE_TYPE_NONE:
998       break;
999     case KEYDB_RESOURCE_TYPE_KEYRING:
1000       keyring_push_found_state (hd->active[hd->found].u.kr);
1001       break;
1002     case KEYDB_RESOURCE_TYPE_KEYBOX:
1003       keybox_push_found_state (hd->active[hd->found].u.kb);
1004       break;
1005     }
1006
1007   hd->saved_found = hd->found;
1008   hd->found = -1;
1009 }
1010
1011
1012 void
1013 keydb_pop_found_state (KEYDB_HANDLE hd)
1014 {
1015   if (!hd)
1016     return;
1017
1018   hd->found = hd->saved_found;
1019   hd->saved_found = -1;
1020   if (hd->found < 0 || hd->found >= hd->used)
1021     return;
1022
1023   switch (hd->active[hd->found].type)
1024     {
1025     case KEYDB_RESOURCE_TYPE_NONE:
1026       break;
1027     case KEYDB_RESOURCE_TYPE_KEYRING:
1028       keyring_pop_found_state (hd->active[hd->found].u.kr);
1029       break;
1030     case KEYDB_RESOURCE_TYPE_KEYBOX:
1031       keybox_pop_found_state (hd->active[hd->found].u.kb);
1032       break;
1033     }
1034 }
1035
1036
1037 \f
1038 static gpg_error_t
1039 parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
1040                       const u32 *sigstatus, kbnode_t *r_keyblock)
1041 {
1042   gpg_error_t err;
1043   PACKET *pkt;
1044   kbnode_t keyblock = NULL;
1045   kbnode_t node, *tail;
1046   int in_cert, save_mode;
1047   u32 n_sigs;
1048   int pk_count, uid_count;
1049
1050   *r_keyblock = NULL;
1051
1052   pkt = xtrymalloc (sizeof *pkt);
1053   if (!pkt)
1054     return gpg_error_from_syserror ();
1055   init_packet (pkt);
1056   save_mode = set_packet_list_mode (0);
1057   in_cert = 0;
1058   n_sigs = 0;
1059   tail = NULL;
1060   pk_count = uid_count = 0;
1061   while ((err = parse_packet (iobuf, pkt)) != -1)
1062     {
1063       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
1064         {
1065           free_packet (pkt);
1066           init_packet (pkt);
1067           continue;
1068         }
1069       if (err)
1070         {
1071           log_error ("parse_keyblock_image: read error: %s\n",
1072                      gpg_strerror (err));
1073           err = gpg_error (GPG_ERR_INV_KEYRING);
1074           break;
1075         }
1076
1077       /* Filter allowed packets.  */
1078       switch (pkt->pkttype)
1079         {
1080         case PKT_PUBLIC_KEY:
1081         case PKT_PUBLIC_SUBKEY:
1082         case PKT_SECRET_KEY:
1083         case PKT_SECRET_SUBKEY:
1084         case PKT_USER_ID:
1085         case PKT_ATTRIBUTE:
1086         case PKT_SIGNATURE:
1087           break; /* Allowed per RFC.  */
1088
1089         default:
1090           /* Note that can't allow ring trust packets here and some of
1091              the other GPG specific packets don't make sense either.  */
1092           log_error ("skipped packet of type %d in keybox\n",
1093                      (int)pkt->pkttype);
1094           free_packet(pkt);
1095           init_packet(pkt);
1096           continue;
1097         }
1098
1099       /* Other sanity checks.  */
1100       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
1101         {
1102           log_error ("parse_keyblock_image: first packet in a keybox blob "
1103                      "is not a public key packet\n");
1104           err = gpg_error (GPG_ERR_INV_KEYRING);
1105           break;
1106         }
1107       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
1108                       || pkt->pkttype == PKT_SECRET_KEY))
1109         {
1110           log_error ("parse_keyblock_image: "
1111                      "multiple keyblocks in a keybox blob\n");
1112           err = gpg_error (GPG_ERR_INV_KEYRING);
1113           break;
1114         }
1115       in_cert = 1;
1116
1117       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
1118         {
1119           PKT_signature *sig = pkt->pkt.signature;
1120
1121           n_sigs++;
1122           if (n_sigs > sigstatus[0])
1123             {
1124               log_error ("parse_keyblock_image: "
1125                          "more signatures than found in the meta data\n");
1126               err = gpg_error (GPG_ERR_INV_KEYRING);
1127               break;
1128
1129             }
1130           if (sigstatus[n_sigs])
1131             {
1132               sig->flags.checked = 1;
1133               if (sigstatus[n_sigs] == 1 )
1134                 ; /* missing key */
1135               else if (sigstatus[n_sigs] == 2 )
1136                 ; /* bad signature */
1137               else if (sigstatus[n_sigs] < 0x10000000)
1138                 ; /* bad flag */
1139               else
1140                 {
1141                   sig->flags.valid = 1;
1142                   /* Fixme: Shall we set the expired flag here?  */
1143                 }
1144             }
1145         }
1146
1147       node = new_kbnode (pkt);
1148
1149       switch (pkt->pkttype)
1150         {
1151         case PKT_PUBLIC_KEY:
1152         case PKT_PUBLIC_SUBKEY:
1153         case PKT_SECRET_KEY:
1154         case PKT_SECRET_SUBKEY:
1155           if (++pk_count == pk_no)
1156             node->flag |= 1;
1157           break;
1158
1159         case PKT_USER_ID:
1160           if (++uid_count == uid_no)
1161             node->flag |= 2;
1162           break;
1163
1164         default:
1165           break;
1166         }
1167
1168       if (!keyblock)
1169         keyblock = node;
1170       else
1171         *tail = node;
1172       tail = &node->next;
1173       pkt = xtrymalloc (sizeof *pkt);
1174       if (!pkt)
1175         {
1176           err = gpg_error_from_syserror ();
1177           break;
1178         }
1179       init_packet (pkt);
1180     }
1181   set_packet_list_mode (save_mode);
1182
1183   if (err == -1 && keyblock)
1184     err = 0; /* Got the entire keyblock.  */
1185
1186   if (!err && sigstatus && n_sigs != sigstatus[0])
1187     {
1188       log_error ("parse_keyblock_image: signature count does not match\n");
1189       err = gpg_error (GPG_ERR_INV_KEYRING);
1190     }
1191
1192   if (err)
1193     release_kbnode (keyblock);
1194   else
1195     *r_keyblock = keyblock;
1196   free_packet (pkt);
1197   xfree (pkt);
1198   return err;
1199 }
1200
1201
1202 gpg_error_t
1203 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
1204 {
1205   gpg_error_t err = 0;
1206
1207   *ret_kb = NULL;
1208
1209   if (!hd)
1210     return gpg_error (GPG_ERR_INV_ARG);
1211
1212   if (DBG_CLOCK)
1213     log_clock ("keydb_get_keybock enter");
1214
1215   if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
1216     {
1217       err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
1218       if (err)
1219         {
1220           log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
1221           keyblock_cache_clear (hd);
1222         }
1223       else
1224         {
1225           err = parse_keyblock_image (hd->keyblock_cache.iobuf,
1226                                       hd->keyblock_cache.pk_no,
1227                                       hd->keyblock_cache.uid_no,
1228                                       hd->keyblock_cache.sigstatus,
1229                                       ret_kb);
1230           if (err)
1231             keyblock_cache_clear (hd);
1232           if (DBG_CLOCK)
1233             log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1234                        : "keydb_get_keyblock leave (cached)");
1235           return err;
1236         }
1237     }
1238
1239   if (hd->found < 0 || hd->found >= hd->used)
1240     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1241
1242   switch (hd->active[hd->found].type)
1243     {
1244     case KEYDB_RESOURCE_TYPE_NONE:
1245       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1246       break;
1247     case KEYDB_RESOURCE_TYPE_KEYRING:
1248       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1249       break;
1250     case KEYDB_RESOURCE_TYPE_KEYBOX:
1251       {
1252         iobuf_t iobuf;
1253         u32 *sigstatus;
1254         int pk_no, uid_no;
1255
1256         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1257                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1258         if (!err)
1259           {
1260             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1261                                         ret_kb);
1262             if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1263               {
1264                 hd->keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1265                 hd->keyblock_cache.sigstatus = sigstatus;
1266                 hd->keyblock_cache.iobuf     = iobuf;
1267                 hd->keyblock_cache.pk_no     = pk_no;
1268                 hd->keyblock_cache.uid_no    = uid_no;
1269               }
1270             else
1271               {
1272                 xfree (sigstatus);
1273                 iobuf_close (iobuf);
1274               }
1275           }
1276       }
1277       break;
1278     }
1279
1280   if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1281     keyblock_cache_clear (hd);
1282
1283   if (DBG_CLOCK)
1284     log_clock (err? "keydb_get_keyblock leave (failed)"
1285                : "keydb_get_keyblock leave");
1286   return err;
1287 }
1288
1289
1290 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1291    only then stores a new iobuf object at R_IOBUF and a signature
1292    status vecotor at R_SIGSTATUS.  */
1293 static gpg_error_t
1294 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1295 {
1296   gpg_error_t err;
1297   iobuf_t iobuf;
1298   kbnode_t kbctx, node;
1299   u32 n_sigs;
1300   u32 *sigstatus;
1301
1302   *r_iobuf = NULL;
1303   if (r_sigstatus)
1304     *r_sigstatus = NULL;
1305
1306   /* Allocate a vector for the signature cache.  This is an array of
1307      u32 values with the first value giving the number of elements to
1308      follow and each element descriping the cache status of the
1309      signature.  */
1310   if (r_sigstatus)
1311     {
1312       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1313         if (node->pkt->pkttype == PKT_SIGNATURE)
1314           n_sigs++;
1315       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1316       if (!sigstatus)
1317         return gpg_error_from_syserror ();
1318     }
1319   else
1320     sigstatus = NULL;
1321
1322   iobuf = iobuf_temp ();
1323   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1324     {
1325       /* Make sure to use only packets valid on a keyblock.  */
1326       switch (node->pkt->pkttype)
1327         {
1328         case PKT_PUBLIC_KEY:
1329         case PKT_PUBLIC_SUBKEY:
1330         case PKT_SIGNATURE:
1331         case PKT_USER_ID:
1332         case PKT_ATTRIBUTE:
1333           /* Note that we don't want the ring trust packets.  They are
1334              not useful. */
1335           break;
1336         default:
1337           continue;
1338         }
1339
1340       err = build_packet (iobuf, node->pkt);
1341       if (err)
1342         {
1343           iobuf_close (iobuf);
1344           return err;
1345         }
1346
1347       /* Build signature status vector.  */
1348       if (node->pkt->pkttype == PKT_SIGNATURE)
1349         {
1350           PKT_signature *sig = node->pkt->pkt.signature;
1351
1352           n_sigs++;
1353           /* Fixme: Detect the "missing key" status.  */
1354           if (sig->flags.checked && sigstatus)
1355             {
1356               if (sig->flags.valid)
1357                 {
1358                   if (!sig->expiredate)
1359                     sigstatus[n_sigs] = 0xffffffff;
1360                   else if (sig->expiredate < 0x1000000)
1361                     sigstatus[n_sigs] = 0x10000000;
1362                   else
1363                     sigstatus[n_sigs] = sig->expiredate;
1364                 }
1365               else
1366                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1367             }
1368         }
1369     }
1370   if (sigstatus)
1371     sigstatus[0] = n_sigs;
1372
1373   *r_iobuf = iobuf;
1374   if (r_sigstatus)
1375     *r_sigstatus = sigstatus;
1376   return 0;
1377 }
1378
1379
1380 gpg_error_t
1381 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1382 {
1383   gpg_error_t err;
1384
1385   if (!hd)
1386     return gpg_error (GPG_ERR_INV_ARG);
1387
1388   kid_not_found_flush ();
1389   keyblock_cache_clear (hd);
1390
1391   if (hd->found < 0 || hd->found >= hd->used)
1392     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1393
1394   if (opt.dry_run)
1395     return 0;
1396
1397   err = lock_all (hd);
1398   if (err)
1399     return err;
1400
1401   switch (hd->active[hd->found].type)
1402     {
1403     case KEYDB_RESOURCE_TYPE_NONE:
1404       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1405       break;
1406     case KEYDB_RESOURCE_TYPE_KEYRING:
1407       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1408       break;
1409     case KEYDB_RESOURCE_TYPE_KEYBOX:
1410       {
1411         iobuf_t iobuf;
1412
1413         err = build_keyblock_image (kb, &iobuf, NULL);
1414         if (!err)
1415           {
1416             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1417                                           iobuf_get_temp_buffer (iobuf),
1418                                           iobuf_get_temp_length (iobuf));
1419             iobuf_close (iobuf);
1420           }
1421       }
1422       break;
1423     }
1424
1425   unlock_all (hd);
1426   return err;
1427 }
1428
1429
1430 gpg_error_t
1431 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1432 {
1433   gpg_error_t err;
1434   int idx;
1435
1436   if (!hd)
1437     return gpg_error (GPG_ERR_INV_ARG);
1438
1439   kid_not_found_flush ();
1440   keyblock_cache_clear (hd);
1441
1442   if (opt.dry_run)
1443     return 0;
1444
1445   if (hd->found >= 0 && hd->found < hd->used)
1446     idx = hd->found;
1447   else if (hd->current >= 0 && hd->current < hd->used)
1448     idx = hd->current;
1449   else
1450     return gpg_error (GPG_ERR_GENERAL);
1451
1452   err = lock_all (hd);
1453   if (err)
1454     return err;
1455
1456   switch (hd->active[idx].type)
1457     {
1458     case KEYDB_RESOURCE_TYPE_NONE:
1459       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1460       break;
1461     case KEYDB_RESOURCE_TYPE_KEYRING:
1462       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1463       break;
1464     case KEYDB_RESOURCE_TYPE_KEYBOX:
1465       { /* We need to turn our kbnode_t list of packets into a proper
1466            keyblock first.  This is required by the OpenPGP key parser
1467            included in the keybox code.  Eventually we can change this
1468            kludge to have the caller pass the image.  */
1469         iobuf_t iobuf;
1470         u32 *sigstatus;
1471
1472         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1473         if (!err)
1474           {
1475             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1476                                           iobuf_get_temp_buffer (iobuf),
1477                                           iobuf_get_temp_length (iobuf),
1478                                           sigstatus);
1479             xfree (sigstatus);
1480             iobuf_close (iobuf);
1481           }
1482       }
1483       break;
1484     }
1485
1486   unlock_all (hd);
1487   return err;
1488 }
1489
1490
1491 gpg_error_t
1492 keydb_delete_keyblock (KEYDB_HANDLE hd)
1493 {
1494   gpg_error_t rc;
1495
1496   if (!hd)
1497     return gpg_error (GPG_ERR_INV_ARG);
1498
1499   kid_not_found_flush ();
1500   keyblock_cache_clear (hd);
1501
1502   if (hd->found < 0 || hd->found >= hd->used)
1503     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1504
1505   if (opt.dry_run)
1506     return 0;
1507
1508   rc = lock_all (hd);
1509   if (rc)
1510     return rc;
1511
1512   switch (hd->active[hd->found].type)
1513     {
1514     case KEYDB_RESOURCE_TYPE_NONE:
1515       rc = gpg_error (GPG_ERR_GENERAL);
1516       break;
1517     case KEYDB_RESOURCE_TYPE_KEYRING:
1518       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1519       break;
1520     case KEYDB_RESOURCE_TYPE_KEYBOX:
1521       rc = keybox_delete (hd->active[hd->found].u.kb);
1522       break;
1523     }
1524
1525   unlock_all (hd);
1526   return rc;
1527 }
1528
1529
1530 \f
1531 gpg_error_t
1532 keydb_locate_writable (KEYDB_HANDLE hd)
1533 {
1534   gpg_error_t rc;
1535
1536   if (!hd)
1537     return GPG_ERR_INV_ARG;
1538
1539   rc = keydb_search_reset (hd); /* this does reset hd->current */
1540   if (rc)
1541     return rc;
1542
1543   /* If we have a primary set, try that one first */
1544   if (primary_keyring)
1545     {
1546       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1547         {
1548           if(hd->active[hd->current].token==primary_keyring)
1549             {
1550               if(keyring_is_writable (hd->active[hd->current].token))
1551                 return 0;
1552               else
1553                 break;
1554             }
1555         }
1556
1557       rc = keydb_search_reset (hd); /* this does reset hd->current */
1558       if (rc)
1559         return rc;
1560     }
1561
1562   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1563     {
1564       switch (hd->active[hd->current].type)
1565         {
1566         case KEYDB_RESOURCE_TYPE_NONE:
1567           BUG();
1568           break;
1569         case KEYDB_RESOURCE_TYPE_KEYRING:
1570           if (keyring_is_writable (hd->active[hd->current].token))
1571             return 0; /* found (hd->current is set to it) */
1572           break;
1573         case KEYDB_RESOURCE_TYPE_KEYBOX:
1574           if (keybox_is_writable (hd->active[hd->current].token))
1575             return 0; /* found (hd->current is set to it) */
1576           break;
1577         }
1578     }
1579
1580   return gpg_error (GPG_ERR_NOT_FOUND);
1581 }
1582
1583 void
1584 keydb_rebuild_caches (int noisy)
1585 {
1586   int i, rc;
1587
1588   for (i=0; i < used_resources; i++)
1589     {
1590       if (!keyring_is_writable (all_resources[i].token))
1591         continue;
1592       switch (all_resources[i].type)
1593         {
1594         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1595           break;
1596         case KEYDB_RESOURCE_TYPE_KEYRING:
1597           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1598           if (rc)
1599             log_error (_("failed to rebuild keyring cache: %s\n"),
1600                        gpg_strerror (rc));
1601           break;
1602         case KEYDB_RESOURCE_TYPE_KEYBOX:
1603           /* N/A.  */
1604           break;
1605         }
1606     }
1607 }
1608
1609
1610 unsigned long
1611 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1612 {
1613   return hd ? hd->skipped_long_blobs : 0;
1614 }
1615
1616
1617 gpg_error_t
1618 keydb_search_reset (KEYDB_HANDLE hd)
1619 {
1620   gpg_error_t rc = 0;
1621   int i;
1622
1623   if (!hd)
1624     return gpg_error (GPG_ERR_INV_ARG);
1625
1626   keyblock_cache_clear (hd);
1627
1628   if (DBG_CLOCK)
1629     log_clock ("keydb_search_reset");
1630
1631   if (DBG_CACHE)
1632     log_debug ("keydb_search: reset  (hd=%p)", hd);
1633
1634   hd->skipped_long_blobs = 0;
1635   hd->current = 0;
1636   hd->found = -1;
1637   /* Now reset all resources.  */
1638   for (i=0; !rc && i < hd->used; i++)
1639     {
1640       switch (hd->active[i].type)
1641         {
1642         case KEYDB_RESOURCE_TYPE_NONE:
1643           break;
1644         case KEYDB_RESOURCE_TYPE_KEYRING:
1645           rc = keyring_search_reset (hd->active[i].u.kr);
1646           break;
1647         case KEYDB_RESOURCE_TYPE_KEYBOX:
1648           rc = keybox_search_reset (hd->active[i].u.kb);
1649           break;
1650         }
1651     }
1652   hd->is_reset = 1;
1653   return rc;
1654 }
1655
1656
1657 gpg_error_t
1658 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1659               size_t ndesc, size_t *descindex)
1660 {
1661   int i;
1662   gpg_error_t rc;
1663   int was_reset = hd->is_reset;
1664   /* If an entry is already in the cache, then don't add it again.  */
1665   int already_in_cache = 0;
1666
1667   if (descindex)
1668     *descindex = 0; /* Make sure it is always set on return.  */
1669
1670   if (!hd)
1671     return gpg_error (GPG_ERR_INV_ARG);
1672
1673   if (DBG_CLOCK)
1674     log_clock ("keydb_search enter");
1675
1676   if (DBG_LOOKUP)
1677     {
1678       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
1679       for (i = 0; i < ndesc; i ++)
1680         {
1681           char *t = keydb_search_desc_dump (&desc[i]);
1682           log_debug ("%s   %d: %s\n", __func__, i, t);
1683           xfree (t);
1684         }
1685     }
1686
1687
1688   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1689       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1690     {
1691       if (DBG_CLOCK)
1692         log_clock ("keydb_search leave (not found, cached)");
1693       return gpg_error (GPG_ERR_NOT_FOUND);
1694     }
1695
1696   /* NB: If one of the exact search modes below is used in a loop to
1697      walk over all keys (with the same fingerprint) the caching must
1698      have been disabled for the handle.  */
1699   if (!hd->no_caching
1700       && ndesc == 1
1701       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1702           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1703       && hd->keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1704       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, 20))
1705     {
1706       /* (DESCINDEX is already set).  */
1707       if (DBG_CLOCK)
1708         log_clock ("keydb_search leave (cached)");
1709       return 0;
1710     }
1711
1712   rc = -1;
1713   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1714          && hd->current >= 0 && hd->current < hd->used)
1715     {
1716       if (DBG_LOOKUP)
1717         log_debug ("%s: searching %s (resource %d of %d)\n",
1718                    __func__,
1719                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1720                    ? "keyring"
1721                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1722                       ? "keybox" : "unknown type"),
1723                    hd->current, hd->used);
1724
1725        switch (hd->active[hd->current].type)
1726         {
1727         case KEYDB_RESOURCE_TYPE_NONE:
1728           BUG(); /* we should never see it here */
1729           break;
1730         case KEYDB_RESOURCE_TYPE_KEYRING:
1731           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1732                                ndesc, descindex, 1);
1733           break;
1734         case KEYDB_RESOURCE_TYPE_KEYBOX:
1735           do
1736             rc = keybox_search (hd->active[hd->current].u.kb, desc,
1737                                 ndesc, KEYBOX_BLOBTYPE_PGP,
1738                                 descindex, &hd->skipped_long_blobs);
1739           while (rc == GPG_ERR_LEGACY_KEY);
1740           break;
1741         }
1742
1743       if (DBG_LOOKUP)
1744         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1745                    __func__,
1746                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1747                    ? "keyring"
1748                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1749                       ? "keybox" : "unknown type"),
1750                    hd->current, hd->used,
1751                    rc == -1 ? "EOF" : gpg_strerror (rc));
1752
1753       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1754         {
1755           /* EOF -> switch to next resource */
1756           hd->current++;
1757         }
1758       else if (!rc)
1759         hd->found = hd->current;
1760     }
1761   hd->is_reset = 0;
1762
1763   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1764         ? gpg_error (GPG_ERR_NOT_FOUND)
1765         : rc);
1766
1767   keyblock_cache_clear (hd);
1768   if (!hd->no_caching
1769       && !rc
1770       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1771                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1772       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
1773     {
1774       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1775       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, 20);
1776     }
1777
1778   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
1779       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
1780       && !already_in_cache)
1781     kid_not_found_insert (desc[0].u.kid);
1782
1783   if (DBG_CLOCK)
1784     log_clock (rc? "keydb_search leave (not found)"
1785                  : "keydb_search leave (found)");
1786   return rc;
1787 }
1788
1789
1790 gpg_error_t
1791 keydb_search_first (KEYDB_HANDLE hd)
1792 {
1793   gpg_error_t err;
1794   KEYDB_SEARCH_DESC desc;
1795
1796   err = keydb_search_reset (hd);
1797   if (err)
1798     return err;
1799
1800   memset (&desc, 0, sizeof desc);
1801   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1802   return keydb_search (hd, &desc, 1, NULL);
1803 }
1804
1805
1806 gpg_error_t
1807 keydb_search_next (KEYDB_HANDLE hd)
1808 {
1809   KEYDB_SEARCH_DESC desc;
1810
1811   memset (&desc, 0, sizeof desc);
1812   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1813   return keydb_search (hd, &desc, 1, NULL);
1814 }
1815
1816 gpg_error_t
1817 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1818 {
1819   KEYDB_SEARCH_DESC desc;
1820
1821   memset (&desc, 0, sizeof desc);
1822   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1823   desc.u.kid[0] = kid[0];
1824   desc.u.kid[1] = kid[1];
1825   return keydb_search (hd, &desc, 1, NULL);
1826 }
1827
1828 gpg_error_t
1829 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1830 {
1831   KEYDB_SEARCH_DESC desc;
1832
1833   memset (&desc, 0, sizeof desc);
1834   desc.mode = KEYDB_SEARCH_MODE_FPR;
1835   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1836   return keydb_search (hd, &desc, 1, NULL);
1837 }