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