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