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