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