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