More changes on the way to remove secring.gpg.
[gnupg.git] / g10 / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 
3  *               2008, 2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30
31 #include "gpg.h"
32 #include "util.h"
33 #include "options.h"
34 #include "main.h" /*try_make_homedir ()*/
35 #include "packet.h"
36 #include "keyring.h"
37 #include "keydb.h" 
38 #include "i18n.h"
39
40 static int active_handles;
41
42 typedef enum {
43     KEYDB_RESOURCE_TYPE_NONE = 0,
44     KEYDB_RESOURCE_TYPE_KEYRING
45 } KeydbResourceType;
46 #define MAX_KEYDB_RESOURCES 40
47
48 struct resource_item {
49   KeydbResourceType type;
50   union {
51     KEYRING_HANDLE kr;
52   } u;
53   void *token;
54   int secret;
55 };
56
57 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
58 static int used_resources;
59 static void *primary_keyring=NULL;
60
61 struct keydb_handle {
62   int locked;
63   int found;
64   int current;
65   int used; /* items in active */
66   struct resource_item active[MAX_KEYDB_RESOURCES];
67 };
68
69
70 static int lock_all (KEYDB_HANDLE hd);
71 static void unlock_all (KEYDB_HANDLE hd);
72
73
74 /* Handle the creation of a keyring if it does not yet exist.  Take
75    into acount that other processes might have the keyring already
76    locked.  This lock check does not work if the directory itself is
77    not yet available. */
78 static int
79 maybe_create_keyring (char *filename, int force)
80 {
81   dotlock_t lockhd = NULL;
82   IOBUF iobuf;
83   int rc;
84   mode_t oldmask;
85   char *last_slash_in_filename;
86   int save_slash;
87
88   /* A quick test whether the filename already exists. */
89   if (!access (filename, F_OK))
90     return 0;
91
92   /* If we don't want to create a new file at all, there is no need to
93      go any further - bail out right here.  */
94   if (!force) 
95     return gpg_error (GPG_ERR_ENOENT);
96
97   /* First of all we try to create the home directory.  Note, that we
98      don't do any locking here because any sane application of gpg
99      would create the home directory by itself and not rely on gpg's
100      tricky auto-creation which is anyway only done for some home
101      directory name patterns. */
102   last_slash_in_filename = strrchr (filename, DIRSEP_C);
103 #if HAVE_W32_SYSTEM
104   {
105     /* Windows may either have a slash or a backslash.  Take care of it.  */
106     char *p = strrchr (filename, '/');
107     if (!last_slash_in_filename || p > last_slash_in_filename)
108       last_slash_in_filename = p;
109   }
110 #endif /*HAVE_W32_SYSTEM*/
111   if (!last_slash_in_filename)
112     return gpg_error (GPG_ERR_ENOENT);  /* No slash at all - should
113                                            not happen though.  */
114   save_slash = *last_slash_in_filename;
115   *last_slash_in_filename = 0;
116   if (access(filename, F_OK))
117     { 
118       static int tried;
119       
120       if (!tried)
121         {
122           tried = 1;
123           try_make_homedir (filename);
124         }
125       if (access (filename, F_OK))
126         {
127           rc = gpg_error_from_syserror ();
128           *last_slash_in_filename = save_slash;
129           goto leave;
130         }
131     }
132   *last_slash_in_filename = save_slash;
133
134   /* To avoid races with other instances of gpg trying to create or
135      update the keyring (it is removed during an update for a short
136      time), we do the next stuff in a locked state. */
137   lockhd = create_dotlock (filename);
138   if (!lockhd)
139     {
140       /* A reason for this to fail is that the directory is not
141          writable. However, this whole locking stuff does not make
142          sense if this is the case. An empty non-writable directory
143          with no keyring is not really useful at all. */
144       if (opt.verbose)
145         log_info ("can't allocate lock for `%s'\n", filename );
146
147       if (!force) 
148         return gpg_error (GPG_ERR_ENOENT); 
149       else
150         return gpg_error (GPG_ERR_GENERAL);
151     }
152
153   if ( make_dotlock (lockhd, -1) )
154     {
155       /* This is something bad.  Probably a stale lockfile.  */
156       log_info ("can't lock `%s'\n", filename );
157       rc = G10ERR_GENERAL;
158       goto leave;
159     }
160
161   /* Now the real test while we are locked. */
162   if (!access(filename, F_OK))
163     {
164       rc = 0;  /* Okay, we may access the file now.  */
165       goto leave;
166     }
167
168   /* The file does not yet exist, create it now. */
169   oldmask = umask (077);
170   if (is_secured_filename (filename))
171     {
172       iobuf = NULL;
173       gpg_err_set_errno (EPERM);
174     }
175   else
176     iobuf = iobuf_create (filename);
177   umask (oldmask);
178   if (!iobuf) 
179     {
180       rc = gpg_error_from_syserror ();
181       log_error ( _("error creating keyring `%s': %s\n"),
182                   filename, strerror(errno));
183       goto leave;
184     }
185
186   if (!opt.quiet)
187     log_info (_("keyring `%s' created\n"), filename);
188
189   iobuf_close (iobuf);
190   /* Must invalidate that ugly cache */
191   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, filename);
192   rc = 0;
193
194  leave:
195   if (lockhd)
196     {
197       release_dotlock (lockhd);
198       destroy_dotlock (lockhd);
199     }
200   return rc;
201 }
202
203
204 /*
205  * Register a resource (which currently may only be a keyring file).
206  * The first keyring which is added by this function is
207  * created if it does not exist.
208  * Note: this function may be called before secure memory is
209  * available.
210  * Flag 1   - Force.
211  * Flag 2   - Mark resource as primary.
212  * Flag 4   - This is a default resources.
213  * Flag 8   - Open as read-only.
214  */
215 int
216 keydb_add_resource (const char *url, int flags, int secret)
217 {
218     static int any_secret, any_public;
219     const char *resname = url;
220     char *filename = NULL;
221     int force = (flags&1);
222     int read_only = !!(flags&8);
223     int rc = 0;
224     KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
225     void *token;
226
227     if (read_only)
228       force = 0;
229
230     /* Do we have an URL?
231      *  gnupg-ring:filename  := this is a plain keyring
232      *  filename := See what is is, but create as plain keyring.
233      */
234     if (strlen (resname) > 11) {
235         if (!strncmp( resname, "gnupg-ring:", 11) ) {
236             rt = KEYDB_RESOURCE_TYPE_KEYRING;
237             resname += 11;
238         }
239 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
240         else if (strchr (resname, ':')) {
241             log_error ("invalid key resource URL `%s'\n", url );
242             rc = G10ERR_GENERAL;
243             goto leave;
244         }
245 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
246     }
247
248     if (*resname != DIRSEP_C ) { /* do tilde expansion etc */
249         if (strchr(resname, DIRSEP_C) )
250             filename = make_filename (resname, NULL);
251         else
252             filename = make_filename (opt.homedir, resname, NULL);
253     }
254     else
255         filename = xstrdup (resname);
256
257     if (!force && !read_only)
258         force = secret? !any_secret : !any_public;
259
260     /* See whether we can determine the filetype.  */
261     if (rt == KEYDB_RESOURCE_TYPE_NONE) {
262         FILE *fp = fopen( filename, "rb" );
263
264         if (fp) {
265             u32 magic;
266
267             if (fread( &magic, 4, 1, fp) == 1 ) {
268                 if (magic == 0x13579ace || magic == 0xce9a5713)
269                     ; /* GDBM magic - no more support */
270                 else
271                     rt = KEYDB_RESOURCE_TYPE_KEYRING;
272             }
273             else /* maybe empty: assume ring */
274                 rt = KEYDB_RESOURCE_TYPE_KEYRING;
275             fclose( fp );
276         }
277         else /* no file yet: create ring */
278             rt = KEYDB_RESOURCE_TYPE_KEYRING;
279     }
280
281     switch (rt) {
282       case KEYDB_RESOURCE_TYPE_NONE:
283         log_error ("unknown type of key resource `%s'\n", url );
284         rc = G10ERR_GENERAL;
285         goto leave;
286
287       case KEYDB_RESOURCE_TYPE_KEYRING:
288         rc = maybe_create_keyring (filename, force);
289         if (rc)
290           goto leave;
291
292         if(keyring_register_filename (filename, secret, read_only, &token))
293           {
294             if (used_resources >= MAX_KEYDB_RESOURCES)
295               rc = G10ERR_RESOURCE_LIMIT;
296             else 
297               {
298                 if(flags&2)
299                   primary_keyring=token;
300                 all_resources[used_resources].type = rt;
301                 all_resources[used_resources].u.kr = NULL; /* Not used here */
302                 all_resources[used_resources].token = token;
303                 all_resources[used_resources].secret = secret;
304                 used_resources++;
305               }
306           }
307         else
308           {
309             /* This keyring was already registered, so ignore it.
310                However, we can still mark it as primary even if it was
311                already registered. */
312             if(flags&2)
313               primary_keyring=token;
314           }
315         break;
316
317       default:
318         log_error ("resource type of `%s' not supported\n", url);
319         rc = G10ERR_GENERAL;
320         goto leave;
321     }
322
323     /* fixme: check directory permissions and print a warning */
324
325   leave:
326     if (rc)
327       {
328         /* Secret keyrings are not required in all cases.  To avoid
329            having gpg return failure we use log_info here if the
330            rewsource is a secret one and marked as default
331            resource.  */
332         if ((flags&4) && secret)
333           log_info (_("keyblock resource `%s': %s\n"),
334                     filename, g10_errstr(rc));
335         else
336           log_error (_("keyblock resource `%s': %s\n"),
337                      filename, g10_errstr(rc));
338       }
339     else if (secret)
340         any_secret = 1;
341     else
342         any_public = 1;
343     xfree (filename);
344     return rc;
345 }
346
347
348
349
350 KEYDB_HANDLE
351 keydb_new (void)
352 {
353   KEYDB_HANDLE hd;
354   int i, j;
355   int secret = 0; /* FIXME: Remove the secret stuff all together.  */
356   
357   hd = xmalloc_clear (sizeof *hd);
358   hd->found = -1;
359   
360   assert (used_resources <= MAX_KEYDB_RESOURCES);
361   for (i=j=0; i < used_resources; i++)
362     {
363       if (!all_resources[i].secret != !secret)
364         continue;
365       switch (all_resources[i].type)
366         {
367         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
368           break;
369         case KEYDB_RESOURCE_TYPE_KEYRING:
370           hd->active[j].type   = all_resources[i].type;
371           hd->active[j].token  = all_resources[i].token;
372           hd->active[j].secret = all_resources[i].secret;
373           hd->active[j].u.kr = keyring_new (all_resources[i].token, secret);
374           if (!hd->active[j].u.kr) {
375             xfree (hd);
376             return NULL; /* fixme: release all previously allocated handles*/
377           }
378           j++;
379           break;
380         }
381     }
382   hd->used = j;
383   
384   active_handles++;
385   return hd;
386 }
387
388 void 
389 keydb_release (KEYDB_HANDLE hd)
390 {
391     int i;
392
393     if (!hd)
394         return;
395     assert (active_handles > 0);
396     active_handles--;
397
398     unlock_all (hd);
399     for (i=0; i < hd->used; i++) {
400         switch (hd->active[i].type) {
401           case KEYDB_RESOURCE_TYPE_NONE:
402             break;
403           case KEYDB_RESOURCE_TYPE_KEYRING:
404             keyring_release (hd->active[i].u.kr);
405             break;
406         }
407     }
408
409     xfree (hd);
410 }
411
412
413 /*
414  * Return the name of the current resource.  This is function first
415  * looks for the last found found, then for the current search
416  * position, and last returns the first available resource.  The
417  * returned string is only valid as long as the handle exists.  This
418  * function does only return NULL if no handle is specified, in all
419  * other error cases an empty string is returned.
420  */
421 const char *
422 keydb_get_resource_name (KEYDB_HANDLE hd)
423 {
424     int idx;
425     const char *s = NULL;
426
427     if (!hd) 
428         return NULL;
429
430     if ( hd->found >= 0 && hd->found < hd->used) 
431         idx = hd->found;
432     else if ( hd->current >= 0 && hd->current < hd->used) 
433         idx = hd->current;
434     else
435         idx = 0;
436
437     switch (hd->active[idx].type) {
438       case KEYDB_RESOURCE_TYPE_NONE:
439         s = NULL; 
440         break;
441       case KEYDB_RESOURCE_TYPE_KEYRING:
442         s = keyring_get_resource_name (hd->active[idx].u.kr);
443         break;
444     }
445
446     return s? s: "";
447 }
448
449
450
451 static int 
452 lock_all (KEYDB_HANDLE hd)
453 {
454     int i, rc = 0;
455
456     for (i=0; !rc && i < hd->used; i++) {
457         switch (hd->active[i].type) {
458           case KEYDB_RESOURCE_TYPE_NONE:
459             break;
460           case KEYDB_RESOURCE_TYPE_KEYRING:
461             rc = keyring_lock (hd->active[i].u.kr, 1);
462             break;
463         }
464     }
465
466     if (rc) {
467         /* revert the already set locks */
468         for (i--; i >= 0; i--) {
469             switch (hd->active[i].type) {
470               case KEYDB_RESOURCE_TYPE_NONE:
471                 break;
472               case KEYDB_RESOURCE_TYPE_KEYRING:
473                 keyring_lock (hd->active[i].u.kr, 0);
474                 break;
475             }
476         }
477     }
478     else
479         hd->locked = 1;
480
481     return rc;
482 }
483
484 static void
485 unlock_all (KEYDB_HANDLE hd)
486 {
487     int i;
488
489     if (!hd->locked)
490         return;
491
492     for (i=hd->used-1; i >= 0; i--) {
493         switch (hd->active[i].type) {
494           case KEYDB_RESOURCE_TYPE_NONE:
495             break;
496           case KEYDB_RESOURCE_TYPE_KEYRING:
497             keyring_lock (hd->active[i].u.kr, 0);
498             break;
499         }
500     }
501     hd->locked = 0;
502 }
503
504
505 /*
506  * Return the last found keyring.  Caller must free it.
507  * The returned keyblock has the kbode flag bit 0 set for the node with
508  * the public key used to locate the keyblock or flag bit 1 set for 
509  * the user ID node.
510  */
511 int
512 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
513 {
514     int rc = 0;
515
516     if (!hd)
517         return G10ERR_INV_ARG;
518
519     if ( hd->found < 0 || hd->found >= hd->used) 
520         return -1; /* nothing found */
521
522     switch (hd->active[hd->found].type) {
523       case KEYDB_RESOURCE_TYPE_NONE:
524         rc = G10ERR_GENERAL; /* oops */
525         break;
526       case KEYDB_RESOURCE_TYPE_KEYRING:
527         rc = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
528         break;
529     }
530
531     return rc;
532 }
533
534 /* 
535  * update the current keyblock with KB
536  */
537 int
538 keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
539 {
540     int rc = 0;
541
542     if (!hd)
543         return G10ERR_INV_ARG;
544
545     if ( hd->found < 0 || hd->found >= hd->used) 
546         return -1; /* nothing found */
547
548     if( opt.dry_run )
549         return 0;
550
551     rc = lock_all (hd);
552     if (rc)
553         return rc;
554
555     switch (hd->active[hd->found].type) {
556       case KEYDB_RESOURCE_TYPE_NONE:
557         rc = G10ERR_GENERAL; /* oops */
558         break;
559       case KEYDB_RESOURCE_TYPE_KEYRING:
560         rc = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
561         break;
562     }
563
564     unlock_all (hd);
565     return rc;
566 }
567
568
569 /* 
570  * Insert a new KB into one of the resources. 
571  */
572 int
573 keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
574 {
575     int rc = -1;
576     int idx;
577
578     if (!hd) 
579         return G10ERR_INV_ARG;
580
581     if( opt.dry_run )
582         return 0;
583
584     if ( hd->found >= 0 && hd->found < hd->used) 
585         idx = hd->found;
586     else if ( hd->current >= 0 && hd->current < hd->used) 
587         idx = hd->current;
588     else
589         return G10ERR_GENERAL;
590
591     rc = lock_all (hd);
592     if (rc)
593         return rc;
594
595     switch (hd->active[idx].type) {
596       case KEYDB_RESOURCE_TYPE_NONE:
597         rc = G10ERR_GENERAL; /* oops */
598         break;
599       case KEYDB_RESOURCE_TYPE_KEYRING:
600         rc = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
601         break;
602     }
603
604     unlock_all (hd);
605     return rc;
606 }
607
608
609 /* 
610  * The current keyblock will be deleted.
611  */
612 int
613 keydb_delete_keyblock (KEYDB_HANDLE hd)
614 {
615     int rc = -1;
616
617     if (!hd)
618         return G10ERR_INV_ARG;
619
620     if ( hd->found < 0 || hd->found >= hd->used) 
621         return -1; /* nothing found */
622
623     if( opt.dry_run )
624         return 0;
625
626     rc = lock_all (hd);
627     if (rc)
628         return rc;
629
630     switch (hd->active[hd->found].type) {
631       case KEYDB_RESOURCE_TYPE_NONE:
632         rc = G10ERR_GENERAL; /* oops */
633         break;
634       case KEYDB_RESOURCE_TYPE_KEYRING:
635         rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
636         break;
637     }
638
639     unlock_all (hd);
640     return rc;
641 }
642
643 \f
644 /*
645  * Locate the default writable key resource, so that the next
646  * operation (which is only relevant for inserts) will be done on this
647  * resource.  
648  */
649 int
650 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
651 {
652   int rc;
653
654   (void)reserved;
655
656   if (!hd)
657     return G10ERR_INV_ARG;
658   
659   rc = keydb_search_reset (hd); /* this does reset hd->current */
660   if (rc)
661     return rc;
662
663   /* If we have a primary set, try that one first */
664   if(primary_keyring)
665     {
666       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
667         {
668           if(hd->active[hd->current].token==primary_keyring)
669             {
670               if(keyring_is_writable (hd->active[hd->current].token))
671                 return 0;
672               else
673                 break;
674             }
675         }
676
677       rc = keydb_search_reset (hd); /* this does reset hd->current */
678       if (rc)
679         return rc;
680     }
681
682   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++) 
683     {
684       switch (hd->active[hd->current].type) 
685         {
686         case KEYDB_RESOURCE_TYPE_NONE:
687           BUG();
688           break;
689         case KEYDB_RESOURCE_TYPE_KEYRING:
690           if (keyring_is_writable (hd->active[hd->current].token))
691             return 0; /* found (hd->current is set to it) */
692           break;
693         }
694     }
695   
696   return -1;
697 }
698
699 /*
700  * Rebuild the caches of all key resources.
701  */
702 void
703 keydb_rebuild_caches (int noisy)
704 {
705   int i, rc;
706   
707   for (i=0; i < used_resources; i++)
708     {
709       if (all_resources[i].secret)
710         continue;
711       if (!keyring_is_writable (all_resources[i].token))
712         continue;
713       switch (all_resources[i].type)
714         {
715         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
716           break;
717         case KEYDB_RESOURCE_TYPE_KEYRING:
718           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
719           if (rc)
720             log_error (_("failed to rebuild keyring cache: %s\n"),
721                        g10_errstr (rc));
722           break;
723         }
724     }
725 }
726
727
728
729 /* 
730  * Start the next search on this handle right at the beginning
731  */
732 int 
733 keydb_search_reset (KEYDB_HANDLE hd)
734 {
735     int i, rc = 0;
736
737     if (!hd)
738         return G10ERR_INV_ARG;
739
740     hd->current = 0; 
741     hd->found = -1;
742     /* and reset all resources */
743     for (i=0; !rc && i < hd->used; i++) {
744         switch (hd->active[i].type) {
745           case KEYDB_RESOURCE_TYPE_NONE:
746             break;
747           case KEYDB_RESOURCE_TYPE_KEYRING:
748             rc = keyring_search_reset (hd->active[i].u.kr);
749             break;
750         }
751     }
752     return rc; 
753 }
754
755
756 /* 
757  * Search through all keydb resources, starting at the current position,
758  * for a keyblock which contains one of the keys described in the DESC array.
759  */
760 int 
761 keydb_search2 (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
762                size_t ndesc, size_t *descindex)
763 {
764     int rc = -1;
765
766     if (!hd)
767         return G10ERR_INV_ARG;
768
769     while (rc == -1 && hd->current >= 0 && hd->current < hd->used) {
770         switch (hd->active[hd->current].type) {
771           case KEYDB_RESOURCE_TYPE_NONE:
772             BUG(); /* we should never see it here */
773             break;
774           case KEYDB_RESOURCE_TYPE_KEYRING:
775             rc = keyring_search (hd->active[hd->current].u.kr, desc,
776                                  ndesc, descindex);
777             break;
778         }
779         if (rc == -1) /* EOF -> switch to next resource */
780             hd->current++; 
781         else if (!rc)
782             hd->found = hd->current;
783     }
784
785     return rc; 
786 }
787
788 int
789 keydb_search_first (KEYDB_HANDLE hd)
790 {
791     KEYDB_SEARCH_DESC desc;
792
793     memset (&desc, 0, sizeof desc);
794     desc.mode = KEYDB_SEARCH_MODE_FIRST;
795     return keydb_search (hd, &desc, 1);
796 }
797
798 int
799 keydb_search_next (KEYDB_HANDLE hd)
800 {
801     KEYDB_SEARCH_DESC desc;
802
803     memset (&desc, 0, sizeof desc);
804     desc.mode = KEYDB_SEARCH_MODE_NEXT;
805     return keydb_search (hd, &desc, 1);
806 }
807
808 int
809 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
810 {
811     KEYDB_SEARCH_DESC desc;
812
813     memset (&desc, 0, sizeof desc);
814     desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
815     desc.u.kid[0] = kid[0];
816     desc.u.kid[1] = kid[1];
817     return keydb_search (hd, &desc, 1);
818 }
819
820 int
821 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
822 {
823     KEYDB_SEARCH_DESC desc;
824
825     memset (&desc, 0, sizeof desc);
826     desc.mode = KEYDB_SEARCH_MODE_FPR;
827     memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
828     return keydb_search (hd, &desc, 1);
829 }