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