kbx/
[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     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   hd = keydb_new (0);
1454   if (!hd)
1455     {
1456       log_error ("keydb_new failed\n");
1457       goto leave;
1458     }
1459
1460   if (!names)
1461     ndesc = 1;
1462   else
1463     {
1464       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++) 
1465         ;
1466     }
1467
1468   desc = xtrycalloc (ndesc, sizeof *desc);
1469   if (!ndesc)
1470     {
1471       log_error ("allocating memory failed: %s\n",
1472                  gpg_strerror (out_of_core ()));
1473       goto leave;
1474     }
1475
1476   if (!names)
1477     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1478   else 
1479     {
1480       for (ndesc=0, sl=names; sl; sl = sl->next) 
1481         {
1482           rc = keydb_classify_name (sl->d, desc+ndesc);
1483           if (rc)
1484             {
1485               log_error ("key `%s' not found: %s\n",
1486                          sl->d, gpg_strerror (rc));
1487               rc = 0;
1488             }
1489           else
1490             ndesc++;
1491         }
1492     }
1493
1494   err = keydb_lock (hd);
1495   if (err)
1496     {
1497       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1498       goto leave;
1499     }
1500
1501   while (!(rc = keydb_search (hd, desc, ndesc)))
1502     {
1503       if (!names) 
1504         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1505
1506       err = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &old_value);
1507       if (err)
1508         {
1509           log_error (_("error getting stored flags: %s\n"),
1510                      gpg_strerror (err));
1511           goto leave;
1512         }
1513  
1514       value = (old_value & ~VALIDITY_REVOKED);
1515       if (value != old_value)
1516         {
1517           err = keydb_set_flags (hd, KEYBOX_FLAG_VALIDITY, 0, value);
1518           if (err)
1519             {
1520               log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1521               goto leave;
1522             }
1523         }
1524     }
1525   if (rc && rc != -1)
1526     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1527   
1528  leave:
1529   xfree (desc);
1530   keydb_release (hd);
1531 }
1532
1533