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