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