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