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