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