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