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