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