0ef3c8f42b99387717e9b6034cb42cce1883c501
[gnupg.git] / sm / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
3  * Copyright (C) 2014 g10 Code GmbH
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 "gpgsm.h"
32 #include "../kbx/keybox.h"
33 #include "keydb.h"
34 #include "i18n.h"
35
36 static int active_handles;
37
38 typedef enum {
39     KEYDB_RESOURCE_TYPE_NONE = 0,
40     KEYDB_RESOURCE_TYPE_KEYBOX
41 } KeydbResourceType;
42 #define MAX_KEYDB_RESOURCES 20
43
44 struct resource_item {
45   KeydbResourceType type;
46   union {
47     KEYBOX_HANDLE kr;
48   } u;
49   void *token;
50   int secret;
51   dotlock_t lockhandle;
52 };
53
54 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
55 static int used_resources;
56
57 struct keydb_handle {
58   int locked;
59   int found;
60   int saved_found;
61   int current;
62   int is_ephemeral;
63   int used; /* items in active */
64   struct resource_item active[MAX_KEYDB_RESOURCES];
65 };
66
67
68 static int lock_all (KEYDB_HANDLE hd);
69 static void unlock_all (KEYDB_HANDLE hd);
70
71
72 static void
73 try_make_homedir (const char *fname)
74 {
75   const char *defhome = standard_homedir ();
76
77   /* Create the directory only if the supplied directory name is the
78      same as the default one.  This way we avoid to create arbitrary
79      directories when a non-default home directory is used.  To cope
80      with HOME, we do compare only the suffix if we see that the
81      default homedir does start with a tilde.  */
82   if ( opt.dry_run || opt.no_homedir_creation )
83     return;
84
85   if (
86 #ifdef HAVE_W32_SYSTEM
87       ( !compare_filenames (fname, defhome) )
88 #else
89       ( *defhome == '~'
90         && (strlen(fname) >= strlen (defhome+1)
91             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
92       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
93 #endif
94       )
95     {
96       if (gnupg_mkdir (fname, "-rwx"))
97         log_info (_("can't create directory '%s': %s\n"),
98                   fname, strerror(errno) );
99       else if (!opt.quiet )
100         log_info (_("directory '%s' created\n"), fname);
101     }
102 }
103
104
105 /* Handle the creation of a keybox if it does not yet exist.  Take
106    into acount that other processes might have the keybox already
107    locked.  This lock check does not work if the directory itself is
108    not yet available.  If R_CREATED is not NULL it will be set to true
109    if the function created a new keybox.  */
110 static gpg_error_t
111 maybe_create_keybox (char *filename, int force, int *r_created)
112 {
113   dotlock_t lockhd = NULL;
114   FILE *fp;
115   int rc;
116   mode_t oldmask;
117   char *last_slash_in_filename;
118   int save_slash;
119
120   if (r_created)
121     *r_created = 0;
122
123   /* A quick test whether the filename already exists. */
124   if (!access (filename, F_OK))
125     return 0;
126
127   /* If we don't want to create a new file at all, there is no need to
128      go any further - bail out right here.  */
129   if (!force)
130     return gpg_error (GPG_ERR_ENOENT);
131
132   /* First of all we try to create the home directory.  Note, that we
133      don't do any locking here because any sane application of gpg
134      would create the home directory by itself and not rely on gpg's
135      tricky auto-creation which is anyway only done for some home
136      directory name patterns. */
137   last_slash_in_filename = strrchr (filename, DIRSEP_C);
138 #if HAVE_W32_SYSTEM
139   {
140     /* Windows may either have a slash or a backslash.  Take care of it.  */
141     char *p = strrchr (filename, '/');
142     if (!last_slash_in_filename || p > last_slash_in_filename)
143       last_slash_in_filename = p;
144   }
145 #endif /*HAVE_W32_SYSTEM*/
146   if (!last_slash_in_filename)
147     return gpg_error (GPG_ERR_ENOENT);  /* No slash at all - should
148                                            not happen though.  */
149   save_slash = *last_slash_in_filename;
150   *last_slash_in_filename = 0;
151   if (access(filename, F_OK))
152     {
153       static int tried;
154
155       if (!tried)
156         {
157           tried = 1;
158           try_make_homedir (filename);
159         }
160       if (access (filename, F_OK))
161         {
162           rc = gpg_error_from_syserror ();
163           *last_slash_in_filename = save_slash;
164           goto leave;
165         }
166     }
167   *last_slash_in_filename = save_slash;
168
169   /* To avoid races with other instances of gpg trying to create or
170      update the keybox (it is removed during an update for a short
171      time), we do the next stuff in a locked state. */
172   lockhd = dotlock_create (filename, 0);
173   if (!lockhd)
174     {
175       /* A reason for this to fail is that the directory is not
176          writable. However, this whole locking stuff does not make
177          sense if this is the case. An empty non-writable directory
178          with no keyring is not really useful at all. */
179       if (opt.verbose)
180         log_info ("can't allocate lock for '%s'\n", filename );
181
182       if (!force)
183         return gpg_error (GPG_ERR_ENOENT);
184       else
185         return gpg_error (GPG_ERR_GENERAL);
186     }
187
188   if ( dotlock_take (lockhd, -1) )
189     {
190       /* This is something bad.  Probably a stale lockfile.  */
191       log_info ("can't lock '%s'\n", filename);
192       rc = gpg_error (GPG_ERR_GENERAL);
193       goto leave;
194     }
195
196   /* Now the real test while we are locked. */
197   if (!access(filename, F_OK))
198     {
199       rc = 0;  /* Okay, we may access the file now.  */
200       goto leave;
201     }
202
203   /* The file does not yet exist, create it now. */
204   oldmask = umask (077);
205   fp = fopen (filename, "w");
206   if (!fp)
207     {
208       rc = gpg_error_from_syserror ();
209       umask (oldmask);
210       log_error (_("error creating keybox '%s': %s\n"),
211                  filename, gpg_strerror (rc));
212       goto leave;
213     }
214   umask (oldmask);
215
216   if (!opt.quiet)
217     log_info (_("keybox '%s' created\n"), filename);
218   if (r_created)
219     *r_created = 1;
220
221   fclose (fp);
222   rc = 0;
223
224  leave:
225   if (lockhd)
226     {
227       dotlock_release (lockhd);
228       dotlock_destroy (lockhd);
229     }
230   return rc;
231 }
232
233
234 /*
235  * Register a resource (which currently may only be a keybox file).
236  * The first keybox which is added by this function is created if it
237  * does not exist.  If AUTO_CREATED is not NULL it will be set to true
238  * if the function has created a new keybox.
239  */
240 gpg_error_t
241 keydb_add_resource (const char *url, int force, int secret, int *auto_created)
242 {
243   static int any_secret, any_public;
244   const char *resname = url;
245   char *filename = NULL;
246   gpg_error_t err = 0;
247   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
248
249   if (auto_created)
250     *auto_created = 0;
251
252   /* Do we have an URL?
253      gnupg-kbx:filename := this is a plain keybox
254      filename := See what is is, but create as plain keybox.
255   */
256   if (strlen (resname) > 10)
257     {
258       if (!strncmp (resname, "gnupg-kbx:", 10) )
259         {
260           rt = KEYDB_RESOURCE_TYPE_KEYBOX;
261           resname += 10;
262         }
263 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
264       else if (strchr (resname, ':'))
265         {
266           log_error ("invalid key resource URL '%s'\n", url );
267           err = gpg_error (GPG_ERR_GENERAL);
268           goto leave;
269         }
270 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
271     }
272
273   if (*resname != DIRSEP_C )
274     { /* do tilde expansion etc */
275       if (strchr(resname, DIRSEP_C) )
276         filename = make_filename (resname, NULL);
277       else
278         filename = make_filename (opt.homedir, resname, NULL);
279     }
280   else
281     filename = xstrdup (resname);
282
283   if (!force)
284     force = secret? !any_secret : !any_public;
285
286   /* see whether we can determine the filetype */
287   if (rt == KEYDB_RESOURCE_TYPE_NONE)
288     {
289       FILE *fp = fopen( filename, "rb" );
290
291       if (fp)
292         {
293           u32 magic;
294
295           /* FIXME: check for the keybox magic */
296           if (fread (&magic, 4, 1, fp) == 1 )
297             {
298               if (magic == 0x13579ace || magic == 0xce9a5713)
299                 ; /* GDBM magic - no more support */
300               else
301                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
302             }
303           else /* maybe empty: assume keybox */
304             rt = KEYDB_RESOURCE_TYPE_KEYBOX;
305           fclose (fp);
306         }
307       else /* no file yet: create keybox */
308         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
309     }
310
311   switch (rt)
312     {
313     case KEYDB_RESOURCE_TYPE_NONE:
314       log_error ("unknown type of key resource '%s'\n", url );
315       err = gpg_error (GPG_ERR_GENERAL);
316       goto leave;
317
318     case KEYDB_RESOURCE_TYPE_KEYBOX:
319       err = maybe_create_keybox (filename, force, auto_created);
320       if (err)
321         goto leave;
322       /* Now register the file */
323       {
324         void *token;
325
326         err = keybox_register_file (filename, secret, &token);
327         if (gpg_err_code (err) == GPG_ERR_EEXIST)
328           ; /* Already registered - ignore.  */
329         else if (err)
330           ; /* Other error.  */
331         else if (used_resources >= MAX_KEYDB_RESOURCES)
332           err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
333         else
334           {
335             all_resources[used_resources].type = rt;
336             all_resources[used_resources].u.kr = NULL; /* Not used here */
337             all_resources[used_resources].token = token;
338             all_resources[used_resources].secret = secret;
339
340             all_resources[used_resources].lockhandle
341               = dotlock_create (filename, 0);
342             if (!all_resources[used_resources].lockhandle)
343               log_fatal ( _("can't create lock for '%s'\n"), filename);
344
345             /* Do a compress run if needed and the file is not locked. */
346             if (!dotlock_take (all_resources[used_resources].lockhandle, 0))
347               {
348                 KEYBOX_HANDLE kbxhd = keybox_new_x509 (token, secret);
349
350                 if (kbxhd)
351                   {
352                     keybox_compress (kbxhd);
353                     keybox_release (kbxhd);
354                   }
355                 dotlock_release (all_resources[used_resources].lockhandle);
356               }
357
358             used_resources++;
359           }
360       }
361       break;
362
363     default:
364       log_error ("resource type of '%s' not supported\n", url);
365       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
366       goto leave;
367     }
368
369   /* fixme: check directory permissions and print a warning */
370
371  leave:
372   if (err)
373     log_error ("keyblock resource '%s': %s\n", filename, gpg_strerror (err));
374   else if (secret)
375     any_secret = 1;
376   else
377     any_public = 1;
378   xfree (filename);
379   return err;
380 }
381
382
383 KEYDB_HANDLE
384 keydb_new (int secret)
385 {
386   KEYDB_HANDLE hd;
387   int i, j;
388
389   hd = xcalloc (1, sizeof *hd);
390   hd->found = -1;
391   hd->saved_found = -1;
392
393   assert (used_resources <= MAX_KEYDB_RESOURCES);
394   for (i=j=0; i < used_resources; i++)
395     {
396       if (!all_resources[i].secret != !secret)
397         continue;
398       switch (all_resources[i].type)
399         {
400         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
401           break;
402         case KEYDB_RESOURCE_TYPE_KEYBOX:
403           hd->active[j].type   = all_resources[i].type;
404           hd->active[j].token  = all_resources[i].token;
405           hd->active[j].secret = all_resources[i].secret;
406           hd->active[j].lockhandle = all_resources[i].lockhandle;
407           hd->active[j].u.kr = keybox_new_x509 (all_resources[i].token, secret);
408           if (!hd->active[j].u.kr)
409             {
410               xfree (hd);
411               return NULL; /* fixme: release all previously allocated handles*/
412             }
413           j++;
414           break;
415         }
416     }
417   hd->used = j;
418
419   active_handles++;
420   return hd;
421 }
422
423 void
424 keydb_release (KEYDB_HANDLE hd)
425 {
426   int i;
427
428   if (!hd)
429     return;
430   assert (active_handles > 0);
431   active_handles--;
432
433   unlock_all (hd);
434   for (i=0; i < hd->used; i++)
435     {
436       switch (hd->active[i].type)
437         {
438         case KEYDB_RESOURCE_TYPE_NONE:
439           break;
440         case KEYDB_RESOURCE_TYPE_KEYBOX:
441           keybox_release (hd->active[i].u.kr);
442           break;
443         }
444     }
445
446     xfree (hd);
447 }
448
449
450 /* Return the name of the current resource.  This is function first
451    looks for the last found found, then for the current search
452    position, and last returns the first available resource.  The
453    returned string is only valid as long as the handle exists.  This
454    function does only return NULL if no handle is specified, in all
455    other error cases an empty string is returned.  */
456 const char *
457 keydb_get_resource_name (KEYDB_HANDLE hd)
458 {
459   int idx;
460   const char *s = NULL;
461
462   if (!hd)
463     return NULL;
464
465   if ( hd->found >= 0 && hd->found < hd->used)
466     idx = hd->found;
467   else if ( hd->current >= 0 && hd->current < hd->used)
468     idx = hd->current;
469   else
470     idx = 0;
471
472   switch (hd->active[idx].type)
473     {
474     case KEYDB_RESOURCE_TYPE_NONE:
475       s = NULL;
476       break;
477     case KEYDB_RESOURCE_TYPE_KEYBOX:
478       s = keybox_get_resource_name (hd->active[idx].u.kr);
479       break;
480     }
481
482   return s? s: "";
483 }
484
485 /* Switch the handle into ephemeral mode and return the original value. */
486 int
487 keydb_set_ephemeral (KEYDB_HANDLE hd, int yes)
488 {
489   int i;
490
491   if (!hd)
492     return 0;
493
494   yes = !!yes;
495   if (hd->is_ephemeral != yes)
496     {
497       for (i=0; i < hd->used; i++)
498         {
499           switch (hd->active[i].type)
500             {
501             case KEYDB_RESOURCE_TYPE_NONE:
502               break;
503             case KEYDB_RESOURCE_TYPE_KEYBOX:
504               keybox_set_ephemeral (hd->active[i].u.kr, yes);
505               break;
506             }
507         }
508     }
509
510   i = hd->is_ephemeral;
511   hd->is_ephemeral = yes;
512   return i;
513 }
514
515
516 /* If the keyring has not yet been locked, lock it now.  This
517    operation is required before any update operation; it is optional
518    for an insert operation.  The lock is released with
519    keydb_released. */
520 gpg_error_t
521 keydb_lock (KEYDB_HANDLE hd)
522 {
523   if (!hd)
524     return gpg_error (GPG_ERR_INV_HANDLE);
525   if (hd->locked)
526     return 0; /* Already locked. */
527   return lock_all (hd);
528 }
529
530
531 \f
532 static int
533 lock_all (KEYDB_HANDLE hd)
534 {
535   int i, rc = 0;
536
537   /* Fixme: This locking scheme may lead to deadlock if the resources
538      are not added in the same order by all processes.  We are
539      currently only allowing one resource so it is not a problem. */
540   for (i=0; i < hd->used; i++)
541     {
542       switch (hd->active[i].type)
543         {
544         case KEYDB_RESOURCE_TYPE_NONE:
545           break;
546         case KEYDB_RESOURCE_TYPE_KEYBOX:
547           if (hd->active[i].lockhandle)
548             rc = dotlock_take (hd->active[i].lockhandle, -1);
549           break;
550         }
551       if (rc)
552         break;
553     }
554
555     if (rc)
556       {
557         /* revert the already set locks */
558         for (i--; i >= 0; i--)
559           {
560             switch (hd->active[i].type)
561               {
562               case KEYDB_RESOURCE_TYPE_NONE:
563                 break;
564               case KEYDB_RESOURCE_TYPE_KEYBOX:
565                 if (hd->active[i].lockhandle)
566                   dotlock_release (hd->active[i].lockhandle);
567                 break;
568               }
569           }
570       }
571     else
572       hd->locked = 1;
573
574     /* make_dotlock () does not yet guarantee that errno is set, thus
575        we can't rely on the error reason and will simply use
576        EACCES. */
577     return rc? gpg_error (GPG_ERR_EACCES) : 0;
578 }
579
580 static void
581 unlock_all (KEYDB_HANDLE hd)
582 {
583   int i;
584
585   if (!hd->locked)
586     return;
587
588   for (i=hd->used-1; i >= 0; i--)
589     {
590       switch (hd->active[i].type)
591         {
592         case KEYDB_RESOURCE_TYPE_NONE:
593           break;
594         case KEYDB_RESOURCE_TYPE_KEYBOX:
595           if (hd->active[i].lockhandle)
596             dotlock_release (hd->active[i].lockhandle);
597           break;
598         }
599     }
600   hd->locked = 0;
601 }
602
603
604 \f
605 /* Push the last found state if any.  */
606 void
607 keydb_push_found_state (KEYDB_HANDLE hd)
608 {
609   if (!hd)
610     return;
611
612   if (hd->found < 0 || hd->found >= hd->used)
613     {
614       hd->saved_found = -1;
615       return;
616     }
617
618   switch (hd->active[hd->found].type)
619     {
620     case KEYDB_RESOURCE_TYPE_NONE:
621       break;
622     case KEYDB_RESOURCE_TYPE_KEYBOX:
623       keybox_push_found_state (hd->active[hd->found].u.kr);
624       break;
625     }
626
627   hd->saved_found = hd->found;
628   hd->found = -1;
629 }
630
631
632 /* Pop the last found state.  */
633 void
634 keydb_pop_found_state (KEYDB_HANDLE hd)
635 {
636   if (!hd)
637     return;
638
639   hd->found = hd->saved_found;
640   hd->saved_found = -1;
641   if (hd->found < 0 || hd->found >= hd->used)
642     return;
643
644   switch (hd->active[hd->found].type)
645     {
646     case KEYDB_RESOURCE_TYPE_NONE:
647       break;
648     case KEYDB_RESOURCE_TYPE_KEYBOX:
649       keybox_pop_found_state (hd->active[hd->found].u.kr);
650       break;
651     }
652 }
653
654
655 \f
656 /*
657   Return the last found object.  Caller must free it.  The returned
658   keyblock has the kbode flag bit 0 set for the node with the public
659   key used to locate the keyblock or flag bit 1 set for the user ID
660   node.  */
661 int
662 keydb_get_cert (KEYDB_HANDLE hd, ksba_cert_t *r_cert)
663 {
664   int rc = 0;
665
666   if (!hd)
667     return gpg_error (GPG_ERR_INV_VALUE);
668
669   if ( hd->found < 0 || hd->found >= hd->used)
670     return -1; /* nothing found */
671
672   switch (hd->active[hd->found].type)
673     {
674     case KEYDB_RESOURCE_TYPE_NONE:
675       rc = gpg_error (GPG_ERR_GENERAL); /* oops */
676       break;
677     case KEYDB_RESOURCE_TYPE_KEYBOX:
678       rc = keybox_get_cert (hd->active[hd->found].u.kr, r_cert);
679       break;
680     }
681
682   return rc;
683 }
684
685 /* Return a flag of the last found object. WHICH is the flag requested;
686    it should be one of the KEYBOX_FLAG_ values.  If the operation is
687    successful, the flag value will be stored at the address given by
688    VALUE.  Return 0 on success or an error code. */
689 gpg_error_t
690 keydb_get_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int *value)
691 {
692   int err = 0;
693
694   if (!hd)
695     return gpg_error (GPG_ERR_INV_VALUE);
696
697   if ( hd->found < 0 || hd->found >= hd->used)
698     return gpg_error (GPG_ERR_NOTHING_FOUND);
699
700   switch (hd->active[hd->found].type)
701     {
702     case KEYDB_RESOURCE_TYPE_NONE:
703       err = gpg_error (GPG_ERR_GENERAL); /* oops */
704       break;
705     case KEYDB_RESOURCE_TYPE_KEYBOX:
706       err = keybox_get_flags (hd->active[hd->found].u.kr, which, idx, value);
707       break;
708     }
709
710   return err;
711 }
712
713 /* Set a flag of the last found object. WHICH is the flag to be set; it
714    should be one of the KEYBOX_FLAG_ values.  If the operation is
715    successful, the flag value will be stored in the keybox.  Note,
716    that some flag values can't be updated and thus may return an
717    error, some other flag values may be masked out before an update.
718    Returns 0 on success or an error code. */
719 gpg_error_t
720 keydb_set_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int value)
721 {
722   int err = 0;
723
724   if (!hd)
725     return gpg_error (GPG_ERR_INV_VALUE);
726
727   if ( hd->found < 0 || hd->found >= hd->used)
728     return gpg_error (GPG_ERR_NOTHING_FOUND);
729
730   if (!hd->locked)
731     return gpg_error (GPG_ERR_NOT_LOCKED);
732
733   switch (hd->active[hd->found].type)
734     {
735     case KEYDB_RESOURCE_TYPE_NONE:
736       err = gpg_error (GPG_ERR_GENERAL); /* oops */
737       break;
738     case KEYDB_RESOURCE_TYPE_KEYBOX:
739       err = keybox_set_flags (hd->active[hd->found].u.kr, which, idx, value);
740       break;
741     }
742
743   return err;
744 }
745
746 /*
747  * Insert a new Certificate into one of the resources.
748  */
749 int
750 keydb_insert_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
751 {
752   int rc = -1;
753   int idx;
754   unsigned char digest[20];
755
756   if (!hd)
757     return gpg_error (GPG_ERR_INV_VALUE);
758
759   if (opt.dry_run)
760     return 0;
761
762   if ( hd->found >= 0 && hd->found < hd->used)
763     idx = hd->found;
764   else if ( hd->current >= 0 && hd->current < hd->used)
765     idx = hd->current;
766   else
767     return gpg_error (GPG_ERR_GENERAL);
768
769   if (!hd->locked)
770     return gpg_error (GPG_ERR_NOT_LOCKED);
771
772   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
773
774   switch (hd->active[idx].type)
775     {
776     case KEYDB_RESOURCE_TYPE_NONE:
777       rc = gpg_error (GPG_ERR_GENERAL);
778       break;
779     case KEYDB_RESOURCE_TYPE_KEYBOX:
780       rc = keybox_insert_cert (hd->active[idx].u.kr, cert, digest);
781       break;
782     }
783
784   unlock_all (hd);
785   return rc;
786 }
787
788
789
790 /* Update the current keyblock with KB.  */
791 int
792 keydb_update_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
793 {
794   int rc = 0;
795   unsigned char digest[20];
796
797   if (!hd)
798     return gpg_error (GPG_ERR_INV_VALUE);
799
800   if ( hd->found < 0 || hd->found >= hd->used)
801     return -1; /* nothing found */
802
803   if (opt.dry_run)
804     return 0;
805
806   rc = lock_all (hd);
807   if (rc)
808     return rc;
809
810   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
811
812   switch (hd->active[hd->found].type)
813     {
814     case KEYDB_RESOURCE_TYPE_NONE:
815       rc = gpg_error (GPG_ERR_GENERAL); /* oops */
816       break;
817     case KEYDB_RESOURCE_TYPE_KEYBOX:
818       rc = keybox_update_cert (hd->active[hd->found].u.kr, cert, digest);
819       break;
820     }
821
822   unlock_all (hd);
823   return rc;
824 }
825
826
827 /*
828  * The current keyblock or cert will be deleted.
829  */
830 int
831 keydb_delete (KEYDB_HANDLE hd, int unlock)
832 {
833   int rc = -1;
834
835   if (!hd)
836     return gpg_error (GPG_ERR_INV_VALUE);
837
838   if ( hd->found < 0 || hd->found >= hd->used)
839     return -1; /* nothing found */
840
841   if( opt.dry_run )
842     return 0;
843
844   if (!hd->locked)
845     return gpg_error (GPG_ERR_NOT_LOCKED);
846
847   switch (hd->active[hd->found].type)
848     {
849     case KEYDB_RESOURCE_TYPE_NONE:
850       rc = gpg_error (GPG_ERR_GENERAL);
851       break;
852     case KEYDB_RESOURCE_TYPE_KEYBOX:
853       rc = keybox_delete (hd->active[hd->found].u.kr);
854       break;
855     }
856
857   if (unlock)
858     unlock_all (hd);
859   return rc;
860 }
861
862
863 \f
864 /*
865  * Locate the default writable key resource, so that the next
866  * operation (which is only relevant for inserts) will be done on this
867  * resource.
868  */
869 int
870 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
871 {
872   int rc;
873
874   (void)reserved;
875
876   if (!hd)
877     return gpg_error (GPG_ERR_INV_VALUE);
878
879   rc = keydb_search_reset (hd); /* this does reset hd->current */
880   if (rc)
881     return rc;
882
883   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
884     {
885       switch (hd->active[hd->current].type)
886         {
887         case KEYDB_RESOURCE_TYPE_NONE:
888           BUG();
889           break;
890         case KEYDB_RESOURCE_TYPE_KEYBOX:
891           if (keybox_is_writable (hd->active[hd->current].token))
892             return 0; /* found (hd->current is set to it) */
893           break;
894         }
895     }
896
897   return -1;
898 }
899
900 /*
901  * Rebuild the caches of all key resources.
902  */
903 void
904 keydb_rebuild_caches (void)
905 {
906   int i;
907
908   for (i=0; i < used_resources; i++)
909     {
910       if (all_resources[i].secret)
911         continue;
912       switch (all_resources[i].type)
913         {
914         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
915           break;
916         case KEYDB_RESOURCE_TYPE_KEYBOX:
917 /*            rc = keybox_rebuild_cache (all_resources[i].token); */
918 /*            if (rc) */
919 /*              log_error (_("failed to rebuild keybox cache: %s\n"), */
920 /*                         g10_errstr (rc)); */
921           break;
922         }
923     }
924 }
925
926
927
928 /*
929  * Start the next search on this handle right at the beginning
930  */
931 int
932 keydb_search_reset (KEYDB_HANDLE hd)
933 {
934   int i, rc = 0;
935
936   if (!hd)
937     return gpg_error (GPG_ERR_INV_VALUE);
938
939   hd->current = 0;
940   hd->found = -1;
941   /* and reset all resources */
942   for (i=0; !rc && i < hd->used; i++)
943     {
944       switch (hd->active[i].type)
945         {
946         case KEYDB_RESOURCE_TYPE_NONE:
947           break;
948         case KEYDB_RESOURCE_TYPE_KEYBOX:
949           rc = keybox_search_reset (hd->active[i].u.kr);
950           break;
951         }
952     }
953   return rc; /* fixme: we need to map error codes or share them with
954                 all modules*/
955 }
956
957 /*
958  * Search through all keydb resources, starting at the current position,
959  * for a keyblock which contains one of the keys described in the DESC array.
960  */
961 int
962 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
963 {
964   int rc = -1;
965   unsigned long skipped;
966
967   if (!hd)
968     return gpg_error (GPG_ERR_INV_VALUE);
969
970   while (rc == -1 && hd->current >= 0 && hd->current < hd->used)
971     {
972       switch (hd->active[hd->current].type)
973         {
974         case KEYDB_RESOURCE_TYPE_NONE:
975           BUG(); /* we should never see it here */
976           break;
977         case KEYDB_RESOURCE_TYPE_KEYBOX:
978           rc = keybox_search (hd->active[hd->current].u.kr, desc, ndesc,
979                               KEYBOX_BLOBTYPE_X509,
980                               NULL, &skipped);
981           break;
982         }
983       if (rc == -1) /* EOF -> switch to next resource */
984         hd->current++;
985       else if (!rc)
986         hd->found = hd->current;
987     }
988
989   return rc;
990 }
991
992
993 int
994 keydb_search_first (KEYDB_HANDLE hd)
995 {
996   KEYDB_SEARCH_DESC desc;
997
998   memset (&desc, 0, sizeof desc);
999   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1000   return keydb_search (hd, &desc, 1);
1001 }
1002
1003 int
1004 keydb_search_next (KEYDB_HANDLE hd)
1005 {
1006   KEYDB_SEARCH_DESC desc;
1007
1008   memset (&desc, 0, sizeof desc);
1009   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1010   return keydb_search (hd, &desc, 1);
1011 }
1012
1013 int
1014 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1015 {
1016   KEYDB_SEARCH_DESC desc;
1017
1018   (void)kid;
1019
1020   memset (&desc, 0, sizeof desc);
1021   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1022   desc.u.kid[0] = kid[0];
1023   desc.u.kid[1] = kid[1];
1024   return keydb_search (hd, &desc, 1);
1025 }
1026
1027 int
1028 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1029 {
1030   KEYDB_SEARCH_DESC desc;
1031
1032   memset (&desc, 0, sizeof desc);
1033   desc.mode = KEYDB_SEARCH_MODE_FPR;
1034   memcpy (desc.u.fpr, fpr, 20);
1035   return keydb_search (hd, &desc, 1);
1036 }
1037
1038 int
1039 keydb_search_issuer (KEYDB_HANDLE hd, const char *issuer)
1040 {
1041   KEYDB_SEARCH_DESC desc;
1042   int rc;
1043
1044   memset (&desc, 0, sizeof desc);
1045   desc.mode = KEYDB_SEARCH_MODE_ISSUER;
1046   desc.u.name = issuer;
1047   rc = keydb_search (hd, &desc, 1);
1048   return rc;
1049 }
1050
1051 int
1052 keydb_search_issuer_sn (KEYDB_HANDLE hd,
1053                         const char *issuer, ksba_const_sexp_t serial)
1054 {
1055   KEYDB_SEARCH_DESC desc;
1056   int rc;
1057   const unsigned char *s;
1058
1059   memset (&desc, 0, sizeof desc);
1060   desc.mode = KEYDB_SEARCH_MODE_ISSUER_SN;
1061   s = serial;
1062   if (*s !='(')
1063     return gpg_error (GPG_ERR_INV_VALUE);
1064   s++;
1065   for (desc.snlen = 0; digitp (s); s++)
1066     desc.snlen = 10*desc.snlen + atoi_1 (s);
1067   if (*s !=':')
1068     return gpg_error (GPG_ERR_INV_VALUE);
1069   desc.sn = s+1;
1070   desc.u.name = issuer;
1071   rc = keydb_search (hd, &desc, 1);
1072   return rc;
1073 }
1074
1075 int
1076 keydb_search_subject (KEYDB_HANDLE hd, const char *name)
1077 {
1078   KEYDB_SEARCH_DESC desc;
1079   int rc;
1080
1081   memset (&desc, 0, sizeof desc);
1082   desc.mode = KEYDB_SEARCH_MODE_SUBJECT;
1083   desc.u.name = name;
1084   rc = keydb_search (hd, &desc, 1);
1085   return rc;
1086 }
1087
1088
1089 \f
1090 /* Store the certificate in the key DB but make sure that it does not
1091    already exists.  We do this simply by comparing the fingerprint.
1092    If EXISTED is not NULL it will be set to true if the certificate
1093    was already in the DB. */
1094 int
1095 keydb_store_cert (ksba_cert_t cert, int ephemeral, int *existed)
1096 {
1097   KEYDB_HANDLE kh;
1098   int rc;
1099   unsigned char fpr[20];
1100
1101   if (existed)
1102     *existed = 0;
1103
1104   if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
1105     {
1106       log_error (_("failed to get the fingerprint\n"));
1107       return gpg_error (GPG_ERR_GENERAL);
1108     }
1109
1110   kh = keydb_new (0);
1111   if (!kh)
1112     {
1113       log_error (_("failed to allocate keyDB handle\n"));
1114       return gpg_error (GPG_ERR_ENOMEM);;
1115     }
1116
1117   /* Set the ephemeral flag so that the search looks at all
1118      records.  */
1119   keydb_set_ephemeral (kh, 1);
1120
1121   rc = lock_all (kh);
1122   if (rc)
1123     return rc;
1124
1125   rc = keydb_search_fpr (kh, fpr);
1126   if (rc != -1)
1127     {
1128       keydb_release (kh);
1129       if (!rc)
1130         {
1131           if (existed)
1132             *existed = 1;
1133           if (!ephemeral)
1134             {
1135               /* Remove ephemeral flags from existing certificate to "store"
1136                  it permanently. */
1137               rc = keydb_set_cert_flags (cert, 1, KEYBOX_FLAG_BLOB, 0,
1138                                          KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
1139               if (rc)
1140                 {
1141                   log_error ("clearing ephemeral flag failed: %s\n",
1142                              gpg_strerror (rc));
1143                   return rc;
1144                 }
1145             }
1146           return 0; /* okay */
1147         }
1148       log_error (_("problem looking for existing certificate: %s\n"),
1149                  gpg_strerror (rc));
1150       return rc;
1151     }
1152
1153   /* Reset the ephemeral flag if not requested.  */
1154   if (!ephemeral)
1155     keydb_set_ephemeral (kh, 0);
1156
1157   rc = keydb_locate_writable (kh, 0);
1158   if (rc)
1159     {
1160       log_error (_("error finding writable keyDB: %s\n"), gpg_strerror (rc));
1161       keydb_release (kh);
1162       return rc;
1163     }
1164
1165   rc = keydb_insert_cert (kh, cert);
1166   if (rc)
1167     {
1168       log_error (_("error storing certificate: %s\n"), gpg_strerror (rc));
1169       keydb_release (kh);
1170       return rc;
1171     }
1172   keydb_release (kh);
1173   return 0;
1174 }
1175
1176
1177 /* This is basically keydb_set_flags but it implements a complete
1178    transaction by locating the certificate in the DB and updating the
1179    flags. */
1180 gpg_error_t
1181 keydb_set_cert_flags (ksba_cert_t cert, int ephemeral,
1182                       int which, int idx,
1183                       unsigned int mask, unsigned int value)
1184 {
1185   KEYDB_HANDLE kh;
1186   gpg_error_t err;
1187   unsigned char fpr[20];
1188   unsigned int old_value;
1189
1190   if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
1191     {
1192       log_error (_("failed to get the fingerprint\n"));
1193       return gpg_error (GPG_ERR_GENERAL);
1194     }
1195
1196   kh = keydb_new (0);
1197   if (!kh)
1198     {
1199       log_error (_("failed to allocate keyDB handle\n"));
1200       return gpg_error (GPG_ERR_ENOMEM);;
1201     }
1202
1203   if (ephemeral)
1204     keydb_set_ephemeral (kh, 1);
1205
1206   err = keydb_lock (kh);
1207   if (err)
1208     {
1209       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1210       keydb_release (kh);
1211       return err;
1212     }
1213
1214   err = keydb_search_fpr (kh, fpr);
1215   if (err)
1216     {
1217       if (err == -1)
1218         err = gpg_error (GPG_ERR_NOT_FOUND);
1219       else
1220         log_error (_("problem re-searching certificate: %s\n"),
1221                    gpg_strerror (err));
1222       keydb_release (kh);
1223       return err;
1224     }
1225
1226   err = keydb_get_flags (kh, which, idx, &old_value);
1227   if (err)
1228     {
1229       log_error (_("error getting stored flags: %s\n"), gpg_strerror (err));
1230       keydb_release (kh);
1231       return err;
1232     }
1233
1234   value = ((old_value & ~mask) | (value & mask));
1235
1236   if (value != old_value)
1237     {
1238       err = keydb_set_flags (kh, which, idx, value);
1239       if (err)
1240         {
1241           log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1242           keydb_release (kh);
1243           return err;
1244         }
1245     }
1246
1247   keydb_release (kh);
1248   return 0;
1249 }
1250
1251
1252 /* Reset all the certificate flags we have stored with the certificates
1253    for performance reasons. */
1254 void
1255 keydb_clear_some_cert_flags (ctrl_t ctrl, strlist_t names)
1256 {
1257   gpg_error_t err;
1258   KEYDB_HANDLE hd = NULL;
1259   KEYDB_SEARCH_DESC *desc = NULL;
1260   int ndesc;
1261   strlist_t sl;
1262   int rc=0;
1263   unsigned int old_value, value;
1264
1265   (void)ctrl;
1266
1267   hd = keydb_new (0);
1268   if (!hd)
1269     {
1270       log_error ("keydb_new failed\n");
1271       goto leave;
1272     }
1273
1274   if (!names)
1275     ndesc = 1;
1276   else
1277     {
1278       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
1279         ;
1280     }
1281
1282   desc = xtrycalloc (ndesc, sizeof *desc);
1283   if (!ndesc)
1284     {
1285       log_error ("allocating memory failed: %s\n",
1286                  gpg_strerror (out_of_core ()));
1287       goto leave;
1288     }
1289
1290   if (!names)
1291     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1292   else
1293     {
1294       for (ndesc=0, sl=names; sl; sl = sl->next)
1295         {
1296           rc = classify_user_id (sl->d, desc+ndesc, 0);
1297           if (rc)
1298             log_error ("key '%s' not found: %s\n", sl->d, gpg_strerror (rc));
1299           else
1300             ndesc++;
1301         }
1302     }
1303
1304   err = keydb_lock (hd);
1305   if (err)
1306     {
1307       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1308       goto leave;
1309     }
1310
1311   while (!(rc = keydb_search (hd, desc, ndesc)))
1312     {
1313       if (!names)
1314         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1315
1316       err = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &old_value);
1317       if (err)
1318         {
1319           log_error (_("error getting stored flags: %s\n"),
1320                      gpg_strerror (err));
1321           goto leave;
1322         }
1323
1324       value = (old_value & ~VALIDITY_REVOKED);
1325       if (value != old_value)
1326         {
1327           err = keydb_set_flags (hd, KEYBOX_FLAG_VALIDITY, 0, value);
1328           if (err)
1329             {
1330               log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1331               goto leave;
1332             }
1333         }
1334     }
1335   if (rc && rc != -1)
1336     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1337
1338  leave:
1339   xfree (desc);
1340   keydb_release (hd);
1341 }