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