gpg: Minor cleanup for key listing related code.
[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       if (pkt->pkttype == PKT_COMPRESSED)
775         {
776           log_error ("skipped compressed packet in keybox blob\n");
777           free_packet(pkt);
778           init_packet(pkt);
779           continue;
780         }
781       if (pkt->pkttype == PKT_RING_TRUST)
782         {
783           log_info ("skipped ring trust packet in keybox blob\n");
784           free_packet(pkt);
785           init_packet(pkt);
786           continue;
787         }
788
789       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
790         {
791           log_error ("parse_keyblock_image: first packet in a keybox blob "
792                      "is not a public key packet\n");
793           err = gpg_error (GPG_ERR_INV_KEYRING);
794           break;
795         }
796       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
797                       || pkt->pkttype == PKT_SECRET_KEY))
798         {
799           log_error ("parse_keyblock_image: "
800                      "multiple keyblocks in a keybox blob\n");
801           err = gpg_error (GPG_ERR_INV_KEYRING);
802           break;
803         }
804       in_cert = 1;
805
806       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
807         {
808           PKT_signature *sig = pkt->pkt.signature;
809
810           n_sigs++;
811           if (n_sigs > sigstatus[0])
812             {
813               log_error ("parse_keyblock_image: "
814                          "more signatures than found in the meta data\n");
815               err = gpg_error (GPG_ERR_INV_KEYRING);
816               break;
817
818             }
819           if (sigstatus[n_sigs])
820             {
821               sig->flags.checked = 1;
822               if (sigstatus[n_sigs] == 1 )
823                 ; /* missing key */
824               else if (sigstatus[n_sigs] == 2 )
825                 ; /* bad signature */
826               else if (sigstatus[n_sigs] < 0x10000000)
827                 ; /* bad flag */
828               else
829                 {
830                   sig->flags.valid = 1;
831                   /* Fixme: Shall we set the expired flag here?  */
832                 }
833             }
834         }
835
836       node = new_kbnode (pkt);
837
838       switch (pkt->pkttype)
839         {
840         case PKT_PUBLIC_KEY:
841         case PKT_PUBLIC_SUBKEY:
842         case PKT_SECRET_KEY:
843         case PKT_SECRET_SUBKEY:
844           if (++pk_count == pk_no)
845             node->flag |= 1;
846           break;
847
848         case PKT_USER_ID:
849           if (++uid_count == uid_no)
850             node->flag |= 2;
851           break;
852
853         default:
854           break;
855         }
856
857       if (!keyblock)
858         keyblock = node;
859       else
860         *tail = node;
861       tail = &node->next;
862       pkt = xtrymalloc (sizeof *pkt);
863       if (!pkt)
864         {
865           err = gpg_error_from_syserror ();
866           break;
867         }
868       init_packet (pkt);
869     }
870   set_packet_list_mode (save_mode);
871
872   if (err == -1 && keyblock)
873     err = 0; /* Got the entire keyblock.  */
874
875   if (!err && sigstatus && n_sigs != sigstatus[0])
876     {
877       log_error ("parse_keyblock_image: signature count does not match\n");
878       err = gpg_error (GPG_ERR_INV_KEYRING);
879     }
880
881   if (err)
882     release_kbnode (keyblock);
883   else
884     *r_keyblock = keyblock;
885   free_packet (pkt);
886   xfree (pkt);
887   return err;
888 }
889
890
891 /*
892  * Return the last found keyring.  Caller must free it.
893  * The returned keyblock has the kbode flag bit 0 set for the node with
894  * the public key used to locate the keyblock or flag bit 1 set for
895  * the user ID node.
896  */
897 gpg_error_t
898 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
899 {
900   gpg_error_t err = 0;
901
902   *ret_kb = NULL;
903
904   if (!hd)
905     return gpg_error (GPG_ERR_INV_ARG);
906
907   if (keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
908     {
909       iobuf_seek (keyblock_cache.iobuf, 0);
910       err = parse_keyblock_image (keyblock_cache.iobuf,
911                                   keyblock_cache.pk_no,
912                                   keyblock_cache.uid_no,
913                                   keyblock_cache.sigstatus,
914                                   ret_kb);
915       if (err)
916         keyblock_cache_clear ();
917       return err;
918     }
919
920   if (hd->found < 0 || hd->found >= hd->used)
921     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
922
923   switch (hd->active[hd->found].type)
924     {
925     case KEYDB_RESOURCE_TYPE_NONE:
926       err = gpg_error (GPG_ERR_GENERAL); /* oops */
927       break;
928     case KEYDB_RESOURCE_TYPE_KEYRING:
929       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
930       break;
931     case KEYDB_RESOURCE_TYPE_KEYBOX:
932       {
933         iobuf_t iobuf;
934         u32 *sigstatus;
935         int pk_no, uid_no;
936
937         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
938                                    &iobuf, &pk_no, &uid_no, &sigstatus);
939         if (!err)
940           {
941             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
942                                         ret_kb);
943             if (!err && keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
944               {
945                 keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
946                 keyblock_cache.sigstatus = sigstatus;
947                 keyblock_cache.iobuf     = iobuf;
948                 keyblock_cache.pk_no     = pk_no;
949                 keyblock_cache.uid_no    = uid_no;
950               }
951             else
952               {
953                 xfree (sigstatus);
954                 iobuf_close (iobuf);
955               }
956           }
957       }
958       break;
959     }
960
961   if (keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
962     keyblock_cache_clear ();
963
964   return err;
965 }
966
967
968 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
969    only then stores a new iobuf object at R_IOBUF and a signature
970    status vecotor at R_SIGSTATUS.  */
971 static gpg_error_t
972 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
973 {
974   gpg_error_t err;
975   iobuf_t iobuf;
976   kbnode_t kbctx, node;
977   u32 n_sigs;
978   u32 *sigstatus;
979
980   *r_iobuf = NULL;
981   if (r_sigstatus)
982     *r_sigstatus = NULL;
983
984   /* Allocate a vector for the signature cache.  This is an array of
985      u32 values with the first value giving the number of elements to
986      follow and each element descriping the cache status of the
987      signature.  */
988   if (r_sigstatus)
989     {
990       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
991         if (node->pkt->pkttype == PKT_SIGNATURE)
992           n_sigs++;
993       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
994       if (!sigstatus)
995         return gpg_error_from_syserror ();
996     }
997   else
998     sigstatus = NULL;
999
1000   iobuf = iobuf_temp ();
1001   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1002     {
1003       /* Make sure to use only packets valid on a keyblock.  */
1004       switch (node->pkt->pkttype)
1005         {
1006         case PKT_PUBLIC_KEY:
1007         case PKT_PUBLIC_SUBKEY:
1008         case PKT_SIGNATURE:
1009         case PKT_USER_ID:
1010         case PKT_ATTRIBUTE:
1011           /* Note that we don't want the ring trust packets.  They are
1012              not useful. */
1013           break;
1014         default:
1015           continue;
1016         }
1017
1018       err = build_packet (iobuf, node->pkt);
1019       if (err)
1020         {
1021           iobuf_close (iobuf);
1022           return err;
1023         }
1024
1025       /* Build signature status vector.  */
1026       if (node->pkt->pkttype == PKT_SIGNATURE)
1027         {
1028           PKT_signature *sig = node->pkt->pkt.signature;
1029
1030           n_sigs++;
1031           /* Fixme: Detect the "missing key" status.  */
1032           if (sig->flags.checked && sigstatus)
1033             {
1034               if (sig->flags.valid)
1035                 {
1036                   if (!sig->expiredate)
1037                     sigstatus[n_sigs] = 0xffffffff;
1038                   else if (sig->expiredate < 0x1000000)
1039                     sigstatus[n_sigs] = 0x10000000;
1040                   else
1041                     sigstatus[n_sigs] = sig->expiredate;
1042                 }
1043               else
1044                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1045             }
1046         }
1047     }
1048   if (sigstatus)
1049     sigstatus[0] = n_sigs;
1050
1051   *r_iobuf = iobuf;
1052   if (r_sigstatus)
1053     *r_sigstatus = sigstatus;
1054   return 0;
1055 }
1056
1057
1058 /*
1059  * Update the current keyblock with the keyblock KB
1060  */
1061 gpg_error_t
1062 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1063 {
1064   gpg_error_t err;
1065
1066   if (!hd)
1067     return gpg_error (GPG_ERR_INV_ARG);
1068
1069   keyblock_cache_clear ();
1070
1071   if (hd->found < 0 || hd->found >= hd->used)
1072     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1073
1074   if (opt.dry_run)
1075     return 0;
1076
1077   err = lock_all (hd);
1078   if (err)
1079     return err;
1080
1081   switch (hd->active[hd->found].type)
1082     {
1083     case KEYDB_RESOURCE_TYPE_NONE:
1084       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1085       break;
1086     case KEYDB_RESOURCE_TYPE_KEYRING:
1087       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1088       break;
1089     case KEYDB_RESOURCE_TYPE_KEYBOX:
1090       {
1091         iobuf_t iobuf;
1092
1093         err = build_keyblock_image (kb, &iobuf, NULL);
1094         if (!err)
1095           {
1096             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1097                                           iobuf_get_temp_buffer (iobuf),
1098                                           iobuf_get_temp_length (iobuf));
1099             iobuf_close (iobuf);
1100           }
1101       }
1102       break;
1103     }
1104
1105   unlock_all (hd);
1106   return err;
1107 }
1108
1109
1110 /*
1111  * Insert a new KB into one of the resources.
1112  */
1113 gpg_error_t
1114 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1115 {
1116   gpg_error_t err;
1117   int idx;
1118
1119   if (!hd)
1120     return gpg_error (GPG_ERR_INV_ARG);
1121
1122   keyblock_cache_clear ();
1123
1124   if (opt.dry_run)
1125     return 0;
1126
1127   if (hd->found >= 0 && hd->found < hd->used)
1128     idx = hd->found;
1129   else if (hd->current >= 0 && hd->current < hd->used)
1130     idx = hd->current;
1131   else
1132     return gpg_error (GPG_ERR_GENERAL);
1133
1134   err = lock_all (hd);
1135   if (err)
1136     return err;
1137
1138   switch (hd->active[idx].type)
1139     {
1140     case KEYDB_RESOURCE_TYPE_NONE:
1141       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1142       break;
1143     case KEYDB_RESOURCE_TYPE_KEYRING:
1144       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1145       break;
1146     case KEYDB_RESOURCE_TYPE_KEYBOX:
1147       { /* We need to turn our kbnode_t list of packets into a proper
1148            keyblock first.  This is required by the OpenPGP key parser
1149            included in the keybox code.  Eventually we can change this
1150            kludge to have the caller pass the image.  */
1151         iobuf_t iobuf;
1152         u32 *sigstatus;
1153
1154         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1155         if (!err)
1156           {
1157             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1158                                           iobuf_get_temp_buffer (iobuf),
1159                                           iobuf_get_temp_length (iobuf),
1160                                           sigstatus);
1161             xfree (sigstatus);
1162             iobuf_close (iobuf);
1163           }
1164       }
1165       break;
1166     }
1167
1168   unlock_all (hd);
1169   return err;
1170 }
1171
1172
1173 /*
1174  * Delete the current keyblock.
1175  */
1176 gpg_error_t
1177 keydb_delete_keyblock (KEYDB_HANDLE hd)
1178 {
1179   gpg_error_t rc;
1180
1181   if (!hd)
1182     return gpg_error (GPG_ERR_INV_ARG);
1183
1184   keyblock_cache_clear ();
1185
1186   if (hd->found < 0 || hd->found >= hd->used)
1187     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1188
1189   if (opt.dry_run)
1190     return 0;
1191
1192   rc = lock_all (hd);
1193   if (rc)
1194     return rc;
1195
1196   switch (hd->active[hd->found].type)
1197     {
1198     case KEYDB_RESOURCE_TYPE_NONE:
1199       rc = gpg_error (GPG_ERR_GENERAL);
1200       break;
1201     case KEYDB_RESOURCE_TYPE_KEYRING:
1202       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1203       break;
1204     case KEYDB_RESOURCE_TYPE_KEYBOX:
1205       rc = keybox_delete (hd->active[hd->found].u.kb);
1206       break;
1207     }
1208
1209   unlock_all (hd);
1210   return rc;
1211 }
1212
1213
1214 \f
1215 /*
1216  * Locate the default writable key resource, so that the next
1217  * operation (which is only relevant for inserts) will be done on this
1218  * resource.
1219  */
1220 gpg_error_t
1221 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
1222 {
1223   gpg_error_t rc;
1224
1225   (void)reserved;
1226
1227   if (!hd)
1228     return G10ERR_INV_ARG;
1229
1230   rc = keydb_search_reset (hd); /* this does reset hd->current */
1231   if (rc)
1232     return rc;
1233
1234   /* If we have a primary set, try that one first */
1235   if (primary_keyring)
1236     {
1237       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1238         {
1239           if(hd->active[hd->current].token==primary_keyring)
1240             {
1241               if(keyring_is_writable (hd->active[hd->current].token))
1242                 return 0;
1243               else
1244                 break;
1245             }
1246         }
1247
1248       rc = keydb_search_reset (hd); /* this does reset hd->current */
1249       if (rc)
1250         return rc;
1251     }
1252
1253   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1254     {
1255       switch (hd->active[hd->current].type)
1256         {
1257         case KEYDB_RESOURCE_TYPE_NONE:
1258           BUG();
1259           break;
1260         case KEYDB_RESOURCE_TYPE_KEYRING:
1261           if (keyring_is_writable (hd->active[hd->current].token))
1262             return 0; /* found (hd->current is set to it) */
1263           break;
1264         case KEYDB_RESOURCE_TYPE_KEYBOX:
1265           if (keybox_is_writable (hd->active[hd->current].token))
1266             return 0; /* found (hd->current is set to it) */
1267           break;
1268         }
1269     }
1270
1271   return gpg_error (GPG_ERR_NOT_FOUND);
1272 }
1273
1274 /*
1275  * Rebuild the caches of all key resources.
1276  */
1277 void
1278 keydb_rebuild_caches (int noisy)
1279 {
1280   int i, rc;
1281
1282   keyblock_cache_clear ();
1283
1284   for (i=0; i < used_resources; i++)
1285     {
1286       if (!keyring_is_writable (all_resources[i].token))
1287         continue;
1288       switch (all_resources[i].type)
1289         {
1290         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1291           break;
1292         case KEYDB_RESOURCE_TYPE_KEYRING:
1293           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1294           if (rc)
1295             log_error (_("failed to rebuild keyring cache: %s\n"),
1296                        g10_errstr (rc));
1297           break;
1298         case KEYDB_RESOURCE_TYPE_KEYBOX:
1299           /* N/A.  */
1300           break;
1301         }
1302     }
1303 }
1304
1305
1306 /* Return the number of skipped blocks since the last search reset.  */
1307 unsigned long
1308 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1309 {
1310   return hd ? hd->skipped_long_blobs : 0;
1311 }
1312
1313
1314 /*
1315  * Start the next search on this handle right at the beginning
1316  */
1317 gpg_error_t
1318 keydb_search_reset (KEYDB_HANDLE hd)
1319 {
1320   gpg_error_t rc = 0;
1321   int i;
1322
1323   if (!hd)
1324     return gpg_error (GPG_ERR_INV_ARG);
1325
1326   keyblock_cache_clear ();
1327
1328   if (DBG_CLOCK)
1329     log_clock ("keydb_search_reset");
1330
1331   if (DBG_CACHE)
1332     log_debug ("keydb_search: reset  (hd=%p)", hd);
1333
1334   hd->skipped_long_blobs = 0;
1335   hd->current = 0;
1336   hd->found = -1;
1337   /* Now reset all resources.  */
1338   for (i=0; !rc && i < hd->used; i++)
1339     {
1340       switch (hd->active[i].type)
1341         {
1342         case KEYDB_RESOURCE_TYPE_NONE:
1343           break;
1344         case KEYDB_RESOURCE_TYPE_KEYRING:
1345           rc = keyring_search_reset (hd->active[i].u.kr);
1346           break;
1347         case KEYDB_RESOURCE_TYPE_KEYBOX:
1348           rc = keybox_search_reset (hd->active[i].u.kb);
1349           break;
1350         }
1351     }
1352   return rc;
1353 }
1354
1355
1356 static void
1357 dump_search_desc (KEYDB_HANDLE hd, const char *text,
1358                   KEYDB_SEARCH_DESC *desc, size_t ndesc)
1359 {
1360   int n;
1361   const char *s;
1362
1363   for (n=0; n < ndesc; n++)
1364     {
1365       switch (desc[n].mode)
1366         {
1367         case KEYDB_SEARCH_MODE_NONE:      s = "none";      break;
1368         case KEYDB_SEARCH_MODE_EXACT:     s = "exact";     break;
1369         case KEYDB_SEARCH_MODE_SUBSTR:    s = "substr";    break;
1370         case KEYDB_SEARCH_MODE_MAIL:      s = "mail";      break;
1371         case KEYDB_SEARCH_MODE_MAILSUB:   s = "mailsub";   break;
1372         case KEYDB_SEARCH_MODE_MAILEND:   s = "mailend";   break;
1373         case KEYDB_SEARCH_MODE_WORDS:     s = "words";     break;
1374         case KEYDB_SEARCH_MODE_SHORT_KID: s = "short_kid"; break;
1375         case KEYDB_SEARCH_MODE_LONG_KID:  s = "long_kid";  break;
1376         case KEYDB_SEARCH_MODE_FPR16:     s = "fpr16";     break;
1377         case KEYDB_SEARCH_MODE_FPR20:     s = "fpr20";     break;
1378         case KEYDB_SEARCH_MODE_FPR:       s = "fpr";       break;
1379         case KEYDB_SEARCH_MODE_ISSUER:    s = "issuer";    break;
1380         case KEYDB_SEARCH_MODE_ISSUER_SN: s = "issuer_sn"; break;
1381         case KEYDB_SEARCH_MODE_SN:        s = "sn";        break;
1382         case KEYDB_SEARCH_MODE_SUBJECT:   s = "subject";   break;
1383         case KEYDB_SEARCH_MODE_KEYGRIP:   s = "keygrip";   break;
1384         case KEYDB_SEARCH_MODE_FIRST:     s = "first";     break;
1385         case KEYDB_SEARCH_MODE_NEXT:      s = "next";      break;
1386         default:                          s = "?";         break;
1387         }
1388       if (!n)
1389         log_debug ("%s: mode=%s  (hd=%p)", text, s, hd);
1390       else
1391         log_debug ("%*s  mode=%s", (int)strlen (text), "", s);
1392       if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
1393         log_printf (" %08lX%08lX", (unsigned long)desc[n].u.kid[0],
1394                     (unsigned long)desc[n].u.kid[1]);
1395       else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1396         log_printf (" %08lX", (unsigned long)desc[n].u.kid[1]);
1397       else if (desc[n].mode == KEYDB_SEARCH_MODE_SUBSTR)
1398         log_printf (" '%s'", desc[n].u.name);
1399     }
1400 }
1401
1402
1403 /*
1404  * Search through all keydb resources, starting at the current
1405  * position, for a keyblock which contains one of the keys described
1406  * in the DESC array.  Returns GPG_ERR_NOT_FOUND if no matching
1407  * keyring was found.
1408  */
1409 gpg_error_t
1410 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1411               size_t ndesc, size_t *descindex)
1412 {
1413   gpg_error_t rc;
1414
1415   if (descindex)
1416     *descindex = 0; /* Make sure it is always set on return.  */
1417
1418   if (!hd)
1419     return gpg_error (GPG_ERR_INV_ARG);
1420
1421   if (DBG_CLOCK)
1422     log_clock ("keydb_search enter");
1423
1424   if (DBG_CACHE)
1425     dump_search_desc (hd, "keydb_search", desc, ndesc);
1426
1427   if (!hd->no_caching
1428       && ndesc == 1
1429       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1430           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1431       && keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1432       && !memcmp (keyblock_cache.fpr, desc[0].u.fpr, 20))
1433     {
1434       /* (DESCINDEX is already set).  */
1435       if (DBG_CLOCK)
1436         log_clock ("keydb_search leave (cached)");
1437       return 0;
1438     }
1439
1440   rc = -1;
1441   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1442          && hd->current >= 0 && hd->current < hd->used)
1443     {
1444       switch (hd->active[hd->current].type)
1445         {
1446         case KEYDB_RESOURCE_TYPE_NONE:
1447           BUG(); /* we should never see it here */
1448           break;
1449         case KEYDB_RESOURCE_TYPE_KEYRING:
1450           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1451                                ndesc, descindex);
1452           break;
1453         case KEYDB_RESOURCE_TYPE_KEYBOX:
1454           rc = keybox_search (hd->active[hd->current].u.kb, desc,
1455                               ndesc, KEYBOX_BLOBTYPE_PGP,
1456                               descindex, &hd->skipped_long_blobs);
1457           break;
1458         }
1459       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1460         {
1461           /* EOF -> switch to next resource */
1462           hd->current++;
1463         }
1464       else if (!rc)
1465         hd->found = hd->current;
1466     }
1467
1468   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1469         ? gpg_error (GPG_ERR_NOT_FOUND)
1470         : rc);
1471
1472   keyblock_cache_clear ();
1473   if (!hd->no_caching
1474       && !rc
1475       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1476                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR))
1477     {
1478       keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1479       memcpy (keyblock_cache.fpr, desc[0].u.fpr, 20);
1480     }
1481
1482   if (DBG_CLOCK)
1483     log_clock (rc? "keydb_search leave (not found)"
1484                  : "keydb_search leave (found)");
1485   return rc;
1486 }
1487
1488
1489 gpg_error_t
1490 keydb_search_first (KEYDB_HANDLE hd)
1491 {
1492   KEYDB_SEARCH_DESC desc;
1493
1494   memset (&desc, 0, sizeof desc);
1495   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1496   return keydb_search (hd, &desc, 1, NULL);
1497 }
1498
1499 gpg_error_t
1500 keydb_search_next (KEYDB_HANDLE hd)
1501 {
1502   KEYDB_SEARCH_DESC desc;
1503
1504   memset (&desc, 0, sizeof desc);
1505   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1506   return keydb_search (hd, &desc, 1, NULL);
1507 }
1508
1509 gpg_error_t
1510 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1511 {
1512   KEYDB_SEARCH_DESC desc;
1513
1514   memset (&desc, 0, sizeof desc);
1515   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1516   desc.u.kid[0] = kid[0];
1517   desc.u.kid[1] = kid[1];
1518   return keydb_search (hd, &desc, 1, NULL);
1519 }
1520
1521 gpg_error_t
1522 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1523 {
1524   KEYDB_SEARCH_DESC desc;
1525
1526   memset (&desc, 0, sizeof desc);
1527   desc.mode = KEYDB_SEARCH_MODE_FPR;
1528   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1529   return keydb_search (hd, &desc, 1, NULL);
1530 }