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