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