gpg: Add some debugging output.
[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
40 /* off_item is a funny named for an object used to keep track of known
41  * keys.  The idea was to use the offset to seek to the known keyblock, but
42  * this is not possible if more than one process is using the keyring.
43  */
44 struct off_item {
45   struct off_item *next;
46   u32 kid[2];
47   /*off_t off;*/
48 };
49
50 typedef struct off_item **OffsetHashTable;
51
52
53 typedef struct keyring_name *KR_NAME;
54 struct keyring_name
55 {
56   struct keyring_name *next;
57   int read_only;
58   dotlock_t lockhd;
59   int is_locked;
60   int did_full_scan;
61   char fname[1];
62 };
63 typedef struct keyring_name const * CONST_KR_NAME;
64
65 static KR_NAME kr_names;
66 static int active_handles;
67
68 static OffsetHashTable kr_offtbl;
69 static int kr_offtbl_ready;
70
71
72 struct keyring_handle
73 {
74   CONST_KR_NAME resource;
75   struct {
76     CONST_KR_NAME kr;
77     IOBUF iobuf;
78     int eof;
79     int error;
80   } current;
81   struct {
82     CONST_KR_NAME kr;
83     off_t offset;
84     size_t pk_no;
85     size_t uid_no;
86     unsigned int n_packets; /*used for delete and update*/
87   } found, saved_found;
88   struct {
89     char *name;
90     char *pattern;
91   } word_match;
92 };
93
94
95
96 static int do_copy (int mode, const char *fname, KBNODE root,
97                     off_t start_offset, unsigned int n_packets );
98
99
100 \f
101 static struct off_item *
102 new_offset_item (void)
103 {
104   struct off_item *k;
105
106   k = xmalloc_clear (sizeof *k);
107   return k;
108 }
109
110 #if 0
111 static void
112 release_offset_items (struct off_item *k)
113 {
114   struct off_item *k2;
115
116   for (; k; k = k2)
117     {
118       k2 = k->next;
119       xfree (k);
120     }
121 }
122 #endif
123
124 static OffsetHashTable
125 new_offset_hash_table (void)
126 {
127   struct off_item **tbl;
128
129   tbl = xmalloc_clear (2048 * sizeof *tbl);
130   return tbl;
131 }
132
133 #if 0
134 static void
135 release_offset_hash_table (OffsetHashTable tbl)
136 {
137   int i;
138
139   if (!tbl)
140     return;
141   for (i=0; i < 2048; i++)
142     release_offset_items (tbl[i]);
143   xfree (tbl);
144 }
145 #endif
146
147 static struct off_item *
148 lookup_offset_hash_table (OffsetHashTable tbl, u32 *kid)
149 {
150   struct off_item *k;
151
152   for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
153     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
154       return k;
155   return NULL;
156 }
157
158 static void
159 update_offset_hash_table (OffsetHashTable tbl, u32 *kid, off_t off)
160 {
161   struct off_item *k;
162
163   (void)off;
164
165   for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
166     {
167       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
168         {
169           /*k->off = off;*/
170           return;
171         }
172     }
173
174   k = new_offset_item ();
175   k->kid[0] = kid[0];
176   k->kid[1] = kid[1];
177   /*k->off = off;*/
178   k->next = tbl[(kid[1] & 0x07ff)];
179   tbl[(kid[1] & 0x07ff)] = k;
180 }
181
182 static void
183 update_offset_hash_table_from_kb (OffsetHashTable tbl, KBNODE node, off_t off)
184 {
185   for (; node; node = node->next)
186     {
187       if (node->pkt->pkttype == PKT_PUBLIC_KEY
188           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
189         {
190           u32 aki[2];
191           keyid_from_pk (node->pkt->pkt.public_key, aki);
192           update_offset_hash_table (tbl, aki, off);
193         }
194     }
195 }
196
197 /*
198  * Register a filename for plain keyring files.  ptr is set to a
199  * pointer to be used to create a handles etc, or the already-issued
200  * pointer if it has already been registered.  The function returns 1
201  * if a new keyring was registered.
202 */
203 int
204 keyring_register_filename (const char *fname, int read_only, void **ptr)
205 {
206     KR_NAME kr;
207
208     if (active_handles)
209         BUG (); /* We don't allow that */
210
211     for (kr=kr_names; kr; kr = kr->next)
212       {
213         if (same_file_p (kr->fname, fname))
214           {
215             /* Already registered. */
216             if (read_only)
217               kr->read_only = 1;
218             *ptr=kr;
219             return 0;
220           }
221       }
222
223     kr = xmalloc (sizeof *kr + strlen (fname));
224     strcpy (kr->fname, fname);
225     kr->read_only = read_only;
226     kr->lockhd = NULL;
227     kr->is_locked = 0;
228     kr->did_full_scan = 0;
229     /* keep a list of all issued pointers */
230     kr->next = kr_names;
231     kr_names = kr;
232
233     /* create the offset table the first time a function here is used */
234     if (!kr_offtbl)
235       kr_offtbl = new_offset_hash_table ();
236
237     *ptr=kr;
238
239     return 1;
240 }
241
242 int
243 keyring_is_writable (void *token)
244 {
245   KR_NAME r = token;
246
247   return r? (r->read_only || !access (r->fname, W_OK)) : 0;
248 }
249
250
251 \f
252 /* Create a new handle for the resource associated with TOKEN.
253
254    The returned handle must be released using keyring_release (). */
255 KEYRING_HANDLE
256 keyring_new (void *token)
257 {
258   KEYRING_HANDLE hd;
259   KR_NAME resource = token;
260
261   assert (resource);
262
263   hd = xmalloc_clear (sizeof *hd);
264   hd->resource = resource;
265   active_handles++;
266   return hd;
267 }
268
269 void
270 keyring_release (KEYRING_HANDLE hd)
271 {
272     if (!hd)
273         return;
274     assert (active_handles > 0);
275     active_handles--;
276     xfree (hd->word_match.name);
277     xfree (hd->word_match.pattern);
278     iobuf_close (hd->current.iobuf);
279     xfree (hd);
280 }
281
282
283 /* Save the current found state in HD for later retrieval by
284    keybox_pop_found_state.  Only one state may be saved.  */
285 void
286 keyring_push_found_state (KEYRING_HANDLE hd)
287 {
288   hd->saved_found = hd->found;
289   hd->found.kr = NULL;
290 }
291
292
293 /* Restore the saved found state in HD.  */
294 void
295 keyring_pop_found_state (KEYRING_HANDLE hd)
296 {
297   hd->found = hd->saved_found;
298   hd->saved_found.kr = NULL;
299 }
300
301
302 const char *
303 keyring_get_resource_name (KEYRING_HANDLE hd)
304 {
305     if (!hd || !hd->resource)
306       return NULL;
307     return hd->resource->fname;
308 }
309
310
311 /*
312  * Lock the keyring with the given handle, or unlock if YES is false.
313  * We ignore the handle and lock all registered files.
314  */
315 int
316 keyring_lock (KEYRING_HANDLE hd, int yes)
317 {
318     KR_NAME kr;
319     int rc = 0;
320
321     (void)hd;
322
323     if (yes) {
324         /* first make sure the lock handles are created */
325         for (kr=kr_names; kr; kr = kr->next) {
326             if (!keyring_is_writable(kr))
327                 continue;
328             if (!kr->lockhd) {
329                 kr->lockhd = dotlock_create (kr->fname, 0);
330                 if (!kr->lockhd) {
331                     log_info ("can't allocate lock for '%s'\n", kr->fname );
332                     rc = GPG_ERR_GENERAL;
333                 }
334             }
335         }
336         if (rc)
337             return rc;
338
339         /* and now set the locks */
340         for (kr=kr_names; kr; kr = kr->next) {
341             if (!keyring_is_writable(kr))
342                 continue;
343             if (kr->is_locked)
344                 ;
345             else if (dotlock_take (kr->lockhd, -1) ) {
346                 log_info ("can't lock '%s'\n", kr->fname );
347                 rc = GPG_ERR_GENERAL;
348             }
349             else
350                 kr->is_locked = 1;
351         }
352     }
353
354     if (rc || !yes) {
355         for (kr=kr_names; kr; kr = kr->next) {
356             if (!keyring_is_writable(kr))
357                 continue;
358             if (!kr->is_locked)
359                 ;
360             else if (dotlock_release (kr->lockhd))
361                 log_info ("can't unlock '%s'\n", kr->fname );
362             else
363                 kr->is_locked = 0;
364         }
365     }
366
367     return rc;
368 }
369
370
371 \f
372 /*
373  * Return the last found keyblock.  Caller must free it.
374  * The returned keyblock has the kbode flag bit 0 set for the node with
375  * the public key used to locate the keyblock or flag bit 1 set for
376  * the user ID node.
377  */
378 int
379 keyring_get_keyblock (KEYRING_HANDLE hd, KBNODE *ret_kb)
380 {
381     PACKET *pkt;
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     hd->found.n_packets = 0;;
412     lastnode = NULL;
413     save_mode = set_packet_list_mode(0);
414     while ((rc=parse_packet (a, pkt)) != -1) {
415         hd->found.n_packets++;
416         if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET) {
417             free_packet (pkt);
418             init_packet (pkt);
419             continue;
420         }
421         if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
422           break;  /* Upper layer needs to handle this.  */
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 (kr_offtbl)
577         {
578           update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
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 && kr_offtbl)
623       {
624         update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
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)
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_offtbl;
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_offtbl = !!kr_offtbl;
1027   if (!use_offtbl)
1028     {
1029       if (DBG_LOOKUP)
1030         log_debug ("%s: no offset table.\n", __func__);
1031     }
1032   else if (!kr_offtbl_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 off_item *oi;
1042
1043       if (DBG_LOOKUP)
1044         log_debug ("%s: look up by long key id, checking cache\n", __func__);
1045
1046       oi = lookup_offset_hash_table (kr_offtbl, 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 (!(rc=search_packet (hd->current.iobuf, &pkt, &offset, need_uid)))
1098     {
1099       byte afp[MAX_FINGERPRINT_LEN];
1100       size_t an;
1101
1102       if (pkt.pkttype == PKT_PUBLIC_KEY  || pkt.pkttype == PKT_SECRET_KEY)
1103         {
1104           main_offset = offset;
1105           pk_no = uid_no = 0;
1106           initial_skip = 0;
1107         }
1108       if (initial_skip)
1109         {
1110           free_packet (&pkt);
1111           continue;
1112         }
1113
1114       pk = NULL;
1115       uid = NULL;
1116       if (   pkt.pkttype == PKT_PUBLIC_KEY
1117              || pkt.pkttype == PKT_PUBLIC_SUBKEY
1118              || pkt.pkttype == PKT_SECRET_KEY
1119              || pkt.pkttype == PKT_SECRET_SUBKEY)
1120         {
1121           pk = pkt.pkt.public_key;
1122           ++pk_no;
1123
1124           if (need_fpr) {
1125             fingerprint_from_pk (pk, afp, &an);
1126             while (an < 20) /* fill up to 20 bytes */
1127               afp[an++] = 0;
1128           }
1129           if (need_keyid)
1130             keyid_from_pk (pk, aki);
1131
1132           if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
1133             update_offset_hash_table (kr_offtbl, aki, main_offset);
1134         }
1135       else if (pkt.pkttype == PKT_USER_ID)
1136         {
1137           uid = pkt.pkt.user_id;
1138           ++uid_no;
1139         }
1140
1141       for (n=0; n < ndesc; n++)
1142         {
1143           switch (desc[n].mode) {
1144           case KEYDB_SEARCH_MODE_NONE:
1145             BUG ();
1146             break;
1147           case KEYDB_SEARCH_MODE_EXACT:
1148           case KEYDB_SEARCH_MODE_SUBSTR:
1149           case KEYDB_SEARCH_MODE_MAIL:
1150           case KEYDB_SEARCH_MODE_MAILSUB:
1151           case KEYDB_SEARCH_MODE_MAILEND:
1152           case KEYDB_SEARCH_MODE_WORDS:
1153             if ( uid && !compare_name (desc[n].mode,
1154                                        desc[n].u.name,
1155                                        uid->name, uid->len))
1156               goto found;
1157             break;
1158
1159           case KEYDB_SEARCH_MODE_SHORT_KID:
1160             if (pk && desc[n].u.kid[1] == aki[1])
1161               goto found;
1162             break;
1163           case KEYDB_SEARCH_MODE_LONG_KID:
1164             if (pk && desc[n].u.kid[0] == aki[0]
1165                 && desc[n].u.kid[1] == aki[1])
1166               goto found;
1167             break;
1168           case KEYDB_SEARCH_MODE_FPR16:
1169             if (pk && !memcmp (desc[n].u.fpr, afp, 16))
1170               goto found;
1171             break;
1172           case KEYDB_SEARCH_MODE_FPR20:
1173           case KEYDB_SEARCH_MODE_FPR:
1174             if (pk && !memcmp (desc[n].u.fpr, afp, 20))
1175               goto found;
1176             break;
1177           case KEYDB_SEARCH_MODE_FIRST:
1178             if (pk)
1179               goto found;
1180             break;
1181           case KEYDB_SEARCH_MODE_NEXT:
1182             if (pk)
1183               goto found;
1184             break;
1185           default:
1186             rc = GPG_ERR_INV_ARG;
1187             goto found;
1188           }
1189         }
1190       free_packet (&pkt);
1191       continue;
1192     found:
1193       if (DBG_LOOKUP)
1194         log_debug ("%s: packet starting at offset %zx matched descriptor %zd\n",
1195                    __func__, offset, n);
1196
1197       /* Record which desc we matched on.  Note this value is only
1198          meaningful if this function returns with no errors. */
1199       if(descindex)
1200         *descindex=n;
1201       for (n=any_skip?0:ndesc; n < ndesc; n++)
1202         {
1203           if (desc[n].skipfnc
1204               && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid_no))
1205             {
1206               if (DBG_LOOKUP)
1207                 log_debug ("%s: skipping match: desc %zd's skip function returned TRUE\n",
1208                            __func__, n);
1209               break;
1210             }
1211         }
1212       if (n == ndesc)
1213         goto real_found;
1214       free_packet (&pkt);
1215     }
1216  real_found:
1217   if (!rc)
1218     {
1219       if (DBG_LOOKUP)
1220         log_debug ("%s: returing success\n", __func__);
1221       hd->found.offset = main_offset;
1222       hd->found.kr = hd->current.kr;
1223       hd->found.pk_no = pk? pk_no : 0;
1224       hd->found.uid_no = uid? uid_no : 0;
1225     }
1226   else if (rc == -1)
1227     {
1228       if (DBG_LOOKUP)
1229         log_debug ("%s: no matches (EOF)\n", __func__);
1230
1231       hd->current.eof = 1;
1232       /* if we scanned all keyrings, we are sure that
1233        * all known key IDs are in our offtbl, mark that. */
1234       if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
1235         {
1236           KR_NAME kr;
1237
1238           /* First set the did_full_scan flag for this keyring.  */
1239           for (kr=kr_names; kr; kr = kr->next)
1240             {
1241               if (hd->resource == kr)
1242                 {
1243                   kr->did_full_scan = 1;
1244                   break;
1245                 }
1246             }
1247           /* Then check whether all flags are set and if so, mark the
1248              offtbl ready */
1249           for (kr=kr_names; kr; kr = kr->next)
1250             {
1251               if (!kr->did_full_scan)
1252                 break;
1253             }
1254           if (!kr)
1255             kr_offtbl_ready = 1;
1256         }
1257     }
1258   else
1259     {
1260       if (DBG_LOOKUP)
1261         log_debug ("%s: error encountered during search: %s (%d)\n",
1262                    __func__, gpg_strerror (rc), rc);
1263       hd->current.error = rc;
1264     }
1265
1266   free_packet(&pkt);
1267   set_packet_list_mode(save_mode);
1268   return rc;
1269 }
1270
1271
1272 static int
1273 create_tmp_file (const char *template,
1274                  char **r_bakfname, char **r_tmpfname, IOBUF *r_fp)
1275 {
1276   char *bakfname, *tmpfname;
1277   mode_t oldmask;
1278
1279   *r_bakfname = NULL;
1280   *r_tmpfname = NULL;
1281
1282 # ifdef USE_ONLY_8DOT3
1283   /* Here is another Windoze bug?:
1284    * you can't rename("pubring.gpg.tmp", "pubring.gpg");
1285    * but        rename("pubring.gpg.tmp", "pubring.aaa");
1286    * works.  So we replace .gpg by .bak or .tmp
1287    */
1288   if (strlen (template) > 4
1289       && !strcmp (template+strlen(template)-4, EXTSEP_S GPGEXT_GPG) )
1290     {
1291       bakfname = xmalloc (strlen (template) + 1);
1292       strcpy (bakfname, template);
1293       strcpy (bakfname+strlen(template)-4, EXTSEP_S "bak");
1294
1295       tmpfname = xmalloc (strlen( template ) + 1 );
1296       strcpy (tmpfname,template);
1297       strcpy (tmpfname+strlen(template)-4, EXTSEP_S "tmp");
1298     }
1299     else
1300       { /* file does not end with gpg; hmmm */
1301         bakfname = xmalloc (strlen( template ) + 5);
1302         strcpy (stpcpy(bakfname, template), EXTSEP_S "bak");
1303
1304         tmpfname = xmalloc (strlen( template ) + 5);
1305         strcpy (stpcpy(tmpfname, template), EXTSEP_S "tmp");
1306     }
1307 # else /* Posix file names */
1308     bakfname = xmalloc (strlen( template ) + 2);
1309     strcpy (stpcpy (bakfname,template),"~");
1310
1311     tmpfname = xmalloc (strlen( template ) + 5);
1312     strcpy (stpcpy(tmpfname,template), EXTSEP_S "tmp");
1313 # endif /* Posix filename */
1314
1315     /* Create the temp file with limited access.  Note that the umask
1316        call is not anymore needed because iobuf_create now takes care
1317        of it.  However, it does not harm and thus we keep it.  */
1318     oldmask=umask(077);
1319     if (is_secured_filename (tmpfname))
1320       {
1321         *r_fp = NULL;
1322         gpg_err_set_errno (EPERM);
1323       }
1324     else
1325       *r_fp = iobuf_create (tmpfname, 1);
1326     umask(oldmask);
1327     if (!*r_fp)
1328       {
1329         int rc = gpg_error_from_syserror ();
1330         log_error(_("can't create '%s': %s\n"), tmpfname, strerror(errno) );
1331         xfree (tmpfname);
1332         xfree (bakfname);
1333         return rc;
1334       }
1335
1336     *r_bakfname = bakfname;
1337     *r_tmpfname = tmpfname;
1338     return 0;
1339 }
1340
1341
1342 static int
1343 rename_tmp_file (const char *bakfname, const char *tmpfname, const char *fname)
1344 {
1345   int rc = 0;
1346
1347   /* Invalidate close caches.  */
1348   if (iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)tmpfname ))
1349     {
1350       rc = gpg_error_from_syserror ();
1351       goto fail;
1352     }
1353   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)bakfname );
1354   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname );
1355
1356   /* First make a backup file. */
1357 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1358   gnupg_remove (bakfname);
1359 #endif
1360   if (rename (fname, bakfname) )
1361     {
1362       rc = gpg_error_from_syserror ();
1363       log_error ("renaming '%s' to '%s' failed: %s\n",
1364                  fname, bakfname, strerror(errno) );
1365       return rc;
1366     }
1367
1368   /* then rename the file */
1369 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1370   gnupg_remove( fname );
1371 #endif
1372   if (rename (tmpfname, fname) )
1373     {
1374       rc = gpg_error_from_syserror ();
1375       log_error (_("renaming '%s' to '%s' failed: %s\n"),
1376                  tmpfname, fname, strerror(errno) );
1377       register_secured_file (fname);
1378       goto fail;
1379     }
1380
1381   /* Now make sure the file has the same permissions as the original */
1382
1383 #ifndef HAVE_DOSISH_SYSTEM
1384   {
1385     struct stat statbuf;
1386
1387     statbuf.st_mode=S_IRUSR | S_IWUSR;
1388
1389     if (!stat (bakfname, &statbuf) && !chmod (fname, statbuf.st_mode))
1390       ;
1391     else
1392       log_error ("WARNING: unable to restore permissions to '%s': %s",
1393                  fname, strerror(errno));
1394   }
1395 #endif
1396
1397   return 0;
1398
1399  fail:
1400   return rc;
1401 }
1402
1403
1404 static int
1405 write_keyblock (IOBUF fp, KBNODE keyblock)
1406 {
1407   KBNODE kbctx = NULL, node;
1408   int rc;
1409
1410   while ( (node = walk_kbnode (keyblock, &kbctx, 0)) )
1411     {
1412       if (node->pkt->pkttype == PKT_RING_TRUST)
1413         continue; /* we write it later on our own */
1414
1415       if ( (rc = build_packet (fp, node->pkt) ))
1416         {
1417           log_error ("build_packet(%d) failed: %s\n",
1418                      node->pkt->pkttype, gpg_strerror (rc) );
1419           return rc;
1420         }
1421       if (node->pkt->pkttype == PKT_SIGNATURE)
1422         { /* always write a signature cache packet */
1423           PKT_signature *sig = node->pkt->pkt.signature;
1424           unsigned int cacheval = 0;
1425
1426           if (sig->flags.checked)
1427             {
1428               cacheval |= 1;
1429               if (sig->flags.valid)
1430                 cacheval |= 2;
1431             }
1432           iobuf_put (fp, 0xb0); /* old style packet 12, 1 byte len*/
1433           iobuf_put (fp, 2);    /* 2 bytes */
1434           iobuf_put (fp, 0);    /* unused */
1435           if (iobuf_put (fp, cacheval))
1436             {
1437               rc = gpg_error_from_syserror ();
1438               log_error ("writing sigcache packet failed\n");
1439               return rc;
1440             }
1441         }
1442     }
1443   return 0;
1444 }
1445
1446 /*
1447  * Walk over all public keyrings, check the signatures and replace the
1448  * keyring with a new one where the signature cache is then updated.
1449  * This is only done for the public keyrings.
1450  */
1451 int
1452 keyring_rebuild_cache (void *token,int noisy)
1453 {
1454   KEYRING_HANDLE hd;
1455   KEYDB_SEARCH_DESC desc;
1456   KBNODE keyblock = NULL, node;
1457   const char *lastresname = NULL, *resname;
1458   IOBUF tmpfp = NULL;
1459   char *tmpfilename = NULL;
1460   char *bakfilename = NULL;
1461   int rc;
1462   ulong count = 0, sigcount = 0;
1463
1464   hd = keyring_new (token);
1465   memset (&desc, 0, sizeof desc);
1466   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1467
1468   rc=keyring_lock (hd, 1);
1469   if(rc)
1470     goto leave;
1471
1472   for (;;)
1473     {
1474       rc = keyring_search (hd, &desc, 1, NULL);
1475       if (rc && gpg_err_code (rc) != GPG_ERR_LEGACY_KEY)
1476         break;  /* ready.  */
1477
1478       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1479       resname = keyring_get_resource_name (hd);
1480       if (lastresname != resname )
1481         { /* we have switched to a new keyring - commit changes */
1482           if (tmpfp)
1483             {
1484               if (iobuf_close (tmpfp))
1485                 {
1486                   rc = gpg_error_from_syserror ();
1487                   log_error ("error closing '%s': %s\n",
1488                              tmpfilename, strerror (errno));
1489                   goto leave;
1490                 }
1491               /* because we have switched resources, we can be sure that
1492                * the original file is closed */
1493               tmpfp = NULL;
1494             }
1495           rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1496                                              lastresname) : 0;
1497           xfree (tmpfilename);  tmpfilename = NULL;
1498           xfree (bakfilename);  bakfilename = NULL;
1499           if (rc)
1500             goto leave;
1501           lastresname = resname;
1502           if (noisy && !opt.quiet)
1503             log_info (_("caching keyring '%s'\n"), resname);
1504           rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
1505           if (rc)
1506             goto leave;
1507         }
1508
1509       if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1510         continue;
1511
1512       release_kbnode (keyblock);
1513       rc = keyring_get_keyblock (hd, &keyblock);
1514       if (rc)
1515         {
1516           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1517             continue;  /* Skip legacy keys.  */
1518           log_error ("keyring_get_keyblock failed: %s\n", gpg_strerror (rc));
1519           goto leave;
1520         }
1521       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1522         {
1523           /* We had a few reports about corrupted keyrings; if we have
1524              been called directly from the command line we delete such
1525              a keyblock instead of bailing out.  */
1526           log_error ("unexpected keyblock found (pkttype=%d)%s\n",
1527                      keyblock->pkt->pkttype, noisy? " - deleted":"");
1528           if (noisy)
1529             continue;
1530           log_info ("Hint: backup your keys and try running '%s'\n",
1531                     "gpg --rebuild-keydb-caches");
1532           rc = gpg_error (GPG_ERR_INV_KEYRING);
1533           goto leave;
1534         }
1535
1536       if (keyblock->pkt->pkt.public_key->version < 4)
1537         {
1538           /* We do not copy/cache v3 keys or any other unknown
1539              packets.  It is better to remove them from the keyring.
1540              The code required to keep them in the keyring would be
1541              too complicated.  Given that we do not touch the old
1542              secring.gpg a suitable backup for decryption of v3 stuff
1543              using an older gpg version will always be available.
1544              Note: This test is actually superfluous because we
1545              already acted upon GPG_ERR_LEGACY_KEY.      */
1546         }
1547       else
1548         {
1549           /* Check all signature to set the signature's cache flags. */
1550           for (node=keyblock; node; node=node->next)
1551             {
1552               /* Note that this doesn't cache the result of a
1553                  revocation issued by a designated revoker.  This is
1554                  because the pk in question does not carry the revkeys
1555                  as we haven't merged the key and selfsigs.  It is
1556                  questionable whether this matters very much since
1557                  there are very very few designated revoker revocation
1558                  packets out there. */
1559               if (node->pkt->pkttype == PKT_SIGNATURE)
1560                 {
1561                   PKT_signature *sig=node->pkt->pkt.signature;
1562
1563                   if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
1564                      && (openpgp_md_test_algo(sig->digest_algo)
1565                          || openpgp_pk_test_algo(sig->pubkey_algo)))
1566                     sig->flags.checked=sig->flags.valid=0;
1567                   else
1568                     check_key_signature (keyblock, node, NULL);
1569
1570                   sigcount++;
1571                 }
1572             }
1573
1574           /* Write the keyblock to the temporary file.  */
1575           rc = write_keyblock (tmpfp, keyblock);
1576           if (rc)
1577             goto leave;
1578
1579           if ( !(++count % 50) && noisy && !opt.quiet)
1580             log_info(_("%lu keys cached so far (%lu signatures)\n"),
1581                      count, sigcount );
1582         }
1583     } /* end main loop */
1584   if (rc == -1)
1585     rc = 0;
1586   if (rc)
1587     {
1588       log_error ("keyring_search failed: %s\n", gpg_strerror (rc));
1589       goto leave;
1590     }
1591   if(noisy || opt.verbose)
1592     log_info(_("%lu keys cached (%lu signatures)\n"), count, sigcount );
1593   if (tmpfp)
1594     {
1595       if (iobuf_close (tmpfp))
1596         {
1597           rc = gpg_error_from_syserror ();
1598           log_error ("error closing '%s': %s\n",
1599                      tmpfilename, strerror (errno));
1600           goto leave;
1601         }
1602       /* because we have switched resources, we can be sure that
1603        * the original file is closed */
1604       tmpfp = NULL;
1605     }
1606   rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1607                                      lastresname) : 0;
1608   xfree (tmpfilename);  tmpfilename = NULL;
1609   xfree (bakfilename);  bakfilename = NULL;
1610
1611  leave:
1612   if (tmpfp)
1613     iobuf_cancel (tmpfp);
1614   xfree (tmpfilename);
1615   xfree (bakfilename);
1616   release_kbnode (keyblock);
1617   keyring_lock (hd, 0);
1618   keyring_release (hd);
1619   return rc;
1620 }
1621
1622 \f
1623 /****************
1624  * Perform insert/delete/update operation.
1625  * mode 1 = insert
1626  *      2 = delete
1627  *      3 = update
1628  */
1629 static int
1630 do_copy (int mode, const char *fname, KBNODE root,
1631          off_t start_offset, unsigned int n_packets )
1632 {
1633     IOBUF fp, newfp;
1634     int rc=0;
1635     char *bakfname = NULL;
1636     char *tmpfname = NULL;
1637
1638     /* Open the source file. Because we do a rename, we have to check the
1639        permissions of the file */
1640     if (access (fname, W_OK))
1641       return gpg_error_from_syserror ();
1642
1643     fp = iobuf_open (fname);
1644     if (mode == 1 && !fp && errno == ENOENT) {
1645         /* insert mode but file does not exist: create a new file */
1646         KBNODE kbctx, node;
1647         mode_t oldmask;
1648
1649         oldmask=umask(077);
1650         if (is_secured_filename (fname)) {
1651             newfp = NULL;
1652             gpg_err_set_errno (EPERM);
1653         }
1654         else
1655             newfp = iobuf_create (fname, 1);
1656         umask(oldmask);
1657         if( !newfp )
1658           {
1659             rc = gpg_error_from_syserror ();
1660             log_error (_("can't create '%s': %s\n"), fname, strerror(errno));
1661             return rc;
1662           }
1663         if( !opt.quiet )
1664             log_info(_("%s: keyring created\n"), fname );
1665
1666         kbctx=NULL;
1667         while ( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1668             if( (rc = build_packet( newfp, node->pkt )) ) {
1669                 log_error("build_packet(%d) failed: %s\n",
1670                             node->pkt->pkttype, gpg_strerror (rc) );
1671                 iobuf_cancel(newfp);
1672                 return rc;
1673             }
1674         }
1675         if( iobuf_close(newfp) ) {
1676             rc = gpg_error_from_syserror ();
1677             log_error ("%s: close failed: %s\n", fname, strerror(errno));
1678             return rc;
1679         }
1680         return 0; /* ready */
1681     }
1682
1683     if( !fp )
1684       {
1685         rc = gpg_error_from_syserror ();
1686         log_error(_("can't open '%s': %s\n"), fname, strerror(errno) );
1687         goto leave;
1688       }
1689
1690     /* Create the new file.  */
1691     rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
1692     if (rc) {
1693         iobuf_close(fp);
1694         goto leave;
1695     }
1696
1697     if( mode == 1 ) { /* insert */
1698         /* copy everything to the new file */
1699         rc = copy_all_packets (fp, newfp);
1700         if( rc != -1 ) {
1701             log_error("%s: copy to '%s' failed: %s\n",
1702                       fname, tmpfname, gpg_strerror (rc) );
1703             iobuf_close(fp);
1704             iobuf_cancel(newfp);
1705             goto leave;
1706         }
1707         rc = 0;
1708     }
1709
1710     if( mode == 2 || mode == 3 ) { /* delete or update */
1711         /* copy first part to the new file */
1712         rc = copy_some_packets( fp, newfp, start_offset );
1713         if( rc ) { /* should never get EOF here */
1714             log_error ("%s: copy to '%s' failed: %s\n",
1715                        fname, tmpfname, gpg_strerror (rc) );
1716             iobuf_close(fp);
1717             iobuf_cancel(newfp);
1718             goto leave;
1719         }
1720         /* skip this keyblock */
1721         assert( n_packets );
1722         rc = skip_some_packets( fp, n_packets );
1723         if( rc ) {
1724             log_error("%s: skipping %u packets failed: %s\n",
1725                             fname, n_packets, gpg_strerror (rc));
1726             iobuf_close(fp);
1727             iobuf_cancel(newfp);
1728             goto leave;
1729         }
1730     }
1731
1732     if( mode == 1 || mode == 3 ) { /* insert or update */
1733         rc = write_keyblock (newfp, root);
1734         if (rc) {
1735           iobuf_close(fp);
1736           iobuf_cancel(newfp);
1737           goto leave;
1738         }
1739     }
1740
1741     if( mode == 2 || mode == 3 ) { /* delete or update */
1742         /* copy the rest */
1743         rc = copy_all_packets( fp, newfp );
1744         if( rc != -1 ) {
1745             log_error("%s: copy to '%s' failed: %s\n",
1746                       fname, tmpfname, gpg_strerror (rc) );
1747             iobuf_close(fp);
1748             iobuf_cancel(newfp);
1749             goto leave;
1750         }
1751         rc = 0;
1752     }
1753
1754     /* close both files */
1755     if( iobuf_close(fp) ) {
1756         rc = gpg_error_from_syserror ();
1757         log_error("%s: close failed: %s\n", fname, strerror(errno) );
1758         goto leave;
1759     }
1760     if( iobuf_close(newfp) ) {
1761         rc = gpg_error_from_syserror ();
1762         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1763         goto leave;
1764     }
1765
1766     rc = rename_tmp_file (bakfname, tmpfname, fname);
1767
1768   leave:
1769     xfree(bakfname);
1770     xfree(tmpfname);
1771     return rc;
1772 }