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