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