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