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