g10: Don't leak memory if we fail to initialize a new database handle.
[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       iobuf_seek (keyblock_cache.iobuf, 0);
1130       err = parse_keyblock_image (keyblock_cache.iobuf,
1131                                   keyblock_cache.pk_no,
1132                                   keyblock_cache.uid_no,
1133                                   keyblock_cache.sigstatus,
1134                                   ret_kb);
1135       if (err)
1136         keyblock_cache_clear ();
1137       if (DBG_CLOCK)
1138         log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1139                       : "keydb_get_keyblock leave (cached)");
1140       return err;
1141     }
1142
1143   if (hd->found < 0 || hd->found >= hd->used)
1144     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1145
1146   switch (hd->active[hd->found].type)
1147     {
1148     case KEYDB_RESOURCE_TYPE_NONE:
1149       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1150       break;
1151     case KEYDB_RESOURCE_TYPE_KEYRING:
1152       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1153       break;
1154     case KEYDB_RESOURCE_TYPE_KEYBOX:
1155       {
1156         iobuf_t iobuf;
1157         u32 *sigstatus;
1158         int pk_no, uid_no;
1159
1160         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1161                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1162         if (!err)
1163           {
1164             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1165                                         ret_kb);
1166             if (!err && keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1167               {
1168                 keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1169                 keyblock_cache.sigstatus = sigstatus;
1170                 keyblock_cache.iobuf     = iobuf;
1171                 keyblock_cache.pk_no     = pk_no;
1172                 keyblock_cache.uid_no    = uid_no;
1173               }
1174             else
1175               {
1176                 xfree (sigstatus);
1177                 iobuf_close (iobuf);
1178               }
1179           }
1180       }
1181       break;
1182     }
1183
1184   if (keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1185     keyblock_cache_clear ();
1186
1187   if (DBG_CLOCK)
1188     log_clock (err? "keydb_get_keyblock leave (failed)"
1189                : "keydb_get_keyblock leave");
1190   return err;
1191 }
1192
1193
1194 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1195    only then stores a new iobuf object at R_IOBUF and a signature
1196    status vecotor at R_SIGSTATUS.  */
1197 static gpg_error_t
1198 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1199 {
1200   gpg_error_t err;
1201   iobuf_t iobuf;
1202   kbnode_t kbctx, node;
1203   u32 n_sigs;
1204   u32 *sigstatus;
1205
1206   *r_iobuf = NULL;
1207   if (r_sigstatus)
1208     *r_sigstatus = NULL;
1209
1210   /* Allocate a vector for the signature cache.  This is an array of
1211      u32 values with the first value giving the number of elements to
1212      follow and each element descriping the cache status of the
1213      signature.  */
1214   if (r_sigstatus)
1215     {
1216       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1217         if (node->pkt->pkttype == PKT_SIGNATURE)
1218           n_sigs++;
1219       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1220       if (!sigstatus)
1221         return gpg_error_from_syserror ();
1222     }
1223   else
1224     sigstatus = NULL;
1225
1226   iobuf = iobuf_temp ();
1227   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1228     {
1229       /* Make sure to use only packets valid on a keyblock.  */
1230       switch (node->pkt->pkttype)
1231         {
1232         case PKT_PUBLIC_KEY:
1233         case PKT_PUBLIC_SUBKEY:
1234         case PKT_SIGNATURE:
1235         case PKT_USER_ID:
1236         case PKT_ATTRIBUTE:
1237           /* Note that we don't want the ring trust packets.  They are
1238              not useful. */
1239           break;
1240         default:
1241           continue;
1242         }
1243
1244       err = build_packet (iobuf, node->pkt);
1245       if (err)
1246         {
1247           iobuf_close (iobuf);
1248           return err;
1249         }
1250
1251       /* Build signature status vector.  */
1252       if (node->pkt->pkttype == PKT_SIGNATURE)
1253         {
1254           PKT_signature *sig = node->pkt->pkt.signature;
1255
1256           n_sigs++;
1257           /* Fixme: Detect the "missing key" status.  */
1258           if (sig->flags.checked && sigstatus)
1259             {
1260               if (sig->flags.valid)
1261                 {
1262                   if (!sig->expiredate)
1263                     sigstatus[n_sigs] = 0xffffffff;
1264                   else if (sig->expiredate < 0x1000000)
1265                     sigstatus[n_sigs] = 0x10000000;
1266                   else
1267                     sigstatus[n_sigs] = sig->expiredate;
1268                 }
1269               else
1270                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1271             }
1272         }
1273     }
1274   if (sigstatus)
1275     sigstatus[0] = n_sigs;
1276
1277   *r_iobuf = iobuf;
1278   if (r_sigstatus)
1279     *r_sigstatus = sigstatus;
1280   return 0;
1281 }
1282
1283
1284 gpg_error_t
1285 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1286 {
1287   gpg_error_t err;
1288
1289   if (!hd)
1290     return gpg_error (GPG_ERR_INV_ARG);
1291
1292   kid_not_found_flush ();
1293   keyblock_cache_clear ();
1294
1295   if (hd->found < 0 || hd->found >= hd->used)
1296     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1297
1298   if (opt.dry_run)
1299     return 0;
1300
1301   err = lock_all (hd);
1302   if (err)
1303     return err;
1304
1305   switch (hd->active[hd->found].type)
1306     {
1307     case KEYDB_RESOURCE_TYPE_NONE:
1308       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1309       break;
1310     case KEYDB_RESOURCE_TYPE_KEYRING:
1311       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1312       break;
1313     case KEYDB_RESOURCE_TYPE_KEYBOX:
1314       {
1315         iobuf_t iobuf;
1316
1317         err = build_keyblock_image (kb, &iobuf, NULL);
1318         if (!err)
1319           {
1320             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1321                                           iobuf_get_temp_buffer (iobuf),
1322                                           iobuf_get_temp_length (iobuf));
1323             iobuf_close (iobuf);
1324           }
1325       }
1326       break;
1327     }
1328
1329   unlock_all (hd);
1330   return err;
1331 }
1332
1333
1334 gpg_error_t
1335 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1336 {
1337   gpg_error_t err;
1338   int idx;
1339
1340   if (!hd)
1341     return gpg_error (GPG_ERR_INV_ARG);
1342
1343   kid_not_found_flush ();
1344   keyblock_cache_clear ();
1345
1346   if (opt.dry_run)
1347     return 0;
1348
1349   if (hd->found >= 0 && hd->found < hd->used)
1350     idx = hd->found;
1351   else if (hd->current >= 0 && hd->current < hd->used)
1352     idx = hd->current;
1353   else
1354     return gpg_error (GPG_ERR_GENERAL);
1355
1356   err = lock_all (hd);
1357   if (err)
1358     return err;
1359
1360   switch (hd->active[idx].type)
1361     {
1362     case KEYDB_RESOURCE_TYPE_NONE:
1363       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1364       break;
1365     case KEYDB_RESOURCE_TYPE_KEYRING:
1366       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1367       break;
1368     case KEYDB_RESOURCE_TYPE_KEYBOX:
1369       { /* We need to turn our kbnode_t list of packets into a proper
1370            keyblock first.  This is required by the OpenPGP key parser
1371            included in the keybox code.  Eventually we can change this
1372            kludge to have the caller pass the image.  */
1373         iobuf_t iobuf;
1374         u32 *sigstatus;
1375
1376         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1377         if (!err)
1378           {
1379             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1380                                           iobuf_get_temp_buffer (iobuf),
1381                                           iobuf_get_temp_length (iobuf),
1382                                           sigstatus);
1383             xfree (sigstatus);
1384             iobuf_close (iobuf);
1385           }
1386       }
1387       break;
1388     }
1389
1390   unlock_all (hd);
1391   return err;
1392 }
1393
1394
1395 gpg_error_t
1396 keydb_delete_keyblock (KEYDB_HANDLE hd)
1397 {
1398   gpg_error_t rc;
1399
1400   if (!hd)
1401     return gpg_error (GPG_ERR_INV_ARG);
1402
1403   kid_not_found_flush ();
1404   keyblock_cache_clear ();
1405
1406   if (hd->found < 0 || hd->found >= hd->used)
1407     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1408
1409   if (opt.dry_run)
1410     return 0;
1411
1412   rc = lock_all (hd);
1413   if (rc)
1414     return rc;
1415
1416   switch (hd->active[hd->found].type)
1417     {
1418     case KEYDB_RESOURCE_TYPE_NONE:
1419       rc = gpg_error (GPG_ERR_GENERAL);
1420       break;
1421     case KEYDB_RESOURCE_TYPE_KEYRING:
1422       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1423       break;
1424     case KEYDB_RESOURCE_TYPE_KEYBOX:
1425       rc = keybox_delete (hd->active[hd->found].u.kb);
1426       break;
1427     }
1428
1429   unlock_all (hd);
1430   return rc;
1431 }
1432
1433
1434 \f
1435 gpg_error_t
1436 keydb_locate_writable (KEYDB_HANDLE hd)
1437 {
1438   gpg_error_t rc;
1439
1440   if (!hd)
1441     return GPG_ERR_INV_ARG;
1442
1443   rc = keydb_search_reset (hd); /* this does reset hd->current */
1444   if (rc)
1445     return rc;
1446
1447   /* If we have a primary set, try that one first */
1448   if (primary_keyring)
1449     {
1450       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1451         {
1452           if(hd->active[hd->current].token==primary_keyring)
1453             {
1454               if(keyring_is_writable (hd->active[hd->current].token))
1455                 return 0;
1456               else
1457                 break;
1458             }
1459         }
1460
1461       rc = keydb_search_reset (hd); /* this does reset hd->current */
1462       if (rc)
1463         return rc;
1464     }
1465
1466   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1467     {
1468       switch (hd->active[hd->current].type)
1469         {
1470         case KEYDB_RESOURCE_TYPE_NONE:
1471           BUG();
1472           break;
1473         case KEYDB_RESOURCE_TYPE_KEYRING:
1474           if (keyring_is_writable (hd->active[hd->current].token))
1475             return 0; /* found (hd->current is set to it) */
1476           break;
1477         case KEYDB_RESOURCE_TYPE_KEYBOX:
1478           if (keybox_is_writable (hd->active[hd->current].token))
1479             return 0; /* found (hd->current is set to it) */
1480           break;
1481         }
1482     }
1483
1484   return gpg_error (GPG_ERR_NOT_FOUND);
1485 }
1486
1487 void
1488 keydb_rebuild_caches (int noisy)
1489 {
1490   int i, rc;
1491
1492   keyblock_cache_clear ();
1493
1494   for (i=0; i < used_resources; i++)
1495     {
1496       if (!keyring_is_writable (all_resources[i].token))
1497         continue;
1498       switch (all_resources[i].type)
1499         {
1500         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1501           break;
1502         case KEYDB_RESOURCE_TYPE_KEYRING:
1503           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1504           if (rc)
1505             log_error (_("failed to rebuild keyring cache: %s\n"),
1506                        gpg_strerror (rc));
1507           break;
1508         case KEYDB_RESOURCE_TYPE_KEYBOX:
1509           /* N/A.  */
1510           break;
1511         }
1512     }
1513 }
1514
1515
1516 unsigned long
1517 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1518 {
1519   return hd ? hd->skipped_long_blobs : 0;
1520 }
1521
1522
1523 gpg_error_t
1524 keydb_search_reset (KEYDB_HANDLE hd)
1525 {
1526   gpg_error_t rc = 0;
1527   int i;
1528
1529   if (!hd)
1530     return gpg_error (GPG_ERR_INV_ARG);
1531
1532   keyblock_cache_clear ();
1533
1534   if (DBG_CLOCK)
1535     log_clock ("keydb_search_reset");
1536
1537   if (DBG_CACHE)
1538     log_debug ("keydb_search: reset  (hd=%p)", hd);
1539
1540   hd->skipped_long_blobs = 0;
1541   hd->current = 0;
1542   hd->found = -1;
1543   /* Now reset all resources.  */
1544   for (i=0; !rc && i < hd->used; i++)
1545     {
1546       switch (hd->active[i].type)
1547         {
1548         case KEYDB_RESOURCE_TYPE_NONE:
1549           break;
1550         case KEYDB_RESOURCE_TYPE_KEYRING:
1551           rc = keyring_search_reset (hd->active[i].u.kr);
1552           break;
1553         case KEYDB_RESOURCE_TYPE_KEYBOX:
1554           rc = keybox_search_reset (hd->active[i].u.kb);
1555           break;
1556         }
1557     }
1558   hd->is_reset = 1;
1559   return rc;
1560 }
1561
1562
1563 static void
1564 dump_search_desc (KEYDB_HANDLE hd, const char *text,
1565                   KEYDB_SEARCH_DESC *desc, size_t ndesc)
1566 {
1567   int n;
1568   const char *s;
1569
1570   for (n=0; n < ndesc; n++)
1571     {
1572       switch (desc[n].mode)
1573         {
1574         case KEYDB_SEARCH_MODE_NONE:      s = "none";      break;
1575         case KEYDB_SEARCH_MODE_EXACT:     s = "exact";     break;
1576         case KEYDB_SEARCH_MODE_SUBSTR:    s = "substr";    break;
1577         case KEYDB_SEARCH_MODE_MAIL:      s = "mail";      break;
1578         case KEYDB_SEARCH_MODE_MAILSUB:   s = "mailsub";   break;
1579         case KEYDB_SEARCH_MODE_MAILEND:   s = "mailend";   break;
1580         case KEYDB_SEARCH_MODE_WORDS:     s = "words";     break;
1581         case KEYDB_SEARCH_MODE_SHORT_KID: s = "short_kid"; break;
1582         case KEYDB_SEARCH_MODE_LONG_KID:  s = "long_kid";  break;
1583         case KEYDB_SEARCH_MODE_FPR16:     s = "fpr16";     break;
1584         case KEYDB_SEARCH_MODE_FPR20:     s = "fpr20";     break;
1585         case KEYDB_SEARCH_MODE_FPR:       s = "fpr";       break;
1586         case KEYDB_SEARCH_MODE_ISSUER:    s = "issuer";    break;
1587         case KEYDB_SEARCH_MODE_ISSUER_SN: s = "issuer_sn"; break;
1588         case KEYDB_SEARCH_MODE_SN:        s = "sn";        break;
1589         case KEYDB_SEARCH_MODE_SUBJECT:   s = "subject";   break;
1590         case KEYDB_SEARCH_MODE_KEYGRIP:   s = "keygrip";   break;
1591         case KEYDB_SEARCH_MODE_FIRST:     s = "first";     break;
1592         case KEYDB_SEARCH_MODE_NEXT:      s = "next";      break;
1593         default:                          s = "?";         break;
1594         }
1595       if (!n)
1596         log_debug ("%s: mode=%s  (hd=%p)", text, s, hd);
1597       else
1598         log_debug ("%*s  mode=%s", (int)strlen (text), "", s);
1599       if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
1600         log_printf (" %08lX%08lX", (unsigned long)desc[n].u.kid[0],
1601                     (unsigned long)desc[n].u.kid[1]);
1602       else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1603         log_printf (" %08lX", (unsigned long)desc[n].u.kid[1]);
1604       else if (desc[n].mode == KEYDB_SEARCH_MODE_SUBSTR)
1605         log_printf (" '%s'", desc[n].u.name);
1606     }
1607 }
1608
1609
1610 gpg_error_t
1611 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1612               size_t ndesc, size_t *descindex)
1613 {
1614   gpg_error_t rc;
1615   int was_reset = hd->is_reset;
1616   /* If an entry is already in the cache, then don't add it again.  */
1617   int already_in_cache = 0;
1618
1619   if (descindex)
1620     *descindex = 0; /* Make sure it is always set on return.  */
1621
1622   if (!hd)
1623     return gpg_error (GPG_ERR_INV_ARG);
1624
1625   if (DBG_CLOCK)
1626     log_clock ("keydb_search enter");
1627
1628   if (DBG_CACHE)
1629     dump_search_desc (hd, "keydb_search", desc, ndesc);
1630
1631
1632   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1633       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1634     {
1635       if (DBG_CLOCK)
1636         log_clock ("keydb_search leave (not found, cached)");
1637       return gpg_error (GPG_ERR_NOT_FOUND);
1638     }
1639
1640   /* NB: If one of the exact search modes below is used in a loop to
1641      walk over all keys (with the same fingerprint) the caching must
1642      have been disabled for the handle.  */
1643   if (!hd->no_caching
1644       && ndesc == 1
1645       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1646           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1647       && keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1648       && !memcmp (keyblock_cache.fpr, desc[0].u.fpr, 20))
1649     {
1650       /* (DESCINDEX is already set).  */
1651       if (DBG_CLOCK)
1652         log_clock ("keydb_search leave (cached)");
1653       return 0;
1654     }
1655
1656   rc = -1;
1657   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1658          && hd->current >= 0 && hd->current < hd->used)
1659     {
1660       switch (hd->active[hd->current].type)
1661         {
1662         case KEYDB_RESOURCE_TYPE_NONE:
1663           BUG(); /* we should never see it here */
1664           break;
1665         case KEYDB_RESOURCE_TYPE_KEYRING:
1666           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1667                                ndesc, descindex);
1668           break;
1669         case KEYDB_RESOURCE_TYPE_KEYBOX:
1670           rc = keybox_search (hd->active[hd->current].u.kb, desc,
1671                               ndesc, KEYBOX_BLOBTYPE_PGP,
1672                               descindex, &hd->skipped_long_blobs);
1673           break;
1674         }
1675       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1676         {
1677           /* EOF -> switch to next resource */
1678           hd->current++;
1679         }
1680       else if (!rc)
1681         hd->found = hd->current;
1682     }
1683   hd->is_reset = 0;
1684
1685   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1686         ? gpg_error (GPG_ERR_NOT_FOUND)
1687         : rc);
1688
1689   keyblock_cache_clear ();
1690   if (!hd->no_caching
1691       && !rc
1692       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1693                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR))
1694     {
1695       keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1696       memcpy (keyblock_cache.fpr, desc[0].u.fpr, 20);
1697     }
1698
1699   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
1700       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
1701       && !already_in_cache)
1702     kid_not_found_insert (desc[0].u.kid);
1703
1704   if (DBG_CLOCK)
1705     log_clock (rc? "keydb_search leave (not found)"
1706                  : "keydb_search leave (found)");
1707   return rc;
1708 }
1709
1710
1711 gpg_error_t
1712 keydb_search_first (KEYDB_HANDLE hd)
1713 {
1714   gpg_error_t err;
1715   KEYDB_SEARCH_DESC desc;
1716
1717   err = keydb_search_reset (hd);
1718   if (err)
1719     return err;
1720
1721   memset (&desc, 0, sizeof desc);
1722   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1723   err = keydb_search (hd, &desc, 1, NULL);
1724   if (gpg_err_code (err) == GPG_ERR_LEGACY_KEY)
1725     err = keydb_search_next (hd);
1726   return err;
1727 }
1728
1729
1730 gpg_error_t
1731 keydb_search_next (KEYDB_HANDLE hd)
1732 {
1733   gpg_error_t err;
1734   KEYDB_SEARCH_DESC desc;
1735
1736   do
1737     {
1738       memset (&desc, 0, sizeof desc);
1739       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1740       err = keydb_search (hd, &desc, 1, NULL);
1741     }
1742   while (gpg_err_code (err) == GPG_ERR_LEGACY_KEY);
1743
1744   return err;
1745 }
1746
1747 gpg_error_t
1748 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1749 {
1750   KEYDB_SEARCH_DESC desc;
1751
1752   memset (&desc, 0, sizeof desc);
1753   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1754   desc.u.kid[0] = kid[0];
1755   desc.u.kid[1] = kid[1];
1756   return keydb_search (hd, &desc, 1, NULL);
1757 }
1758
1759 gpg_error_t
1760 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1761 {
1762   gpg_error_t err;
1763   KEYDB_SEARCH_DESC desc;
1764
1765   memset (&desc, 0, sizeof desc);
1766   desc.mode = KEYDB_SEARCH_MODE_FPR;
1767   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1768   do
1769     {
1770       err = keydb_search (hd, &desc, 1, NULL);
1771     }
1772   while (gpg_err_code (err) == GPG_ERR_LEGACY_KEY);
1773
1774   return err;
1775 }