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