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