gpg: Fix cache consistency problem.
[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           break;  /* Upper layer needs to handle this.  */
423         if (rc) {
424             log_error ("keyring_get_keyblock: read error: %s\n",
425                        gpg_strerror (rc) );
426             rc = GPG_ERR_INV_KEYRING;
427             break;
428         }
429
430         /* Filter allowed packets.  */
431         switch (pkt->pkttype)
432           {
433           case PKT_PUBLIC_KEY:
434           case PKT_PUBLIC_SUBKEY:
435           case PKT_SECRET_KEY:
436           case PKT_SECRET_SUBKEY:
437           case PKT_USER_ID:
438           case PKT_ATTRIBUTE:
439           case PKT_SIGNATURE:
440             break; /* Allowed per RFC.  */
441           case PKT_RING_TRUST:
442           case PKT_OLD_COMMENT:
443           case PKT_COMMENT:
444           case PKT_GPG_CONTROL:
445             break; /* Allowed by us.  */
446
447           default:
448             log_error ("skipped packet of type %d in keyring\n",
449                        (int)pkt->pkttype);
450             free_packet(pkt);
451             init_packet(pkt);
452             continue;
453           }
454
455         if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
456                         || pkt->pkttype == PKT_SECRET_KEY)) {
457             hd->found.n_packets--; /* fix counter */
458             break; /* ready */
459         }
460
461         in_cert = 1;
462         if (pkt->pkttype == PKT_RING_TRUST)
463           {
464             /*(this code is duplicated after the loop)*/
465             if ( lastnode
466                  && lastnode->pkt->pkttype == PKT_SIGNATURE
467                  && (pkt->pkt.ring_trust->sigcache & 1) ) {
468                 /* This is a ring trust packet with a checked signature
469                  * status cache following directly a signature paket.
470                  * Set the cache status into that signature packet.  */
471                 PKT_signature *sig = lastnode->pkt->pkt.signature;
472
473                 sig->flags.checked = 1;
474                 sig->flags.valid = !!(pkt->pkt.ring_trust->sigcache & 2);
475             }
476             /* Reset LASTNODE, so that we set the cache status only from
477              * the ring trust packet immediately following a signature. */
478             lastnode = NULL;
479             free_packet(pkt);
480             init_packet(pkt);
481             continue;
482           }
483
484
485         node = lastnode = new_kbnode (pkt);
486         if (!keyblock)
487           keyblock = node;
488         else
489           add_kbnode (keyblock, node);
490         switch (pkt->pkttype)
491           {
492           case PKT_PUBLIC_KEY:
493           case PKT_PUBLIC_SUBKEY:
494           case PKT_SECRET_KEY:
495           case PKT_SECRET_SUBKEY:
496             if (++pk_no == hd->found.pk_no)
497               node->flag |= 1;
498             break;
499
500           case PKT_USER_ID:
501             if (++uid_no == hd->found.uid_no)
502               node->flag |= 2;
503             break;
504
505           default:
506             break;
507           }
508
509         pkt = xmalloc (sizeof *pkt);
510         init_packet(pkt);
511     }
512     set_packet_list_mode(save_mode);
513
514     if (rc == -1 && keyblock)
515         rc = 0; /* got the entire keyblock */
516
517     if (rc || !ret_kb)
518         release_kbnode (keyblock);
519     else {
520         /*(duplicated from the loop body)*/
521         if ( pkt && pkt->pkttype == PKT_RING_TRUST
522              && lastnode
523              && lastnode->pkt->pkttype == PKT_SIGNATURE
524              && (pkt->pkt.ring_trust->sigcache & 1) ) {
525             PKT_signature *sig = lastnode->pkt->pkt.signature;
526             sig->flags.checked = 1;
527             sig->flags.valid = !!(pkt->pkt.ring_trust->sigcache & 2);
528         }
529         *ret_kb = keyblock;
530     }
531     free_packet (pkt);
532     xfree (pkt);
533     iobuf_close(a);
534
535     /* Make sure that future search operations fail immediately when
536      * we know that we are working on a invalid keyring
537      */
538     if (gpg_err_code (rc) == GPG_ERR_INV_KEYRING)
539         hd->current.error = rc;
540
541     return rc;
542 }
543
544 int
545 keyring_update_keyblock (KEYRING_HANDLE hd, KBNODE kb)
546 {
547     int rc;
548
549     if (!hd->found.kr)
550         return -1; /* no successful prior search */
551
552     if (hd->found.kr->read_only)
553       return gpg_error (GPG_ERR_EACCES);
554
555     if (!hd->found.n_packets) {
556         /* need to know the number of packets - do a dummy get_keyblock*/
557         rc = keyring_get_keyblock (hd, NULL);
558         if (rc) {
559             log_error ("re-reading keyblock failed: %s\n", gpg_strerror (rc));
560             return rc;
561         }
562         if (!hd->found.n_packets)
563             BUG ();
564     }
565
566     /* The open iobuf isn't needed anymore and in fact is a problem when
567        it comes to renaming the keyring files on some operating systems,
568        so close it here */
569     iobuf_close(hd->current.iobuf);
570     hd->current.iobuf = NULL;
571
572     /* do the update */
573     rc = do_copy (3, hd->found.kr->fname, kb,
574                   hd->found.offset, hd->found.n_packets );
575     if (!rc) {
576       if (kr_offtbl)
577         {
578           update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
579         }
580       /* better reset the found info */
581       hd->found.kr = NULL;
582       hd->found.offset = 0;
583     }
584     return rc;
585 }
586
587 int
588 keyring_insert_keyblock (KEYRING_HANDLE hd, KBNODE kb)
589 {
590     int rc;
591     const char *fname;
592
593     if (!hd)
594         fname = NULL;
595     else if (hd->found.kr)
596       {
597         fname = hd->found.kr->fname;
598         if (hd->found.kr->read_only)
599           return gpg_error (GPG_ERR_EACCES);
600       }
601     else if (hd->current.kr)
602       {
603         fname = hd->current.kr->fname;
604         if (hd->current.kr->read_only)
605           return gpg_error (GPG_ERR_EACCES);
606       }
607     else
608         fname = hd->resource? hd->resource->fname:NULL;
609
610     if (!fname)
611         return GPG_ERR_GENERAL;
612
613     /* Close this one otherwise we will lose the position for
614      * a next search.  Fixme: it would be better to adjust the position
615      * after the write opertions.
616      */
617     iobuf_close (hd->current.iobuf);
618     hd->current.iobuf = NULL;
619
620     /* do the insert */
621     rc = do_copy (1, fname, kb, 0, 0 );
622     if (!rc && kr_offtbl)
623       {
624         update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
625       }
626
627     return rc;
628 }
629
630
631 int
632 keyring_delete_keyblock (KEYRING_HANDLE hd)
633 {
634     int rc;
635
636     if (!hd->found.kr)
637         return -1; /* no successful prior search */
638
639     if (hd->found.kr->read_only)
640       return gpg_error (GPG_ERR_EACCES);
641
642     if (!hd->found.n_packets) {
643         /* need to know the number of packets - do a dummy get_keyblock*/
644         rc = keyring_get_keyblock (hd, NULL);
645         if (rc) {
646             log_error ("re-reading keyblock failed: %s\n", gpg_strerror (rc));
647             return rc;
648         }
649         if (!hd->found.n_packets)
650             BUG ();
651     }
652
653     /* close this one otherwise we will lose the position for
654      * a next search.  Fixme: it would be better to adjust the position
655      * after the write opertions.
656      */
657     iobuf_close (hd->current.iobuf);
658     hd->current.iobuf = NULL;
659
660     /* do the delete */
661     rc = do_copy (2, hd->found.kr->fname, NULL,
662                   hd->found.offset, hd->found.n_packets );
663     if (!rc) {
664         /* better reset the found info */
665         hd->found.kr = NULL;
666         hd->found.offset = 0;
667         /* Delete is a rare operations, so we don't remove the keys
668          * from the offset table */
669     }
670     return rc;
671 }
672
673
674 \f
675 /*
676  * Start the next search on this handle right at the beginning
677  */
678 int
679 keyring_search_reset (KEYRING_HANDLE hd)
680 {
681     assert (hd);
682
683     hd->current.kr = NULL;
684     iobuf_close (hd->current.iobuf);
685     hd->current.iobuf = NULL;
686     hd->current.eof = 0;
687     hd->current.error = 0;
688
689     hd->found.kr = NULL;
690     hd->found.offset = 0;
691     return 0;
692 }
693
694
695 static int
696 prepare_search (KEYRING_HANDLE hd)
697 {
698     if (hd->current.error) {
699         /* If the last key was a legacy key, we simply ignore the error so that
700            we can easily use search_next.  */
701         if (gpg_err_code (hd->current.error) == GPG_ERR_LEGACY_KEY)
702             hd->current.error = 0;
703         else
704             return hd->current.error; /* still in error state */
705     }
706
707     if (hd->current.kr && !hd->current.eof) {
708         if ( !hd->current.iobuf )
709             return GPG_ERR_GENERAL; /* Position invalid after a modify.  */
710         return 0; /* okay */
711     }
712
713     if (!hd->current.kr && hd->current.eof)
714         return -1; /* still EOF */
715
716     if (!hd->current.kr) { /* start search with first keyring */
717         hd->current.kr = hd->resource;
718         if (!hd->current.kr) {
719             hd->current.eof = 1;
720             return -1; /* keyring not available */
721         }
722         assert (!hd->current.iobuf);
723     }
724     else { /* EOF */
725         iobuf_close (hd->current.iobuf);
726         hd->current.iobuf = NULL;
727         hd->current.kr = NULL;
728         hd->current.eof = 1;
729         return -1;
730     }
731
732     hd->current.eof = 0;
733     hd->current.iobuf = iobuf_open (hd->current.kr->fname);
734     if (!hd->current.iobuf)
735       {
736         hd->current.error = gpg_error_from_syserror ();
737         log_error(_("can't open '%s'\n"), hd->current.kr->fname );
738         return hd->current.error;
739       }
740
741     return 0;
742 }
743
744 \f
745 /* A map of the all characters valid used for word_match()
746  * Valid characters are in in this table converted to uppercase.
747  * because the upper 128 bytes have special meaning, we assume
748  * that they are all valid.
749  * Note: We must use numerical values here in case that this program
750  * will be converted to those little blue HAL9000s with their strange
751  * EBCDIC character set (user ids are UTF-8).
752  * wk 2000-04-13: Hmmm, does this really make sense, given the fact that
753  * we can run gpg now on a S/390 running GNU/Linux, where the code
754  * translation is done by the device drivers?
755  */
756 static const byte word_match_chars[256] = {
757   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
758   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
759   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
760   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
761   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
762   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
763   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
764   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
765   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
766   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
767   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
768   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
769   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
770   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
771   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
772   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
773   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
774   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
775   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
776   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
777   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
778   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
779   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
780   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
781   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
782   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
783   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
784   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
785   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
786   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
787   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
788   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
789 };
790
791 /****************
792  * Do a word match (original user id starts with a '+').
793  * The pattern is already tokenized to a more suitable format:
794  * There are only the real words in it delimited by one space
795  * and all converted to uppercase.
796  *
797  * Returns: 0 if all words match.
798  *
799  * Note: This algorithm is a straightforward one and not very
800  *       fast.  It works for UTF-8 strings.  The uidlen should
801  *       be removed but due to the fact that old versions of
802  *       pgp don't use UTF-8 we still use the length; this should
803  *       be fixed in parse-packet (and replace \0 by some special
804  *       UTF-8 encoding)
805  */
806 static int
807 word_match( const byte *uid, size_t uidlen, const byte *pattern )
808 {
809     size_t wlen, n;
810     const byte *p;
811     const byte *s;
812
813     for( s=pattern; *s; ) {
814         do {
815             /* skip leading delimiters */
816             while( uidlen && !word_match_chars[*uid] )
817                 uid++, uidlen--;
818             /* get length of the word */
819             n = uidlen; p = uid;
820             while( n && word_match_chars[*p] )
821                 p++, n--;
822             wlen = p - uid;
823             /* and compare against the current word from pattern */
824             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
825                 if( word_match_chars[*p] != s[n] )
826                     break;
827             }
828             if( n == wlen && (s[n] == ' ' || !s[n]) )
829                 break; /* found */
830             uid += wlen;
831             uidlen -= wlen;
832         } while( uidlen );
833         if( !uidlen )
834             return -1; /* not found */
835
836         /* advance to next word in pattern */
837         for(; *s != ' ' && *s ; s++ )
838             ;
839         if( *s )
840             s++ ;
841     }
842     return 0; /* found */
843 }
844
845 /****************
846  * prepare word word_match; that is parse the name and
847  * build the pattern.
848  * caller has to free the returned pattern
849  */
850 static char*
851 prepare_word_match (const byte *name)
852 {
853     byte *pattern, *p;
854     int c;
855
856     /* the original length is always enough for the pattern */
857     p = pattern = xmalloc(strlen(name)+1);
858     do {
859         /* skip leading delimiters */
860         while( *name && !word_match_chars[*name] )
861             name++;
862         /* copy as long as we don't have a delimiter and convert
863          * to uppercase.
864          * fixme: how can we handle utf8 uppercasing */
865         for( ; *name &&  (c=word_match_chars[*name]); name++ )
866             *p++ = c;
867         *p++ = ' '; /* append pattern delimiter */
868     } while( *name );
869     p[-1] = 0; /* replace last pattern delimiter by EOS */
870
871     return pattern;
872 }
873
874
875
876
877 static int
878 compare_name (int mode, const char *name, const char *uid, size_t uidlen)
879 {
880     int i;
881     const char *s, *se;
882
883     if (mode == KEYDB_SEARCH_MODE_EXACT) {
884         for (i=0; name[i] && uidlen; i++, uidlen--)
885             if (uid[i] != name[i])
886                 break;
887         if (!uidlen && !name[i])
888             return 0; /* found */
889     }
890     else if (mode == KEYDB_SEARCH_MODE_SUBSTR) {
891         if (ascii_memistr( uid, uidlen, name ))
892             return 0;
893     }
894     else if (   mode == KEYDB_SEARCH_MODE_MAIL
895              || mode == KEYDB_SEARCH_MODE_MAILSUB
896              || mode == KEYDB_SEARCH_MODE_MAILEND) {
897         for (i=0, s= uid; i < uidlen && *s != '<'; s++, i++)
898             ;
899         if (i < uidlen)  {
900             /* skip opening delim and one char and look for the closing one*/
901             s++; i++;
902             for (se=s+1, i++; i < uidlen && *se != '>'; se++, i++)
903                 ;
904             if (i < uidlen) {
905                 i = se - s;
906                 if (mode == KEYDB_SEARCH_MODE_MAIL) {
907                     if( strlen(name)-2 == i
908                         && !ascii_memcasecmp( s, name+1, i) )
909                         return 0;
910                 }
911                 else if (mode == KEYDB_SEARCH_MODE_MAILSUB) {
912                     if( ascii_memistr( s, i, name ) )
913                         return 0;
914                 }
915                 else { /* email from end */
916                     /* nyi */
917                 }
918             }
919         }
920     }
921     else if (mode == KEYDB_SEARCH_MODE_WORDS)
922         return word_match (uid, uidlen, name);
923     else
924         BUG();
925
926     return -1; /* not found */
927 }
928
929 \f
930 /*
931  * Search through the keyring(s), starting at the current position,
932  * for a keyblock which contains one of the keys described in the DESC array.
933  */
934 int
935 keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
936                 size_t ndesc, size_t *descindex)
937 {
938   int rc;
939   PACKET pkt;
940   int save_mode;
941   off_t offset, main_offset;
942   size_t n;
943   int need_uid, need_words, need_keyid, need_fpr, any_skip;
944   int pk_no, uid_no;
945   int initial_skip;
946   int scanned_from_start;
947   int use_offtbl;
948   PKT_user_id *uid = NULL;
949   PKT_public_key *pk = NULL;
950   u32 aki[2];
951
952   /* figure out what information we need */
953   need_uid = need_words = need_keyid = need_fpr = any_skip = 0;
954   for (n=0; n < ndesc; n++)
955     {
956       switch (desc[n].mode)
957         {
958         case KEYDB_SEARCH_MODE_EXACT:
959         case KEYDB_SEARCH_MODE_SUBSTR:
960         case KEYDB_SEARCH_MODE_MAIL:
961         case KEYDB_SEARCH_MODE_MAILSUB:
962         case KEYDB_SEARCH_MODE_MAILEND:
963           need_uid = 1;
964           break;
965         case KEYDB_SEARCH_MODE_WORDS:
966           need_uid = 1;
967           need_words = 1;
968           break;
969         case KEYDB_SEARCH_MODE_SHORT_KID:
970         case KEYDB_SEARCH_MODE_LONG_KID:
971           need_keyid = 1;
972           break;
973         case KEYDB_SEARCH_MODE_FPR16:
974         case KEYDB_SEARCH_MODE_FPR20:
975         case KEYDB_SEARCH_MODE_FPR:
976           need_fpr = 1;
977           break;
978         case KEYDB_SEARCH_MODE_FIRST:
979           /* always restart the search in this mode */
980           keyring_search_reset (hd);
981           break;
982         default: break;
983         }
984       if (desc[n].skipfnc)
985         {
986           any_skip = 1;
987           need_keyid = 1;
988         }
989     }
990
991   rc = prepare_search (hd);
992   if (rc)
993     return rc;
994
995   use_offtbl = !!kr_offtbl;
996   if (!use_offtbl)
997     ;
998   else if (!kr_offtbl_ready)
999     need_keyid = 1;
1000   else if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID)
1001     {
1002       struct off_item *oi;
1003
1004       oi = lookup_offset_hash_table (kr_offtbl, desc[0].u.kid);
1005       if (!oi)
1006         { /* We know that we don't have this key */
1007           hd->found.kr = NULL;
1008           hd->current.eof = 1;
1009           return -1;
1010         }
1011       /* We could now create a positive search status and return.
1012        * However the problem is that another instance of gpg may
1013        * have changed the keyring so that the offsets are not valid
1014        * anymore - therefore we don't do it
1015        */
1016     }
1017
1018   if (need_words)
1019     {
1020       const char *name = NULL;
1021
1022       log_debug ("word search mode does not yet work\n");
1023       /* FIXME: here is a long standing bug in our function and in addition we
1024          just use the first search description */
1025       for (n=0; n < ndesc && !name; n++)
1026         {
1027           if (desc[n].mode == KEYDB_SEARCH_MODE_WORDS)
1028             name = desc[n].u.name;
1029         }
1030       assert (name);
1031       if ( !hd->word_match.name || strcmp (hd->word_match.name, name) )
1032         {
1033           /* name changed */
1034           xfree (hd->word_match.name);
1035           xfree (hd->word_match.pattern);
1036           hd->word_match.name = xstrdup (name);
1037           hd->word_match.pattern = prepare_word_match (name);
1038         }
1039       /*  name = hd->word_match.pattern; */
1040     }
1041
1042   init_packet(&pkt);
1043   save_mode = set_packet_list_mode(0);
1044
1045   hd->found.kr = NULL;
1046   main_offset = 0;
1047   pk_no = uid_no = 0;
1048   initial_skip = 1; /* skip until we see the start of a keyblock */
1049   scanned_from_start = iobuf_tell (hd->current.iobuf) == 0;
1050   while (!(rc=search_packet (hd->current.iobuf, &pkt, &offset, need_uid)))
1051     {
1052       byte afp[MAX_FINGERPRINT_LEN];
1053       size_t an;
1054
1055       if (pkt.pkttype == PKT_PUBLIC_KEY  || pkt.pkttype == PKT_SECRET_KEY)
1056         {
1057           main_offset = offset;
1058           pk_no = uid_no = 0;
1059           initial_skip = 0;
1060         }
1061       if (initial_skip)
1062         {
1063           free_packet (&pkt);
1064           continue;
1065         }
1066
1067       pk = NULL;
1068       uid = NULL;
1069       if (   pkt.pkttype == PKT_PUBLIC_KEY
1070              || pkt.pkttype == PKT_PUBLIC_SUBKEY
1071              || pkt.pkttype == PKT_SECRET_KEY
1072              || pkt.pkttype == PKT_SECRET_SUBKEY)
1073         {
1074           pk = pkt.pkt.public_key;
1075           ++pk_no;
1076
1077           if (need_fpr) {
1078             fingerprint_from_pk (pk, afp, &an);
1079             while (an < 20) /* fill up to 20 bytes */
1080               afp[an++] = 0;
1081           }
1082           if (need_keyid)
1083             keyid_from_pk (pk, aki);
1084
1085           if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
1086             update_offset_hash_table (kr_offtbl, aki, main_offset);
1087         }
1088       else if (pkt.pkttype == PKT_USER_ID)
1089         {
1090           uid = pkt.pkt.user_id;
1091           ++uid_no;
1092         }
1093
1094       for (n=0; n < ndesc; n++)
1095         {
1096           switch (desc[n].mode) {
1097           case KEYDB_SEARCH_MODE_NONE:
1098             BUG ();
1099             break;
1100           case KEYDB_SEARCH_MODE_EXACT:
1101           case KEYDB_SEARCH_MODE_SUBSTR:
1102           case KEYDB_SEARCH_MODE_MAIL:
1103           case KEYDB_SEARCH_MODE_MAILSUB:
1104           case KEYDB_SEARCH_MODE_MAILEND:
1105           case KEYDB_SEARCH_MODE_WORDS:
1106             if ( uid && !compare_name (desc[n].mode,
1107                                        desc[n].u.name,
1108                                        uid->name, uid->len))
1109               goto found;
1110             break;
1111
1112           case KEYDB_SEARCH_MODE_SHORT_KID:
1113             if (pk && desc[n].u.kid[1] == aki[1])
1114               goto found;
1115             break;
1116           case KEYDB_SEARCH_MODE_LONG_KID:
1117             if (pk && desc[n].u.kid[0] == aki[0]
1118                 && desc[n].u.kid[1] == aki[1])
1119               goto found;
1120             break;
1121           case KEYDB_SEARCH_MODE_FPR16:
1122             if (pk && !memcmp (desc[n].u.fpr, afp, 16))
1123               goto found;
1124             break;
1125           case KEYDB_SEARCH_MODE_FPR20:
1126           case KEYDB_SEARCH_MODE_FPR:
1127             if (pk && !memcmp (desc[n].u.fpr, afp, 20))
1128               goto found;
1129             break;
1130           case KEYDB_SEARCH_MODE_FIRST:
1131             if (pk)
1132               goto found;
1133             break;
1134           case KEYDB_SEARCH_MODE_NEXT:
1135             if (pk)
1136               goto found;
1137             break;
1138           default:
1139             rc = GPG_ERR_INV_ARG;
1140             goto found;
1141           }
1142         }
1143       free_packet (&pkt);
1144       continue;
1145     found:
1146       /* Record which desc we matched on.  Note this value is only
1147          meaningful if this function returns with no errors. */
1148       if(descindex)
1149         *descindex=n;
1150       for (n=any_skip?0:ndesc; n < ndesc; n++)
1151         {
1152           if (desc[n].skipfnc
1153               && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid_no))
1154             break;
1155         }
1156       if (n == ndesc)
1157         goto real_found;
1158       free_packet (&pkt);
1159     }
1160  real_found:
1161   if (!rc)
1162     {
1163       hd->found.offset = main_offset;
1164       hd->found.kr = hd->current.kr;
1165       hd->found.pk_no = pk? pk_no : 0;
1166       hd->found.uid_no = uid? uid_no : 0;
1167     }
1168   else if (rc == -1)
1169     {
1170       hd->current.eof = 1;
1171       /* if we scanned all keyrings, we are sure that
1172        * all known key IDs are in our offtbl, mark that. */
1173       if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
1174         {
1175           KR_NAME kr;
1176
1177           /* First set the did_full_scan flag for this keyring.  */
1178           for (kr=kr_names; kr; kr = kr->next)
1179             {
1180               if (hd->resource == kr)
1181                 {
1182                   kr->did_full_scan = 1;
1183                   break;
1184                 }
1185             }
1186           /* Then check whether all flags are set and if so, mark the
1187              offtbl ready */
1188           for (kr=kr_names; kr; kr = kr->next)
1189             {
1190               if (!kr->did_full_scan)
1191                 break;
1192             }
1193           if (!kr)
1194             kr_offtbl_ready = 1;
1195         }
1196     }
1197   else
1198     hd->current.error = rc;
1199
1200   free_packet(&pkt);
1201   set_packet_list_mode(save_mode);
1202   return rc;
1203 }
1204
1205
1206 static int
1207 create_tmp_file (const char *template,
1208                  char **r_bakfname, char **r_tmpfname, IOBUF *r_fp)
1209 {
1210   char *bakfname, *tmpfname;
1211   mode_t oldmask;
1212
1213   *r_bakfname = NULL;
1214   *r_tmpfname = NULL;
1215
1216 # ifdef USE_ONLY_8DOT3
1217   /* Here is another Windoze bug?:
1218    * you cant rename("pubring.gpg.tmp", "pubring.gpg");
1219    * but        rename("pubring.gpg.tmp", "pubring.aaa");
1220    * works.  So we replace .gpg by .bak or .tmp
1221    */
1222   if (strlen (template) > 4
1223       && !strcmp (template+strlen(template)-4, EXTSEP_S GPGEXT_GPG) )
1224     {
1225       bakfname = xmalloc (strlen (template) + 1);
1226       strcpy (bakfname, template);
1227       strcpy (bakfname+strlen(template)-4, EXTSEP_S "bak");
1228
1229       tmpfname = xmalloc (strlen( template ) + 1 );
1230       strcpy (tmpfname,template);
1231       strcpy (tmpfname+strlen(template)-4, EXTSEP_S "tmp");
1232     }
1233     else
1234       { /* file does not end with gpg; hmmm */
1235         bakfname = xmalloc (strlen( template ) + 5);
1236         strcpy (stpcpy(bakfname, template), EXTSEP_S "bak");
1237
1238         tmpfname = xmalloc (strlen( template ) + 5);
1239         strcpy (stpcpy(tmpfname, template), EXTSEP_S "tmp");
1240     }
1241 # else /* Posix file names */
1242     bakfname = xmalloc (strlen( template ) + 2);
1243     strcpy (stpcpy (bakfname,template),"~");
1244
1245     tmpfname = xmalloc (strlen( template ) + 5);
1246     strcpy (stpcpy(tmpfname,template), EXTSEP_S "tmp");
1247 # endif /* Posix filename */
1248
1249     /* Create the temp file with limited access.  Note that the umask
1250        call is not anymore needed because iobuf_create now takes care
1251        of it.  However, it does not harm and thus we keep it.  */
1252     oldmask=umask(077);
1253     if (is_secured_filename (tmpfname))
1254       {
1255         *r_fp = NULL;
1256         gpg_err_set_errno (EPERM);
1257       }
1258     else
1259       *r_fp = iobuf_create (tmpfname, 1);
1260     umask(oldmask);
1261     if (!*r_fp)
1262       {
1263         int rc = gpg_error_from_syserror ();
1264         log_error(_("can't create '%s': %s\n"), tmpfname, strerror(errno) );
1265         xfree (tmpfname);
1266         xfree (bakfname);
1267         return rc;
1268       }
1269
1270     *r_bakfname = bakfname;
1271     *r_tmpfname = tmpfname;
1272     return 0;
1273 }
1274
1275
1276 static int
1277 rename_tmp_file (const char *bakfname, const char *tmpfname, const char *fname)
1278 {
1279   int rc = 0;
1280
1281   /* Invalidate close caches.  */
1282   if (iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)tmpfname ))
1283     {
1284       rc = gpg_error_from_syserror ();
1285       goto fail;
1286     }
1287   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)bakfname );
1288   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname );
1289
1290   /* First make a backup file. */
1291 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1292   gnupg_remove (bakfname);
1293 #endif
1294   if (rename (fname, bakfname) )
1295     {
1296       rc = gpg_error_from_syserror ();
1297       log_error ("renaming '%s' to '%s' failed: %s\n",
1298                  fname, bakfname, strerror(errno) );
1299       return rc;
1300     }
1301
1302   /* then rename the file */
1303 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1304   gnupg_remove( fname );
1305 #endif
1306   if (rename (tmpfname, fname) )
1307     {
1308       rc = gpg_error_from_syserror ();
1309       log_error (_("renaming '%s' to '%s' failed: %s\n"),
1310                  tmpfname, fname, strerror(errno) );
1311       register_secured_file (fname);
1312       goto fail;
1313     }
1314
1315   /* Now make sure the file has the same permissions as the original */
1316
1317 #ifndef HAVE_DOSISH_SYSTEM
1318   {
1319     struct stat statbuf;
1320
1321     statbuf.st_mode=S_IRUSR | S_IWUSR;
1322
1323     if (!stat (bakfname, &statbuf) && !chmod (fname, statbuf.st_mode))
1324       ;
1325     else
1326       log_error ("WARNING: unable to restore permissions to '%s': %s",
1327                  fname, strerror(errno));
1328   }
1329 #endif
1330
1331   return 0;
1332
1333  fail:
1334   return rc;
1335 }
1336
1337
1338 static int
1339 write_keyblock (IOBUF fp, KBNODE keyblock)
1340 {
1341   KBNODE kbctx = NULL, node;
1342   int rc;
1343
1344   while ( (node = walk_kbnode (keyblock, &kbctx, 0)) )
1345     {
1346       if (node->pkt->pkttype == PKT_RING_TRUST)
1347         continue; /* we write it later on our own */
1348
1349       if ( (rc = build_packet (fp, node->pkt) ))
1350         {
1351           log_error ("build_packet(%d) failed: %s\n",
1352                      node->pkt->pkttype, gpg_strerror (rc) );
1353           return rc;
1354         }
1355       if (node->pkt->pkttype == PKT_SIGNATURE)
1356         { /* always write a signature cache packet */
1357           PKT_signature *sig = node->pkt->pkt.signature;
1358           unsigned int cacheval = 0;
1359
1360           if (sig->flags.checked)
1361             {
1362               cacheval |= 1;
1363               if (sig->flags.valid)
1364                 cacheval |= 2;
1365             }
1366           iobuf_put (fp, 0xb0); /* old style packet 12, 1 byte len*/
1367           iobuf_put (fp, 2);    /* 2 bytes */
1368           iobuf_put (fp, 0);    /* unused */
1369           if (iobuf_put (fp, cacheval))
1370             {
1371               rc = gpg_error_from_syserror ();
1372               log_error ("writing sigcache packet failed\n");
1373               return rc;
1374             }
1375         }
1376     }
1377   return 0;
1378 }
1379
1380 /*
1381  * Walk over all public keyrings, check the signatures and replace the
1382  * keyring with a new one where the signature cache is then updated.
1383  * This is only done for the public keyrings.
1384  */
1385 int
1386 keyring_rebuild_cache (void *token,int noisy)
1387 {
1388   KEYRING_HANDLE hd;
1389   KEYDB_SEARCH_DESC desc;
1390   KBNODE keyblock = NULL, node;
1391   const char *lastresname = NULL, *resname;
1392   IOBUF tmpfp = NULL;
1393   char *tmpfilename = NULL;
1394   char *bakfilename = NULL;
1395   int rc;
1396   ulong count = 0, sigcount = 0;
1397
1398   hd = keyring_new (token);
1399   memset (&desc, 0, sizeof desc);
1400   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1401
1402   rc=keyring_lock (hd, 1);
1403   if(rc)
1404     goto leave;
1405
1406   for (;;)
1407     {
1408       rc = keyring_search (hd, &desc, 1, NULL);
1409       if (rc && gpg_err_code (rc) != GPG_ERR_LEGACY_KEY)
1410         break;  /* ready.  */
1411
1412       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1413       resname = keyring_get_resource_name (hd);
1414       if (lastresname != resname )
1415         { /* we have switched to a new keyring - commit changes */
1416           if (tmpfp)
1417             {
1418               if (iobuf_close (tmpfp))
1419                 {
1420                   rc = gpg_error_from_syserror ();
1421                   log_error ("error closing '%s': %s\n",
1422                              tmpfilename, strerror (errno));
1423                   goto leave;
1424                 }
1425               /* because we have switched resources, we can be sure that
1426                * the original file is closed */
1427               tmpfp = NULL;
1428             }
1429           rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1430                                              lastresname) : 0;
1431           xfree (tmpfilename);  tmpfilename = NULL;
1432           xfree (bakfilename);  bakfilename = NULL;
1433           if (rc)
1434             goto leave;
1435           lastresname = resname;
1436           if (noisy && !opt.quiet)
1437             log_info (_("caching keyring '%s'\n"), resname);
1438           rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
1439           if (rc)
1440             goto leave;
1441         }
1442
1443       if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1444         continue;
1445
1446       release_kbnode (keyblock);
1447       rc = keyring_get_keyblock (hd, &keyblock);
1448       if (rc)
1449         {
1450           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1451             continue;  /* Skip legacy keys.  */
1452           log_error ("keyring_get_keyblock failed: %s\n", gpg_strerror (rc));
1453           goto leave;
1454         }
1455       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1456         {
1457           /* We had a few reports about corrupted keyrings; if we have
1458              been called directly from the command line we delete such
1459              a keyblock instead of bailing out.  */
1460           log_error ("unexpected keyblock found (pkttype=%d)%s\n",
1461                      keyblock->pkt->pkttype, noisy? " - deleted":"");
1462           if (noisy)
1463             continue;
1464           log_info ("Hint: backup your keys and try running '%s'\n",
1465                     "gpg --rebuild-keydb-caches");
1466           rc = gpg_error (GPG_ERR_INV_KEYRING);
1467           goto leave;
1468         }
1469
1470       if (keyblock->pkt->pkt.public_key->version < 4)
1471         {
1472           /* We do not copy/cache v3 keys or any other unknown
1473              packets.  It is better to remove them from the keyring.
1474              The code required to keep them in the keyring would be
1475              too complicated.  Given that we do not touch the old
1476              secring.gpg a suitable backup for decryption of v3 stuff
1477              using an older gpg version will always be available.
1478              Note: This test is actually superfluous because we
1479              already acted upon GPG_ERR_LEGACY_KEY.      */
1480         }
1481       else
1482         {
1483           /* Check all signature to set the signature's cache flags. */
1484           for (node=keyblock; node; node=node->next)
1485             {
1486               /* Note that this doesn't cache the result of a
1487                  revocation issued by a designated revoker.  This is
1488                  because the pk in question does not carry the revkeys
1489                  as we haven't merged the key and selfsigs.  It is
1490                  questionable whether this matters very much since
1491                  there are very very few designated revoker revocation
1492                  packets out there. */
1493               if (node->pkt->pkttype == PKT_SIGNATURE)
1494                 {
1495                   PKT_signature *sig=node->pkt->pkt.signature;
1496
1497                   if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
1498                      && (openpgp_md_test_algo(sig->digest_algo)
1499                          || openpgp_pk_test_algo(sig->pubkey_algo)))
1500                     sig->flags.checked=sig->flags.valid=0;
1501                   else
1502                     check_key_signature (keyblock, node, NULL);
1503
1504                   sigcount++;
1505                 }
1506             }
1507
1508           /* Write the keyblock to the temporary file.  */
1509           rc = write_keyblock (tmpfp, keyblock);
1510           if (rc)
1511             goto leave;
1512
1513           if ( !(++count % 50) && noisy && !opt.quiet)
1514             log_info(_("%lu keys cached so far (%lu signatures)\n"),
1515                      count, sigcount );
1516         }
1517     } /* end main loop */
1518   if (rc == -1)
1519     rc = 0;
1520   if (rc)
1521     {
1522       log_error ("keyring_search failed: %s\n", gpg_strerror (rc));
1523       goto leave;
1524     }
1525   if(noisy || opt.verbose)
1526     log_info(_("%lu keys cached (%lu signatures)\n"), count, sigcount );
1527   if (tmpfp)
1528     {
1529       if (iobuf_close (tmpfp))
1530         {
1531           rc = gpg_error_from_syserror ();
1532           log_error ("error closing '%s': %s\n",
1533                      tmpfilename, strerror (errno));
1534           goto leave;
1535         }
1536       /* because we have switched resources, we can be sure that
1537        * the original file is closed */
1538       tmpfp = NULL;
1539     }
1540   rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1541                                      lastresname) : 0;
1542   xfree (tmpfilename);  tmpfilename = NULL;
1543   xfree (bakfilename);  bakfilename = NULL;
1544
1545  leave:
1546   if (tmpfp)
1547     iobuf_cancel (tmpfp);
1548   xfree (tmpfilename);
1549   xfree (bakfilename);
1550   release_kbnode (keyblock);
1551   keyring_lock (hd, 0);
1552   keyring_release (hd);
1553   return rc;
1554 }
1555
1556 \f
1557 /****************
1558  * Perform insert/delete/update operation.
1559  * mode 1 = insert
1560  *      2 = delete
1561  *      3 = update
1562  */
1563 static int
1564 do_copy (int mode, const char *fname, KBNODE root,
1565          off_t start_offset, unsigned int n_packets )
1566 {
1567     IOBUF fp, newfp;
1568     int rc=0;
1569     char *bakfname = NULL;
1570     char *tmpfname = NULL;
1571
1572     /* Open the source file. Because we do a rename, we have to check the
1573        permissions of the file */
1574     if (access (fname, W_OK))
1575       return gpg_error_from_syserror ();
1576
1577     fp = iobuf_open (fname);
1578     if (mode == 1 && !fp && errno == ENOENT) {
1579         /* insert mode but file does not exist: create a new file */
1580         KBNODE kbctx, node;
1581         mode_t oldmask;
1582
1583         oldmask=umask(077);
1584         if (is_secured_filename (fname)) {
1585             newfp = NULL;
1586             gpg_err_set_errno (EPERM);
1587         }
1588         else
1589             newfp = iobuf_create (fname, 1);
1590         umask(oldmask);
1591         if( !newfp )
1592           {
1593             rc = gpg_error_from_syserror ();
1594             log_error (_("can't create '%s': %s\n"), fname, strerror(errno));
1595             return rc;
1596           }
1597         if( !opt.quiet )
1598             log_info(_("%s: keyring created\n"), fname );
1599
1600         kbctx=NULL;
1601         while ( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1602             if( (rc = build_packet( newfp, node->pkt )) ) {
1603                 log_error("build_packet(%d) failed: %s\n",
1604                             node->pkt->pkttype, gpg_strerror (rc) );
1605                 iobuf_cancel(newfp);
1606                 return rc;
1607             }
1608         }
1609         if( iobuf_close(newfp) ) {
1610             rc = gpg_error_from_syserror ();
1611             log_error ("%s: close failed: %s\n", fname, strerror(errno));
1612             return rc;
1613         }
1614         return 0; /* ready */
1615     }
1616
1617     if( !fp )
1618       {
1619         rc = gpg_error_from_syserror ();
1620         log_error(_("can't open '%s': %s\n"), fname, strerror(errno) );
1621         goto leave;
1622       }
1623
1624     /* Create the new file.  */
1625     rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
1626     if (rc) {
1627         iobuf_close(fp);
1628         goto leave;
1629     }
1630
1631     if( mode == 1 ) { /* insert */
1632         /* copy everything to the new file */
1633         rc = copy_all_packets (fp, newfp);
1634         if( rc != -1 ) {
1635             log_error("%s: copy to '%s' failed: %s\n",
1636                       fname, tmpfname, gpg_strerror (rc) );
1637             iobuf_close(fp);
1638             iobuf_cancel(newfp);
1639             goto leave;
1640         }
1641         rc = 0;
1642     }
1643
1644     if( mode == 2 || mode == 3 ) { /* delete or update */
1645         /* copy first part to the new file */
1646         rc = copy_some_packets( fp, newfp, start_offset );
1647         if( rc ) { /* should never get EOF here */
1648             log_error ("%s: copy to '%s' failed: %s\n",
1649                        fname, tmpfname, gpg_strerror (rc) );
1650             iobuf_close(fp);
1651             iobuf_cancel(newfp);
1652             goto leave;
1653         }
1654         /* skip this keyblock */
1655         assert( n_packets );
1656         rc = skip_some_packets( fp, n_packets );
1657         if( rc ) {
1658             log_error("%s: skipping %u packets failed: %s\n",
1659                             fname, n_packets, gpg_strerror (rc));
1660             iobuf_close(fp);
1661             iobuf_cancel(newfp);
1662             goto leave;
1663         }
1664     }
1665
1666     if( mode == 1 || mode == 3 ) { /* insert or update */
1667         rc = write_keyblock (newfp, root);
1668         if (rc) {
1669           iobuf_close(fp);
1670           iobuf_cancel(newfp);
1671           goto leave;
1672         }
1673     }
1674
1675     if( mode == 2 || mode == 3 ) { /* delete or update */
1676         /* copy the rest */
1677         rc = copy_all_packets( fp, newfp );
1678         if( rc != -1 ) {
1679             log_error("%s: copy to '%s' failed: %s\n",
1680                       fname, tmpfname, gpg_strerror (rc) );
1681             iobuf_close(fp);
1682             iobuf_cancel(newfp);
1683             goto leave;
1684         }
1685         rc = 0;
1686     }
1687
1688     /* close both files */
1689     if( iobuf_close(fp) ) {
1690         rc = gpg_error_from_syserror ();
1691         log_error("%s: close failed: %s\n", fname, strerror(errno) );
1692         goto leave;
1693     }
1694     if( iobuf_close(newfp) ) {
1695         rc = gpg_error_from_syserror ();
1696         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1697         goto leave;
1698     }
1699
1700     rc = rename_tmp_file (bakfname, tmpfname, fname);
1701
1702   leave:
1703     xfree(bakfname);
1704     xfree(tmpfname);
1705     return rc;
1706 }