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