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