Update estream.
[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 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       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, 2, 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 readonly = !!(flags&8);
223     int rc = 0;
224     KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
225     void *token;
226
227     if (readonly)
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 && !readonly)
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, readonly, &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 (int secret)
352 {
353   KEYDB_HANDLE hd;
354   int i, j;
355   
356   hd = xmalloc_clear (sizeof *hd);
357   hd->found = -1;
358   
359   assert (used_resources <= MAX_KEYDB_RESOURCES);
360   for (i=j=0; i < used_resources; i++)
361     {
362       if (!all_resources[i].secret != !secret)
363         continue;
364       switch (all_resources[i].type)
365         {
366         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
367           break;
368         case KEYDB_RESOURCE_TYPE_KEYRING:
369           hd->active[j].type   = all_resources[i].type;
370           hd->active[j].token  = all_resources[i].token;
371           hd->active[j].secret = all_resources[i].secret;
372           hd->active[j].u.kr = keyring_new (all_resources[i].token, secret);
373           if (!hd->active[j].u.kr) {
374             xfree (hd);
375             return NULL; /* fixme: release all previously allocated handles*/
376           }
377           j++;
378           break;
379         }
380     }
381   hd->used = j;
382   
383   active_handles++;
384   return hd;
385 }
386
387 void 
388 keydb_release (KEYDB_HANDLE hd)
389 {
390     int i;
391
392     if (!hd)
393         return;
394     assert (active_handles > 0);
395     active_handles--;
396
397     unlock_all (hd);
398     for (i=0; i < hd->used; i++) {
399         switch (hd->active[i].type) {
400           case KEYDB_RESOURCE_TYPE_NONE:
401             break;
402           case KEYDB_RESOURCE_TYPE_KEYRING:
403             keyring_release (hd->active[i].u.kr);
404             break;
405         }
406     }
407
408     xfree (hd);
409 }
410
411
412 /*
413  * Return the name of the current resource.  This is function first
414  * looks for the last found found, then for the current search
415  * position, and last returns the first available resource.  The
416  * returned string is only valid as long as the handle exists.  This
417  * function does only return NULL if no handle is specified, in all
418  * other error cases an empty string is returned.
419  */
420 const char *
421 keydb_get_resource_name (KEYDB_HANDLE hd)
422 {
423     int idx;
424     const char *s = NULL;
425
426     if (!hd) 
427         return NULL;
428
429     if ( hd->found >= 0 && hd->found < hd->used) 
430         idx = hd->found;
431     else if ( hd->current >= 0 && hd->current < hd->used) 
432         idx = hd->current;
433     else
434         idx = 0;
435
436     switch (hd->active[idx].type) {
437       case KEYDB_RESOURCE_TYPE_NONE:
438         s = NULL; 
439         break;
440       case KEYDB_RESOURCE_TYPE_KEYRING:
441         s = keyring_get_resource_name (hd->active[idx].u.kr);
442         break;
443     }
444
445     return s? s: "";
446 }
447
448
449
450 static int 
451 lock_all (KEYDB_HANDLE hd)
452 {
453     int i, rc = 0;
454
455     for (i=0; !rc && i < hd->used; i++) {
456         switch (hd->active[i].type) {
457           case KEYDB_RESOURCE_TYPE_NONE:
458             break;
459           case KEYDB_RESOURCE_TYPE_KEYRING:
460             rc = keyring_lock (hd->active[i].u.kr, 1);
461             break;
462         }
463     }
464
465     if (rc) {
466         /* revert the already set locks */
467         for (i--; i >= 0; i--) {
468             switch (hd->active[i].type) {
469               case KEYDB_RESOURCE_TYPE_NONE:
470                 break;
471               case KEYDB_RESOURCE_TYPE_KEYRING:
472                 keyring_lock (hd->active[i].u.kr, 0);
473                 break;
474             }
475         }
476     }
477     else
478         hd->locked = 1;
479
480     return rc;
481 }
482
483 static void
484 unlock_all (KEYDB_HANDLE hd)
485 {
486     int i;
487
488     if (!hd->locked)
489         return;
490
491     for (i=hd->used-1; i >= 0; i--) {
492         switch (hd->active[i].type) {
493           case KEYDB_RESOURCE_TYPE_NONE:
494             break;
495           case KEYDB_RESOURCE_TYPE_KEYRING:
496             keyring_lock (hd->active[i].u.kr, 0);
497             break;
498         }
499     }
500     hd->locked = 0;
501 }
502
503
504 /*
505  * Return the last found keyring.  Caller must free it.
506  * The returned keyblock has the kbode flag bit 0 set for the node with
507  * the public key used to locate the keyblock or flag bit 1 set for 
508  * the user ID node.
509  */
510 int
511 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
512 {
513     int rc = 0;
514
515     if (!hd)
516         return G10ERR_INV_ARG;
517
518     if ( hd->found < 0 || hd->found >= hd->used) 
519         return -1; /* nothing found */
520
521     switch (hd->active[hd->found].type) {
522       case KEYDB_RESOURCE_TYPE_NONE:
523         rc = G10ERR_GENERAL; /* oops */
524         break;
525       case KEYDB_RESOURCE_TYPE_KEYRING:
526         rc = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
527         break;
528     }
529
530     return rc;
531 }
532
533 /* 
534  * update the current keyblock with KB
535  */
536 int
537 keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
538 {
539     int rc = 0;
540
541     if (!hd)
542         return G10ERR_INV_ARG;
543
544     if ( hd->found < 0 || hd->found >= hd->used) 
545         return -1; /* nothing found */
546
547     if( opt.dry_run )
548         return 0;
549
550     rc = lock_all (hd);
551     if (rc)
552         return rc;
553
554     switch (hd->active[hd->found].type) {
555       case KEYDB_RESOURCE_TYPE_NONE:
556         rc = G10ERR_GENERAL; /* oops */
557         break;
558       case KEYDB_RESOURCE_TYPE_KEYRING:
559         rc = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
560         break;
561     }
562
563     unlock_all (hd);
564     return rc;
565 }
566
567
568 /* 
569  * Insert a new KB into one of the resources. 
570  */
571 int
572 keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
573 {
574     int rc = -1;
575     int idx;
576
577     if (!hd) 
578         return G10ERR_INV_ARG;
579
580     if( opt.dry_run )
581         return 0;
582
583     if ( hd->found >= 0 && hd->found < hd->used) 
584         idx = hd->found;
585     else if ( hd->current >= 0 && hd->current < hd->used) 
586         idx = hd->current;
587     else
588         return G10ERR_GENERAL;
589
590     rc = lock_all (hd);
591     if (rc)
592         return rc;
593
594     switch (hd->active[idx].type) {
595       case KEYDB_RESOURCE_TYPE_NONE:
596         rc = G10ERR_GENERAL; /* oops */
597         break;
598       case KEYDB_RESOURCE_TYPE_KEYRING:
599         rc = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
600         break;
601     }
602
603     unlock_all (hd);
604     return rc;
605 }
606
607
608 /* 
609  * The current keyblock will be deleted.
610  */
611 int
612 keydb_delete_keyblock (KEYDB_HANDLE hd)
613 {
614     int rc = -1;
615
616     if (!hd)
617         return G10ERR_INV_ARG;
618
619     if ( hd->found < 0 || hd->found >= hd->used) 
620         return -1; /* nothing found */
621
622     if( opt.dry_run )
623         return 0;
624
625     rc = lock_all (hd);
626     if (rc)
627         return rc;
628
629     switch (hd->active[hd->found].type) {
630       case KEYDB_RESOURCE_TYPE_NONE:
631         rc = G10ERR_GENERAL; /* oops */
632         break;
633       case KEYDB_RESOURCE_TYPE_KEYRING:
634         rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
635         break;
636     }
637
638     unlock_all (hd);
639     return rc;
640 }
641
642 \f
643 /*
644  * Locate the default writable key resource, so that the next
645  * operation (which is only relevant for inserts) will be done on this
646  * resource.  
647  */
648 int
649 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
650 {
651   int rc;
652
653   (void)reserved;
654
655   if (!hd)
656     return G10ERR_INV_ARG;
657   
658   rc = keydb_search_reset (hd); /* this does reset hd->current */
659   if (rc)
660     return rc;
661
662   /* If we have a primary set, try that one first */
663   if(primary_keyring)
664     {
665       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
666         {
667           if(hd->active[hd->current].token==primary_keyring)
668             {
669               if(keyring_is_writable (hd->active[hd->current].token))
670                 return 0;
671               else
672                 break;
673             }
674         }
675
676       rc = keydb_search_reset (hd); /* this does reset hd->current */
677       if (rc)
678         return rc;
679     }
680
681   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++) 
682     {
683       switch (hd->active[hd->current].type) 
684         {
685         case KEYDB_RESOURCE_TYPE_NONE:
686           BUG();
687           break;
688         case KEYDB_RESOURCE_TYPE_KEYRING:
689           if (keyring_is_writable (hd->active[hd->current].token))
690             return 0; /* found (hd->current is set to it) */
691           break;
692         }
693     }
694   
695   return -1;
696 }
697
698 /*
699  * Rebuild the caches of all key resources.
700  */
701 void
702 keydb_rebuild_caches (int noisy)
703 {
704   int i, rc;
705   
706   for (i=0; i < used_resources; i++)
707     {
708       if (all_resources[i].secret)
709         continue;
710       if (!keyring_is_writable (all_resources[i].token))
711         continue;
712       switch (all_resources[i].type)
713         {
714         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
715           break;
716         case KEYDB_RESOURCE_TYPE_KEYRING:
717           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
718           if (rc)
719             log_error (_("failed to rebuild keyring cache: %s\n"),
720                        g10_errstr (rc));
721           break;
722         }
723     }
724 }
725
726
727
728 /* 
729  * Start the next search on this handle right at the beginning
730  */
731 int 
732 keydb_search_reset (KEYDB_HANDLE hd)
733 {
734     int i, rc = 0;
735
736     if (!hd)
737         return G10ERR_INV_ARG;
738
739     hd->current = 0; 
740     hd->found = -1;
741     /* and reset all resources */
742     for (i=0; !rc && i < hd->used; i++) {
743         switch (hd->active[i].type) {
744           case KEYDB_RESOURCE_TYPE_NONE:
745             break;
746           case KEYDB_RESOURCE_TYPE_KEYRING:
747             rc = keyring_search_reset (hd->active[i].u.kr);
748             break;
749         }
750     }
751     return rc; 
752 }
753
754
755 /* 
756  * Search through all keydb resources, starting at the current position,
757  * for a keyblock which contains one of the keys described in the DESC array.
758  */
759 int 
760 keydb_search2 (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
761                size_t ndesc, size_t *descindex)
762 {
763     int rc = -1;
764
765     if (!hd)
766         return G10ERR_INV_ARG;
767
768     while (rc == -1 && hd->current >= 0 && hd->current < hd->used) {
769         switch (hd->active[hd->current].type) {
770           case KEYDB_RESOURCE_TYPE_NONE:
771             BUG(); /* we should never see it here */
772             break;
773           case KEYDB_RESOURCE_TYPE_KEYRING:
774             rc = keyring_search (hd->active[hd->current].u.kr, desc,
775                                  ndesc, descindex);
776             break;
777         }
778         if (rc == -1) /* EOF -> switch to next resource */
779             hd->current++; 
780         else if (!rc)
781             hd->found = hd->current;
782     }
783
784     return rc; 
785 }
786
787 int
788 keydb_search_first (KEYDB_HANDLE hd)
789 {
790     KEYDB_SEARCH_DESC desc;
791
792     memset (&desc, 0, sizeof desc);
793     desc.mode = KEYDB_SEARCH_MODE_FIRST;
794     return keydb_search (hd, &desc, 1);
795 }
796
797 int
798 keydb_search_next (KEYDB_HANDLE hd)
799 {
800     KEYDB_SEARCH_DESC desc;
801
802     memset (&desc, 0, sizeof desc);
803     desc.mode = KEYDB_SEARCH_MODE_NEXT;
804     return keydb_search (hd, &desc, 1);
805 }
806
807 int
808 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
809 {
810     KEYDB_SEARCH_DESC desc;
811
812     memset (&desc, 0, sizeof desc);
813     desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
814     desc.u.kid[0] = kid[0];
815     desc.u.kid[1] = kid[1];
816     return keydb_search (hd, &desc, 1);
817 }
818
819 int
820 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
821 {
822     KEYDB_SEARCH_DESC desc;
823
824     memset (&desc, 0, sizeof desc);
825     desc.mode = KEYDB_SEARCH_MODE_FPR;
826     memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
827     return keydb_search (hd, &desc, 1);
828 }