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