gpg: No need to create a trustdb when encrypting with --always-trust.
[gnupg.git] / sm / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <assert.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <unistd.h>
29
30 #include "gpgsm.h"
31 #include "../kbx/keybox.h"
32 #include "keydb.h"
33 #include "i18n.h"
34
35 static int active_handles;
36
37 typedef enum {
38     KEYDB_RESOURCE_TYPE_NONE = 0,
39     KEYDB_RESOURCE_TYPE_KEYBOX
40 } KeydbResourceType;
41 #define MAX_KEYDB_RESOURCES 20
42
43 struct resource_item {
44   KeydbResourceType type;
45   union {
46     KEYBOX_HANDLE kr;
47   } u;
48   void *token;
49   int secret;
50   DOTLOCK 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 current;
60   int is_ephemeral;
61   int used; /* items in active */
62   struct resource_item active[MAX_KEYDB_RESOURCES];
63 };
64
65
66 static int lock_all (KEYDB_HANDLE hd);
67 static void unlock_all (KEYDB_HANDLE hd);
68
69
70 /*
71  * Register a resource (which currently may only be a keybox file).
72  * The first keybox which is added by this function is created if it
73  * does not exist.  If AUTO_CREATED is not NULL it will be set to true
74  * if the function has created a a new keybox.
75  */
76 int
77 keydb_add_resource (const char *url, int force, int secret, int *auto_created)
78 {
79   static int any_secret, any_public;
80   const char *resname = url;
81   char *filename = NULL;
82   int rc = 0;
83   FILE *fp;
84   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
85
86   if (auto_created)
87     *auto_created = 0;
88
89   /* Do we have an URL?
90      gnupg-kbx:filename := this is a plain keybox
91      filename := See what is is, but create as plain keybox.
92   */
93   if (strlen (resname) > 10)
94     {
95       if (!strncmp (resname, "gnupg-kbx:", 10) )
96         {
97           rt = KEYDB_RESOURCE_TYPE_KEYBOX;
98           resname += 10;
99         }
100 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
101       else if (strchr (resname, ':'))
102         {
103           log_error ("invalid key resource URL `%s'\n", url );
104           rc = gpg_error (GPG_ERR_GENERAL);
105           goto leave;
106         }
107 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
108     }
109
110   if (*resname != DIRSEP_C )
111     { /* do tilde expansion etc */
112       if (strchr(resname, DIRSEP_C) )
113         filename = make_filename (resname, NULL);
114       else
115         filename = make_filename (opt.homedir, resname, NULL);
116     }
117   else
118     filename = xstrdup (resname);
119
120   if (!force)
121     force = secret? !any_secret : !any_public;
122
123   /* see whether we can determine the filetype */
124   if (rt == KEYDB_RESOURCE_TYPE_NONE)
125     {
126       FILE *fp2 = fopen( filename, "rb" );
127
128       if (fp2) {
129         u32 magic;
130
131         /* FIXME: check for the keybox magic */
132         if (fread( &magic, 4, 1, fp2) == 1 )
133           {
134             if (magic == 0x13579ace || magic == 0xce9a5713)
135               ; /* GDBM magic - no more support */
136             else
137               rt = KEYDB_RESOURCE_TYPE_KEYBOX;
138           }
139         else /* maybe empty: assume ring */
140           rt = KEYDB_RESOURCE_TYPE_KEYBOX;
141         fclose (fp2);
142       }
143       else /* no file yet: create ring */
144         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
145     }
146
147   switch (rt)
148     {
149     case KEYDB_RESOURCE_TYPE_NONE:
150       log_error ("unknown type of key resource `%s'\n", url );
151       rc = gpg_error (GPG_ERR_GENERAL);
152       goto leave;
153
154     case KEYDB_RESOURCE_TYPE_KEYBOX:
155       fp = fopen (filename, "rb");
156       if (!fp && !force)
157         {
158           rc = gpg_error (gpg_err_code_from_errno (errno));
159           goto leave;
160         }
161
162       if (!fp)
163         { /* no file */
164 #if 0 /* no autocreate of the homedirectory yet */
165           {
166             char *last_slash_in_filename;
167
168             last_slash_in_filename = strrchr (filename, DIRSEP_C);
169             *last_slash_in_filename = 0;
170             if (access (filename, F_OK))
171               { /* on the first time we try to create the default
172                    homedir and in this case the process will be
173                    terminated, so that on the next invocation can
174                    read the options file in on startup */
175                 try_make_homedir (filename);
176                 rc = gpg_error (GPG_ERR_FILE_OPEN_ERROR);
177                 *last_slash_in_filename = DIRSEP_C;
178                 goto leave;
179               }
180             *last_slash_in_filename = DIRSEP_C;
181           }
182 #endif
183           fp = fopen (filename, "w");
184           if (!fp)
185             {
186               rc = gpg_error (gpg_err_code_from_errno (errno));
187               log_error (_("error creating keybox `%s': %s\n"),
188                          filename, strerror(errno));
189               if (errno == ENOENT)
190                 log_info (_("you may want to start the gpg-agent first\n"));
191               goto leave;
192             }
193
194           if (!opt.quiet)
195             log_info (_("keybox `%s' created\n"), filename);
196           if (auto_created)
197             *auto_created = 1;
198         }
199         fclose (fp);
200         fp = NULL;
201         /* now register the file */
202         {
203
204           void *token = keybox_register_file (filename, secret);
205           if (!token)
206             ; /* already registered - ignore it */
207           else if (used_resources >= MAX_KEYDB_RESOURCES)
208             rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
209           else
210             {
211               all_resources[used_resources].type = rt;
212               all_resources[used_resources].u.kr = NULL; /* Not used here */
213               all_resources[used_resources].token = token;
214               all_resources[used_resources].secret = secret;
215
216               all_resources[used_resources].lockhandle
217                 = create_dotlock (filename);
218               if (!all_resources[used_resources].lockhandle)
219                 log_fatal ( _("can't create lock for `%s'\n"), filename);
220
221               /* Do a compress run if needed and the file is not locked. */
222               if (!make_dotlock (all_resources[used_resources].lockhandle, 0))
223                 {
224                   KEYBOX_HANDLE kbxhd = keybox_new (token, secret);
225
226                   if (kbxhd)
227                     {
228                       keybox_compress (kbxhd);
229                       keybox_release (kbxhd);
230                     }
231                   release_dotlock (all_resources[used_resources].lockhandle);
232                 }
233
234               used_resources++;
235             }
236         }
237
238
239         break;
240     default:
241       log_error ("resource type of `%s' not supported\n", url);
242       rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
243       goto leave;
244     }
245
246   /* fixme: check directory permissions and print a warning */
247
248  leave:
249   if (rc)
250     log_error ("keyblock resource `%s': %s\n", filename, gpg_strerror(rc));
251   else if (secret)
252     any_secret = 1;
253   else
254     any_public = 1;
255   xfree (filename);
256   return rc;
257 }
258
259
260 KEYDB_HANDLE
261 keydb_new (int secret)
262 {
263   KEYDB_HANDLE hd;
264   int i, j;
265
266   hd = xcalloc (1, sizeof *hd);
267   hd->found = -1;
268
269   assert (used_resources <= MAX_KEYDB_RESOURCES);
270   for (i=j=0; i < used_resources; i++)
271     {
272       if (!all_resources[i].secret != !secret)
273         continue;
274       switch (all_resources[i].type)
275         {
276         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
277           break;
278         case KEYDB_RESOURCE_TYPE_KEYBOX:
279           hd->active[j].type   = all_resources[i].type;
280           hd->active[j].token  = all_resources[i].token;
281           hd->active[j].secret = all_resources[i].secret;
282           hd->active[j].lockhandle = all_resources[i].lockhandle;
283           hd->active[j].u.kr = keybox_new (all_resources[i].token, secret);
284           if (!hd->active[j].u.kr)
285             {
286               xfree (hd);
287               return NULL; /* fixme: release all previously allocated handles*/
288             }
289           j++;
290           break;
291         }
292     }
293   hd->used = j;
294
295   active_handles++;
296   return hd;
297 }
298
299 void
300 keydb_release (KEYDB_HANDLE hd)
301 {
302   int i;
303
304   if (!hd)
305     return;
306   assert (active_handles > 0);
307   active_handles--;
308
309   unlock_all (hd);
310   for (i=0; i < hd->used; i++)
311     {
312       switch (hd->active[i].type)
313         {
314         case KEYDB_RESOURCE_TYPE_NONE:
315           break;
316         case KEYDB_RESOURCE_TYPE_KEYBOX:
317           keybox_release (hd->active[i].u.kr);
318           break;
319         }
320     }
321
322     xfree (hd);
323 }
324
325
326 /* Return the name of the current resource.  This is function first
327    looks for the last found found, then for the current search
328    position, and last returns the first available resource.  The
329    returned string is only valid as long as the handle exists.  This
330    function does only return NULL if no handle is specified, in all
331    other error cases an empty string is returned.  */
332 const char *
333 keydb_get_resource_name (KEYDB_HANDLE hd)
334 {
335   int idx;
336   const char *s = NULL;
337
338   if (!hd)
339     return NULL;
340
341   if ( hd->found >= 0 && hd->found < hd->used)
342     idx = hd->found;
343   else if ( hd->current >= 0 && hd->current < hd->used)
344     idx = hd->current;
345   else
346     idx = 0;
347
348   switch (hd->active[idx].type)
349     {
350     case KEYDB_RESOURCE_TYPE_NONE:
351       s = NULL;
352       break;
353     case KEYDB_RESOURCE_TYPE_KEYBOX:
354       s = keybox_get_resource_name (hd->active[idx].u.kr);
355       break;
356     }
357
358   return s? s: "";
359 }
360
361 /* Switch the handle into ephemeral mode and return the orginal value. */
362 int
363 keydb_set_ephemeral (KEYDB_HANDLE hd, int yes)
364 {
365   int i;
366
367   if (!hd)
368     return 0;
369
370   yes = !!yes;
371   if (hd->is_ephemeral != yes)
372     {
373       for (i=0; i < hd->used; i++)
374         {
375           switch (hd->active[i].type)
376             {
377             case KEYDB_RESOURCE_TYPE_NONE:
378               break;
379             case KEYDB_RESOURCE_TYPE_KEYBOX:
380               keybox_set_ephemeral (hd->active[i].u.kr, yes);
381               break;
382             }
383         }
384     }
385
386   i = hd->is_ephemeral;
387   hd->is_ephemeral = yes;
388   return i;
389 }
390
391
392 /* If the keyring has not yet been locked, lock it now.  This
393    operation is required before any update operation; it is optional
394    for an insert operation.  The lock is released with
395    keydb_released. */
396 gpg_error_t
397 keydb_lock (KEYDB_HANDLE hd)
398 {
399   if (!hd)
400     return gpg_error (GPG_ERR_INV_HANDLE);
401   if (hd->locked)
402     return 0; /* Already locked. */
403   return lock_all (hd);
404 }
405
406
407 \f
408 static int
409 lock_all (KEYDB_HANDLE hd)
410 {
411   int i, rc = 0;
412
413   /* Fixme: This locking scheme may lead to deadlock if the resources
414      are not added in the same order by all processes.  We are
415      currently only allowing one resource so it is not a problem. */
416   for (i=0; i < hd->used; i++)
417     {
418       switch (hd->active[i].type)
419         {
420         case KEYDB_RESOURCE_TYPE_NONE:
421           break;
422         case KEYDB_RESOURCE_TYPE_KEYBOX:
423           if (hd->active[i].lockhandle)
424             rc = make_dotlock (hd->active[i].lockhandle, -1);
425           break;
426         }
427       if (rc)
428         break;
429     }
430
431     if (rc)
432       {
433         /* revert the already set locks */
434         for (i--; i >= 0; i--)
435           {
436             switch (hd->active[i].type)
437               {
438               case KEYDB_RESOURCE_TYPE_NONE:
439                 break;
440               case KEYDB_RESOURCE_TYPE_KEYBOX:
441                 if (hd->active[i].lockhandle)
442                   release_dotlock (hd->active[i].lockhandle);
443                 break;
444               }
445           }
446       }
447     else
448       hd->locked = 1;
449
450     /* make_dotlock () does not yet guarantee that errno is set, thus
451        we can't rely on the error reason and will simply use
452        EACCES. */
453     return rc? gpg_error (GPG_ERR_EACCES) : 0;
454 }
455
456 static void
457 unlock_all (KEYDB_HANDLE hd)
458 {
459   int i;
460
461   if (!hd->locked)
462     return;
463
464   for (i=hd->used-1; i >= 0; i--)
465     {
466       switch (hd->active[i].type)
467         {
468         case KEYDB_RESOURCE_TYPE_NONE:
469           break;
470         case KEYDB_RESOURCE_TYPE_KEYBOX:
471           if (hd->active[i].lockhandle)
472             release_dotlock (hd->active[i].lockhandle);
473           break;
474         }
475     }
476   hd->locked = 0;
477 }
478
479 \f
480 #if 0
481 /*
482  * Return the last found keybox.  Caller must free it.
483  * The returned keyblock has the kbode flag bit 0 set for the node with
484  * the public key used to locate the keyblock or flag bit 1 set for
485  * the user ID node.
486  */
487 int
488 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
489 {
490     int rc = 0;
491
492     if (!hd)
493         return G10ERR_INV_ARG;
494
495     if ( hd->found < 0 || hd->found >= hd->used)
496         return -1; /* nothing found */
497
498     switch (hd->active[hd->found].type) {
499       case KEYDB_RESOURCE_TYPE_NONE:
500         rc = G10ERR_GENERAL; /* oops */
501         break;
502       case KEYDB_RESOURCE_TYPE_KEYBOX:
503         rc = keybox_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
504         break;
505     }
506
507     return rc;
508 }
509
510 /*
511  * update the current keyblock with KB
512  */
513 int
514 keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
515 {
516     int rc = 0;
517
518     if (!hd)
519         return G10ERR_INV_ARG;
520
521     if ( hd->found < 0 || hd->found >= hd->used)
522         return -1; /* nothing found */
523
524     if( opt.dry_run )
525         return 0;
526
527     if (!hd->locked)
528       return gpg_error (GPG_ERR_NOT_LOCKED);
529
530     switch (hd->active[hd->found].type) {
531       case KEYDB_RESOURCE_TYPE_NONE:
532         rc = G10ERR_GENERAL; /* oops */
533         break;
534       case KEYDB_RESOURCE_TYPE_KEYBOX:
535         rc = keybox_update_keyblock (hd->active[hd->found].u.kr, kb);
536         break;
537     }
538
539     unlock_all (hd);
540     return rc;
541 }
542
543
544 /*
545  * Insert a new KB into one of the resources.
546  */
547 int
548 keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
549 {
550     int rc = -1;
551     int idx;
552
553     if (!hd)
554         return G10ERR_INV_ARG;
555
556     if( opt.dry_run )
557         return 0;
558
559     if ( hd->found >= 0 && hd->found < hd->used)
560         idx = hd->found;
561     else if ( hd->current >= 0 && hd->current < hd->used)
562         idx = hd->current;
563     else
564         return G10ERR_GENERAL;
565
566     rc = lock_all (hd);
567     if (rc)
568         return rc;
569
570     switch (hd->active[idx].type) {
571       case KEYDB_RESOURCE_TYPE_NONE:
572         rc = G10ERR_GENERAL; /* oops */
573         break;
574       case KEYDB_RESOURCE_TYPE_KEYBOX:
575         rc = keybox_insert_keyblock (hd->active[idx].u.kr, kb);
576         break;
577     }
578
579     unlock_all (hd);
580     return rc;
581 }
582
583 #endif /*disabled code*/
584
585
586 \f
587 /*
588   Return the last found object.  Caller must free it.  The returned
589   keyblock has the kbode flag bit 0 set for the node with the public
590   key used to locate the keyblock or flag bit 1 set for the user ID
591   node.  */
592 int
593 keydb_get_cert (KEYDB_HANDLE hd, ksba_cert_t *r_cert)
594 {
595   int rc = 0;
596
597   if (!hd)
598     return gpg_error (GPG_ERR_INV_VALUE);
599
600   if ( hd->found < 0 || hd->found >= hd->used)
601     return -1; /* nothing found */
602
603   switch (hd->active[hd->found].type)
604     {
605     case KEYDB_RESOURCE_TYPE_NONE:
606       rc = gpg_error (GPG_ERR_GENERAL); /* oops */
607       break;
608     case KEYDB_RESOURCE_TYPE_KEYBOX:
609       rc = keybox_get_cert (hd->active[hd->found].u.kr, r_cert);
610       break;
611     }
612
613   return rc;
614 }
615
616 /* Return a flag of the last found object. WHICH is the flag requested;
617    it should be one of the KEYBOX_FLAG_ values.  If the operation is
618    successful, the flag value will be stored at the address given by
619    VALUE.  Return 0 on success or an error code. */
620 gpg_error_t
621 keydb_get_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int *value)
622 {
623   int err = 0;
624
625   if (!hd)
626     return gpg_error (GPG_ERR_INV_VALUE);
627
628   if ( hd->found < 0 || hd->found >= hd->used)
629     return gpg_error (GPG_ERR_NOTHING_FOUND);
630
631   switch (hd->active[hd->found].type)
632     {
633     case KEYDB_RESOURCE_TYPE_NONE:
634       err = gpg_error (GPG_ERR_GENERAL); /* oops */
635       break;
636     case KEYDB_RESOURCE_TYPE_KEYBOX:
637       err = keybox_get_flags (hd->active[hd->found].u.kr, which, idx, value);
638       break;
639     }
640
641   return err;
642 }
643
644 /* Set a flag of the last found object. WHICH is the flag to be set; it
645    should be one of the KEYBOX_FLAG_ values.  If the operation is
646    successful, the flag value will be stored in the keybox.  Note,
647    that some flag values can't be updated and thus may return an
648    error, some other flag values may be masked out before an update.
649    Returns 0 on success or an error code. */
650 gpg_error_t
651 keydb_set_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int value)
652 {
653   int err = 0;
654
655   if (!hd)
656     return gpg_error (GPG_ERR_INV_VALUE);
657
658   if ( hd->found < 0 || hd->found >= hd->used)
659     return gpg_error (GPG_ERR_NOTHING_FOUND);
660
661   if (!hd->locked)
662     return gpg_error (GPG_ERR_NOT_LOCKED);
663
664   switch (hd->active[hd->found].type)
665     {
666     case KEYDB_RESOURCE_TYPE_NONE:
667       err = gpg_error (GPG_ERR_GENERAL); /* oops */
668       break;
669     case KEYDB_RESOURCE_TYPE_KEYBOX:
670       err = keybox_set_flags (hd->active[hd->found].u.kr, which, idx, value);
671       break;
672     }
673
674   return err;
675 }
676
677 /*
678  * Insert a new Certificate into one of the resources.
679  */
680 int
681 keydb_insert_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
682 {
683   int rc = -1;
684   int idx;
685   unsigned char digest[20];
686
687   if (!hd)
688     return gpg_error (GPG_ERR_INV_VALUE);
689
690   if (opt.dry_run)
691     return 0;
692
693   if ( hd->found >= 0 && hd->found < hd->used)
694     idx = hd->found;
695   else if ( hd->current >= 0 && hd->current < hd->used)
696     idx = hd->current;
697   else
698     return gpg_error (GPG_ERR_GENERAL);
699
700   if (!hd->locked)
701     return gpg_error (GPG_ERR_NOT_LOCKED);
702
703   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
704
705   switch (hd->active[idx].type)
706     {
707     case KEYDB_RESOURCE_TYPE_NONE:
708       rc = gpg_error (GPG_ERR_GENERAL);
709       break;
710     case KEYDB_RESOURCE_TYPE_KEYBOX:
711       rc = keybox_insert_cert (hd->active[idx].u.kr, cert, digest);
712       break;
713     }
714
715   unlock_all (hd);
716   return rc;
717 }
718
719
720
721 /* Update the current keyblock with KB.  */
722 int
723 keydb_update_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
724 {
725   int rc = 0;
726   unsigned char digest[20];
727
728   if (!hd)
729     return gpg_error (GPG_ERR_INV_VALUE);
730
731   if ( hd->found < 0 || hd->found >= hd->used)
732     return -1; /* nothing found */
733
734   if (opt.dry_run)
735     return 0;
736
737   rc = lock_all (hd);
738   if (rc)
739     return rc;
740
741   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
742
743   switch (hd->active[hd->found].type)
744     {
745     case KEYDB_RESOURCE_TYPE_NONE:
746       rc = gpg_error (GPG_ERR_GENERAL); /* oops */
747       break;
748     case KEYDB_RESOURCE_TYPE_KEYBOX:
749       rc = keybox_update_cert (hd->active[hd->found].u.kr, cert, digest);
750       break;
751     }
752
753   unlock_all (hd);
754   return rc;
755 }
756
757
758 /*
759  * The current keyblock or cert will be deleted.
760  */
761 int
762 keydb_delete (KEYDB_HANDLE hd, int unlock)
763 {
764   int rc = -1;
765
766   if (!hd)
767     return gpg_error (GPG_ERR_INV_VALUE);
768
769   if ( hd->found < 0 || hd->found >= hd->used)
770     return -1; /* nothing found */
771
772   if( opt.dry_run )
773     return 0;
774
775   if (!hd->locked)
776     return gpg_error (GPG_ERR_NOT_LOCKED);
777
778   switch (hd->active[hd->found].type)
779     {
780     case KEYDB_RESOURCE_TYPE_NONE:
781       rc = gpg_error (GPG_ERR_GENERAL);
782       break;
783     case KEYDB_RESOURCE_TYPE_KEYBOX:
784       rc = keybox_delete (hd->active[hd->found].u.kr);
785       break;
786     }
787
788   if (unlock)
789     unlock_all (hd);
790   return rc;
791 }
792
793
794 \f
795 /*
796  * Locate the default writable key resource, so that the next
797  * operation (which is only relevant for inserts) will be done on this
798  * resource.
799  */
800 int
801 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
802 {
803   int rc;
804
805   (void)reserved;
806
807   if (!hd)
808     return gpg_error (GPG_ERR_INV_VALUE);
809
810   rc = keydb_search_reset (hd); /* this does reset hd->current */
811   if (rc)
812     return rc;
813
814   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
815     {
816       switch (hd->active[hd->current].type)
817         {
818         case KEYDB_RESOURCE_TYPE_NONE:
819           BUG();
820           break;
821         case KEYDB_RESOURCE_TYPE_KEYBOX:
822           if (keybox_is_writable (hd->active[hd->current].token))
823             return 0; /* found (hd->current is set to it) */
824           break;
825         }
826     }
827
828   return -1;
829 }
830
831 /*
832  * Rebuild the caches of all key resources.
833  */
834 void
835 keydb_rebuild_caches (void)
836 {
837   int i;
838
839   for (i=0; i < used_resources; i++)
840     {
841       if (all_resources[i].secret)
842         continue;
843       switch (all_resources[i].type)
844         {
845         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
846           break;
847         case KEYDB_RESOURCE_TYPE_KEYBOX:
848 /*            rc = keybox_rebuild_cache (all_resources[i].token); */
849 /*            if (rc) */
850 /*              log_error (_("failed to rebuild keybox cache: %s\n"), */
851 /*                         g10_errstr (rc)); */
852           break;
853         }
854     }
855 }
856
857
858
859 /*
860  * Start the next search on this handle right at the beginning
861  */
862 int
863 keydb_search_reset (KEYDB_HANDLE hd)
864 {
865   int i, rc = 0;
866
867   if (!hd)
868     return gpg_error (GPG_ERR_INV_VALUE);
869
870   hd->current = 0;
871   hd->found = -1;
872   /* and reset all resources */
873   for (i=0; !rc && i < hd->used; i++)
874     {
875       switch (hd->active[i].type)
876         {
877         case KEYDB_RESOURCE_TYPE_NONE:
878           break;
879         case KEYDB_RESOURCE_TYPE_KEYBOX:
880           rc = keybox_search_reset (hd->active[i].u.kr);
881           break;
882         }
883     }
884   return rc; /* fixme: we need to map error codes or share them with
885                 all modules*/
886 }
887
888 /*
889  * Search through all keydb resources, starting at the current position,
890  * for a keyblock which contains one of the keys described in the DESC array.
891  */
892 int
893 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
894 {
895   int rc = -1;
896
897   if (!hd)
898     return gpg_error (GPG_ERR_INV_VALUE);
899
900   while (rc == -1 && hd->current >= 0 && hd->current < hd->used)
901     {
902       switch (hd->active[hd->current].type)
903         {
904         case KEYDB_RESOURCE_TYPE_NONE:
905           BUG(); /* we should never see it here */
906           break;
907         case KEYDB_RESOURCE_TYPE_KEYBOX:
908           rc = keybox_search (hd->active[hd->current].u.kr, desc, ndesc);
909           break;
910         }
911       if (rc == -1) /* EOF -> switch to next resource */
912         hd->current++;
913       else if (!rc)
914         hd->found = hd->current;
915     }
916
917   return rc;
918 }
919
920
921 int
922 keydb_search_first (KEYDB_HANDLE hd)
923 {
924   KEYDB_SEARCH_DESC desc;
925
926   memset (&desc, 0, sizeof desc);
927   desc.mode = KEYDB_SEARCH_MODE_FIRST;
928   return keydb_search (hd, &desc, 1);
929 }
930
931 int
932 keydb_search_next (KEYDB_HANDLE hd)
933 {
934   KEYDB_SEARCH_DESC desc;
935
936   memset (&desc, 0, sizeof desc);
937   desc.mode = KEYDB_SEARCH_MODE_NEXT;
938   return keydb_search (hd, &desc, 1);
939 }
940
941 int
942 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
943 {
944   KEYDB_SEARCH_DESC desc;
945
946   (void)kid;
947
948   memset (&desc, 0, sizeof desc);
949   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
950 /*    desc.u.kid[0] = kid[0]; */
951 /*    desc.u.kid[1] = kid[1]; */
952   return keydb_search (hd, &desc, 1);
953 }
954
955 int
956 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
957 {
958   KEYDB_SEARCH_DESC desc;
959
960   memset (&desc, 0, sizeof desc);
961   desc.mode = KEYDB_SEARCH_MODE_FPR;
962   memcpy (desc.u.fpr, fpr, 20);
963   return keydb_search (hd, &desc, 1);
964 }
965
966 int
967 keydb_search_issuer (KEYDB_HANDLE hd, const char *issuer)
968 {
969   KEYDB_SEARCH_DESC desc;
970   int rc;
971
972   memset (&desc, 0, sizeof desc);
973   desc.mode = KEYDB_SEARCH_MODE_ISSUER;
974   desc.u.name = issuer;
975   rc = keydb_search (hd, &desc, 1);
976   return rc;
977 }
978
979 int
980 keydb_search_issuer_sn (KEYDB_HANDLE hd,
981                         const char *issuer, ksba_const_sexp_t serial)
982 {
983   KEYDB_SEARCH_DESC desc;
984   int rc;
985   const unsigned char *s;
986
987   memset (&desc, 0, sizeof desc);
988   desc.mode = KEYDB_SEARCH_MODE_ISSUER_SN;
989   s = serial;
990   if (*s !='(')
991     return gpg_error (GPG_ERR_INV_VALUE);
992   s++;
993   for (desc.snlen = 0; digitp (s); s++)
994     desc.snlen = 10*desc.snlen + atoi_1 (s);
995   if (*s !=':')
996     return gpg_error (GPG_ERR_INV_VALUE);
997   desc.sn = s+1;
998   desc.u.name = issuer;
999   rc = keydb_search (hd, &desc, 1);
1000   return rc;
1001 }
1002
1003 int
1004 keydb_search_subject (KEYDB_HANDLE hd, const char *name)
1005 {
1006   KEYDB_SEARCH_DESC desc;
1007   int rc;
1008
1009   memset (&desc, 0, sizeof desc);
1010   desc.mode = KEYDB_SEARCH_MODE_SUBJECT;
1011   desc.u.name = name;
1012   rc = keydb_search (hd, &desc, 1);
1013   return rc;
1014 }
1015
1016
1017 static int
1018 classify_user_id (const char *name,
1019                   KEYDB_SEARCH_DESC *desc,
1020                   int *force_exact )
1021 {
1022   const char *s;
1023   int hexprefix = 0;
1024   int hexlength;
1025   int mode = 0;
1026
1027   /* clear the structure so that the mode field is set to zero unless
1028    * we set it to the correct value right at the end of this function */
1029   memset (desc, 0, sizeof *desc);
1030   *force_exact = 0;
1031   /* Skip leading spaces.  Fixme: what about trailing white space? */
1032   for(s = name; *s && spacep (s); s++ )
1033     ;
1034
1035   switch (*s)
1036     {
1037     case 0:  /* empty string is an error */
1038       return 0;
1039
1040     case '.': /* an email address, compare from end */
1041       mode = KEYDB_SEARCH_MODE_MAILEND;
1042       s++;
1043       desc->u.name = s;
1044       break;
1045
1046     case '<': /* an email address */
1047       mode = KEYDB_SEARCH_MODE_MAIL;
1048       s++;
1049       desc->u.name = s;
1050       break;
1051
1052     case '@':  /* part of an email address */
1053       mode = KEYDB_SEARCH_MODE_MAILSUB;
1054       s++;
1055       desc->u.name = s;
1056       break;
1057
1058     case '=':  /* exact compare */
1059       mode = KEYDB_SEARCH_MODE_EXACT;
1060       s++;
1061       desc->u.name = s;
1062       break;
1063
1064     case '*':  /* case insensitive substring search */
1065       mode = KEYDB_SEARCH_MODE_SUBSTR;
1066       s++;
1067       desc->u.name = s;
1068       break;
1069
1070     case '+':  /* compare individual words */
1071       mode = KEYDB_SEARCH_MODE_WORDS;
1072       s++;
1073       desc->u.name = s;
1074       break;
1075
1076     case '/': /* subject's DN */
1077       s++;
1078       if (!*s || spacep (s))
1079         return 0; /* no DN or prefixed with a space */
1080       desc->u.name = s;
1081       mode = KEYDB_SEARCH_MODE_SUBJECT;
1082       break;
1083
1084     case '#':
1085       {
1086         const char *si;
1087
1088         s++;
1089         if ( *s == '/')
1090           { /* "#/" indicates an issuer's DN */
1091             s++;
1092             if (!*s || spacep (s))
1093               return 0; /* no DN or prefixed with a space */
1094             desc->u.name = s;
1095             mode = KEYDB_SEARCH_MODE_ISSUER;
1096           }
1097         else
1098           { /* serialnumber + optional issuer ID */
1099             for (si=s; *si && *si != '/'; si++)
1100               {
1101                 if (!strchr("01234567890abcdefABCDEF", *si))
1102                   return 0; /* invalid digit in serial number*/
1103               }
1104             desc->sn = (const unsigned char*)s;
1105             desc->snlen = -1;
1106             if (!*si)
1107               mode = KEYDB_SEARCH_MODE_SN;
1108             else
1109               {
1110                 s = si+1;
1111                 if (!*s || spacep (s))
1112                   return 0; /* no DN or prefixed with a space */
1113                 desc->u.name = s;
1114                 mode = KEYDB_SEARCH_MODE_ISSUER_SN;
1115               }
1116           }
1117       }
1118       break;
1119
1120     case ':': /*Unified fingerprint */
1121       {
1122         const char *se, *si;
1123         int i;
1124
1125         se = strchr (++s,':');
1126         if (!se)
1127           return 0;
1128         for (i=0,si=s; si < se; si++, i++ )
1129           {
1130             if (!strchr("01234567890abcdefABCDEF", *si))
1131               return 0; /* invalid digit */
1132           }
1133         if (i != 32 && i != 40)
1134           return 0; /* invalid length of fpr*/
1135         for (i=0,si=s; si < se; i++, si +=2)
1136           desc->u.fpr[i] = hextobyte(si);
1137         for (; i < 20; i++)
1138           desc->u.fpr[i]= 0;
1139         s = se + 1;
1140         mode = KEYDB_SEARCH_MODE_FPR;
1141       }
1142       break;
1143
1144     case '&': /* Keygrip*/
1145       {
1146         if (hex2bin (s+1, desc->u.grip, 20) < 0)
1147           return 0; /* Invalid. */
1148         mode = KEYDB_SEARCH_MODE_KEYGRIP;
1149       }
1150       break;
1151
1152     default:
1153       if (s[0] == '0' && s[1] == 'x')
1154         {
1155           hexprefix = 1;
1156           s += 2;
1157         }
1158
1159       hexlength = strspn(s, "0123456789abcdefABCDEF");
1160       if (hexlength >= 8 && s[hexlength] =='!')
1161         {
1162           *force_exact = 1;
1163           hexlength++; /* just for the following check */
1164         }
1165
1166       /* check if a hexadecimal number is terminated by EOS or blank */
1167       if (hexlength && s[hexlength] && !spacep (s+hexlength))
1168         {
1169           if (hexprefix) /* a "0x" prefix without correct */
1170             return 0;    /* termination is an error */
1171           /* The first chars looked like a hex number, but really is
1172              not */
1173           hexlength = 0;
1174         }
1175
1176       if (*force_exact)
1177         hexlength--; /* remove the bang */
1178
1179       if (hexlength == 8
1180           || (!hexprefix && hexlength == 9 && *s == '0'))
1181         { /* short keyid */
1182           unsigned long kid;
1183           if (hexlength == 9)
1184             s++;
1185           kid = strtoul( s, NULL, 16 );
1186           desc->u.kid[4] = kid >> 24;
1187           desc->u.kid[5] = kid >> 16;
1188           desc->u.kid[6] = kid >>  8;
1189           desc->u.kid[7] = kid;
1190           mode = KEYDB_SEARCH_MODE_SHORT_KID;
1191         }
1192       else if (hexlength == 16
1193                || (!hexprefix && hexlength == 17 && *s == '0'))
1194         { /* complete keyid */
1195           unsigned long kid0, kid1;
1196           char buf[9];
1197           if (hexlength == 17)
1198             s++;
1199           mem2str(buf, s, 9 );
1200           kid0 = strtoul (buf, NULL, 16);
1201           kid1 = strtoul (s+8, NULL, 16);
1202           desc->u.kid[0] = kid0 >> 24;
1203           desc->u.kid[1] = kid0 >> 16;
1204           desc->u.kid[2] = kid0 >>  8;
1205           desc->u.kid[3] = kid0;
1206           desc->u.kid[4] = kid1 >> 24;
1207           desc->u.kid[5] = kid1 >> 16;
1208           desc->u.kid[6] = kid1 >>  8;
1209           desc->u.kid[7] = kid1;
1210           mode = KEYDB_SEARCH_MODE_LONG_KID;
1211         }
1212       else if (hexlength == 32
1213                || (!hexprefix && hexlength == 33 && *s == '0'))
1214         { /* md5 fingerprint */
1215           int i;
1216           if (hexlength == 33)
1217             s++;
1218           memset(desc->u.fpr+16, 0, 4);
1219           for (i=0; i < 16; i++, s+=2)
1220             {
1221               int c = hextobyte(s);
1222               if (c == -1)
1223                 return 0;
1224               desc->u.fpr[i] = c;
1225             }
1226           mode = KEYDB_SEARCH_MODE_FPR16;
1227         }
1228       else if (hexlength == 40
1229                || (!hexprefix && hexlength == 41 && *s == '0'))
1230         { /* sha1/rmd160 fingerprint */
1231           int i;
1232           if (hexlength == 41)
1233             s++;
1234           for (i=0; i < 20; i++, s+=2)
1235             {
1236               int c = hextobyte(s);
1237               if (c == -1)
1238                 return 0;
1239               desc->u.fpr[i] = c;
1240             }
1241           mode = KEYDB_SEARCH_MODE_FPR20;
1242         }
1243       else if (!hexprefix)
1244         {
1245           /* The fingerprint in an X.509 listing is often delimited by
1246              colons, so we try to single this case out. */
1247           mode = 0;
1248           hexlength = strspn (s, ":0123456789abcdefABCDEF");
1249           if (hexlength == 59 && (!s[hexlength] || spacep (s+hexlength)))
1250             {
1251               int i;
1252
1253               for (i=0; i < 20; i++, s += 3)
1254                 {
1255                   int c = hextobyte(s);
1256                   if (c == -1 || (i < 19 && s[2] != ':'))
1257                     break;
1258                   desc->u.fpr[i] = c;
1259                 }
1260               if (i == 20)
1261                 mode = KEYDB_SEARCH_MODE_FPR20;
1262             }
1263           if (!mode) /* default is substring search */
1264             {
1265               *force_exact = 0;
1266               desc->u.name = s;
1267               mode = KEYDB_SEARCH_MODE_SUBSTR;
1268             }
1269         }
1270       else
1271         { /* hex number with a prefix but a wrong length */
1272           return 0;
1273         }
1274     }
1275
1276   desc->mode = mode;
1277   return mode;
1278 }
1279
1280
1281 int
1282 keydb_classify_name (const char *name, KEYDB_SEARCH_DESC *desc)
1283 {
1284   int dummy;
1285   KEYDB_SEARCH_DESC dummy_desc;
1286
1287   if (!desc)
1288     desc = &dummy_desc;
1289
1290   if (!classify_user_id (name, desc, &dummy))
1291     return gpg_error (GPG_ERR_INV_NAME);
1292   return 0;
1293 }
1294
1295 \f
1296 /* Store the certificate in the key DB but make sure that it does not
1297    already exists.  We do this simply by comparing the fingerprint.
1298    If EXISTED is not NULL it will be set to true if the certificate
1299    was already in the DB. */
1300 int
1301 keydb_store_cert (ksba_cert_t cert, int ephemeral, int *existed)
1302 {
1303   KEYDB_HANDLE kh;
1304   int rc;
1305   unsigned char fpr[20];
1306
1307   if (existed)
1308     *existed = 0;
1309
1310   if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
1311     {
1312       log_error (_("failed to get the fingerprint\n"));
1313       return gpg_error (GPG_ERR_GENERAL);
1314     }
1315
1316   kh = keydb_new (0);
1317   if (!kh)
1318     {
1319       log_error (_("failed to allocate keyDB handle\n"));
1320       return gpg_error (GPG_ERR_ENOMEM);;
1321     }
1322
1323   if (ephemeral)
1324     keydb_set_ephemeral (kh, 1);
1325
1326   rc = lock_all (kh);
1327   if (rc)
1328     return rc;
1329
1330   rc = keydb_search_fpr (kh, fpr);
1331   if (rc != -1)
1332     {
1333       keydb_release (kh);
1334       if (!rc)
1335         {
1336           if (existed)
1337             *existed = 1;
1338           return 0; /* okay */
1339         }
1340       log_error (_("problem looking for existing certificate: %s\n"),
1341                  gpg_strerror (rc));
1342       return rc;
1343     }
1344
1345   rc = keydb_locate_writable (kh, 0);
1346   if (rc)
1347     {
1348       log_error (_("error finding writable keyDB: %s\n"), gpg_strerror (rc));
1349       keydb_release (kh);
1350       return rc;
1351     }
1352
1353   rc = keydb_insert_cert (kh, cert);
1354   if (rc)
1355     {
1356       log_error (_("error storing certificate: %s\n"), gpg_strerror (rc));
1357       keydb_release (kh);
1358       return rc;
1359     }
1360   keydb_release (kh);
1361   return 0;
1362 }
1363
1364
1365 /* This is basically keydb_set_flags but it implements a complete
1366    transaction by locating the certificate in the DB and updating the
1367    flags. */
1368 gpg_error_t
1369 keydb_set_cert_flags (ksba_cert_t cert, int ephemeral,
1370                       int which, int idx,
1371                       unsigned int mask, unsigned int value)
1372 {
1373   KEYDB_HANDLE kh;
1374   gpg_error_t err;
1375   unsigned char fpr[20];
1376   unsigned int old_value;
1377
1378   if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
1379     {
1380       log_error (_("failed to get the fingerprint\n"));
1381       return gpg_error (GPG_ERR_GENERAL);
1382     }
1383
1384   kh = keydb_new (0);
1385   if (!kh)
1386     {
1387       log_error (_("failed to allocate keyDB handle\n"));
1388       return gpg_error (GPG_ERR_ENOMEM);;
1389     }
1390
1391   if (ephemeral)
1392     keydb_set_ephemeral (kh, 1);
1393
1394   err = keydb_lock (kh);
1395   if (err)
1396     {
1397       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1398       keydb_release (kh);
1399       return err;
1400     }
1401
1402   err = keydb_search_fpr (kh, fpr);
1403   if (err)
1404     {
1405       if (err == -1)
1406         err = gpg_error (GPG_ERR_NOT_FOUND);
1407       else
1408         log_error (_("problem re-searching certificate: %s\n"),
1409                    gpg_strerror (err));
1410       keydb_release (kh);
1411       return err;
1412     }
1413
1414   err = keydb_get_flags (kh, which, idx, &old_value);
1415   if (err)
1416     {
1417       log_error (_("error getting stored flags: %s\n"), gpg_strerror (err));
1418       keydb_release (kh);
1419       return err;
1420     }
1421
1422   value = ((old_value & ~mask) | (value & mask));
1423
1424   if (value != old_value)
1425     {
1426       err = keydb_set_flags (kh, which, idx, value);
1427       if (err)
1428         {
1429           log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1430           keydb_release (kh);
1431           return err;
1432         }
1433     }
1434
1435   keydb_release (kh);
1436   return 0;
1437 }
1438
1439
1440 /* Reset all the certificate flags we have stored with the certificates
1441    for performance reasons. */
1442 void
1443 keydb_clear_some_cert_flags (ctrl_t ctrl, strlist_t names)
1444 {
1445   gpg_error_t err;
1446   KEYDB_HANDLE hd = NULL;
1447   KEYDB_SEARCH_DESC *desc = NULL;
1448   int ndesc;
1449   strlist_t sl;
1450   int rc=0;
1451   unsigned int old_value, value;
1452
1453   (void)ctrl;
1454
1455   hd = keydb_new (0);
1456   if (!hd)
1457     {
1458       log_error ("keydb_new failed\n");
1459       goto leave;
1460     }
1461
1462   if (!names)
1463     ndesc = 1;
1464   else
1465     {
1466       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
1467         ;
1468     }
1469
1470   desc = xtrycalloc (ndesc, sizeof *desc);
1471   if (!ndesc)
1472     {
1473       log_error ("allocating memory failed: %s\n",
1474                  gpg_strerror (out_of_core ()));
1475       goto leave;
1476     }
1477
1478   if (!names)
1479     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1480   else
1481     {
1482       for (ndesc=0, sl=names; sl; sl = sl->next)
1483         {
1484           rc = keydb_classify_name (sl->d, desc+ndesc);
1485           if (rc)
1486             {
1487               log_error ("key `%s' not found: %s\n",
1488                          sl->d, gpg_strerror (rc));
1489               rc = 0;
1490             }
1491           else
1492             ndesc++;
1493         }
1494     }
1495
1496   err = keydb_lock (hd);
1497   if (err)
1498     {
1499       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1500       goto leave;
1501     }
1502
1503   while (!(rc = keydb_search (hd, desc, ndesc)))
1504     {
1505       if (!names)
1506         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1507
1508       err = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &old_value);
1509       if (err)
1510         {
1511           log_error (_("error getting stored flags: %s\n"),
1512                      gpg_strerror (err));
1513           goto leave;
1514         }
1515
1516       value = (old_value & ~VALIDITY_REVOKED);
1517       if (value != old_value)
1518         {
1519           err = keydb_set_flags (hd, KEYBOX_FLAG_VALIDITY, 0, value);
1520           if (err)
1521             {
1522               log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1523               goto leave;
1524             }
1525         }
1526     }
1527   if (rc && rc != -1)
1528     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1529
1530  leave:
1531   xfree (desc);
1532   keydb_release (hd);
1533 }
1534
1535