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