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