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