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