Add minimalistic protected-headers support
[gpgol.git] / src / keycache.h
1 #ifndef KEYCACHE_H
2 #define KEYCACHE_H
3
4 /* @file keycache.h
5  * @brief Internal keycache
6  *
7  * Copyright (C) 2018 Intevation GmbH
8  *
9  * This file is part of GpgOL.
10  *
11  * GpgOL is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * GpgOL is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * along with this program; if not, see <http://www.gnu.org/licenses/>.
23  */
24
25 #include "config.h"
26
27 #include <memory>
28 #include <vector>
29
30 #include <gpgme++/global.h>
31
32 namespace GpgME
33 {
34   class Key;
35   class Data;
36 };
37
38 class Mail;
39
40 class KeyCache
41 {
42 protected:
43     /** Internal ctor */
44     explicit KeyCache ();
45
46 public:
47     /** Get the KeyCache */
48     static KeyCache* instance ();
49
50     /* Try to find a key for signing in the internal secret key
51        cache. If no proper key is found a Null key is
52        returned.*/
53     GpgME::Key getSigningKey (const char *addr, GpgME::Protocol proto) const;
54
55     /* Get the keys for recipents. The keys
56        are taken from the internal cache. If
57        one recipient can't be resolved an empty
58        list is returned.
59        */
60     std::vector<GpgME::Key> getEncryptionKeys (const std::vector<std::string> &recipients,
61                                                GpgME::Protocol proto) const;
62
63     /* Start a key location in a background thread filling
64        the key cache.
65
66        The mail argument is used to add / remove the
67        locator thread counter.
68
69        async
70        */
71     void startLocate (const std::vector<std::string> &addrs, Mail *mail) const;
72
73     /* Look for a secret key for the addr.
74
75        async
76     */
77     void startLocateSecret (const char *addr, Mail *mail) const;
78
79     /* Start a key location in a background thread filling
80        the key cache.
81
82        async
83        */
84     void startLocate (const char *addr, Mail *mail) const;
85
86     /* Check that a mail is resolvable through the keycache.
87      *
88      * For OpenPGP only the recipients are checked as we can
89      * generate a new key for the sender.
90      **/
91     bool isMailResolvable (Mail *mail);
92
93     /* Search / Update a key in the cache. This is meant to be
94        called e.g. after a verify to update the key.
95
96        async
97
98        A known issue is that a get right after it might
99        still return an outdated key but the get after that
100        would return the updated one. This is acceptable as
101        it only poses a minor problem with TOFU while we
102        can show the correct state in the tooltip. */
103     void update (const char *fpr, GpgME::Protocol proto);
104
105     /* Get a cached key. If block is true it will block
106        if the key is currently searched for.
107
108        This function will not search a key. Call update
109        to insert keys into the cache */
110     GpgME::Key getByFpr (const char *fpr, bool block = true) const;
111
112     /* Import key data from the address book for the address mbox.
113        Keys imported this way take precedence over other keys for
114        this mail address regardless of validity.
115
116        The mail argument is used to add / remove the
117        locator thread counter.
118
119        async
120     */
121     void importFromAddrBook (const std::string &mbox,
122                              const char *key_data,
123                              Mail *mail) const;
124
125     /* Get optional overrides for an address. */
126     std::vector<GpgME::Key> getOverrides (const std::string &mbox);
127
128     /* Populate the fingerprint and secret key maps */
129     void populate ();
130
131     /* Get a vector of ultimately trusted keys. */
132     std::vector<GpgME::Key> getUltimateKeys ();
133
134     /* Import PGP Keys from a Data object. Returns
135        true on success. */
136     static bool import_pgp_key_data(const GpgME::Data &data);
137
138     // Internal for thread
139     void setSmimeKey(const std::string &mbox, const GpgME::Key &key);
140     void setPgpKey(const std::string &mbox, const GpgME::Key &key);
141     void setSmimeKeySecret(const std::string &mbox, const GpgME::Key &key);
142     void setPgpKeySecret(const std::string &mbox, const GpgME::Key &key);
143     void onUpdateJobDone(const char *fpr, const GpgME::Key &key);
144     void onAddrBookImportJobDone (const std::string &fpr,
145                                   const std::vector<std::string> &result_fprs);
146
147 private:
148
149     class Private;
150     std::shared_ptr<Private> d;
151 };
152
153 #endif