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