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