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