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