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