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