w32: Fix deadlock introduced by keybox_file_rename.
[gnupg.git] / g10 / keyring.c
1 /* keyring.c - keyring file handling
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1997-2015 Werner Koch
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 <unistd.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30
31 #include "gpg.h"
32 #include "util.h"
33 #include "keyring.h"
34 #include "packet.h"
35 #include "keydb.h"
36 #include "options.h"
37 #include "main.h" /*for check_key_signature()*/
38 #include "i18n.h"
39 #include "../kbx/keybox.h"
40
41
42 typedef struct keyring_resource *KR_RESOURCE;
43 struct keyring_resource
44 {
45   struct keyring_resource *next;
46   int read_only;
47   dotlock_t lockhd;
48   int is_locked;
49   int did_full_scan;
50   char fname[1];
51 };
52 typedef struct keyring_resource const * CONST_KR_RESOURCE;
53
54 static KR_RESOURCE kr_resources;
55
56 struct keyring_handle
57 {
58   CONST_KR_RESOURCE resource;
59   struct {
60     CONST_KR_RESOURCE kr;
61     IOBUF iobuf;
62     int eof;
63     int error;
64   } current;
65   struct {
66     CONST_KR_RESOURCE kr;
67     off_t offset;
68     size_t pk_no;
69     size_t uid_no;
70     unsigned int n_packets; /*used for delete and update*/
71   } found, saved_found;
72   struct {
73     char *name;
74     char *pattern;
75   } word_match;
76 };
77
78 /* The number of extant handles.  */
79 static int active_handles;
80
81 static int do_copy (int mode, const char *fname, KBNODE root,
82                     off_t start_offset, unsigned int n_packets );
83
84
85 \f
86 /* We keep a cache of entries that we have entered in the DB.  This
87    includes not only public keys, but also subkeys.
88
89    Note: we'd like to keep the offset of the items that are present,
90    however, this doesn't work, because another concurrent GnuPG
91    process could modify the keyring.  */
92 struct key_present {
93   struct key_present *next;
94   u32 kid[2];
95 };
96
97 /* For the hash table, we use separate chaining with linked lists.
98    This means that we have an array of N linked lists (buckets), which
99    is indexed by KEYID[1] mod N.  Elements present in the keyring will
100    be on the list; elements not present in the keyring will not be on
101    the list.
102
103    Note: since the hash table stores both present and not present
104    information, it cannot be used until we complete a full scan of the
105    keyring.  This is indicated by key_present_hash_ready.  */
106 typedef struct key_present **key_present_hash_t;
107 static key_present_hash_t key_present_hash;
108 static int key_present_hash_ready;
109
110 #define KEY_PRESENT_HASH_BUCKETS 2048
111
112 /* Allocate a new value for a key present hash table.  */
113 static struct key_present *
114 key_present_value_new (void)
115 {
116   struct key_present *k;
117
118   k = xmalloc_clear (sizeof *k);
119   return k;
120 }
121
122 /* Allocate a new key present hash table.  */
123 static key_present_hash_t
124 key_present_hash_new (void)
125 {
126   struct key_present **tbl;
127
128   tbl = xmalloc_clear (KEY_PRESENT_HASH_BUCKETS * sizeof *tbl);
129   return tbl;
130 }
131
132 /* Return whether the value described by KID if it is in the hash
133    table.  Otherwise, return NULL.  */
134 static struct key_present *
135 key_present_hash_lookup (key_present_hash_t tbl, u32 *kid)
136 {
137   struct key_present *k;
138
139   for (k = tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))]; k; k = k->next)
140     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
141       return k;
142   return NULL;
143 }
144
145 /* Add the key to the hash table TBL if it is not already present.  */
146 static void
147 key_present_hash_update (key_present_hash_t tbl, u32 *kid)
148 {
149   struct key_present *k;
150
151   for (k = tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))]; k; k = k->next)
152     {
153       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
154         return;
155     }
156
157   k = key_present_value_new ();
158   k->kid[0] = kid[0];
159   k->kid[1] = kid[1];
160   k->next = tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))];
161   tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))] = k;
162 }
163
164 /* Add all the keys (public and subkeys) present in the keyblock to
165    the hash TBL.  */
166 static void
167 key_present_hash_update_from_kb (key_present_hash_t tbl, KBNODE node)
168 {
169   for (; node; node = node->next)
170     {
171       if (node->pkt->pkttype == PKT_PUBLIC_KEY
172           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
173         {
174           u32 aki[2];
175           keyid_from_pk (node->pkt->pkt.public_key, aki);
176           key_present_hash_update (tbl, aki);
177         }
178     }
179 }
180 \f
181 /*
182  * Register a filename for plain keyring files.  ptr is set to a
183  * pointer to be used to create a handles etc, or the already-issued
184  * pointer if it has already been registered.  The function returns 1
185  * if a new keyring was registered.
186 */
187 int
188 keyring_register_filename (const char *fname, int read_only, void **ptr)
189 {
190     KR_RESOURCE kr;
191
192     if (active_handles)
193       /* There are open handles.  */
194       BUG ();
195
196     for (kr=kr_resources; kr; kr = kr->next)
197       {
198         if (same_file_p (kr->fname, fname))
199           {
200             /* Already registered. */
201             if (read_only)
202               kr->read_only = 1;
203             *ptr=kr;
204             return 0;
205           }
206       }
207
208     kr = xmalloc (sizeof *kr + strlen (fname));
209     strcpy (kr->fname, fname);
210     kr->read_only = read_only;
211     kr->lockhd = NULL;
212     kr->is_locked = 0;
213     kr->did_full_scan = 0;
214     /* keep a list of all issued pointers */
215     kr->next = kr_resources;
216     kr_resources = kr;
217
218     /* create the offset table the first time a function here is used */
219     if (!key_present_hash)
220       key_present_hash = key_present_hash_new ();
221
222     *ptr=kr;
223
224     return 1;
225 }
226
227 int
228 keyring_is_writable (void *token)
229 {
230   KR_RESOURCE r = token;
231
232   return r? (r->read_only || !access (r->fname, W_OK)) : 0;
233 }
234
235
236 \f
237 /* Create a new handle for the resource associated with TOKEN.
238    On error NULL is returned and ERRNO is set.
239    The returned handle must be released using keyring_release (). */
240 KEYRING_HANDLE
241 keyring_new (void *token)
242 {
243   KEYRING_HANDLE hd;
244   KR_RESOURCE resource = token;
245
246   assert (resource);
247
248   hd = xtrycalloc (1, sizeof *hd);
249   if (!hd)
250     return hd;
251   hd->resource = resource;
252   active_handles++;
253   return hd;
254 }
255
256 void
257 keyring_release (KEYRING_HANDLE hd)
258 {
259     if (!hd)
260         return;
261     assert (active_handles > 0);
262     active_handles--;
263     xfree (hd->word_match.name);
264     xfree (hd->word_match.pattern);
265     iobuf_close (hd->current.iobuf);
266     xfree (hd);
267 }
268
269
270 /* Save the current found state in HD for later retrieval by
271    keybox_pop_found_state.  Only one state may be saved.  */
272 void
273 keyring_push_found_state (KEYRING_HANDLE hd)
274 {
275   hd->saved_found = hd->found;
276   hd->found.kr = NULL;
277 }
278
279
280 /* Restore the saved found state in HD.  */
281 void
282 keyring_pop_found_state (KEYRING_HANDLE hd)
283 {
284   hd->found = hd->saved_found;
285   hd->saved_found.kr = NULL;
286 }
287
288
289 const char *
290 keyring_get_resource_name (KEYRING_HANDLE hd)
291 {
292     if (!hd || !hd->resource)
293       return NULL;
294     return hd->resource->fname;
295 }
296
297
298 /*
299  * Lock the keyring with the given handle, or unlock if YES is false.
300  * We ignore the handle and lock all registered files.
301  */
302 int
303 keyring_lock (KEYRING_HANDLE hd, int yes)
304 {
305     KR_RESOURCE kr;
306     int rc = 0;
307
308     (void)hd;
309
310     if (yes) {
311         /* first make sure the lock handles are created */
312         for (kr=kr_resources; kr; kr = kr->next) {
313             if (!keyring_is_writable(kr))
314                 continue;
315             if (!kr->lockhd) {
316                 kr->lockhd = dotlock_create (kr->fname, 0);
317                 if (!kr->lockhd) {
318                     log_info ("can't allocate lock for '%s'\n", kr->fname );
319                     rc = GPG_ERR_GENERAL;
320                 }
321             }
322         }
323         if (rc)
324             return rc;
325
326         /* and now set the locks */
327         for (kr=kr_resources; kr; kr = kr->next) {
328             if (!keyring_is_writable(kr))
329                 continue;
330             if (kr->is_locked)
331                 continue;
332
333 #ifdef HAVE_W32_SYSTEM
334             /* Under Windows we need to CloseHandle the file before we
335              * try to lock it.  This is because another process might
336              * have taken the lock and is using keybox_file_rename to
337              * rename the base file.  How if our dotlock_take below is
338              * waiting for the lock but we have the base file still
339              * open, keybox_file_rename will never succeed as we are
340              * in a deadlock.  */
341             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0,
342                          (char*)kr->fname);
343 #endif /*HAVE_W32_SYSTEM*/
344             if (dotlock_take (kr->lockhd, -1) ) {
345                 log_info ("can't lock '%s'\n", kr->fname );
346                 rc = GPG_ERR_GENERAL;
347             }
348             else
349                 kr->is_locked = 1;
350         }
351     }
352
353     if (rc || !yes) {
354         for (kr=kr_resources; kr; kr = kr->next) {
355             if (!keyring_is_writable(kr))
356                 continue;
357             if (!kr->is_locked)
358                 continue;
359
360             if (dotlock_release (kr->lockhd))
361                 log_info ("can't unlock '%s'\n", kr->fname );
362             else
363                 kr->is_locked = 0;
364         }
365     }
366
367     return rc;
368 }
369
370
371 \f
372 /*
373  * Return the last found keyblock.  Caller must free it.
374  * The returned keyblock has the kbode flag bit 0 set for the node with
375  * the public key used to locate the keyblock or flag bit 1 set for
376  * the user ID node.
377  */
378 int
379 keyring_get_keyblock (KEYRING_HANDLE hd, KBNODE *ret_kb)
380 {
381     PACKET *pkt;
382     int rc;
383     KBNODE keyblock = NULL, node, lastnode;
384     IOBUF a;
385     int in_cert = 0;
386     int pk_no = 0;
387     int uid_no = 0;
388     int save_mode;
389
390     if (ret_kb)
391         *ret_kb = NULL;
392
393     if (!hd->found.kr)
394         return -1; /* no successful search */
395
396     a = iobuf_open (hd->found.kr->fname);
397     if (!a)
398       {
399         log_error(_("can't open '%s'\n"), hd->found.kr->fname);
400         return GPG_ERR_KEYRING_OPEN;
401       }
402
403     if (iobuf_seek (a, hd->found.offset) ) {
404         log_error ("can't seek '%s'\n", hd->found.kr->fname);
405         iobuf_close(a);
406         return GPG_ERR_KEYRING_OPEN;
407     }
408
409     pkt = xmalloc (sizeof *pkt);
410     init_packet (pkt);
411     hd->found.n_packets = 0;;
412     lastnode = NULL;
413     save_mode = set_packet_list_mode(0);
414     while ((rc=parse_packet (a, pkt)) != -1) {
415         hd->found.n_packets++;
416         if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET) {
417             free_packet (pkt);
418             init_packet (pkt);
419             continue;
420         }
421         if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
422           {
423             if (in_cert)
424               /* It is not this key that is problematic, but the
425                  following key.  */
426               {
427                 rc = 0;
428                 hd->found.n_packets --;
429               }
430             else
431               /* Upper layer needs to handle this.  */
432               {
433               }
434             break;
435           }
436         if (rc) {
437             log_error ("keyring_get_keyblock: read error: %s\n",
438                        gpg_strerror (rc) );
439             rc = GPG_ERR_INV_KEYRING;
440             break;
441         }
442
443         /* Filter allowed packets.  */
444         switch (pkt->pkttype)
445           {
446           case PKT_PUBLIC_KEY:
447           case PKT_PUBLIC_SUBKEY:
448           case PKT_SECRET_KEY:
449           case PKT_SECRET_SUBKEY:
450           case PKT_USER_ID:
451           case PKT_ATTRIBUTE:
452           case PKT_SIGNATURE:
453             break; /* Allowed per RFC.  */
454           case PKT_RING_TRUST:
455           case PKT_OLD_COMMENT:
456           case PKT_COMMENT:
457           case PKT_GPG_CONTROL:
458             break; /* Allowed by us.  */
459
460           default:
461             log_error ("skipped packet of type %d in keyring\n",
462                        (int)pkt->pkttype);
463             free_packet(pkt);
464             init_packet(pkt);
465             continue;
466           }
467
468         if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
469                         || pkt->pkttype == PKT_SECRET_KEY)) {
470             hd->found.n_packets--; /* fix counter */
471             break; /* ready */
472         }
473
474         in_cert = 1;
475         if (pkt->pkttype == PKT_RING_TRUST)
476           {
477             /*(this code is duplicated after the loop)*/
478             if ( lastnode
479                  && lastnode->pkt->pkttype == PKT_SIGNATURE
480                  && (pkt->pkt.ring_trust->sigcache & 1) ) {
481                 /* This is a ring trust packet with a checked signature
482                  * status cache following directly a signature paket.
483                  * Set the cache status into that signature packet.  */
484                 PKT_signature *sig = lastnode->pkt->pkt.signature;
485
486                 sig->flags.checked = 1;
487                 sig->flags.valid = !!(pkt->pkt.ring_trust->sigcache & 2);
488             }
489             /* Reset LASTNODE, so that we set the cache status only from
490              * the ring trust packet immediately following a signature. */
491             lastnode = NULL;
492             free_packet(pkt);
493             init_packet(pkt);
494             continue;
495           }
496
497
498         node = lastnode = new_kbnode (pkt);
499         if (!keyblock)
500           keyblock = node;
501         else
502           add_kbnode (keyblock, node);
503         switch (pkt->pkttype)
504           {
505           case PKT_PUBLIC_KEY:
506           case PKT_PUBLIC_SUBKEY:
507           case PKT_SECRET_KEY:
508           case PKT_SECRET_SUBKEY:
509             if (++pk_no == hd->found.pk_no)
510               node->flag |= 1;
511             break;
512
513           case PKT_USER_ID:
514             if (++uid_no == hd->found.uid_no)
515               node->flag |= 2;
516             break;
517
518           default:
519             break;
520           }
521
522         pkt = xmalloc (sizeof *pkt);
523         init_packet(pkt);
524     }
525     set_packet_list_mode(save_mode);
526
527     if (rc == -1 && keyblock)
528         rc = 0; /* got the entire keyblock */
529
530     if (rc || !ret_kb)
531         release_kbnode (keyblock);
532     else {
533         /*(duplicated from the loop body)*/
534         if ( pkt && pkt->pkttype == PKT_RING_TRUST
535              && lastnode
536              && lastnode->pkt->pkttype == PKT_SIGNATURE
537              && (pkt->pkt.ring_trust->sigcache & 1) ) {
538             PKT_signature *sig = lastnode->pkt->pkt.signature;
539             sig->flags.checked = 1;
540             sig->flags.valid = !!(pkt->pkt.ring_trust->sigcache & 2);
541         }
542         *ret_kb = keyblock;
543     }
544     free_packet (pkt);
545     xfree (pkt);
546     iobuf_close(a);
547
548     /* Make sure that future search operations fail immediately when
549      * we know that we are working on a invalid keyring
550      */
551     if (gpg_err_code (rc) == GPG_ERR_INV_KEYRING)
552         hd->current.error = rc;
553
554     return rc;
555 }
556
557 int
558 keyring_update_keyblock (KEYRING_HANDLE hd, KBNODE kb)
559 {
560     int rc;
561
562     if (!hd->found.kr)
563         return -1; /* no successful prior search */
564
565     if (hd->found.kr->read_only)
566       return gpg_error (GPG_ERR_EACCES);
567
568     if (!hd->found.n_packets) {
569         /* need to know the number of packets - do a dummy get_keyblock*/
570         rc = keyring_get_keyblock (hd, NULL);
571         if (rc) {
572             log_error ("re-reading keyblock failed: %s\n", gpg_strerror (rc));
573             return rc;
574         }
575         if (!hd->found.n_packets)
576             BUG ();
577     }
578
579     /* The open iobuf isn't needed anymore and in fact is a problem when
580        it comes to renaming the keyring files on some operating systems,
581        so close it here */
582     iobuf_close(hd->current.iobuf);
583     hd->current.iobuf = NULL;
584
585     /* do the update */
586     rc = do_copy (3, hd->found.kr->fname, kb,
587                   hd->found.offset, hd->found.n_packets );
588     if (!rc) {
589       if (key_present_hash)
590         {
591           key_present_hash_update_from_kb (key_present_hash, kb);
592         }
593       /* better reset the found info */
594       hd->found.kr = NULL;
595       hd->found.offset = 0;
596     }
597     return rc;
598 }
599
600 int
601 keyring_insert_keyblock (KEYRING_HANDLE hd, KBNODE kb)
602 {
603     int rc;
604     const char *fname;
605
606     if (!hd)
607         fname = NULL;
608     else if (hd->found.kr)
609       {
610         fname = hd->found.kr->fname;
611         if (hd->found.kr->read_only)
612           return gpg_error (GPG_ERR_EACCES);
613       }
614     else if (hd->current.kr)
615       {
616         fname = hd->current.kr->fname;
617         if (hd->current.kr->read_only)
618           return gpg_error (GPG_ERR_EACCES);
619       }
620     else
621         fname = hd->resource? hd->resource->fname:NULL;
622
623     if (!fname)
624         return GPG_ERR_GENERAL;
625
626     /* Close this one otherwise we will lose the position for
627      * a next search.  Fixme: it would be better to adjust the position
628      * after the write opertions.
629      */
630     iobuf_close (hd->current.iobuf);
631     hd->current.iobuf = NULL;
632
633     /* do the insert */
634     rc = do_copy (1, fname, kb, 0, 0 );
635     if (!rc && key_present_hash)
636       {
637         key_present_hash_update_from_kb (key_present_hash, kb);
638       }
639
640     return rc;
641 }
642
643
644 int
645 keyring_delete_keyblock (KEYRING_HANDLE hd)
646 {
647     int rc;
648
649     if (!hd->found.kr)
650         return -1; /* no successful prior search */
651
652     if (hd->found.kr->read_only)
653       return gpg_error (GPG_ERR_EACCES);
654
655     if (!hd->found.n_packets) {
656         /* need to know the number of packets - do a dummy get_keyblock*/
657         rc = keyring_get_keyblock (hd, NULL);
658         if (rc) {
659             log_error ("re-reading keyblock failed: %s\n", gpg_strerror (rc));
660             return rc;
661         }
662         if (!hd->found.n_packets)
663             BUG ();
664     }
665
666     /* close this one otherwise we will lose the position for
667      * a next search.  Fixme: it would be better to adjust the position
668      * after the write opertions.
669      */
670     iobuf_close (hd->current.iobuf);
671     hd->current.iobuf = NULL;
672
673     /* do the delete */
674     rc = do_copy (2, hd->found.kr->fname, NULL,
675                   hd->found.offset, hd->found.n_packets );
676     if (!rc) {
677         /* better reset the found info */
678         hd->found.kr = NULL;
679         hd->found.offset = 0;
680         /* Delete is a rare operations, so we don't remove the keys
681          * from the offset table */
682     }
683     return rc;
684 }
685
686
687 \f
688 /*
689  * Start the next search on this handle right at the beginning
690  */
691 int
692 keyring_search_reset (KEYRING_HANDLE hd)
693 {
694     assert (hd);
695
696     hd->current.kr = NULL;
697     iobuf_close (hd->current.iobuf);
698     hd->current.iobuf = NULL;
699     hd->current.eof = 0;
700     hd->current.error = 0;
701
702     hd->found.kr = NULL;
703     hd->found.offset = 0;
704     return 0;
705 }
706
707
708 static int
709 prepare_search (KEYRING_HANDLE hd)
710 {
711     if (hd->current.error) {
712         /* If the last key was a legacy key, we simply ignore the error so that
713            we can easily use search_next.  */
714         if (gpg_err_code (hd->current.error) == GPG_ERR_LEGACY_KEY)
715           {
716             if (DBG_LOOKUP)
717               log_debug ("%s: last error was GPG_ERR_LEGACY_KEY, clearing\n",
718                          __func__);
719             hd->current.error = 0;
720           }
721         else
722           {
723             if (DBG_LOOKUP)
724               log_debug ("%s: returning last error: %s\n",
725                          __func__, gpg_strerror (hd->current.error));
726             return hd->current.error; /* still in error state */
727           }
728     }
729
730     if (hd->current.kr && !hd->current.eof) {
731         if ( !hd->current.iobuf )
732           {
733             if (DBG_LOOKUP)
734               log_debug ("%s: missing iobuf!\n", __func__);
735             return GPG_ERR_GENERAL; /* Position invalid after a modify.  */
736           }
737         return 0; /* okay */
738     }
739
740     if (!hd->current.kr && hd->current.eof)
741       {
742         if (DBG_LOOKUP)
743           log_debug ("%s: EOF!\n", __func__);
744         return -1; /* still EOF */
745       }
746
747     if (!hd->current.kr) { /* start search with first keyring */
748         hd->current.kr = hd->resource;
749         if (!hd->current.kr) {
750           if (DBG_LOOKUP)
751             log_debug ("%s: keyring not available!\n", __func__);
752             hd->current.eof = 1;
753             return -1; /* keyring not available */
754         }
755         assert (!hd->current.iobuf);
756     }
757     else { /* EOF */
758         if (DBG_LOOKUP)
759           log_debug ("%s: EOF\n", __func__);
760         iobuf_close (hd->current.iobuf);
761         hd->current.iobuf = NULL;
762         hd->current.kr = NULL;
763         hd->current.eof = 1;
764         return -1;
765     }
766
767     hd->current.eof = 0;
768     hd->current.iobuf = iobuf_open (hd->current.kr->fname);
769     if (!hd->current.iobuf)
770       {
771         hd->current.error = gpg_error_from_syserror ();
772         log_error(_("can't open '%s'\n"), hd->current.kr->fname );
773         return hd->current.error;
774       }
775
776     return 0;
777 }
778
779 \f
780 /* A map of the all characters valid used for word_match()
781  * Valid characters are in in this table converted to uppercase.
782  * because the upper 128 bytes have special meaning, we assume
783  * that they are all valid.
784  * Note: We must use numerical values here in case that this program
785  * will be converted to those little blue HAL9000s with their strange
786  * EBCDIC character set (user ids are UTF-8).
787  * wk 2000-04-13: Hmmm, does this really make sense, given the fact that
788  * we can run gpg now on a S/390 running GNU/Linux, where the code
789  * translation is done by the device drivers?
790  */
791 static const byte word_match_chars[256] = {
792   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
793   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
794   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
795   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
796   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
797   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
798   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
799   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
800   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
801   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
802   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
803   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
804   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
805   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
806   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
807   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
808   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
809   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
810   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
811   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
812   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
813   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
814   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
815   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
816   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
817   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
818   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
819   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
820   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
821   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
822   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
823   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
824 };
825
826 /****************
827  * Do a word match (original user id starts with a '+').
828  * The pattern is already tokenized to a more suitable format:
829  * There are only the real words in it delimited by one space
830  * and all converted to uppercase.
831  *
832  * Returns: 0 if all words match.
833  *
834  * Note: This algorithm is a straightforward one and not very
835  *       fast.  It works for UTF-8 strings.  The uidlen should
836  *       be removed but due to the fact that old versions of
837  *       pgp don't use UTF-8 we still use the length; this should
838  *       be fixed in parse-packet (and replace \0 by some special
839  *       UTF-8 encoding)
840  */
841 static int
842 word_match( const byte *uid, size_t uidlen, const byte *pattern )
843 {
844     size_t wlen, n;
845     const byte *p;
846     const byte *s;
847
848     for( s=pattern; *s; ) {
849         do {
850             /* skip leading delimiters */
851             while( uidlen && !word_match_chars[*uid] )
852                 uid++, uidlen--;
853             /* get length of the word */
854             n = uidlen; p = uid;
855             while( n && word_match_chars[*p] )
856                 p++, n--;
857             wlen = p - uid;
858             /* and compare against the current word from pattern */
859             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
860                 if( word_match_chars[*p] != s[n] )
861                     break;
862             }
863             if( n == wlen && (s[n] == ' ' || !s[n]) )
864                 break; /* found */
865             uid += wlen;
866             uidlen -= wlen;
867         } while( uidlen );
868         if( !uidlen )
869             return -1; /* not found */
870
871         /* advance to next word in pattern */
872         for(; *s != ' ' && *s ; s++ )
873             ;
874         if( *s )
875             s++ ;
876     }
877     return 0; /* found */
878 }
879
880 /****************
881  * prepare word word_match; that is parse the name and
882  * build the pattern.
883  * caller has to free the returned pattern
884  */
885 static char*
886 prepare_word_match (const byte *name)
887 {
888     byte *pattern, *p;
889     int c;
890
891     /* the original length is always enough for the pattern */
892     p = pattern = xmalloc(strlen(name)+1);
893     do {
894         /* skip leading delimiters */
895         while( *name && !word_match_chars[*name] )
896             name++;
897         /* copy as long as we don't have a delimiter and convert
898          * to uppercase.
899          * fixme: how can we handle utf8 uppercasing */
900         for( ; *name &&  (c=word_match_chars[*name]); name++ )
901             *p++ = c;
902         *p++ = ' '; /* append pattern delimiter */
903     } while( *name );
904     p[-1] = 0; /* replace last pattern delimiter by EOS */
905
906     return pattern;
907 }
908
909
910
911
912 static int
913 compare_name (int mode, const char *name, const char *uid, size_t uidlen)
914 {
915     int i;
916     const char *s, *se;
917
918     if (mode == KEYDB_SEARCH_MODE_EXACT) {
919         for (i=0; name[i] && uidlen; i++, uidlen--)
920             if (uid[i] != name[i])
921                 break;
922         if (!uidlen && !name[i])
923             return 0; /* found */
924     }
925     else if (mode == KEYDB_SEARCH_MODE_SUBSTR) {
926         if (ascii_memistr( uid, uidlen, name ))
927             return 0;
928     }
929     else if (   mode == KEYDB_SEARCH_MODE_MAIL
930              || mode == KEYDB_SEARCH_MODE_MAILSUB
931              || mode == KEYDB_SEARCH_MODE_MAILEND) {
932         for (i=0, s= uid; i < uidlen && *s != '<'; s++, i++)
933             ;
934         if (i < uidlen)  {
935             /* skip opening delim and one char and look for the closing one*/
936             s++; i++;
937             for (se=s+1, i++; i < uidlen && *se != '>'; se++, i++)
938                 ;
939             if (i < uidlen) {
940                 i = se - s;
941                 if (mode == KEYDB_SEARCH_MODE_MAIL) {
942                     if( strlen(name)-2 == i
943                         && !ascii_memcasecmp( s, name+1, i) )
944                         return 0;
945                 }
946                 else if (mode == KEYDB_SEARCH_MODE_MAILSUB) {
947                     if( ascii_memistr( s, i, name ) )
948                         return 0;
949                 }
950                 else { /* email from end */
951                     /* nyi */
952                 }
953             }
954         }
955     }
956     else if (mode == KEYDB_SEARCH_MODE_WORDS)
957         return word_match (uid, uidlen, name);
958     else
959         BUG();
960
961     return -1; /* not found */
962 }
963
964 \f
965 /*
966  * Search through the keyring(s), starting at the current position,
967  * for a keyblock which contains one of the keys described in the DESC array.
968  */
969 int
970 keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
971                 size_t ndesc, size_t *descindex, int ignore_legacy)
972 {
973   int rc;
974   PACKET pkt;
975   int save_mode;
976   off_t offset, main_offset;
977   size_t n;
978   int need_uid, need_words, need_keyid, need_fpr, any_skip;
979   int pk_no, uid_no;
980   int initial_skip;
981   int scanned_from_start;
982   int use_key_present_hash;
983   PKT_user_id *uid = NULL;
984   PKT_public_key *pk = NULL;
985   u32 aki[2];
986
987   /* figure out what information we need */
988   need_uid = need_words = need_keyid = need_fpr = any_skip = 0;
989   for (n=0; n < ndesc; n++)
990     {
991       switch (desc[n].mode)
992         {
993         case KEYDB_SEARCH_MODE_EXACT:
994         case KEYDB_SEARCH_MODE_SUBSTR:
995         case KEYDB_SEARCH_MODE_MAIL:
996         case KEYDB_SEARCH_MODE_MAILSUB:
997         case KEYDB_SEARCH_MODE_MAILEND:
998           need_uid = 1;
999           break;
1000         case KEYDB_SEARCH_MODE_WORDS:
1001           need_uid = 1;
1002           need_words = 1;
1003           break;
1004         case KEYDB_SEARCH_MODE_SHORT_KID:
1005         case KEYDB_SEARCH_MODE_LONG_KID:
1006           need_keyid = 1;
1007           break;
1008         case KEYDB_SEARCH_MODE_FPR16:
1009         case KEYDB_SEARCH_MODE_FPR20:
1010         case KEYDB_SEARCH_MODE_FPR:
1011           need_fpr = 1;
1012           break;
1013         case KEYDB_SEARCH_MODE_FIRST:
1014           /* always restart the search in this mode */
1015           keyring_search_reset (hd);
1016           break;
1017         default: break;
1018         }
1019       if (desc[n].skipfnc)
1020         {
1021           any_skip = 1;
1022           need_keyid = 1;
1023         }
1024     }
1025
1026   if (DBG_LOOKUP)
1027     log_debug ("%s: need_uid = %d; need_words = %d; need_keyid = %d; need_fpr = %d; any_skip = %d\n",
1028                __func__, need_uid, need_words, need_keyid, need_fpr, any_skip);
1029
1030   rc = prepare_search (hd);
1031   if (rc)
1032     {
1033       if (DBG_LOOKUP)
1034         log_debug ("%s: prepare_search failed: %s (%d)\n",
1035                    __func__, gpg_strerror (rc), gpg_err_code (rc));
1036       return rc;
1037     }
1038
1039   use_key_present_hash = !!key_present_hash;
1040   if (!use_key_present_hash)
1041     {
1042       if (DBG_LOOKUP)
1043         log_debug ("%s: no offset table.\n", __func__);
1044     }
1045   else if (!key_present_hash_ready)
1046     {
1047       if (DBG_LOOKUP)
1048         log_debug ("%s: initializing offset table. (need_keyid: %d => 1)\n",
1049                    __func__, need_keyid);
1050       need_keyid = 1;
1051     }
1052   else if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID)
1053     {
1054       struct key_present *oi;
1055
1056       if (DBG_LOOKUP)
1057         log_debug ("%s: look up by long key id, checking cache\n", __func__);
1058
1059       oi = key_present_hash_lookup (key_present_hash, desc[0].u.kid);
1060       if (!oi)
1061         { /* We know that we don't have this key */
1062           if (DBG_LOOKUP)
1063             log_debug ("%s: cache says not present\n", __func__);
1064           hd->found.kr = NULL;
1065           hd->current.eof = 1;
1066           return -1;
1067         }
1068       /* We could now create a positive search status and return.
1069        * However the problem is that another instance of gpg may
1070        * have changed the keyring so that the offsets are not valid
1071        * anymore - therefore we don't do it
1072        */
1073     }
1074
1075   if (need_words)
1076     {
1077       const char *name = NULL;
1078
1079       log_debug ("word search mode does not yet work\n");
1080       /* FIXME: here is a long standing bug in our function and in addition we
1081          just use the first search description */
1082       for (n=0; n < ndesc && !name; n++)
1083         {
1084           if (desc[n].mode == KEYDB_SEARCH_MODE_WORDS)
1085             name = desc[n].u.name;
1086         }
1087       assert (name);
1088       if ( !hd->word_match.name || strcmp (hd->word_match.name, name) )
1089         {
1090           /* name changed */
1091           xfree (hd->word_match.name);
1092           xfree (hd->word_match.pattern);
1093           hd->word_match.name = xstrdup (name);
1094           hd->word_match.pattern = prepare_word_match (name);
1095         }
1096       /*  name = hd->word_match.pattern; */
1097     }
1098
1099   init_packet(&pkt);
1100   save_mode = set_packet_list_mode(0);
1101
1102   hd->found.kr = NULL;
1103   main_offset = 0;
1104   pk_no = uid_no = 0;
1105   initial_skip = 1; /* skip until we see the start of a keyblock */
1106   scanned_from_start = iobuf_tell (hd->current.iobuf) == 0;
1107   if (DBG_LOOKUP)
1108     log_debug ("%s: %ssearching from start of resource.\n",
1109                __func__, scanned_from_start ? "" : "not ");
1110   while (1)
1111     {
1112       byte afp[MAX_FINGERPRINT_LEN];
1113       size_t an;
1114
1115       rc = search_packet (hd->current.iobuf, &pkt, &offset, need_uid);
1116       if (ignore_legacy && gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1117         {
1118           free_packet (&pkt);
1119           continue;
1120         }
1121       if (rc)
1122         break;
1123
1124       if (pkt.pkttype == PKT_PUBLIC_KEY  || pkt.pkttype == PKT_SECRET_KEY)
1125         {
1126           main_offset = offset;
1127           pk_no = uid_no = 0;
1128           initial_skip = 0;
1129         }
1130       if (initial_skip)
1131         {
1132           free_packet (&pkt);
1133           continue;
1134         }
1135
1136       pk = NULL;
1137       uid = NULL;
1138       if (   pkt.pkttype == PKT_PUBLIC_KEY
1139              || pkt.pkttype == PKT_PUBLIC_SUBKEY
1140              || pkt.pkttype == PKT_SECRET_KEY
1141              || pkt.pkttype == PKT_SECRET_SUBKEY)
1142         {
1143           pk = pkt.pkt.public_key;
1144           ++pk_no;
1145
1146           if (need_fpr) {
1147             fingerprint_from_pk (pk, afp, &an);
1148             while (an < 20) /* fill up to 20 bytes */
1149               afp[an++] = 0;
1150           }
1151           if (need_keyid)
1152             keyid_from_pk (pk, aki);
1153
1154           if (use_key_present_hash
1155               && !key_present_hash_ready
1156               && scanned_from_start)
1157             key_present_hash_update (key_present_hash, aki);
1158         }
1159       else if (pkt.pkttype == PKT_USER_ID)
1160         {
1161           uid = pkt.pkt.user_id;
1162           ++uid_no;
1163         }
1164
1165       for (n=0; n < ndesc; n++)
1166         {
1167           switch (desc[n].mode) {
1168           case KEYDB_SEARCH_MODE_NONE:
1169             BUG ();
1170             break;
1171           case KEYDB_SEARCH_MODE_EXACT:
1172           case KEYDB_SEARCH_MODE_SUBSTR:
1173           case KEYDB_SEARCH_MODE_MAIL:
1174           case KEYDB_SEARCH_MODE_MAILSUB:
1175           case KEYDB_SEARCH_MODE_MAILEND:
1176           case KEYDB_SEARCH_MODE_WORDS:
1177             if ( uid && !compare_name (desc[n].mode,
1178                                        desc[n].u.name,
1179                                        uid->name, uid->len))
1180               goto found;
1181             break;
1182
1183           case KEYDB_SEARCH_MODE_SHORT_KID:
1184             if (pk && desc[n].u.kid[1] == aki[1])
1185               goto found;
1186             break;
1187           case KEYDB_SEARCH_MODE_LONG_KID:
1188             if (pk && desc[n].u.kid[0] == aki[0]
1189                 && desc[n].u.kid[1] == aki[1])
1190               goto found;
1191             break;
1192           case KEYDB_SEARCH_MODE_FPR16:
1193             if (pk && !memcmp (desc[n].u.fpr, afp, 16))
1194               goto found;
1195             break;
1196           case KEYDB_SEARCH_MODE_FPR20:
1197           case KEYDB_SEARCH_MODE_FPR:
1198             if (pk && !memcmp (desc[n].u.fpr, afp, 20))
1199               goto found;
1200             break;
1201           case KEYDB_SEARCH_MODE_FIRST:
1202             if (pk)
1203               goto found;
1204             break;
1205           case KEYDB_SEARCH_MODE_NEXT:
1206             if (pk)
1207               goto found;
1208             break;
1209           default:
1210             rc = GPG_ERR_INV_ARG;
1211             goto found;
1212           }
1213         }
1214       free_packet (&pkt);
1215       continue;
1216     found:
1217       if (rc)
1218         goto real_found;
1219
1220       if (DBG_LOOKUP)
1221         log_debug ("%s: packet starting at offset %lld matched descriptor %zu\n"
1222                    , __func__, (long long)offset, n);
1223
1224       /* Record which desc we matched on.  Note this value is only
1225          meaningful if this function returns with no errors. */
1226       if(descindex)
1227         *descindex=n;
1228       for (n=any_skip?0:ndesc; n < ndesc; n++)
1229         {
1230           if (desc[n].skipfnc
1231               && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid_no))
1232             {
1233               if (DBG_LOOKUP)
1234                 log_debug ("%s: skipping match: desc %zd's skip function returned TRUE\n",
1235                            __func__, n);
1236               break;
1237             }
1238         }
1239       if (n == ndesc)
1240         goto real_found;
1241       free_packet (&pkt);
1242     }
1243  real_found:
1244   if (!rc)
1245     {
1246       if (DBG_LOOKUP)
1247         log_debug ("%s: returning success\n", __func__);
1248       hd->found.offset = main_offset;
1249       hd->found.kr = hd->current.kr;
1250       hd->found.pk_no = pk? pk_no : 0;
1251       hd->found.uid_no = uid? uid_no : 0;
1252     }
1253   else if (rc == -1)
1254     {
1255       if (DBG_LOOKUP)
1256         log_debug ("%s: no matches (EOF)\n", __func__);
1257
1258       hd->current.eof = 1;
1259       /* if we scanned all keyrings, we are sure that
1260        * all known key IDs are in our offtbl, mark that. */
1261       if (use_key_present_hash
1262           && !key_present_hash_ready
1263           && scanned_from_start)
1264         {
1265           KR_RESOURCE kr;
1266
1267           /* First set the did_full_scan flag for this keyring.  */
1268           for (kr=kr_resources; kr; kr = kr->next)
1269             {
1270               if (hd->resource == kr)
1271                 {
1272                   kr->did_full_scan = 1;
1273                   break;
1274                 }
1275             }
1276           /* Then check whether all flags are set and if so, mark the
1277              offtbl ready */
1278           for (kr=kr_resources; kr; kr = kr->next)
1279             {
1280               if (!kr->did_full_scan)
1281                 break;
1282             }
1283           if (!kr)
1284             key_present_hash_ready = 1;
1285         }
1286     }
1287   else
1288     {
1289       if (DBG_LOOKUP)
1290         log_debug ("%s: error encountered during search: %s (%d)\n",
1291                    __func__, gpg_strerror (rc), rc);
1292       hd->current.error = rc;
1293     }
1294
1295   free_packet(&pkt);
1296   set_packet_list_mode(save_mode);
1297   return rc;
1298 }
1299
1300
1301 static int
1302 create_tmp_file (const char *template,
1303                  char **r_bakfname, char **r_tmpfname, IOBUF *r_fp)
1304 {
1305   gpg_error_t err;
1306   mode_t oldmask;
1307
1308   err = keybox_tmp_names (template, 1, r_bakfname, r_tmpfname);
1309   if (err)
1310     return err;
1311
1312   /* Create the temp file with limited access.  Note that the umask
1313      call is not anymore needed because iobuf_create now takes care of
1314      it.  However, it does not harm and thus we keep it.  */
1315   oldmask = umask (077);
1316   if (is_secured_filename (*r_tmpfname))
1317     {
1318       *r_fp = NULL;
1319       gpg_err_set_errno (EPERM);
1320     }
1321   else
1322     *r_fp = iobuf_create (*r_tmpfname, 1);
1323   umask (oldmask);
1324   if (!*r_fp)
1325     {
1326       err = gpg_error_from_syserror ();
1327       log_error (_("can't create '%s': %s\n"), *r_tmpfname, gpg_strerror (err));
1328       xfree (*r_tmpfname);
1329       *r_tmpfname = NULL;
1330       xfree (*r_bakfname);
1331       *r_bakfname = NULL;
1332     }
1333
1334   return err;
1335 }
1336
1337
1338 static int
1339 rename_tmp_file (const char *bakfname, const char *tmpfname, const char *fname)
1340 {
1341   int rc = 0;
1342
1343   /* Invalidate close caches.  */
1344   if (iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)tmpfname ))
1345     {
1346       rc = gpg_error_from_syserror ();
1347       goto fail;
1348     }
1349   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)bakfname );
1350   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname );
1351
1352   /* First make a backup file. */
1353   rc = keybox_file_rename (fname, bakfname);
1354   if (rc)
1355     goto fail;
1356
1357   /* then rename the file */
1358   rc = keybox_file_rename (tmpfname, fname);
1359   if (rc)
1360     {
1361       register_secured_file (fname);
1362       goto fail;
1363     }
1364
1365   /* Now make sure the file has the same permissions as the original */
1366 #ifndef HAVE_DOSISH_SYSTEM
1367   {
1368     struct stat statbuf;
1369
1370     statbuf.st_mode=S_IRUSR | S_IWUSR;
1371
1372     if (!stat (bakfname, &statbuf) && !chmod (fname, statbuf.st_mode))
1373       ;
1374     else
1375       log_error ("WARNING: unable to restore permissions to '%s': %s",
1376                  fname, strerror(errno));
1377   }
1378 #endif
1379
1380   return 0;
1381
1382  fail:
1383   return rc;
1384 }
1385
1386
1387 static int
1388 write_keyblock (IOBUF fp, KBNODE keyblock)
1389 {
1390   KBNODE kbctx = NULL, node;
1391   int rc;
1392
1393   while ( (node = walk_kbnode (keyblock, &kbctx, 0)) )
1394     {
1395       if (node->pkt->pkttype == PKT_RING_TRUST)
1396         continue; /* we write it later on our own */
1397
1398       if ( (rc = build_packet (fp, node->pkt) ))
1399         {
1400           log_error ("build_packet(%d) failed: %s\n",
1401                      node->pkt->pkttype, gpg_strerror (rc) );
1402           return rc;
1403         }
1404       if (node->pkt->pkttype == PKT_SIGNATURE)
1405         { /* always write a signature cache packet */
1406           PKT_signature *sig = node->pkt->pkt.signature;
1407           unsigned int cacheval = 0;
1408
1409           if (sig->flags.checked)
1410             {
1411               cacheval |= 1;
1412               if (sig->flags.valid)
1413                 cacheval |= 2;
1414             }
1415           iobuf_put (fp, 0xb0); /* old style packet 12, 1 byte len*/
1416           iobuf_put (fp, 2);    /* 2 bytes */
1417           iobuf_put (fp, 0);    /* unused */
1418           if (iobuf_put (fp, cacheval))
1419             {
1420               rc = gpg_error_from_syserror ();
1421               log_error ("writing sigcache packet failed\n");
1422               return rc;
1423             }
1424         }
1425     }
1426   return 0;
1427 }
1428
1429 /*
1430  * Walk over all public keyrings, check the signatures and replace the
1431  * keyring with a new one where the signature cache is then updated.
1432  * This is only done for the public keyrings.
1433  */
1434 int
1435 keyring_rebuild_cache (void *token,int noisy)
1436 {
1437   KEYRING_HANDLE hd;
1438   KEYDB_SEARCH_DESC desc;
1439   KBNODE keyblock = NULL, node;
1440   const char *lastresname = NULL, *resname;
1441   IOBUF tmpfp = NULL;
1442   char *tmpfilename = NULL;
1443   char *bakfilename = NULL;
1444   int rc;
1445   ulong count = 0, sigcount = 0;
1446
1447   hd = keyring_new (token);
1448   if (!hd)
1449     return gpg_error_from_syserror ();
1450   memset (&desc, 0, sizeof desc);
1451   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1452
1453   rc=keyring_lock (hd, 1);
1454   if(rc)
1455     goto leave;
1456
1457   for (;;)
1458     {
1459       rc = keyring_search (hd, &desc, 1, NULL, 0);
1460       if (rc)
1461         break;  /* ready.  */
1462
1463       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1464       resname = keyring_get_resource_name (hd);
1465       if (lastresname != resname )
1466         { /* we have switched to a new keyring - commit changes */
1467           if (tmpfp)
1468             {
1469               if (iobuf_close (tmpfp))
1470                 {
1471                   rc = gpg_error_from_syserror ();
1472                   log_error ("error closing '%s': %s\n",
1473                              tmpfilename, strerror (errno));
1474                   goto leave;
1475                 }
1476               /* because we have switched resources, we can be sure that
1477                * the original file is closed */
1478               tmpfp = NULL;
1479             }
1480           /* Static analyzer note: BAKFILENAME is never NULL here
1481              because it is controlled by LASTRESNAME.  */
1482           rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1483                                              lastresname) : 0;
1484           xfree (tmpfilename);  tmpfilename = NULL;
1485           xfree (bakfilename);  bakfilename = NULL;
1486           if (rc)
1487             goto leave;
1488           lastresname = resname;
1489           if (noisy && !opt.quiet)
1490             log_info (_("caching keyring '%s'\n"), resname);
1491           rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
1492           if (rc)
1493             goto leave;
1494         }
1495
1496       if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1497         continue;
1498
1499       release_kbnode (keyblock);
1500       rc = keyring_get_keyblock (hd, &keyblock);
1501       if (rc)
1502         {
1503           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1504             continue;  /* Skip legacy keys.  */
1505           log_error ("keyring_get_keyblock failed: %s\n", gpg_strerror (rc));
1506           goto leave;
1507         }
1508       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1509         {
1510           /* We had a few reports about corrupted keyrings; if we have
1511              been called directly from the command line we delete such
1512              a keyblock instead of bailing out.  */
1513           log_error ("unexpected keyblock found (pkttype=%d)%s\n",
1514                      keyblock->pkt->pkttype, noisy? " - deleted":"");
1515           if (noisy)
1516             continue;
1517           log_info ("Hint: backup your keys and try running '%s'\n",
1518                     "gpg --rebuild-keydb-caches");
1519           rc = gpg_error (GPG_ERR_INV_KEYRING);
1520           goto leave;
1521         }
1522
1523       if (keyblock->pkt->pkt.public_key->version < 4)
1524         {
1525           /* We do not copy/cache v3 keys or any other unknown
1526              packets.  It is better to remove them from the keyring.
1527              The code required to keep them in the keyring would be
1528              too complicated.  Given that we do not touch the old
1529              secring.gpg a suitable backup for decryption of v3 stuff
1530              using an older gpg version will always be available.
1531              Note: This test is actually superfluous because we
1532              already acted upon GPG_ERR_LEGACY_KEY.      */
1533         }
1534       else
1535         {
1536           /* Check all signature to set the signature's cache flags. */
1537           for (node=keyblock; node; node=node->next)
1538             {
1539               /* Note that this doesn't cache the result of a
1540                  revocation issued by a designated revoker.  This is
1541                  because the pk in question does not carry the revkeys
1542                  as we haven't merged the key and selfsigs.  It is
1543                  questionable whether this matters very much since
1544                  there are very very few designated revoker revocation
1545                  packets out there. */
1546               if (node->pkt->pkttype == PKT_SIGNATURE)
1547                 {
1548                   PKT_signature *sig=node->pkt->pkt.signature;
1549
1550                   if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
1551                      && (openpgp_md_test_algo(sig->digest_algo)
1552                          || openpgp_pk_test_algo(sig->pubkey_algo)))
1553                     sig->flags.checked=sig->flags.valid=0;
1554                   else
1555                     check_key_signature (keyblock, node, NULL);
1556
1557                   sigcount++;
1558                 }
1559             }
1560
1561           /* Write the keyblock to the temporary file.  */
1562           rc = write_keyblock (tmpfp, keyblock);
1563           if (rc)
1564             goto leave;
1565
1566           if ( !(++count % 50) && noisy && !opt.quiet)
1567             log_info(_("%lu keys cached so far (%lu signatures)\n"),
1568                      count, sigcount );
1569         }
1570     } /* end main loop */
1571   if (rc == -1)
1572     rc = 0;
1573   if (rc)
1574     {
1575       log_error ("keyring_search failed: %s\n", gpg_strerror (rc));
1576       goto leave;
1577     }
1578   if(noisy || opt.verbose)
1579     log_info(_("%lu keys cached (%lu signatures)\n"), count, sigcount );
1580   if (tmpfp)
1581     {
1582       if (iobuf_close (tmpfp))
1583         {
1584           rc = gpg_error_from_syserror ();
1585           log_error ("error closing '%s': %s\n",
1586                      tmpfilename, strerror (errno));
1587           goto leave;
1588         }
1589       /* because we have switched resources, we can be sure that
1590        * the original file is closed */
1591       tmpfp = NULL;
1592     }
1593   rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1594                                      lastresname) : 0;
1595   xfree (tmpfilename);  tmpfilename = NULL;
1596   xfree (bakfilename);  bakfilename = NULL;
1597
1598  leave:
1599   if (tmpfp)
1600     iobuf_cancel (tmpfp);
1601   xfree (tmpfilename);
1602   xfree (bakfilename);
1603   release_kbnode (keyblock);
1604   keyring_lock (hd, 0);
1605   keyring_release (hd);
1606   return rc;
1607 }
1608
1609 \f
1610 /****************
1611  * Perform insert/delete/update operation.
1612  * mode 1 = insert
1613  *      2 = delete
1614  *      3 = update
1615  */
1616 static int
1617 do_copy (int mode, const char *fname, KBNODE root,
1618          off_t start_offset, unsigned int n_packets )
1619 {
1620     IOBUF fp, newfp;
1621     int rc=0;
1622     char *bakfname = NULL;
1623     char *tmpfname = NULL;
1624
1625     /* Open the source file. Because we do a rename, we have to check the
1626        permissions of the file */
1627     if (access (fname, W_OK))
1628       return gpg_error_from_syserror ();
1629
1630     fp = iobuf_open (fname);
1631     if (mode == 1 && !fp && errno == ENOENT) {
1632         /* insert mode but file does not exist: create a new file */
1633         KBNODE kbctx, node;
1634         mode_t oldmask;
1635
1636         oldmask=umask(077);
1637         if (is_secured_filename (fname)) {
1638             newfp = NULL;
1639             gpg_err_set_errno (EPERM);
1640         }
1641         else
1642             newfp = iobuf_create (fname, 1);
1643         umask(oldmask);
1644         if( !newfp )
1645           {
1646             rc = gpg_error_from_syserror ();
1647             log_error (_("can't create '%s': %s\n"), fname, strerror(errno));
1648             return rc;
1649           }
1650         if( !opt.quiet )
1651             log_info(_("%s: keyring created\n"), fname );
1652
1653         kbctx=NULL;
1654         while ( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1655             if( (rc = build_packet( newfp, node->pkt )) ) {
1656                 log_error("build_packet(%d) failed: %s\n",
1657                             node->pkt->pkttype, gpg_strerror (rc) );
1658                 iobuf_cancel(newfp);
1659                 return rc;
1660             }
1661         }
1662         if( iobuf_close(newfp) ) {
1663             rc = gpg_error_from_syserror ();
1664             log_error ("%s: close failed: %s\n", fname, strerror(errno));
1665             return rc;
1666         }
1667         return 0; /* ready */
1668     }
1669
1670     if( !fp )
1671       {
1672         rc = gpg_error_from_syserror ();
1673         log_error(_("can't open '%s': %s\n"), fname, strerror(errno) );
1674         goto leave;
1675       }
1676
1677     /* Create the new file.  */
1678     rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
1679     if (rc) {
1680         iobuf_close(fp);
1681         goto leave;
1682     }
1683
1684     if( mode == 1 ) { /* insert */
1685         /* copy everything to the new file */
1686         rc = copy_all_packets (fp, newfp);
1687         if( rc != -1 ) {
1688             log_error("%s: copy to '%s' failed: %s\n",
1689                       fname, tmpfname, gpg_strerror (rc) );
1690             iobuf_close(fp);
1691             iobuf_cancel(newfp);
1692             goto leave;
1693         }
1694     }
1695
1696     if( mode == 2 || mode == 3 ) { /* delete or update */
1697         /* copy first part to the new file */
1698         rc = copy_some_packets( fp, newfp, start_offset );
1699         if( rc ) { /* should never get EOF here */
1700             log_error ("%s: copy to '%s' failed: %s\n",
1701                        fname, tmpfname, gpg_strerror (rc) );
1702             iobuf_close(fp);
1703             iobuf_cancel(newfp);
1704             goto leave;
1705         }
1706         /* skip this keyblock */
1707         assert( n_packets );
1708         rc = skip_some_packets( fp, n_packets );
1709         if( rc ) {
1710             log_error("%s: skipping %u packets failed: %s\n",
1711                             fname, n_packets, gpg_strerror (rc));
1712             iobuf_close(fp);
1713             iobuf_cancel(newfp);
1714             goto leave;
1715         }
1716     }
1717
1718     if( mode == 1 || mode == 3 ) { /* insert or update */
1719         rc = write_keyblock (newfp, root);
1720         if (rc) {
1721           iobuf_close(fp);
1722           iobuf_cancel(newfp);
1723           goto leave;
1724         }
1725     }
1726
1727     if( mode == 2 || mode == 3 ) { /* delete or update */
1728         /* copy the rest */
1729         rc = copy_all_packets( fp, newfp );
1730         if( rc != -1 ) {
1731             log_error("%s: copy to '%s' failed: %s\n",
1732                       fname, tmpfname, gpg_strerror (rc) );
1733             iobuf_close(fp);
1734             iobuf_cancel(newfp);
1735             goto leave;
1736         }
1737     }
1738
1739     /* close both files */
1740     if( iobuf_close(fp) ) {
1741         rc = gpg_error_from_syserror ();
1742         log_error("%s: close failed: %s\n", fname, strerror(errno) );
1743         goto leave;
1744     }
1745     if( iobuf_close(newfp) ) {
1746         rc = gpg_error_from_syserror ();
1747         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1748         goto leave;
1749     }
1750
1751     rc = rename_tmp_file (bakfname, tmpfname, fname);
1752
1753   leave:
1754     xfree(bakfname);
1755     xfree(tmpfname);
1756     return rc;
1757 }