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