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