gpg,w32: Fix a format string error.
[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
40 /* off_item is a funny named for an object used to keep track of known
41  * keys.  The idea was to use the offset to seek to the known keyblock, but
42  * this is not possible if more than one process is using the keyring.
43  */
44 struct off_item {
45   struct off_item *next;
46   u32 kid[2];
47   /*off_t off;*/
48 };
49
50 typedef struct off_item **OffsetHashTable;
51
52
53 typedef struct keyring_name *KR_NAME;
54 struct keyring_name
55 {
56   struct keyring_name *next;
57   int read_only;
58   dotlock_t lockhd;
59   int is_locked;
60   int did_full_scan;
61   char fname[1];
62 };
63 typedef struct keyring_name const * CONST_KR_NAME;
64
65 static KR_NAME kr_names;
66 static int active_handles;
67
68 static OffsetHashTable kr_offtbl;
69 static int kr_offtbl_ready;
70
71
72 struct keyring_handle
73 {
74   CONST_KR_NAME resource;
75   struct {
76     CONST_KR_NAME kr;
77     IOBUF iobuf;
78     int eof;
79     int error;
80   } current;
81   struct {
82     CONST_KR_NAME kr;
83     off_t offset;
84     size_t pk_no;
85     size_t uid_no;
86     unsigned int n_packets; /*used for delete and update*/
87   } found, saved_found;
88   struct {
89     char *name;
90     char *pattern;
91   } word_match;
92 };
93
94
95
96 static int do_copy (int mode, const char *fname, KBNODE root,
97                     off_t start_offset, unsigned int n_packets );
98
99
100 \f
101 static struct off_item *
102 new_offset_item (void)
103 {
104   struct off_item *k;
105
106   k = xmalloc_clear (sizeof *k);
107   return k;
108 }
109
110 #if 0
111 static void
112 release_offset_items (struct off_item *k)
113 {
114   struct off_item *k2;
115
116   for (; k; k = k2)
117     {
118       k2 = k->next;
119       xfree (k);
120     }
121 }
122 #endif
123
124 static OffsetHashTable
125 new_offset_hash_table (void)
126 {
127   struct off_item **tbl;
128
129   tbl = xmalloc_clear (2048 * sizeof *tbl);
130   return tbl;
131 }
132
133 #if 0
134 static void
135 release_offset_hash_table (OffsetHashTable tbl)
136 {
137   int i;
138
139   if (!tbl)
140     return;
141   for (i=0; i < 2048; i++)
142     release_offset_items (tbl[i]);
143   xfree (tbl);
144 }
145 #endif
146
147 static struct off_item *
148 lookup_offset_hash_table (OffsetHashTable tbl, u32 *kid)
149 {
150   struct off_item *k;
151
152   for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
153     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
154       return k;
155   return NULL;
156 }
157
158 static void
159 update_offset_hash_table (OffsetHashTable tbl, u32 *kid, off_t off)
160 {
161   struct off_item *k;
162
163   (void)off;
164
165   for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
166     {
167       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
168         {
169           /*k->off = off;*/
170           return;
171         }
172     }
173
174   k = new_offset_item ();
175   k->kid[0] = kid[0];
176   k->kid[1] = kid[1];
177   /*k->off = off;*/
178   k->next = tbl[(kid[1] & 0x07ff)];
179   tbl[(kid[1] & 0x07ff)] = k;
180 }
181
182 static void
183 update_offset_hash_table_from_kb (OffsetHashTable tbl, KBNODE node, off_t off)
184 {
185   for (; node; node = node->next)
186     {
187       if (node->pkt->pkttype == PKT_PUBLIC_KEY
188           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
189         {
190           u32 aki[2];
191           keyid_from_pk (node->pkt->pkt.public_key, aki);
192           update_offset_hash_table (tbl, aki, off);
193         }
194     }
195 }
196
197 /*
198  * Register a filename for plain keyring files.  ptr is set to a
199  * pointer to be used to create a handles etc, or the already-issued
200  * pointer if it has already been registered.  The function returns 1
201  * if a new keyring was registered.
202 */
203 int
204 keyring_register_filename (const char *fname, int read_only, void **ptr)
205 {
206     KR_NAME kr;
207
208     if (active_handles)
209         BUG (); /* We don't allow that */
210
211     for (kr=kr_names; kr; kr = kr->next)
212       {
213         if (same_file_p (kr->fname, fname))
214           {
215             /* Already registered. */
216             if (read_only)
217               kr->read_only = 1;
218             *ptr=kr;
219             return 0;
220           }
221       }
222
223     kr = xmalloc (sizeof *kr + strlen (fname));
224     strcpy (kr->fname, fname);
225     kr->read_only = read_only;
226     kr->lockhd = NULL;
227     kr->is_locked = 0;
228     kr->did_full_scan = 0;
229     /* keep a list of all issued pointers */
230     kr->next = kr_names;
231     kr_names = kr;
232
233     /* create the offset table the first time a function here is used */
234     if (!kr_offtbl)
235       kr_offtbl = new_offset_hash_table ();
236
237     *ptr=kr;
238
239     return 1;
240 }
241
242 int
243 keyring_is_writable (void *token)
244 {
245   KR_NAME r = token;
246
247   return r? (r->read_only || !access (r->fname, W_OK)) : 0;
248 }
249
250
251 \f
252 /* Create a new handle for the resource associated with TOKEN.
253
254    The returned handle must be released using keyring_release (). */
255 KEYRING_HANDLE
256 keyring_new (void *token)
257 {
258   KEYRING_HANDLE hd;
259   KR_NAME resource = token;
260
261   assert (resource);
262
263   hd = xmalloc_clear (sizeof *hd);
264   hd->resource = resource;
265   active_handles++;
266   return hd;
267 }
268
269 void
270 keyring_release (KEYRING_HANDLE hd)
271 {
272     if (!hd)
273         return;
274     assert (active_handles > 0);
275     active_handles--;
276     xfree (hd->word_match.name);
277     xfree (hd->word_match.pattern);
278     iobuf_close (hd->current.iobuf);
279     xfree (hd);
280 }
281
282
283 /* Save the current found state in HD for later retrieval by
284    keybox_pop_found_state.  Only one state may be saved.  */
285 void
286 keyring_push_found_state (KEYRING_HANDLE hd)
287 {
288   hd->saved_found = hd->found;
289   hd->found.kr = NULL;
290 }
291
292
293 /* Restore the saved found state in HD.  */
294 void
295 keyring_pop_found_state (KEYRING_HANDLE hd)
296 {
297   hd->found = hd->saved_found;
298   hd->saved_found.kr = NULL;
299 }
300
301
302 const char *
303 keyring_get_resource_name (KEYRING_HANDLE hd)
304 {
305     if (!hd || !hd->resource)
306       return NULL;
307     return hd->resource->fname;
308 }
309
310
311 /*
312  * Lock the keyring with the given handle, or unlock if YES is false.
313  * We ignore the handle and lock all registered files.
314  */
315 int
316 keyring_lock (KEYRING_HANDLE hd, int yes)
317 {
318     KR_NAME kr;
319     int rc = 0;
320
321     (void)hd;
322
323     if (yes) {
324         /* first make sure the lock handles are created */
325         for (kr=kr_names; kr; kr = kr->next) {
326             if (!keyring_is_writable(kr))
327                 continue;
328             if (!kr->lockhd) {
329                 kr->lockhd = dotlock_create (kr->fname, 0);
330                 if (!kr->lockhd) {
331                     log_info ("can't allocate lock for '%s'\n", kr->fname );
332                     rc = GPG_ERR_GENERAL;
333                 }
334             }
335         }
336         if (rc)
337             return rc;
338
339         /* and now set the locks */
340         for (kr=kr_names; kr; kr = kr->next) {
341             if (!keyring_is_writable(kr))
342                 continue;
343             if (kr->is_locked)
344                 ;
345             else if (dotlock_take (kr->lockhd, -1) ) {
346                 log_info ("can't lock '%s'\n", kr->fname );
347                 rc = GPG_ERR_GENERAL;
348             }
349             else
350                 kr->is_locked = 1;
351         }
352     }
353
354     if (rc || !yes) {
355         for (kr=kr_names; kr; kr = kr->next) {
356             if (!keyring_is_writable(kr))
357                 continue;
358             if (!kr->is_locked)
359                 ;
360             else 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 (kr_offtbl)
590         {
591           update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
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 && kr_offtbl)
636       {
637         update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
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_offtbl;
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_offtbl = !!kr_offtbl;
1040   if (!use_offtbl)
1041     {
1042       if (DBG_LOOKUP)
1043         log_debug ("%s: no offset table.\n", __func__);
1044     }
1045   else if (!kr_offtbl_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 off_item *oi;
1055
1056       if (DBG_LOOKUP)
1057         log_debug ("%s: look up by long key id, checking cache\n", __func__);
1058
1059       oi = lookup_offset_hash_table (kr_offtbl, 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_offtbl && !kr_offtbl_ready && scanned_from_start)
1155             update_offset_hash_table (kr_offtbl, aki, main_offset);
1156         }
1157       else if (pkt.pkttype == PKT_USER_ID)
1158         {
1159           uid = pkt.pkt.user_id;
1160           ++uid_no;
1161         }
1162
1163       for (n=0; n < ndesc; n++)
1164         {
1165           switch (desc[n].mode) {
1166           case KEYDB_SEARCH_MODE_NONE:
1167             BUG ();
1168             break;
1169           case KEYDB_SEARCH_MODE_EXACT:
1170           case KEYDB_SEARCH_MODE_SUBSTR:
1171           case KEYDB_SEARCH_MODE_MAIL:
1172           case KEYDB_SEARCH_MODE_MAILSUB:
1173           case KEYDB_SEARCH_MODE_MAILEND:
1174           case KEYDB_SEARCH_MODE_WORDS:
1175             if ( uid && !compare_name (desc[n].mode,
1176                                        desc[n].u.name,
1177                                        uid->name, uid->len))
1178               goto found;
1179             break;
1180
1181           case KEYDB_SEARCH_MODE_SHORT_KID:
1182             if (pk && desc[n].u.kid[1] == aki[1])
1183               goto found;
1184             break;
1185           case KEYDB_SEARCH_MODE_LONG_KID:
1186             if (pk && desc[n].u.kid[0] == aki[0]
1187                 && desc[n].u.kid[1] == aki[1])
1188               goto found;
1189             break;
1190           case KEYDB_SEARCH_MODE_FPR16:
1191             if (pk && !memcmp (desc[n].u.fpr, afp, 16))
1192               goto found;
1193             break;
1194           case KEYDB_SEARCH_MODE_FPR20:
1195           case KEYDB_SEARCH_MODE_FPR:
1196             if (pk && !memcmp (desc[n].u.fpr, afp, 20))
1197               goto found;
1198             break;
1199           case KEYDB_SEARCH_MODE_FIRST:
1200             if (pk)
1201               goto found;
1202             break;
1203           case KEYDB_SEARCH_MODE_NEXT:
1204             if (pk)
1205               goto found;
1206             break;
1207           default:
1208             rc = GPG_ERR_INV_ARG;
1209             goto found;
1210           }
1211         }
1212       free_packet (&pkt);
1213       continue;
1214     found:
1215       if (rc)
1216         goto real_found;
1217
1218       if (DBG_LOOKUP)
1219         log_debug ("%s: packet starting at offset %lld matched descriptor %zu\n"
1220                    , __func__, (long long)offset, n);
1221
1222       /* Record which desc we matched on.  Note this value is only
1223          meaningful if this function returns with no errors. */
1224       if(descindex)
1225         *descindex=n;
1226       for (n=any_skip?0:ndesc; n < ndesc; n++)
1227         {
1228           if (desc[n].skipfnc
1229               && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid_no))
1230             {
1231               if (DBG_LOOKUP)
1232                 log_debug ("%s: skipping match: desc %zd's skip function returned TRUE\n",
1233                            __func__, n);
1234               break;
1235             }
1236         }
1237       if (n == ndesc)
1238         goto real_found;
1239       free_packet (&pkt);
1240     }
1241  real_found:
1242   if (!rc)
1243     {
1244       if (DBG_LOOKUP)
1245         log_debug ("%s: returing success\n", __func__);
1246       hd->found.offset = main_offset;
1247       hd->found.kr = hd->current.kr;
1248       hd->found.pk_no = pk? pk_no : 0;
1249       hd->found.uid_no = uid? uid_no : 0;
1250     }
1251   else if (rc == -1)
1252     {
1253       if (DBG_LOOKUP)
1254         log_debug ("%s: no matches (EOF)\n", __func__);
1255
1256       hd->current.eof = 1;
1257       /* if we scanned all keyrings, we are sure that
1258        * all known key IDs are in our offtbl, mark that. */
1259       if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
1260         {
1261           KR_NAME kr;
1262
1263           /* First set the did_full_scan flag for this keyring.  */
1264           for (kr=kr_names; kr; kr = kr->next)
1265             {
1266               if (hd->resource == kr)
1267                 {
1268                   kr->did_full_scan = 1;
1269                   break;
1270                 }
1271             }
1272           /* Then check whether all flags are set and if so, mark the
1273              offtbl ready */
1274           for (kr=kr_names; kr; kr = kr->next)
1275             {
1276               if (!kr->did_full_scan)
1277                 break;
1278             }
1279           if (!kr)
1280             kr_offtbl_ready = 1;
1281         }
1282     }
1283   else
1284     {
1285       if (DBG_LOOKUP)
1286         log_debug ("%s: error encountered during search: %s (%d)\n",
1287                    __func__, gpg_strerror (rc), rc);
1288       hd->current.error = rc;
1289     }
1290
1291   free_packet(&pkt);
1292   set_packet_list_mode(save_mode);
1293   return rc;
1294 }
1295
1296
1297 static int
1298 create_tmp_file (const char *template,
1299                  char **r_bakfname, char **r_tmpfname, IOBUF *r_fp)
1300 {
1301   char *bakfname, *tmpfname;
1302   mode_t oldmask;
1303
1304   *r_bakfname = NULL;
1305   *r_tmpfname = NULL;
1306
1307 # ifdef USE_ONLY_8DOT3
1308   /* Here is another Windoze bug?:
1309    * you can't rename("pubring.gpg.tmp", "pubring.gpg");
1310    * but        rename("pubring.gpg.tmp", "pubring.aaa");
1311    * works.  So we replace .gpg by .bak or .tmp
1312    */
1313   if (strlen (template) > 4
1314       && !strcmp (template+strlen(template)-4, EXTSEP_S GPGEXT_GPG) )
1315     {
1316       bakfname = xmalloc (strlen (template) + 1);
1317       strcpy (bakfname, template);
1318       strcpy (bakfname+strlen(template)-4, EXTSEP_S "bak");
1319
1320       tmpfname = xmalloc (strlen( template ) + 1 );
1321       strcpy (tmpfname,template);
1322       strcpy (tmpfname+strlen(template)-4, EXTSEP_S "tmp");
1323     }
1324     else
1325       { /* file does not end with gpg; hmmm */
1326         bakfname = xmalloc (strlen( template ) + 5);
1327         strcpy (stpcpy(bakfname, template), EXTSEP_S "bak");
1328
1329         tmpfname = xmalloc (strlen( template ) + 5);
1330         strcpy (stpcpy(tmpfname, template), EXTSEP_S "tmp");
1331     }
1332 # else /* Posix file names */
1333     bakfname = xmalloc (strlen( template ) + 2);
1334     strcpy (stpcpy (bakfname,template),"~");
1335
1336     tmpfname = xmalloc (strlen( template ) + 5);
1337     strcpy (stpcpy(tmpfname,template), EXTSEP_S "tmp");
1338 # endif /* Posix filename */
1339
1340     /* Create the temp file with limited access.  Note that the umask
1341        call is not anymore needed because iobuf_create now takes care
1342        of it.  However, it does not harm and thus we keep it.  */
1343     oldmask=umask(077);
1344     if (is_secured_filename (tmpfname))
1345       {
1346         *r_fp = NULL;
1347         gpg_err_set_errno (EPERM);
1348       }
1349     else
1350       *r_fp = iobuf_create (tmpfname, 1);
1351     umask(oldmask);
1352     if (!*r_fp)
1353       {
1354         int rc = gpg_error_from_syserror ();
1355         log_error(_("can't create '%s': %s\n"), tmpfname, strerror(errno) );
1356         xfree (tmpfname);
1357         xfree (bakfname);
1358         return rc;
1359       }
1360
1361     *r_bakfname = bakfname;
1362     *r_tmpfname = tmpfname;
1363     return 0;
1364 }
1365
1366
1367 static int
1368 rename_tmp_file (const char *bakfname, const char *tmpfname, const char *fname)
1369 {
1370   int rc = 0;
1371
1372   /* Invalidate close caches.  */
1373   if (iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)tmpfname ))
1374     {
1375       rc = gpg_error_from_syserror ();
1376       goto fail;
1377     }
1378   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)bakfname );
1379   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname );
1380
1381   /* First make a backup file. */
1382 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1383   gnupg_remove (bakfname);
1384 #endif
1385   if (rename (fname, bakfname) )
1386     {
1387       rc = gpg_error_from_syserror ();
1388       log_error ("renaming '%s' to '%s' failed: %s\n",
1389                  fname, bakfname, strerror(errno) );
1390       return rc;
1391     }
1392
1393   /* then rename the file */
1394 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1395   gnupg_remove( fname );
1396 #endif
1397   if (rename (tmpfname, fname) )
1398     {
1399       rc = gpg_error_from_syserror ();
1400       log_error (_("renaming '%s' to '%s' failed: %s\n"),
1401                  tmpfname, fname, strerror(errno) );
1402       register_secured_file (fname);
1403       goto fail;
1404     }
1405
1406   /* Now make sure the file has the same permissions as the original */
1407
1408 #ifndef HAVE_DOSISH_SYSTEM
1409   {
1410     struct stat statbuf;
1411
1412     statbuf.st_mode=S_IRUSR | S_IWUSR;
1413
1414     if (!stat (bakfname, &statbuf) && !chmod (fname, statbuf.st_mode))
1415       ;
1416     else
1417       log_error ("WARNING: unable to restore permissions to '%s': %s",
1418                  fname, strerror(errno));
1419   }
1420 #endif
1421
1422   return 0;
1423
1424  fail:
1425   return rc;
1426 }
1427
1428
1429 static int
1430 write_keyblock (IOBUF fp, KBNODE keyblock)
1431 {
1432   KBNODE kbctx = NULL, node;
1433   int rc;
1434
1435   while ( (node = walk_kbnode (keyblock, &kbctx, 0)) )
1436     {
1437       if (node->pkt->pkttype == PKT_RING_TRUST)
1438         continue; /* we write it later on our own */
1439
1440       if ( (rc = build_packet (fp, node->pkt) ))
1441         {
1442           log_error ("build_packet(%d) failed: %s\n",
1443                      node->pkt->pkttype, gpg_strerror (rc) );
1444           return rc;
1445         }
1446       if (node->pkt->pkttype == PKT_SIGNATURE)
1447         { /* always write a signature cache packet */
1448           PKT_signature *sig = node->pkt->pkt.signature;
1449           unsigned int cacheval = 0;
1450
1451           if (sig->flags.checked)
1452             {
1453               cacheval |= 1;
1454               if (sig->flags.valid)
1455                 cacheval |= 2;
1456             }
1457           iobuf_put (fp, 0xb0); /* old style packet 12, 1 byte len*/
1458           iobuf_put (fp, 2);    /* 2 bytes */
1459           iobuf_put (fp, 0);    /* unused */
1460           if (iobuf_put (fp, cacheval))
1461             {
1462               rc = gpg_error_from_syserror ();
1463               log_error ("writing sigcache packet failed\n");
1464               return rc;
1465             }
1466         }
1467     }
1468   return 0;
1469 }
1470
1471 /*
1472  * Walk over all public keyrings, check the signatures and replace the
1473  * keyring with a new one where the signature cache is then updated.
1474  * This is only done for the public keyrings.
1475  */
1476 int
1477 keyring_rebuild_cache (void *token,int noisy)
1478 {
1479   KEYRING_HANDLE hd;
1480   KEYDB_SEARCH_DESC desc;
1481   KBNODE keyblock = NULL, node;
1482   const char *lastresname = NULL, *resname;
1483   IOBUF tmpfp = NULL;
1484   char *tmpfilename = NULL;
1485   char *bakfilename = NULL;
1486   int rc;
1487   ulong count = 0, sigcount = 0;
1488
1489   hd = keyring_new (token);
1490   memset (&desc, 0, sizeof desc);
1491   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1492
1493   rc=keyring_lock (hd, 1);
1494   if(rc)
1495     goto leave;
1496
1497   for (;;)
1498     {
1499       rc = keyring_search (hd, &desc, 1, NULL, 0);
1500       if (rc)
1501         break;  /* ready.  */
1502
1503       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1504       resname = keyring_get_resource_name (hd);
1505       if (lastresname != resname )
1506         { /* we have switched to a new keyring - commit changes */
1507           if (tmpfp)
1508             {
1509               if (iobuf_close (tmpfp))
1510                 {
1511                   rc = gpg_error_from_syserror ();
1512                   log_error ("error closing '%s': %s\n",
1513                              tmpfilename, strerror (errno));
1514                   goto leave;
1515                 }
1516               /* because we have switched resources, we can be sure that
1517                * the original file is closed */
1518               tmpfp = NULL;
1519             }
1520           rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1521                                              lastresname) : 0;
1522           xfree (tmpfilename);  tmpfilename = NULL;
1523           xfree (bakfilename);  bakfilename = NULL;
1524           if (rc)
1525             goto leave;
1526           lastresname = resname;
1527           if (noisy && !opt.quiet)
1528             log_info (_("caching keyring '%s'\n"), resname);
1529           rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
1530           if (rc)
1531             goto leave;
1532         }
1533
1534       if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1535         continue;
1536
1537       release_kbnode (keyblock);
1538       rc = keyring_get_keyblock (hd, &keyblock);
1539       if (rc)
1540         {
1541           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1542             continue;  /* Skip legacy keys.  */
1543           log_error ("keyring_get_keyblock failed: %s\n", gpg_strerror (rc));
1544           goto leave;
1545         }
1546       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1547         {
1548           /* We had a few reports about corrupted keyrings; if we have
1549              been called directly from the command line we delete such
1550              a keyblock instead of bailing out.  */
1551           log_error ("unexpected keyblock found (pkttype=%d)%s\n",
1552                      keyblock->pkt->pkttype, noisy? " - deleted":"");
1553           if (noisy)
1554             continue;
1555           log_info ("Hint: backup your keys and try running '%s'\n",
1556                     "gpg --rebuild-keydb-caches");
1557           rc = gpg_error (GPG_ERR_INV_KEYRING);
1558           goto leave;
1559         }
1560
1561       if (keyblock->pkt->pkt.public_key->version < 4)
1562         {
1563           /* We do not copy/cache v3 keys or any other unknown
1564              packets.  It is better to remove them from the keyring.
1565              The code required to keep them in the keyring would be
1566              too complicated.  Given that we do not touch the old
1567              secring.gpg a suitable backup for decryption of v3 stuff
1568              using an older gpg version will always be available.
1569              Note: This test is actually superfluous because we
1570              already acted upon GPG_ERR_LEGACY_KEY.      */
1571         }
1572       else
1573         {
1574           /* Check all signature to set the signature's cache flags. */
1575           for (node=keyblock; node; node=node->next)
1576             {
1577               /* Note that this doesn't cache the result of a
1578                  revocation issued by a designated revoker.  This is
1579                  because the pk in question does not carry the revkeys
1580                  as we haven't merged the key and selfsigs.  It is
1581                  questionable whether this matters very much since
1582                  there are very very few designated revoker revocation
1583                  packets out there. */
1584               if (node->pkt->pkttype == PKT_SIGNATURE)
1585                 {
1586                   PKT_signature *sig=node->pkt->pkt.signature;
1587
1588                   if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
1589                      && (openpgp_md_test_algo(sig->digest_algo)
1590                          || openpgp_pk_test_algo(sig->pubkey_algo)))
1591                     sig->flags.checked=sig->flags.valid=0;
1592                   else
1593                     check_key_signature (keyblock, node, NULL);
1594
1595                   sigcount++;
1596                 }
1597             }
1598
1599           /* Write the keyblock to the temporary file.  */
1600           rc = write_keyblock (tmpfp, keyblock);
1601           if (rc)
1602             goto leave;
1603
1604           if ( !(++count % 50) && noisy && !opt.quiet)
1605             log_info(_("%lu keys cached so far (%lu signatures)\n"),
1606                      count, sigcount );
1607         }
1608     } /* end main loop */
1609   if (rc == -1)
1610     rc = 0;
1611   if (rc)
1612     {
1613       log_error ("keyring_search failed: %s\n", gpg_strerror (rc));
1614       goto leave;
1615     }
1616   if(noisy || opt.verbose)
1617     log_info(_("%lu keys cached (%lu signatures)\n"), count, sigcount );
1618   if (tmpfp)
1619     {
1620       if (iobuf_close (tmpfp))
1621         {
1622           rc = gpg_error_from_syserror ();
1623           log_error ("error closing '%s': %s\n",
1624                      tmpfilename, strerror (errno));
1625           goto leave;
1626         }
1627       /* because we have switched resources, we can be sure that
1628        * the original file is closed */
1629       tmpfp = NULL;
1630     }
1631   rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1632                                      lastresname) : 0;
1633   xfree (tmpfilename);  tmpfilename = NULL;
1634   xfree (bakfilename);  bakfilename = NULL;
1635
1636  leave:
1637   if (tmpfp)
1638     iobuf_cancel (tmpfp);
1639   xfree (tmpfilename);
1640   xfree (bakfilename);
1641   release_kbnode (keyblock);
1642   keyring_lock (hd, 0);
1643   keyring_release (hd);
1644   return rc;
1645 }
1646
1647 \f
1648 /****************
1649  * Perform insert/delete/update operation.
1650  * mode 1 = insert
1651  *      2 = delete
1652  *      3 = update
1653  */
1654 static int
1655 do_copy (int mode, const char *fname, KBNODE root,
1656          off_t start_offset, unsigned int n_packets )
1657 {
1658     IOBUF fp, newfp;
1659     int rc=0;
1660     char *bakfname = NULL;
1661     char *tmpfname = NULL;
1662
1663     /* Open the source file. Because we do a rename, we have to check the
1664        permissions of the file */
1665     if (access (fname, W_OK))
1666       return gpg_error_from_syserror ();
1667
1668     fp = iobuf_open (fname);
1669     if (mode == 1 && !fp && errno == ENOENT) {
1670         /* insert mode but file does not exist: create a new file */
1671         KBNODE kbctx, node;
1672         mode_t oldmask;
1673
1674         oldmask=umask(077);
1675         if (is_secured_filename (fname)) {
1676             newfp = NULL;
1677             gpg_err_set_errno (EPERM);
1678         }
1679         else
1680             newfp = iobuf_create (fname, 1);
1681         umask(oldmask);
1682         if( !newfp )
1683           {
1684             rc = gpg_error_from_syserror ();
1685             log_error (_("can't create '%s': %s\n"), fname, strerror(errno));
1686             return rc;
1687           }
1688         if( !opt.quiet )
1689             log_info(_("%s: keyring created\n"), fname );
1690
1691         kbctx=NULL;
1692         while ( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1693             if( (rc = build_packet( newfp, node->pkt )) ) {
1694                 log_error("build_packet(%d) failed: %s\n",
1695                             node->pkt->pkttype, gpg_strerror (rc) );
1696                 iobuf_cancel(newfp);
1697                 return rc;
1698             }
1699         }
1700         if( iobuf_close(newfp) ) {
1701             rc = gpg_error_from_syserror ();
1702             log_error ("%s: close failed: %s\n", fname, strerror(errno));
1703             return rc;
1704         }
1705         return 0; /* ready */
1706     }
1707
1708     if( !fp )
1709       {
1710         rc = gpg_error_from_syserror ();
1711         log_error(_("can't open '%s': %s\n"), fname, strerror(errno) );
1712         goto leave;
1713       }
1714
1715     /* Create the new file.  */
1716     rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
1717     if (rc) {
1718         iobuf_close(fp);
1719         goto leave;
1720     }
1721
1722     if( mode == 1 ) { /* insert */
1723         /* copy everything to the new file */
1724         rc = copy_all_packets (fp, newfp);
1725         if( rc != -1 ) {
1726             log_error("%s: copy to '%s' failed: %s\n",
1727                       fname, tmpfname, gpg_strerror (rc) );
1728             iobuf_close(fp);
1729             iobuf_cancel(newfp);
1730             goto leave;
1731         }
1732         rc = 0;
1733     }
1734
1735     if( mode == 2 || mode == 3 ) { /* delete or update */
1736         /* copy first part to the new file */
1737         rc = copy_some_packets( fp, newfp, start_offset );
1738         if( rc ) { /* should never get EOF here */
1739             log_error ("%s: copy to '%s' failed: %s\n",
1740                        fname, tmpfname, gpg_strerror (rc) );
1741             iobuf_close(fp);
1742             iobuf_cancel(newfp);
1743             goto leave;
1744         }
1745         /* skip this keyblock */
1746         assert( n_packets );
1747         rc = skip_some_packets( fp, n_packets );
1748         if( rc ) {
1749             log_error("%s: skipping %u packets failed: %s\n",
1750                             fname, n_packets, gpg_strerror (rc));
1751             iobuf_close(fp);
1752             iobuf_cancel(newfp);
1753             goto leave;
1754         }
1755     }
1756
1757     if( mode == 1 || mode == 3 ) { /* insert or update */
1758         rc = write_keyblock (newfp, root);
1759         if (rc) {
1760           iobuf_close(fp);
1761           iobuf_cancel(newfp);
1762           goto leave;
1763         }
1764     }
1765
1766     if( mode == 2 || mode == 3 ) { /* delete or update */
1767         /* copy the rest */
1768         rc = copy_all_packets( fp, newfp );
1769         if( rc != -1 ) {
1770             log_error("%s: copy to '%s' failed: %s\n",
1771                       fname, tmpfname, gpg_strerror (rc) );
1772             iobuf_close(fp);
1773             iobuf_cancel(newfp);
1774             goto leave;
1775         }
1776         rc = 0;
1777     }
1778
1779     /* close both files */
1780     if( iobuf_close(fp) ) {
1781         rc = gpg_error_from_syserror ();
1782         log_error("%s: close failed: %s\n", fname, strerror(errno) );
1783         goto leave;
1784     }
1785     if( iobuf_close(newfp) ) {
1786         rc = gpg_error_from_syserror ();
1787         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1788         goto leave;
1789     }
1790
1791     rc = rename_tmp_file (bakfname, tmpfname, fname);
1792
1793   leave:
1794     xfree(bakfname);
1795     xfree(tmpfname);
1796     return rc;
1797 }