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