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