gpg: Fix duplicate key import due to legacy key in keyring.
[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 rc = 0;
438   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
439   void *token;
440
441   /* Create the resource if it is the first registered one.  */
442   create = (!read_only && !any_registered);
443
444   /* Do we have an URL?
445    *    gnupg-ring:filename  := this is a plain keyring.
446    *    gnupg-kbx:filename   := this is a keybox file.
447    *    filename := See what is is, but create as plain keyring.
448    */
449   if (strlen (resname) > 11 && !strncmp( resname, "gnupg-ring:", 11) )
450     {
451       rt = KEYDB_RESOURCE_TYPE_KEYRING;
452       resname += 11;
453     }
454   else if (strlen (resname) > 10 && !strncmp (resname, "gnupg-kbx:", 10) )
455     {
456       rt = KEYDB_RESOURCE_TYPE_KEYBOX;
457       resname += 10;
458     }
459 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
460   else if (strchr (resname, ':'))
461     {
462       log_error ("invalid key resource URL '%s'\n", url );
463       rc = gpg_error (GPG_ERR_GENERAL);
464       goto leave;
465     }
466 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
467
468   if (*resname != DIRSEP_C
469 #ifdef HAVE_W32_SYSTEM
470       && *resname != '/'  /* Fixme: does not handle drive letters.  */
471 #endif
472         )
473     {
474       /* Do tilde expansion etc. */
475       if (strchr (resname, DIRSEP_C)
476 #ifdef HAVE_W32_SYSTEM
477           || strchr (resname, '/')  /* Windows also accepts this.  */
478 #endif
479           )
480         filename = make_filename (resname, NULL);
481       else
482         filename = make_filename (opt.homedir, resname, NULL);
483     }
484   else
485     filename = xstrdup (resname);
486
487   /* See whether we can determine the filetype.  */
488   if (rt == KEYDB_RESOURCE_TYPE_NONE)
489     {
490       int found, openpgp_flag;
491       int pass = 0;
492       size_t filenamelen;
493
494     check_again:
495       filenamelen = strlen (filename);
496       rt = rt_from_file (filename, &found, &openpgp_flag);
497       if (found)
498         {
499           /* The file exists and we have the resource type in RT.
500
501              Now let us check whether in addition to the "pubring.gpg"
502              a "pubring.kbx with openpgp keys exists.  This is so that
503              GPG 2.1 will use an existing "pubring.kbx" by default iff
504              that file has been created or used by 2.1.  This check is
505              needed because after creation or use of the kbx file with
506              2.1 an older version of gpg may have created a new
507              pubring.gpg for its own use.  */
508           if (!pass && is_default && rt == KEYDB_RESOURCE_TYPE_KEYRING
509               && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
510             {
511               strcpy (filename+filenamelen-4, ".kbx");
512               if ((rt_from_file (filename, &found, &openpgp_flag)
513                    == KEYDB_RESOURCE_TYPE_KEYBOX) && found && openpgp_flag)
514                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
515               else /* Restore filename */
516                 strcpy (filename+filenamelen-4, ".gpg");
517             }
518         }
519       else if (!pass
520                && is_default && create
521                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
522         {
523           /* The file does not exist, the default resource has been
524              requested, the file shall be created, and the file has a
525              ".gpg" suffix.  Change the suffix to ".kbx" and try once
526              more.  This way we achieve that we open an existing
527              ".gpg" keyring, but create a new keybox file with an
528              ".kbx" suffix.  */
529           strcpy (filename+filenamelen-4, ".kbx");
530           pass++;
531           goto check_again;
532         }
533       else /* No file yet: create keybox. */
534         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
535     }
536
537   switch (rt)
538     {
539     case KEYDB_RESOURCE_TYPE_NONE:
540       log_error ("unknown type of key resource '%s'\n", url );
541       rc = gpg_error (GPG_ERR_GENERAL);
542       goto leave;
543
544     case KEYDB_RESOURCE_TYPE_KEYRING:
545       rc = maybe_create_keyring_or_box (filename, 0, create);
546       if (rc)
547         goto leave;
548
549       if (keyring_register_filename (filename, read_only, &token))
550         {
551           if (used_resources >= MAX_KEYDB_RESOURCES)
552             rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
553           else
554             {
555               if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
556                 primary_keyring = token;
557               all_resources[used_resources].type = rt;
558               all_resources[used_resources].u.kr = NULL; /* Not used here */
559               all_resources[used_resources].token = token;
560               used_resources++;
561             }
562         }
563       else
564         {
565           /* This keyring was already registered, so ignore it.
566              However, we can still mark it as primary even if it was
567              already registered.  */
568           if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
569             primary_keyring = token;
570         }
571       break;
572
573     case KEYDB_RESOURCE_TYPE_KEYBOX:
574       {
575         rc = maybe_create_keyring_or_box (filename, 1, create);
576         if (rc)
577           goto leave;
578
579         /* FIXME: How do we register a read-only keybox?  */
580         token = keybox_register_file (filename, 0);
581         if (token)
582           {
583             if (used_resources >= MAX_KEYDB_RESOURCES)
584               rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
585             else
586               {
587                 /* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
588                 /*   primary_keyring = token; */
589                 all_resources[used_resources].type = rt;
590                 all_resources[used_resources].u.kb = NULL; /* Not used here */
591                 all_resources[used_resources].token = token;
592
593                 /* FIXME: Do a compress run if needed and no other
594                    user is currently using the keybox. */
595
596                 used_resources++;
597               }
598           }
599         else
600           {
601             /* Already registered.  We will mark it as the primary key
602                if requested.  */
603             /* FIXME: How to do that?  Change the keybox interface?  */
604             /* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
605             /*   primary_keyring = token; */
606           }
607       }
608       break;
609
610       default:
611         log_error ("resource type of '%s' not supported\n", url);
612         rc = gpg_error (GPG_ERR_GENERAL);
613         goto leave;
614     }
615
616   /* fixme: check directory permissions and print a warning */
617
618  leave:
619   if (rc)
620     log_error (_("keyblock resource '%s': %s\n"), filename, gpg_strerror (rc));
621   else
622     any_registered = 1;
623   xfree (filename);
624   return rc;
625 }
626
627
628 void
629 keydb_dump_stats (void)
630 {
631   if (kid_found_table_count)
632     log_info ("keydb: kid_not_found_table: total: %u\n", kid_found_table_count);
633 }
634
635
636 KEYDB_HANDLE
637 keydb_new (void)
638 {
639   KEYDB_HANDLE hd;
640   int i, j;
641
642   if (DBG_CLOCK)
643     log_clock ("keydb_new");
644
645   hd = xmalloc_clear (sizeof *hd);
646   hd->found = -1;
647   hd->saved_found = -1;
648
649   assert (used_resources <= MAX_KEYDB_RESOURCES);
650   for (i=j=0; i < used_resources; i++)
651     {
652       switch (all_resources[i].type)
653         {
654         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
655           break;
656         case KEYDB_RESOURCE_TYPE_KEYRING:
657           hd->active[j].type   = all_resources[i].type;
658           hd->active[j].token  = all_resources[i].token;
659           hd->active[j].u.kr = keyring_new (all_resources[i].token);
660           if (!hd->active[j].u.kr) {
661             xfree (hd);
662             return NULL; /* fixme: release all previously allocated handles*/
663           }
664           j++;
665           break;
666         case KEYDB_RESOURCE_TYPE_KEYBOX:
667           hd->active[j].type   = all_resources[i].type;
668           hd->active[j].token  = all_resources[i].token;
669           hd->active[j].u.kb   = keybox_new_openpgp (all_resources[i].token, 0);
670           if (!hd->active[j].u.kb)
671             {
672               xfree (hd);
673               return NULL; /* fixme: release all previously allocated handles*/
674             }
675           j++;
676           break;
677         }
678     }
679   hd->used = j;
680
681   active_handles++;
682   return hd;
683 }
684
685
686 void
687 keydb_release (KEYDB_HANDLE hd)
688 {
689   int i;
690
691   if (!hd)
692     return;
693   assert (active_handles > 0);
694   active_handles--;
695
696   unlock_all (hd);
697   for (i=0; i < hd->used; i++)
698     {
699       switch (hd->active[i].type)
700         {
701         case KEYDB_RESOURCE_TYPE_NONE:
702           break;
703         case KEYDB_RESOURCE_TYPE_KEYRING:
704           keyring_release (hd->active[i].u.kr);
705           break;
706         case KEYDB_RESOURCE_TYPE_KEYBOX:
707           keybox_release (hd->active[i].u.kb);
708           break;
709         }
710     }
711
712   xfree (hd);
713 }
714
715
716 /* Set a flag on handle to not use cached results.  This is required
717    for updating a keyring and for key listins.  Fixme: Using a new
718    parameter for keydb_new might be a better solution.  */
719 void
720 keydb_disable_caching (KEYDB_HANDLE hd)
721 {
722   if (hd)
723     hd->no_caching = 1;
724 }
725
726
727 /*
728  * Return the name of the current resource.  This is function first
729  * looks for the last found found, then for the current search
730  * position, and last returns the first available resource.  The
731  * returned string is only valid as long as the handle exists.  This
732  * function does only return NULL if no handle is specified, in all
733  * other error cases an empty string is returned.
734  */
735 const char *
736 keydb_get_resource_name (KEYDB_HANDLE hd)
737 {
738   int idx;
739   const char *s = NULL;
740
741   if (!hd)
742     return NULL;
743
744   if ( hd->found >= 0 && hd->found < hd->used)
745     idx = hd->found;
746   else if ( hd->current >= 0 && hd->current < hd->used)
747     idx = hd->current;
748   else
749     idx = 0;
750
751   switch (hd->active[idx].type)
752     {
753     case KEYDB_RESOURCE_TYPE_NONE:
754       s = NULL;
755       break;
756     case KEYDB_RESOURCE_TYPE_KEYRING:
757       s = keyring_get_resource_name (hd->active[idx].u.kr);
758       break;
759     case KEYDB_RESOURCE_TYPE_KEYBOX:
760       s = keybox_get_resource_name (hd->active[idx].u.kb);
761       break;
762     }
763
764   return s? s: "";
765 }
766
767
768
769 static int
770 lock_all (KEYDB_HANDLE hd)
771 {
772   int i, rc = 0;
773
774   /* Fixme: This locking scheme may lead to a deadlock if the resources
775      are not added in the same order by all processes.  We are
776      currently only allowing one resource so it is not a problem.
777      [Oops: Who claimed the latter]
778
779      To fix this we need to use a lock file to protect lock_all.  */
780
781   for (i=0; !rc && i < hd->used; i++)
782     {
783       switch (hd->active[i].type)
784         {
785         case KEYDB_RESOURCE_TYPE_NONE:
786           break;
787         case KEYDB_RESOURCE_TYPE_KEYRING:
788           rc = keyring_lock (hd->active[i].u.kr, 1);
789           break;
790         case KEYDB_RESOURCE_TYPE_KEYBOX:
791           rc = keybox_lock (hd->active[i].u.kb, 1);
792           break;
793         }
794     }
795
796   if (rc)
797     {
798       /* Revert the already taken locks.  */
799       for (i--; i >= 0; i--)
800         {
801           switch (hd->active[i].type)
802             {
803             case KEYDB_RESOURCE_TYPE_NONE:
804               break;
805             case KEYDB_RESOURCE_TYPE_KEYRING:
806               keyring_lock (hd->active[i].u.kr, 0);
807               break;
808             case KEYDB_RESOURCE_TYPE_KEYBOX:
809               rc = keybox_lock (hd->active[i].u.kb, 0);
810               break;
811             }
812         }
813     }
814   else
815     hd->locked = 1;
816
817   return rc;
818 }
819
820
821 static void
822 unlock_all (KEYDB_HANDLE hd)
823 {
824   int i;
825
826   if (!hd->locked)
827     return;
828
829   for (i=hd->used-1; i >= 0; i--)
830     {
831       switch (hd->active[i].type)
832         {
833         case KEYDB_RESOURCE_TYPE_NONE:
834           break;
835         case KEYDB_RESOURCE_TYPE_KEYRING:
836           keyring_lock (hd->active[i].u.kr, 0);
837           break;
838         case KEYDB_RESOURCE_TYPE_KEYBOX:
839           keybox_lock (hd->active[i].u.kb, 0);
840           break;
841         }
842     }
843   hd->locked = 0;
844 }
845
846
847 \f
848 /* Push the last found state if any.  */
849 void
850 keydb_push_found_state (KEYDB_HANDLE hd)
851 {
852   if (!hd)
853     return;
854
855   if (hd->found < 0 || hd->found >= hd->used)
856     {
857       hd->saved_found = -1;
858       return;
859     }
860
861   switch (hd->active[hd->found].type)
862     {
863     case KEYDB_RESOURCE_TYPE_NONE:
864       break;
865     case KEYDB_RESOURCE_TYPE_KEYRING:
866       keyring_push_found_state (hd->active[hd->found].u.kr);
867       break;
868     case KEYDB_RESOURCE_TYPE_KEYBOX:
869       keybox_push_found_state (hd->active[hd->found].u.kb);
870       break;
871     }
872
873   hd->saved_found = hd->found;
874   hd->found = -1;
875 }
876
877
878 /* Pop the last found state.  */
879 void
880 keydb_pop_found_state (KEYDB_HANDLE hd)
881 {
882   if (!hd)
883     return;
884
885   hd->found = hd->saved_found;
886   hd->saved_found = -1;
887   if (hd->found < 0 || hd->found >= hd->used)
888     return;
889
890   switch (hd->active[hd->found].type)
891     {
892     case KEYDB_RESOURCE_TYPE_NONE:
893       break;
894     case KEYDB_RESOURCE_TYPE_KEYRING:
895       keyring_pop_found_state (hd->active[hd->found].u.kr);
896       break;
897     case KEYDB_RESOURCE_TYPE_KEYBOX:
898       keybox_pop_found_state (hd->active[hd->found].u.kb);
899       break;
900     }
901 }
902
903
904 \f
905 static gpg_error_t
906 parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
907                       const u32 *sigstatus, kbnode_t *r_keyblock)
908 {
909   gpg_error_t err;
910   PACKET *pkt;
911   kbnode_t keyblock = NULL;
912   kbnode_t node, *tail;
913   int in_cert, save_mode;
914   u32 n_sigs;
915   int pk_count, uid_count;
916
917   *r_keyblock = NULL;
918
919   pkt = xtrymalloc (sizeof *pkt);
920   if (!pkt)
921     return gpg_error_from_syserror ();
922   init_packet (pkt);
923   save_mode = set_packet_list_mode (0);
924   in_cert = 0;
925   n_sigs = 0;
926   tail = NULL;
927   pk_count = uid_count = 0;
928   while ((err = parse_packet (iobuf, pkt)) != -1)
929     {
930       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
931         {
932           free_packet (pkt);
933           init_packet (pkt);
934           continue;
935         }
936       if (err)
937         {
938           log_error ("parse_keyblock_image: read error: %s\n",
939                      gpg_strerror (err));
940           err = gpg_error (GPG_ERR_INV_KEYRING);
941           break;
942         }
943
944       /* Filter allowed packets.  */
945       switch (pkt->pkttype)
946         {
947         case PKT_PUBLIC_KEY:
948         case PKT_PUBLIC_SUBKEY:
949         case PKT_SECRET_KEY:
950         case PKT_SECRET_SUBKEY:
951         case PKT_USER_ID:
952         case PKT_ATTRIBUTE:
953         case PKT_SIGNATURE:
954           break; /* Allowed per RFC.  */
955
956         default:
957           /* Note that can't allow ring trust packets here and some of
958              the other GPG specific packets don't make sense either.  */
959           log_error ("skipped packet of type %d in keybox\n",
960                      (int)pkt->pkttype);
961           free_packet(pkt);
962           init_packet(pkt);
963           continue;
964         }
965
966       /* Other sanity checks.  */
967       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
968         {
969           log_error ("parse_keyblock_image: first packet in a keybox blob "
970                      "is not a public key packet\n");
971           err = gpg_error (GPG_ERR_INV_KEYRING);
972           break;
973         }
974       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
975                       || pkt->pkttype == PKT_SECRET_KEY))
976         {
977           log_error ("parse_keyblock_image: "
978                      "multiple keyblocks in a keybox blob\n");
979           err = gpg_error (GPG_ERR_INV_KEYRING);
980           break;
981         }
982       in_cert = 1;
983
984       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
985         {
986           PKT_signature *sig = pkt->pkt.signature;
987
988           n_sigs++;
989           if (n_sigs > sigstatus[0])
990             {
991               log_error ("parse_keyblock_image: "
992                          "more signatures than found in the meta data\n");
993               err = gpg_error (GPG_ERR_INV_KEYRING);
994               break;
995
996             }
997           if (sigstatus[n_sigs])
998             {
999               sig->flags.checked = 1;
1000               if (sigstatus[n_sigs] == 1 )
1001                 ; /* missing key */
1002               else if (sigstatus[n_sigs] == 2 )
1003                 ; /* bad signature */
1004               else if (sigstatus[n_sigs] < 0x10000000)
1005                 ; /* bad flag */
1006               else
1007                 {
1008                   sig->flags.valid = 1;
1009                   /* Fixme: Shall we set the expired flag here?  */
1010                 }
1011             }
1012         }
1013
1014       node = new_kbnode (pkt);
1015
1016       switch (pkt->pkttype)
1017         {
1018         case PKT_PUBLIC_KEY:
1019         case PKT_PUBLIC_SUBKEY:
1020         case PKT_SECRET_KEY:
1021         case PKT_SECRET_SUBKEY:
1022           if (++pk_count == pk_no)
1023             node->flag |= 1;
1024           break;
1025
1026         case PKT_USER_ID:
1027           if (++uid_count == uid_no)
1028             node->flag |= 2;
1029           break;
1030
1031         default:
1032           break;
1033         }
1034
1035       if (!keyblock)
1036         keyblock = node;
1037       else
1038         *tail = node;
1039       tail = &node->next;
1040       pkt = xtrymalloc (sizeof *pkt);
1041       if (!pkt)
1042         {
1043           err = gpg_error_from_syserror ();
1044           break;
1045         }
1046       init_packet (pkt);
1047     }
1048   set_packet_list_mode (save_mode);
1049
1050   if (err == -1 && keyblock)
1051     err = 0; /* Got the entire keyblock.  */
1052
1053   if (!err && sigstatus && n_sigs != sigstatus[0])
1054     {
1055       log_error ("parse_keyblock_image: signature count does not match\n");
1056       err = gpg_error (GPG_ERR_INV_KEYRING);
1057     }
1058
1059   if (err)
1060     release_kbnode (keyblock);
1061   else
1062     *r_keyblock = keyblock;
1063   free_packet (pkt);
1064   xfree (pkt);
1065   return err;
1066 }
1067
1068
1069 /*
1070  * Return the last found keyring.  Caller must free it.
1071  * The returned keyblock has the kbode flag bit 0 set for the node with
1072  * the public key used to locate the keyblock or flag bit 1 set for
1073  * the user ID node.
1074  */
1075 gpg_error_t
1076 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
1077 {
1078   gpg_error_t err = 0;
1079
1080   *ret_kb = NULL;
1081
1082   if (!hd)
1083     return gpg_error (GPG_ERR_INV_ARG);
1084
1085   if (DBG_CLOCK)
1086     log_clock ("keydb_get_keybock enter");
1087
1088   if (keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
1089     {
1090       iobuf_seek (keyblock_cache.iobuf, 0);
1091       err = parse_keyblock_image (keyblock_cache.iobuf,
1092                                   keyblock_cache.pk_no,
1093                                   keyblock_cache.uid_no,
1094                                   keyblock_cache.sigstatus,
1095                                   ret_kb);
1096       if (err)
1097         keyblock_cache_clear ();
1098       if (DBG_CLOCK)
1099         log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1100                       : "keydb_get_keyblock leave (cached)");
1101       return err;
1102     }
1103
1104   if (hd->found < 0 || hd->found >= hd->used)
1105     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1106
1107   switch (hd->active[hd->found].type)
1108     {
1109     case KEYDB_RESOURCE_TYPE_NONE:
1110       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1111       break;
1112     case KEYDB_RESOURCE_TYPE_KEYRING:
1113       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1114       break;
1115     case KEYDB_RESOURCE_TYPE_KEYBOX:
1116       {
1117         iobuf_t iobuf;
1118         u32 *sigstatus;
1119         int pk_no, uid_no;
1120
1121         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1122                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1123         if (!err)
1124           {
1125             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1126                                         ret_kb);
1127             if (!err && keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1128               {
1129                 keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1130                 keyblock_cache.sigstatus = sigstatus;
1131                 keyblock_cache.iobuf     = iobuf;
1132                 keyblock_cache.pk_no     = pk_no;
1133                 keyblock_cache.uid_no    = uid_no;
1134               }
1135             else
1136               {
1137                 xfree (sigstatus);
1138                 iobuf_close (iobuf);
1139               }
1140           }
1141       }
1142       break;
1143     }
1144
1145   if (keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1146     keyblock_cache_clear ();
1147
1148   if (DBG_CLOCK)
1149     log_clock (err? "keydb_get_keyblock leave (failed)"
1150                : "keydb_get_keyblock leave");
1151   return err;
1152 }
1153
1154
1155 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1156    only then stores a new iobuf object at R_IOBUF and a signature
1157    status vecotor at R_SIGSTATUS.  */
1158 static gpg_error_t
1159 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1160 {
1161   gpg_error_t err;
1162   iobuf_t iobuf;
1163   kbnode_t kbctx, node;
1164   u32 n_sigs;
1165   u32 *sigstatus;
1166
1167   *r_iobuf = NULL;
1168   if (r_sigstatus)
1169     *r_sigstatus = NULL;
1170
1171   /* Allocate a vector for the signature cache.  This is an array of
1172      u32 values with the first value giving the number of elements to
1173      follow and each element descriping the cache status of the
1174      signature.  */
1175   if (r_sigstatus)
1176     {
1177       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1178         if (node->pkt->pkttype == PKT_SIGNATURE)
1179           n_sigs++;
1180       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1181       if (!sigstatus)
1182         return gpg_error_from_syserror ();
1183     }
1184   else
1185     sigstatus = NULL;
1186
1187   iobuf = iobuf_temp ();
1188   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1189     {
1190       /* Make sure to use only packets valid on a keyblock.  */
1191       switch (node->pkt->pkttype)
1192         {
1193         case PKT_PUBLIC_KEY:
1194         case PKT_PUBLIC_SUBKEY:
1195         case PKT_SIGNATURE:
1196         case PKT_USER_ID:
1197         case PKT_ATTRIBUTE:
1198           /* Note that we don't want the ring trust packets.  They are
1199              not useful. */
1200           break;
1201         default:
1202           continue;
1203         }
1204
1205       err = build_packet (iobuf, node->pkt);
1206       if (err)
1207         {
1208           iobuf_close (iobuf);
1209           return err;
1210         }
1211
1212       /* Build signature status vector.  */
1213       if (node->pkt->pkttype == PKT_SIGNATURE)
1214         {
1215           PKT_signature *sig = node->pkt->pkt.signature;
1216
1217           n_sigs++;
1218           /* Fixme: Detect the "missing key" status.  */
1219           if (sig->flags.checked && sigstatus)
1220             {
1221               if (sig->flags.valid)
1222                 {
1223                   if (!sig->expiredate)
1224                     sigstatus[n_sigs] = 0xffffffff;
1225                   else if (sig->expiredate < 0x1000000)
1226                     sigstatus[n_sigs] = 0x10000000;
1227                   else
1228                     sigstatus[n_sigs] = sig->expiredate;
1229                 }
1230               else
1231                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1232             }
1233         }
1234     }
1235   if (sigstatus)
1236     sigstatus[0] = n_sigs;
1237
1238   *r_iobuf = iobuf;
1239   if (r_sigstatus)
1240     *r_sigstatus = sigstatus;
1241   return 0;
1242 }
1243
1244
1245 /*
1246  * Update the current keyblock with the keyblock KB
1247  */
1248 gpg_error_t
1249 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1250 {
1251   gpg_error_t err;
1252
1253   if (!hd)
1254     return gpg_error (GPG_ERR_INV_ARG);
1255
1256   kid_not_found_flush ();
1257   keyblock_cache_clear ();
1258
1259   if (hd->found < 0 || hd->found >= hd->used)
1260     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1261
1262   if (opt.dry_run)
1263     return 0;
1264
1265   err = lock_all (hd);
1266   if (err)
1267     return err;
1268
1269   switch (hd->active[hd->found].type)
1270     {
1271     case KEYDB_RESOURCE_TYPE_NONE:
1272       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1273       break;
1274     case KEYDB_RESOURCE_TYPE_KEYRING:
1275       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1276       break;
1277     case KEYDB_RESOURCE_TYPE_KEYBOX:
1278       {
1279         iobuf_t iobuf;
1280
1281         err = build_keyblock_image (kb, &iobuf, NULL);
1282         if (!err)
1283           {
1284             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1285                                           iobuf_get_temp_buffer (iobuf),
1286                                           iobuf_get_temp_length (iobuf));
1287             iobuf_close (iobuf);
1288           }
1289       }
1290       break;
1291     }
1292
1293   unlock_all (hd);
1294   return err;
1295 }
1296
1297
1298 /*
1299  * Insert a new KB into one of the resources.
1300  */
1301 gpg_error_t
1302 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1303 {
1304   gpg_error_t err;
1305   int idx;
1306
1307   if (!hd)
1308     return gpg_error (GPG_ERR_INV_ARG);
1309
1310   kid_not_found_flush ();
1311   keyblock_cache_clear ();
1312
1313   if (opt.dry_run)
1314     return 0;
1315
1316   if (hd->found >= 0 && hd->found < hd->used)
1317     idx = hd->found;
1318   else if (hd->current >= 0 && hd->current < hd->used)
1319     idx = hd->current;
1320   else
1321     return gpg_error (GPG_ERR_GENERAL);
1322
1323   err = lock_all (hd);
1324   if (err)
1325     return err;
1326
1327   switch (hd->active[idx].type)
1328     {
1329     case KEYDB_RESOURCE_TYPE_NONE:
1330       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1331       break;
1332     case KEYDB_RESOURCE_TYPE_KEYRING:
1333       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1334       break;
1335     case KEYDB_RESOURCE_TYPE_KEYBOX:
1336       { /* We need to turn our kbnode_t list of packets into a proper
1337            keyblock first.  This is required by the OpenPGP key parser
1338            included in the keybox code.  Eventually we can change this
1339            kludge to have the caller pass the image.  */
1340         iobuf_t iobuf;
1341         u32 *sigstatus;
1342
1343         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1344         if (!err)
1345           {
1346             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1347                                           iobuf_get_temp_buffer (iobuf),
1348                                           iobuf_get_temp_length (iobuf),
1349                                           sigstatus);
1350             xfree (sigstatus);
1351             iobuf_close (iobuf);
1352           }
1353       }
1354       break;
1355     }
1356
1357   unlock_all (hd);
1358   return err;
1359 }
1360
1361
1362 /*
1363  * Delete the current keyblock.
1364  */
1365 gpg_error_t
1366 keydb_delete_keyblock (KEYDB_HANDLE hd)
1367 {
1368   gpg_error_t rc;
1369
1370   if (!hd)
1371     return gpg_error (GPG_ERR_INV_ARG);
1372
1373   kid_not_found_flush ();
1374   keyblock_cache_clear ();
1375
1376   if (hd->found < 0 || hd->found >= hd->used)
1377     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1378
1379   if (opt.dry_run)
1380     return 0;
1381
1382   rc = lock_all (hd);
1383   if (rc)
1384     return rc;
1385
1386   switch (hd->active[hd->found].type)
1387     {
1388     case KEYDB_RESOURCE_TYPE_NONE:
1389       rc = gpg_error (GPG_ERR_GENERAL);
1390       break;
1391     case KEYDB_RESOURCE_TYPE_KEYRING:
1392       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1393       break;
1394     case KEYDB_RESOURCE_TYPE_KEYBOX:
1395       rc = keybox_delete (hd->active[hd->found].u.kb);
1396       break;
1397     }
1398
1399   unlock_all (hd);
1400   return rc;
1401 }
1402
1403
1404 \f
1405 /*
1406  * Locate the default writable key resource, so that the next
1407  * operation (which is only relevant for inserts) will be done on this
1408  * resource.
1409  */
1410 gpg_error_t
1411 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
1412 {
1413   gpg_error_t rc;
1414
1415   (void)reserved;
1416
1417   if (!hd)
1418     return GPG_ERR_INV_ARG;
1419
1420   rc = keydb_search_reset (hd); /* this does reset hd->current */
1421   if (rc)
1422     return rc;
1423
1424   /* If we have a primary set, try that one first */
1425   if (primary_keyring)
1426     {
1427       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1428         {
1429           if(hd->active[hd->current].token==primary_keyring)
1430             {
1431               if(keyring_is_writable (hd->active[hd->current].token))
1432                 return 0;
1433               else
1434                 break;
1435             }
1436         }
1437
1438       rc = keydb_search_reset (hd); /* this does reset hd->current */
1439       if (rc)
1440         return rc;
1441     }
1442
1443   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1444     {
1445       switch (hd->active[hd->current].type)
1446         {
1447         case KEYDB_RESOURCE_TYPE_NONE:
1448           BUG();
1449           break;
1450         case KEYDB_RESOURCE_TYPE_KEYRING:
1451           if (keyring_is_writable (hd->active[hd->current].token))
1452             return 0; /* found (hd->current is set to it) */
1453           break;
1454         case KEYDB_RESOURCE_TYPE_KEYBOX:
1455           if (keybox_is_writable (hd->active[hd->current].token))
1456             return 0; /* found (hd->current is set to it) */
1457           break;
1458         }
1459     }
1460
1461   return gpg_error (GPG_ERR_NOT_FOUND);
1462 }
1463
1464 /*
1465  * Rebuild the caches of all key resources.
1466  */
1467 void
1468 keydb_rebuild_caches (int noisy)
1469 {
1470   int i, rc;
1471
1472   keyblock_cache_clear ();
1473
1474   for (i=0; i < used_resources; i++)
1475     {
1476       if (!keyring_is_writable (all_resources[i].token))
1477         continue;
1478       switch (all_resources[i].type)
1479         {
1480         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1481           break;
1482         case KEYDB_RESOURCE_TYPE_KEYRING:
1483           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1484           if (rc)
1485             log_error (_("failed to rebuild keyring cache: %s\n"),
1486                        gpg_strerror (rc));
1487           break;
1488         case KEYDB_RESOURCE_TYPE_KEYBOX:
1489           /* N/A.  */
1490           break;
1491         }
1492     }
1493 }
1494
1495
1496 /* Return the number of skipped blocks since the last search reset.  */
1497 unsigned long
1498 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1499 {
1500   return hd ? hd->skipped_long_blobs : 0;
1501 }
1502
1503
1504 /*
1505  * Start the next search on this handle right at the beginning
1506  */
1507 gpg_error_t
1508 keydb_search_reset (KEYDB_HANDLE hd)
1509 {
1510   gpg_error_t rc = 0;
1511   int i;
1512
1513   if (!hd)
1514     return gpg_error (GPG_ERR_INV_ARG);
1515
1516   keyblock_cache_clear ();
1517
1518   if (DBG_CLOCK)
1519     log_clock ("keydb_search_reset");
1520
1521   if (DBG_CACHE)
1522     log_debug ("keydb_search: reset  (hd=%p)", hd);
1523
1524   hd->skipped_long_blobs = 0;
1525   hd->current = 0;
1526   hd->found = -1;
1527   /* Now reset all resources.  */
1528   for (i=0; !rc && i < hd->used; i++)
1529     {
1530       switch (hd->active[i].type)
1531         {
1532         case KEYDB_RESOURCE_TYPE_NONE:
1533           break;
1534         case KEYDB_RESOURCE_TYPE_KEYRING:
1535           rc = keyring_search_reset (hd->active[i].u.kr);
1536           break;
1537         case KEYDB_RESOURCE_TYPE_KEYBOX:
1538           rc = keybox_search_reset (hd->active[i].u.kb);
1539           break;
1540         }
1541     }
1542   return rc;
1543 }
1544
1545
1546 static void
1547 dump_search_desc (KEYDB_HANDLE hd, const char *text,
1548                   KEYDB_SEARCH_DESC *desc, size_t ndesc)
1549 {
1550   int n;
1551   const char *s;
1552
1553   for (n=0; n < ndesc; n++)
1554     {
1555       switch (desc[n].mode)
1556         {
1557         case KEYDB_SEARCH_MODE_NONE:      s = "none";      break;
1558         case KEYDB_SEARCH_MODE_EXACT:     s = "exact";     break;
1559         case KEYDB_SEARCH_MODE_SUBSTR:    s = "substr";    break;
1560         case KEYDB_SEARCH_MODE_MAIL:      s = "mail";      break;
1561         case KEYDB_SEARCH_MODE_MAILSUB:   s = "mailsub";   break;
1562         case KEYDB_SEARCH_MODE_MAILEND:   s = "mailend";   break;
1563         case KEYDB_SEARCH_MODE_WORDS:     s = "words";     break;
1564         case KEYDB_SEARCH_MODE_SHORT_KID: s = "short_kid"; break;
1565         case KEYDB_SEARCH_MODE_LONG_KID:  s = "long_kid";  break;
1566         case KEYDB_SEARCH_MODE_FPR16:     s = "fpr16";     break;
1567         case KEYDB_SEARCH_MODE_FPR20:     s = "fpr20";     break;
1568         case KEYDB_SEARCH_MODE_FPR:       s = "fpr";       break;
1569         case KEYDB_SEARCH_MODE_ISSUER:    s = "issuer";    break;
1570         case KEYDB_SEARCH_MODE_ISSUER_SN: s = "issuer_sn"; break;
1571         case KEYDB_SEARCH_MODE_SN:        s = "sn";        break;
1572         case KEYDB_SEARCH_MODE_SUBJECT:   s = "subject";   break;
1573         case KEYDB_SEARCH_MODE_KEYGRIP:   s = "keygrip";   break;
1574         case KEYDB_SEARCH_MODE_FIRST:     s = "first";     break;
1575         case KEYDB_SEARCH_MODE_NEXT:      s = "next";      break;
1576         default:                          s = "?";         break;
1577         }
1578       if (!n)
1579         log_debug ("%s: mode=%s  (hd=%p)", text, s, hd);
1580       else
1581         log_debug ("%*s  mode=%s", (int)strlen (text), "", s);
1582       if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
1583         log_printf (" %08lX%08lX", (unsigned long)desc[n].u.kid[0],
1584                     (unsigned long)desc[n].u.kid[1]);
1585       else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1586         log_printf (" %08lX", (unsigned long)desc[n].u.kid[1]);
1587       else if (desc[n].mode == KEYDB_SEARCH_MODE_SUBSTR)
1588         log_printf (" '%s'", desc[n].u.name);
1589     }
1590 }
1591
1592
1593 /*
1594  * Search through all keydb resources, starting at the current
1595  * position, for a keyblock which contains one of the keys described
1596  * in the DESC array.  Returns GPG_ERR_NOT_FOUND if no matching
1597  * keyring was found.
1598  */
1599 gpg_error_t
1600 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1601               size_t ndesc, size_t *descindex)
1602 {
1603   gpg_error_t rc;
1604   int once_found = 0;
1605
1606   if (descindex)
1607     *descindex = 0; /* Make sure it is always set on return.  */
1608
1609   if (!hd)
1610     return gpg_error (GPG_ERR_INV_ARG);
1611
1612   if (DBG_CLOCK)
1613     log_clock ("keydb_search enter");
1614
1615   if (DBG_CACHE)
1616     dump_search_desc (hd, "keydb_search", desc, ndesc);
1617
1618
1619   /* Note that we track the found state in the table to cope with the
1620      case that a initial search found the key and the next search
1621      (without a reset) did not found the key.  Without keeping the
1622      found state we would falsely claim that the key has not been
1623      found.  Actually this is quite common because we need to check
1624      for ambgious keyids.  */
1625   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1626       && (once_found = kid_not_found_p (desc[0].u.kid)) == 1 )
1627     {
1628       if (DBG_CLOCK)
1629         log_clock ("keydb_search leave (not found, cached)");
1630       return gpg_error (GPG_ERR_NOT_FOUND);
1631     }
1632
1633   /* NB: If one of the exact search modes below is used in a loop to
1634      walk over all keys (with the same fingerprint) the caching must
1635      have been disabled for the handle.  */
1636   if (!hd->no_caching
1637       && ndesc == 1
1638       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1639           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1640       && keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1641       && !memcmp (keyblock_cache.fpr, desc[0].u.fpr, 20))
1642     {
1643       /* (DESCINDEX is already set).  */
1644       if (DBG_CLOCK)
1645         log_clock ("keydb_search leave (cached)");
1646       return 0;
1647     }
1648
1649   rc = -1;
1650   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1651          && hd->current >= 0 && hd->current < hd->used)
1652     {
1653       switch (hd->active[hd->current].type)
1654         {
1655         case KEYDB_RESOURCE_TYPE_NONE:
1656           BUG(); /* we should never see it here */
1657           break;
1658         case KEYDB_RESOURCE_TYPE_KEYRING:
1659           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1660                                ndesc, descindex);
1661           break;
1662         case KEYDB_RESOURCE_TYPE_KEYBOX:
1663           rc = keybox_search (hd->active[hd->current].u.kb, desc,
1664                               ndesc, KEYBOX_BLOBTYPE_PGP,
1665                               descindex, &hd->skipped_long_blobs);
1666           break;
1667         }
1668       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1669         {
1670           /* EOF -> switch to next resource */
1671           hd->current++;
1672         }
1673       else if (!rc)
1674         hd->found = hd->current;
1675     }
1676
1677   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1678         ? gpg_error (GPG_ERR_NOT_FOUND)
1679         : rc);
1680
1681   keyblock_cache_clear ();
1682   if (!hd->no_caching
1683       && !rc
1684       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1685                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR))
1686     {
1687       keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1688       memcpy (keyblock_cache.fpr, desc[0].u.fpr, 20);
1689     }
1690
1691   if ((!rc || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1692       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1693       && !once_found)
1694     {
1695       kid_not_found_insert (desc[0].u.kid, !rc);
1696     }
1697
1698   if (DBG_CLOCK)
1699     log_clock (rc? "keydb_search leave (not found)"
1700                  : "keydb_search leave (found)");
1701   return rc;
1702 }
1703
1704
1705 /* Note that in contrast to using keydb_search in search first mode,
1706    this function skips legacy keys.  */
1707 gpg_error_t
1708 keydb_search_first (KEYDB_HANDLE hd)
1709 {
1710   gpg_error_t err;
1711   KEYDB_SEARCH_DESC desc;
1712
1713   memset (&desc, 0, sizeof desc);
1714   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1715   err = keydb_search (hd, &desc, 1, NULL);
1716   if (gpg_err_code (err) == GPG_ERR_LEGACY_KEY)
1717     err = keydb_search_next (hd);
1718   return err;
1719 }
1720
1721
1722 /* Note that in contrast to using keydb_search in search next mode,
1723    this fucntion skips legacy keys.  */
1724 gpg_error_t
1725 keydb_search_next (KEYDB_HANDLE hd)
1726 {
1727   gpg_error_t err;
1728   KEYDB_SEARCH_DESC desc;
1729
1730   do
1731     {
1732       memset (&desc, 0, sizeof desc);
1733       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1734       err = keydb_search (hd, &desc, 1, NULL);
1735     }
1736   while (gpg_err_code (err) == GPG_ERR_LEGACY_KEY);
1737
1738   return err;
1739 }
1740
1741 gpg_error_t
1742 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1743 {
1744   KEYDB_SEARCH_DESC desc;
1745
1746   memset (&desc, 0, sizeof desc);
1747   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1748   desc.u.kid[0] = kid[0];
1749   desc.u.kid[1] = kid[1];
1750   return keydb_search (hd, &desc, 1, NULL);
1751 }
1752
1753 gpg_error_t
1754 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1755 {
1756   gpg_error_t err;
1757   KEYDB_SEARCH_DESC desc;
1758
1759   memset (&desc, 0, sizeof desc);
1760   desc.mode = KEYDB_SEARCH_MODE_FPR;
1761   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1762   do
1763     {
1764       err = keydb_search (hd, &desc, 1, NULL);
1765     }
1766   while (gpg_err_code (err) == GPG_ERR_LEGACY_KEY);
1767
1768   return err;
1769 }