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