gpg: Pass CTRL to many more functions.
[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++;
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     hd->current.kr = NULL;
667     iobuf_close (hd->current.iobuf);
668     hd->current.iobuf = NULL;
669     hd->current.eof = 0;
670     hd->current.error = 0;
671
672     hd->found.kr = NULL;
673     hd->found.offset = 0;
674     return 0;
675 }
676
677
678 static int
679 prepare_search (KEYRING_HANDLE hd)
680 {
681     if (hd->current.error) {
682         /* If the last key was a legacy key, we simply ignore the error so that
683            we can easily use search_next.  */
684         if (gpg_err_code (hd->current.error) == GPG_ERR_LEGACY_KEY)
685           {
686             if (DBG_LOOKUP)
687               log_debug ("%s: last error was GPG_ERR_LEGACY_KEY, clearing\n",
688                          __func__);
689             hd->current.error = 0;
690           }
691         else
692           {
693             if (DBG_LOOKUP)
694               log_debug ("%s: returning last error: %s\n",
695                          __func__, gpg_strerror (hd->current.error));
696             return hd->current.error; /* still in error state */
697           }
698     }
699
700     if (hd->current.kr && !hd->current.eof) {
701         if ( !hd->current.iobuf )
702           {
703             if (DBG_LOOKUP)
704               log_debug ("%s: missing iobuf!\n", __func__);
705             return GPG_ERR_GENERAL; /* Position invalid after a modify.  */
706           }
707         return 0; /* okay */
708     }
709
710     if (!hd->current.kr && hd->current.eof)
711       {
712         if (DBG_LOOKUP)
713           log_debug ("%s: EOF!\n", __func__);
714         return -1; /* still EOF */
715       }
716
717     if (!hd->current.kr) { /* start search with first keyring */
718         hd->current.kr = hd->resource;
719         if (!hd->current.kr) {
720           if (DBG_LOOKUP)
721             log_debug ("%s: keyring not available!\n", __func__);
722           hd->current.eof = 1;
723           return -1; /* keyring not available */
724         }
725         log_assert (!hd->current.iobuf);
726     }
727     else { /* EOF */
728         if (DBG_LOOKUP)
729           log_debug ("%s: EOF\n", __func__);
730         iobuf_close (hd->current.iobuf);
731         hd->current.iobuf = NULL;
732         hd->current.kr = NULL;
733         hd->current.eof = 1;
734         return -1;
735     }
736
737     hd->current.eof = 0;
738     hd->current.iobuf = iobuf_open (hd->current.kr->fname);
739     if (!hd->current.iobuf)
740       {
741         hd->current.error = gpg_error_from_syserror ();
742         log_error(_("can't open '%s'\n"), hd->current.kr->fname );
743         return hd->current.error;
744       }
745
746     return 0;
747 }
748
749 \f
750 /* A map of the all characters valid used for word_match()
751  * Valid characters are in this table converted to uppercase.
752  * because the upper 128 bytes have special meaning, we assume
753  * that they are all valid.
754  * Note: We must use numerical values here in case that this program
755  * will be converted to those little blue HAL9000s with their strange
756  * EBCDIC character set (user ids are UTF-8).
757  * wk 2000-04-13: Hmmm, does this really make sense, given the fact that
758  * we can run gpg now on a S/390 running GNU/Linux, where the code
759  * translation is done by the device drivers?
760  */
761 static const byte word_match_chars[256] = {
762   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
763   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
764   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
765   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
766   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
767   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
768   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
769   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
770   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
771   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
772   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
773   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
774   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
775   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
776   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
777   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
778   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
779   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
780   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
781   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
782   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
783   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
784   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
785   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
786   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
787   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
788   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
789   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
790   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
791   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
792   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
793   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
794 };
795
796 /****************
797  * Do a word match (original user id starts with a '+').
798  * The pattern is already tokenized to a more suitable format:
799  * There are only the real words in it delimited by one space
800  * and all converted to uppercase.
801  *
802  * Returns: 0 if all words match.
803  *
804  * Note: This algorithm is a straightforward one and not very
805  *       fast.  It works for UTF-8 strings.  The uidlen should
806  *       be removed but due to the fact that old versions of
807  *       pgp don't use UTF-8 we still use the length; this should
808  *       be fixed in parse-packet (and replace \0 by some special
809  *       UTF-8 encoding)
810  */
811 static int
812 word_match( const byte *uid, size_t uidlen, const byte *pattern )
813 {
814     size_t wlen, n;
815     const byte *p;
816     const byte *s;
817
818     for( s=pattern; *s; ) {
819         do {
820             /* skip leading delimiters */
821             while( uidlen && !word_match_chars[*uid] )
822                 uid++, uidlen--;
823             /* get length of the word */
824             n = uidlen; p = uid;
825             while( n && word_match_chars[*p] )
826                 p++, n--;
827             wlen = p - uid;
828             /* and compare against the current word from pattern */
829             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
830                 if( word_match_chars[*p] != s[n] )
831                     break;
832             }
833             if( n == wlen && (s[n] == ' ' || !s[n]) )
834                 break; /* found */
835             uid += wlen;
836             uidlen -= wlen;
837         } while( uidlen );
838         if( !uidlen )
839             return -1; /* not found */
840
841         /* advance to next word in pattern */
842         for(; *s != ' ' && *s ; s++ )
843             ;
844         if( *s )
845             s++ ;
846     }
847     return 0; /* found */
848 }
849
850 /****************
851  * prepare word word_match; that is parse the name and
852  * build the pattern.
853  * caller has to free the returned pattern
854  */
855 static char*
856 prepare_word_match (const byte *name)
857 {
858     byte *pattern, *p;
859     int c;
860
861     /* the original length is always enough for the pattern */
862     p = pattern = xmalloc(strlen(name)+1);
863     do {
864         /* skip leading delimiters */
865         while( *name && !word_match_chars[*name] )
866             name++;
867         /* copy as long as we don't have a delimiter and convert
868          * to uppercase.
869          * fixme: how can we handle utf8 uppercasing */
870         for( ; *name &&  (c=word_match_chars[*name]); name++ )
871             *p++ = c;
872         *p++ = ' '; /* append pattern delimiter */
873     } while( *name );
874     p[-1] = 0; /* replace last pattern delimiter by EOS */
875
876     return pattern;
877 }
878
879
880
881
882 static int
883 compare_name (int mode, const char *name, const char *uid, size_t uidlen)
884 {
885     int i;
886     const char *s, *se;
887
888     if (mode == KEYDB_SEARCH_MODE_EXACT) {
889         for (i=0; name[i] && uidlen; i++, uidlen--)
890             if (uid[i] != name[i])
891                 break;
892         if (!uidlen && !name[i])
893             return 0; /* found */
894     }
895     else if (mode == KEYDB_SEARCH_MODE_SUBSTR) {
896         if (ascii_memistr( uid, uidlen, name ))
897             return 0;
898     }
899     else if (   mode == KEYDB_SEARCH_MODE_MAIL
900              || mode == KEYDB_SEARCH_MODE_MAILSUB
901              || mode == KEYDB_SEARCH_MODE_MAILEND) {
902         int have_angles = 1;
903         for (i=0, s= uid; i < uidlen && *s != '<'; s++, i++)
904             ;
905         if (i == uidlen)
906           {
907             /* The UID is a plain addr-spec (cf. RFC2822 section 4.3).  */
908             have_angles = 0;
909             s = uid;
910             i = 0;
911           }
912         if (i < uidlen)  {
913             if (have_angles)
914               {
915                 /* skip opening delim and one char and look for the closing one*/
916                 s++; i++;
917                 for (se=s+1, i++; i < uidlen && *se != '>'; se++, i++)
918                   ;
919               }
920             else
921               se = s + uidlen;
922
923             if (i < uidlen) {
924                 i = se - s;
925                 if (mode == KEYDB_SEARCH_MODE_MAIL) {
926                     if( strlen(name)-2 == i
927                         && !ascii_memcasecmp( s, name+1, i) )
928                         return 0;
929                 }
930                 else if (mode == KEYDB_SEARCH_MODE_MAILSUB) {
931                     if( ascii_memistr( s, i, name ) )
932                         return 0;
933                 }
934                 else { /* email from end */
935                     /* nyi */
936                 }
937             }
938         }
939     }
940     else if (mode == KEYDB_SEARCH_MODE_WORDS)
941         return word_match (uid, uidlen, name);
942     else
943         BUG();
944
945     return -1; /* not found */
946 }
947
948 \f
949 /*
950  * Search through the keyring(s), starting at the current position,
951  * for a keyblock which contains one of the keys described in the DESC array.
952  */
953 int
954 keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
955                 size_t ndesc, size_t *descindex, int ignore_legacy)
956 {
957   int rc;
958   PACKET pkt;
959   struct parse_packet_ctx_s parsectx;
960   int save_mode;
961   off_t offset, main_offset;
962   size_t n;
963   int need_uid, need_words, need_keyid, need_fpr, any_skip;
964   int pk_no, uid_no;
965   int initial_skip;
966   int scanned_from_start;
967   int use_key_present_hash;
968   PKT_user_id *uid = NULL;
969   PKT_public_key *pk = NULL;
970   u32 aki[2];
971
972   /* figure out what information we need */
973   need_uid = need_words = need_keyid = need_fpr = any_skip = 0;
974   for (n=0; n < ndesc; n++)
975     {
976       switch (desc[n].mode)
977         {
978         case KEYDB_SEARCH_MODE_EXACT:
979         case KEYDB_SEARCH_MODE_SUBSTR:
980         case KEYDB_SEARCH_MODE_MAIL:
981         case KEYDB_SEARCH_MODE_MAILSUB:
982         case KEYDB_SEARCH_MODE_MAILEND:
983           need_uid = 1;
984           break;
985         case KEYDB_SEARCH_MODE_WORDS:
986           need_uid = 1;
987           need_words = 1;
988           break;
989         case KEYDB_SEARCH_MODE_SHORT_KID:
990         case KEYDB_SEARCH_MODE_LONG_KID:
991           need_keyid = 1;
992           break;
993         case KEYDB_SEARCH_MODE_FPR16:
994         case KEYDB_SEARCH_MODE_FPR20:
995         case KEYDB_SEARCH_MODE_FPR:
996           need_fpr = 1;
997           break;
998         case KEYDB_SEARCH_MODE_FIRST:
999           /* always restart the search in this mode */
1000           keyring_search_reset (hd);
1001           break;
1002         default: break;
1003         }
1004       if (desc[n].skipfnc)
1005         {
1006           any_skip = 1;
1007           need_keyid = 1;
1008         }
1009     }
1010
1011   if (DBG_LOOKUP)
1012     log_debug ("%s: need_uid = %d; need_words = %d; need_keyid = %d; need_fpr = %d; any_skip = %d\n",
1013                __func__, need_uid, need_words, need_keyid, need_fpr, any_skip);
1014
1015   rc = prepare_search (hd);
1016   if (rc)
1017     {
1018       if (DBG_LOOKUP)
1019         log_debug ("%s: prepare_search failed: %s (%d)\n",
1020                    __func__, gpg_strerror (rc), gpg_err_code (rc));
1021       return rc;
1022     }
1023
1024   use_key_present_hash = !!key_present_hash;
1025   if (!use_key_present_hash)
1026     {
1027       if (DBG_LOOKUP)
1028         log_debug ("%s: no offset table.\n", __func__);
1029     }
1030   else if (!key_present_hash_ready)
1031     {
1032       if (DBG_LOOKUP)
1033         log_debug ("%s: initializing offset table. (need_keyid: %d => 1)\n",
1034                    __func__, need_keyid);
1035       need_keyid = 1;
1036     }
1037   else if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID)
1038     {
1039       struct key_present *oi;
1040
1041       if (DBG_LOOKUP)
1042         log_debug ("%s: look up by long key id, checking cache\n", __func__);
1043
1044       oi = key_present_hash_lookup (key_present_hash, desc[0].u.kid);
1045       if (!oi)
1046         { /* We know that we don't have this key */
1047           if (DBG_LOOKUP)
1048             log_debug ("%s: cache says not present\n", __func__);
1049           hd->found.kr = NULL;
1050           hd->current.eof = 1;
1051           return -1;
1052         }
1053       /* We could now create a positive search status and return.
1054        * However the problem is that another instance of gpg may
1055        * have changed the keyring so that the offsets are not valid
1056        * anymore - therefore we don't do it
1057        */
1058     }
1059
1060   if (need_words)
1061     {
1062       const char *name = NULL;
1063
1064       log_debug ("word search mode does not yet work\n");
1065       /* FIXME: here is a long standing bug in our function and in addition we
1066          just use the first search description */
1067       for (n=0; n < ndesc && !name; n++)
1068         {
1069           if (desc[n].mode == KEYDB_SEARCH_MODE_WORDS)
1070             name = desc[n].u.name;
1071         }
1072       log_assert (name);
1073       if ( !hd->word_match.name || strcmp (hd->word_match.name, name) )
1074         {
1075           /* name changed */
1076           xfree (hd->word_match.name);
1077           xfree (hd->word_match.pattern);
1078           hd->word_match.name = xstrdup (name);
1079           hd->word_match.pattern = prepare_word_match (name);
1080         }
1081       /*  name = hd->word_match.pattern; */
1082     }
1083
1084   init_packet(&pkt);
1085   save_mode = set_packet_list_mode(0);
1086
1087   hd->found.kr = NULL;
1088   main_offset = 0;
1089   pk_no = uid_no = 0;
1090   initial_skip = 1; /* skip until we see the start of a keyblock */
1091   scanned_from_start = iobuf_tell (hd->current.iobuf) == 0;
1092   if (DBG_LOOKUP)
1093     log_debug ("%s: %ssearching from start of resource.\n",
1094                __func__, scanned_from_start ? "" : "not ");
1095   init_parse_packet (&parsectx, hd->current.iobuf);
1096   while (1)
1097     {
1098       byte afp[MAX_FINGERPRINT_LEN];
1099       size_t an;
1100
1101       rc = search_packet (&parsectx, &pkt, &offset, need_uid);
1102       if (ignore_legacy && gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1103         {
1104           free_packet (&pkt, &parsectx);
1105           continue;
1106         }
1107       if (rc)
1108         break;
1109
1110       if (pkt.pkttype == PKT_PUBLIC_KEY  || pkt.pkttype == PKT_SECRET_KEY)
1111         {
1112           main_offset = offset;
1113           pk_no = uid_no = 0;
1114           initial_skip = 0;
1115         }
1116       if (initial_skip)
1117         {
1118           free_packet (&pkt, &parsectx);
1119           continue;
1120         }
1121
1122       pk = NULL;
1123       uid = NULL;
1124       if (   pkt.pkttype == PKT_PUBLIC_KEY
1125              || pkt.pkttype == PKT_PUBLIC_SUBKEY
1126              || pkt.pkttype == PKT_SECRET_KEY
1127              || pkt.pkttype == PKT_SECRET_SUBKEY)
1128         {
1129           pk = pkt.pkt.public_key;
1130           ++pk_no;
1131
1132           if (need_fpr) {
1133             fingerprint_from_pk (pk, afp, &an);
1134             while (an < 20) /* fill up to 20 bytes */
1135               afp[an++] = 0;
1136           }
1137           if (need_keyid)
1138             keyid_from_pk (pk, aki);
1139
1140           if (use_key_present_hash
1141               && !key_present_hash_ready
1142               && scanned_from_start)
1143             key_present_hash_update (key_present_hash, aki);
1144         }
1145       else if (pkt.pkttype == PKT_USER_ID)
1146         {
1147           uid = pkt.pkt.user_id;
1148           ++uid_no;
1149         }
1150
1151       for (n=0; n < ndesc; n++)
1152         {
1153           switch (desc[n].mode) {
1154           case KEYDB_SEARCH_MODE_NONE:
1155             BUG ();
1156             break;
1157           case KEYDB_SEARCH_MODE_EXACT:
1158           case KEYDB_SEARCH_MODE_SUBSTR:
1159           case KEYDB_SEARCH_MODE_MAIL:
1160           case KEYDB_SEARCH_MODE_MAILSUB:
1161           case KEYDB_SEARCH_MODE_MAILEND:
1162           case KEYDB_SEARCH_MODE_WORDS:
1163             if ( uid && !compare_name (desc[n].mode,
1164                                        desc[n].u.name,
1165                                        uid->name, uid->len))
1166               goto found;
1167             break;
1168
1169           case KEYDB_SEARCH_MODE_SHORT_KID:
1170             if (pk && desc[n].u.kid[1] == aki[1])
1171               goto found;
1172             break;
1173           case KEYDB_SEARCH_MODE_LONG_KID:
1174             if (pk && desc[n].u.kid[0] == aki[0]
1175                 && desc[n].u.kid[1] == aki[1])
1176               goto found;
1177             break;
1178           case KEYDB_SEARCH_MODE_FPR16:
1179             if (pk && !memcmp (desc[n].u.fpr, afp, 16))
1180               goto found;
1181             break;
1182           case KEYDB_SEARCH_MODE_FPR20:
1183           case KEYDB_SEARCH_MODE_FPR:
1184             if (pk && !memcmp (desc[n].u.fpr, afp, 20))
1185               goto found;
1186             break;
1187           case KEYDB_SEARCH_MODE_FIRST:
1188             if (pk)
1189               goto found;
1190             break;
1191           case KEYDB_SEARCH_MODE_NEXT:
1192             if (pk)
1193               goto found;
1194             break;
1195           default:
1196             rc = GPG_ERR_INV_ARG;
1197             goto found;
1198           }
1199         }
1200       free_packet (&pkt, &parsectx);
1201       continue;
1202     found:
1203       if (rc)
1204         goto real_found;
1205
1206       if (DBG_LOOKUP)
1207         log_debug ("%s: packet starting at offset %lld matched descriptor %zu\n"
1208                    , __func__, (long long)offset, n);
1209
1210       /* Record which desc we matched on.  Note this value is only
1211          meaningful if this function returns with no errors. */
1212       if(descindex)
1213         *descindex=n;
1214       for (n=any_skip?0:ndesc; n < ndesc; n++)
1215         {
1216           if (desc[n].skipfnc
1217               && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid_no))
1218             {
1219               if (DBG_LOOKUP)
1220                 log_debug ("%s: skipping match: desc %zd's skip function returned TRUE\n",
1221                            __func__, n);
1222               break;
1223             }
1224         }
1225       if (n == ndesc)
1226         goto real_found;
1227       free_packet (&pkt, &parsectx);
1228     }
1229  real_found:
1230   if (!rc)
1231     {
1232       if (DBG_LOOKUP)
1233         log_debug ("%s: returning success\n", __func__);
1234       hd->found.offset = main_offset;
1235       hd->found.kr = hd->current.kr;
1236       hd->found.pk_no = pk? pk_no : 0;
1237       hd->found.uid_no = uid? uid_no : 0;
1238     }
1239   else if (rc == -1)
1240     {
1241       if (DBG_LOOKUP)
1242         log_debug ("%s: no matches (EOF)\n", __func__);
1243
1244       hd->current.eof = 1;
1245       /* if we scanned all keyrings, we are sure that
1246        * all known key IDs are in our offtbl, mark that. */
1247       if (use_key_present_hash
1248           && !key_present_hash_ready
1249           && scanned_from_start)
1250         {
1251           KR_RESOURCE kr;
1252
1253           /* First set the did_full_scan flag for this keyring.  */
1254           for (kr=kr_resources; kr; kr = kr->next)
1255             {
1256               if (hd->resource == kr)
1257                 {
1258                   kr->did_full_scan = 1;
1259                   break;
1260                 }
1261             }
1262           /* Then check whether all flags are set and if so, mark the
1263              offtbl ready */
1264           for (kr=kr_resources; kr; kr = kr->next)
1265             {
1266               if (!kr->did_full_scan)
1267                 break;
1268             }
1269           if (!kr)
1270             key_present_hash_ready = 1;
1271         }
1272     }
1273   else
1274     {
1275       if (DBG_LOOKUP)
1276         log_debug ("%s: error encountered during search: %s (%d)\n",
1277                    __func__, gpg_strerror (rc), rc);
1278       hd->current.error = rc;
1279     }
1280
1281   free_packet (&pkt, &parsectx);
1282   deinit_parse_packet (&parsectx);
1283   set_packet_list_mode(save_mode);
1284   return rc;
1285 }
1286
1287
1288 static int
1289 create_tmp_file (const char *template,
1290                  char **r_bakfname, char **r_tmpfname, IOBUF *r_fp)
1291 {
1292   gpg_error_t err;
1293   mode_t oldmask;
1294
1295   err = keybox_tmp_names (template, 1, r_bakfname, r_tmpfname);
1296   if (err)
1297     return err;
1298
1299   /* Create the temp file with limited access.  Note that the umask
1300      call is not anymore needed because iobuf_create now takes care of
1301      it.  However, it does not harm and thus we keep it.  */
1302   oldmask = umask (077);
1303   if (is_secured_filename (*r_tmpfname))
1304     {
1305       *r_fp = NULL;
1306       gpg_err_set_errno (EPERM);
1307     }
1308   else
1309     *r_fp = iobuf_create (*r_tmpfname, 1);
1310   umask (oldmask);
1311   if (!*r_fp)
1312     {
1313       err = gpg_error_from_syserror ();
1314       log_error (_("can't create '%s': %s\n"), *r_tmpfname, gpg_strerror (err));
1315       xfree (*r_tmpfname);
1316       *r_tmpfname = NULL;
1317       xfree (*r_bakfname);
1318       *r_bakfname = NULL;
1319     }
1320
1321   return err;
1322 }
1323
1324
1325 static int
1326 rename_tmp_file (const char *bakfname, const char *tmpfname, const char *fname)
1327 {
1328   int rc = 0;
1329   int block = 0;
1330
1331   /* Invalidate close caches.  */
1332   if (iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)tmpfname ))
1333     {
1334       rc = gpg_error_from_syserror ();
1335       goto fail;
1336     }
1337   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)bakfname );
1338   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname );
1339
1340   /* First make a backup file. */
1341   block = 1;
1342   rc = gnupg_rename_file (fname, bakfname, &block);
1343   if (rc)
1344     goto fail;
1345
1346   /* then rename the file */
1347   rc = gnupg_rename_file (tmpfname, fname, NULL);
1348   if (block)
1349     {
1350       gnupg_unblock_all_signals ();
1351       block = 0;
1352     }
1353   if (rc)
1354     {
1355       register_secured_file (fname);
1356       goto fail;
1357     }
1358
1359   /* Now make sure the file has the same permissions as the original */
1360 #ifndef HAVE_DOSISH_SYSTEM
1361   {
1362     struct stat statbuf;
1363
1364     statbuf.st_mode=S_IRUSR | S_IWUSR;
1365
1366     if (!stat (bakfname, &statbuf) && !chmod (fname, statbuf.st_mode))
1367       ;
1368     else
1369       log_error ("WARNING: unable to restore permissions to '%s': %s",
1370                  fname, strerror(errno));
1371   }
1372 #endif
1373
1374   return 0;
1375
1376  fail:
1377   if (block)
1378     gnupg_unblock_all_signals ();
1379   return rc;
1380 }
1381
1382
1383 static int
1384 write_keyblock (IOBUF fp, KBNODE keyblock)
1385 {
1386   KBNODE kbctx = NULL, node;
1387   int rc;
1388
1389   while ( (node = walk_kbnode (keyblock, &kbctx, 0)) )
1390     {
1391       if ( (rc = build_packet_and_meta (fp, node->pkt) ))
1392         {
1393           log_error ("build_packet(%d) failed: %s\n",
1394                      node->pkt->pkttype, gpg_strerror (rc) );
1395           return rc;
1396         }
1397     }
1398   return 0;
1399 }
1400
1401 /*
1402  * Walk over all public keyrings, check the signatures and replace the
1403  * keyring with a new one where the signature cache is then updated.
1404  * This is only done for the public keyrings.
1405  */
1406 int
1407 keyring_rebuild_cache (ctrl_t ctrl, void *token, int noisy)
1408 {
1409   KEYRING_HANDLE hd;
1410   KEYDB_SEARCH_DESC desc;
1411   KBNODE keyblock = NULL, node;
1412   const char *lastresname = NULL, *resname;
1413   IOBUF tmpfp = NULL;
1414   char *tmpfilename = NULL;
1415   char *bakfilename = NULL;
1416   int rc;
1417   ulong count = 0, sigcount = 0;
1418
1419   hd = keyring_new (token);
1420   if (!hd)
1421     return gpg_error_from_syserror ();
1422   memset (&desc, 0, sizeof desc);
1423   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1424
1425   rc=keyring_lock (hd, 1);
1426   if(rc)
1427     goto leave;
1428
1429   for (;;)
1430     {
1431       rc = keyring_search (hd, &desc, 1, NULL, 1 /* ignore_legacy */);
1432       if (rc)
1433         break;  /* ready.  */
1434
1435       desc.mode = KEYDB_SEARCH_MODE_NEXT;
1436       resname = keyring_get_resource_name (hd);
1437       if (lastresname != resname )
1438         { /* we have switched to a new keyring - commit changes */
1439           if (tmpfp)
1440             {
1441               if (iobuf_close (tmpfp))
1442                 {
1443                   rc = gpg_error_from_syserror ();
1444                   log_error ("error closing '%s': %s\n",
1445                              tmpfilename, strerror (errno));
1446                   goto leave;
1447                 }
1448               /* because we have switched resources, we can be sure that
1449                * the original file is closed */
1450               tmpfp = NULL;
1451             }
1452           /* Static analyzer note: BAKFILENAME is never NULL here
1453              because it is controlled by LASTRESNAME.  */
1454           rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1455                                              lastresname) : 0;
1456           xfree (tmpfilename);  tmpfilename = NULL;
1457           xfree (bakfilename);  bakfilename = NULL;
1458           if (rc)
1459             goto leave;
1460           lastresname = resname;
1461           if (noisy && !opt.quiet)
1462             log_info (_("caching keyring '%s'\n"), resname);
1463           rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
1464           if (rc)
1465             goto leave;
1466         }
1467
1468       release_kbnode (keyblock);
1469       rc = keyring_get_keyblock (hd, &keyblock);
1470       if (rc)
1471         {
1472           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1473             continue;  /* Skip legacy keys.  */
1474           log_error ("keyring_get_keyblock failed: %s\n", gpg_strerror (rc));
1475           goto leave;
1476         }
1477       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1478         {
1479           /* We had a few reports about corrupted keyrings; if we have
1480              been called directly from the command line we delete such
1481              a keyblock instead of bailing out.  */
1482           log_error ("unexpected keyblock found (pkttype=%d)%s\n",
1483                      keyblock->pkt->pkttype, noisy? " - deleted":"");
1484           if (noisy)
1485             continue;
1486           log_info ("Hint: backup your keys and try running '%s'\n",
1487                     "gpg --rebuild-keydb-caches");
1488           rc = gpg_error (GPG_ERR_INV_KEYRING);
1489           goto leave;
1490         }
1491
1492       if (keyblock->pkt->pkt.public_key->version < 4)
1493         {
1494           /* We do not copy/cache v3 keys or any other unknown
1495              packets.  It is better to remove them from the keyring.
1496              The code required to keep them in the keyring would be
1497              too complicated.  Given that we do not touch the old
1498              secring.gpg a suitable backup for decryption of v3 stuff
1499              using an older gpg version will always be available.
1500              Note: This test is actually superfluous because we
1501              already acted upon GPG_ERR_LEGACY_KEY.      */
1502         }
1503       else
1504         {
1505           /* Check all signature to set the signature's cache flags. */
1506           for (node=keyblock; node; node=node->next)
1507             {
1508               /* Note that this doesn't cache the result of a
1509                  revocation issued by a designated revoker.  This is
1510                  because the pk in question does not carry the revkeys
1511                  as we haven't merged the key and selfsigs.  It is
1512                  questionable whether this matters very much since
1513                  there are very very few designated revoker revocation
1514                  packets out there. */
1515               if (node->pkt->pkttype == PKT_SIGNATURE)
1516                 {
1517                   PKT_signature *sig=node->pkt->pkt.signature;
1518
1519                   if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
1520                      && (openpgp_md_test_algo(sig->digest_algo)
1521                          || openpgp_pk_test_algo(sig->pubkey_algo)))
1522                     sig->flags.checked=sig->flags.valid=0;
1523                   else
1524                     check_key_signature (ctrl, keyblock, node, NULL);
1525
1526                   sigcount++;
1527                 }
1528             }
1529
1530           /* Write the keyblock to the temporary file.  */
1531           rc = write_keyblock (tmpfp, keyblock);
1532           if (rc)
1533             goto leave;
1534
1535           if ( !(++count % 50) && noisy && !opt.quiet)
1536             log_info (ngettext("%lu keys cached so far (%lu signature)\n",
1537                                "%lu keys cached so far (%lu signatures)\n",
1538                                sigcount),
1539                       count, sigcount);
1540         }
1541     } /* end main loop */
1542   if (rc == -1)
1543     rc = 0;
1544   if (rc)
1545     {
1546       log_error ("keyring_search failed: %s\n", gpg_strerror (rc));
1547       goto leave;
1548     }
1549
1550   if (noisy || opt.verbose)
1551     {
1552       log_info (ngettext("%lu key cached",
1553                          "%lu keys cached", count), count);
1554       log_printf (ngettext(" (%lu signature)\n",
1555                            " (%lu signatures)\n", sigcount), sigcount);
1556     }
1557
1558   if (tmpfp)
1559     {
1560       if (iobuf_close (tmpfp))
1561         {
1562           rc = gpg_error_from_syserror ();
1563           log_error ("error closing '%s': %s\n",
1564                      tmpfilename, strerror (errno));
1565           goto leave;
1566         }
1567       /* because we have switched resources, we can be sure that
1568        * the original file is closed */
1569       tmpfp = NULL;
1570     }
1571   rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
1572                                      lastresname) : 0;
1573   xfree (tmpfilename);  tmpfilename = NULL;
1574   xfree (bakfilename);  bakfilename = NULL;
1575
1576  leave:
1577   if (tmpfp)
1578     iobuf_cancel (tmpfp);
1579   xfree (tmpfilename);
1580   xfree (bakfilename);
1581   release_kbnode (keyblock);
1582   keyring_lock (hd, 0);
1583   keyring_release (hd);
1584   return rc;
1585 }
1586
1587
1588 \f
1589 /****************
1590  * Perform insert/delete/update operation.
1591  * mode 1 = insert
1592  *      2 = delete
1593  *      3 = update
1594  */
1595 static int
1596 do_copy (int mode, const char *fname, KBNODE root,
1597          off_t start_offset, unsigned int n_packets )
1598 {
1599     IOBUF fp, newfp;
1600     int rc=0;
1601     char *bakfname = NULL;
1602     char *tmpfname = NULL;
1603
1604     /* Open the source file. Because we do a rename, we have to check the
1605        permissions of the file */
1606     if (access (fname, W_OK))
1607       return gpg_error_from_syserror ();
1608
1609     fp = iobuf_open (fname);
1610     if (mode == 1 && !fp && errno == ENOENT) {
1611         /* insert mode but file does not exist: create a new file */
1612         KBNODE kbctx, node;
1613         mode_t oldmask;
1614
1615         oldmask=umask(077);
1616         if (is_secured_filename (fname)) {
1617             newfp = NULL;
1618             gpg_err_set_errno (EPERM);
1619         }
1620         else
1621             newfp = iobuf_create (fname, 1);
1622         umask(oldmask);
1623         if( !newfp )
1624           {
1625             rc = gpg_error_from_syserror ();
1626             log_error (_("can't create '%s': %s\n"), fname, strerror(errno));
1627             return rc;
1628           }
1629         if( !opt.quiet )
1630             log_info(_("%s: keyring created\n"), fname );
1631
1632         kbctx=NULL;
1633         while ( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1634             if( (rc = build_packet( newfp, node->pkt )) ) {
1635                 log_error("build_packet(%d) failed: %s\n",
1636                             node->pkt->pkttype, gpg_strerror (rc) );
1637                 iobuf_cancel(newfp);
1638                 return rc;
1639             }
1640         }
1641         if( iobuf_close(newfp) ) {
1642             rc = gpg_error_from_syserror ();
1643             log_error ("%s: close failed: %s\n", fname, strerror(errno));
1644             return rc;
1645         }
1646         return 0; /* ready */
1647     }
1648
1649     if( !fp )
1650       {
1651         rc = gpg_error_from_syserror ();
1652         log_error(_("can't open '%s': %s\n"), fname, strerror(errno) );
1653         goto leave;
1654       }
1655
1656     /* Create the new file.  */
1657     rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
1658     if (rc) {
1659         iobuf_close(fp);
1660         goto leave;
1661     }
1662
1663     if( mode == 1 ) { /* insert */
1664         /* copy everything to the new file */
1665         rc = copy_all_packets (fp, newfp);
1666         if( rc != -1 ) {
1667             log_error("%s: copy to '%s' failed: %s\n",
1668                       fname, tmpfname, gpg_strerror (rc) );
1669             iobuf_close(fp);
1670             iobuf_cancel(newfp);
1671             goto leave;
1672         }
1673     }
1674
1675     if( mode == 2 || mode == 3 ) { /* delete or update */
1676         /* copy first part to the new file */
1677         rc = copy_some_packets( fp, newfp, start_offset );
1678         if( rc ) { /* should never get EOF here */
1679             log_error ("%s: copy to '%s' failed: %s\n",
1680                        fname, tmpfname, gpg_strerror (rc) );
1681             iobuf_close(fp);
1682             iobuf_cancel(newfp);
1683             goto leave;
1684         }
1685         /* skip this keyblock */
1686         log_assert( n_packets );
1687         rc = skip_some_packets( fp, n_packets );
1688         if( rc ) {
1689             log_error("%s: skipping %u packets failed: %s\n",
1690                             fname, n_packets, gpg_strerror (rc));
1691             iobuf_close(fp);
1692             iobuf_cancel(newfp);
1693             goto leave;
1694         }
1695     }
1696
1697     if( mode == 1 || mode == 3 ) { /* insert or update */
1698         rc = write_keyblock (newfp, root);
1699         if (rc) {
1700           iobuf_close(fp);
1701           iobuf_cancel(newfp);
1702           goto leave;
1703         }
1704     }
1705
1706     if( mode == 2 || mode == 3 ) { /* delete or update */
1707         /* copy the rest */
1708         rc = copy_all_packets( fp, newfp );
1709         if( rc != -1 ) {
1710             log_error("%s: copy to '%s' failed: %s\n",
1711                       fname, tmpfname, gpg_strerror (rc) );
1712             iobuf_close(fp);
1713             iobuf_cancel(newfp);
1714             goto leave;
1715         }
1716     }
1717
1718     /* close both files */
1719     if( iobuf_close(fp) ) {
1720         rc = gpg_error_from_syserror ();
1721         log_error("%s: close failed: %s\n", fname, strerror(errno) );
1722         goto leave;
1723     }
1724     if( iobuf_close(newfp) ) {
1725         rc = gpg_error_from_syserror ();
1726         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1727         goto leave;
1728     }
1729
1730     rc = rename_tmp_file (bakfname, tmpfname, fname);
1731
1732   leave:
1733     xfree(bakfname);
1734     xfree(tmpfname);
1735     return rc;
1736 }