]> git.sommitrealweird.co.uk Git - onak.git/blob - keydb.c
Switch debian build system to dh
[onak.git] / keydb.c
1 /*
2  * keydb.c - Routines for DB access that just use store/fetch.
3  *
4  * Copyright 2002-2004 Jonathan McDowell <noodles@earth.li>
5  *
6  * This program is free software: you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the Free
8  * Software Foundation; version 2 of the License.
9  *
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along with
16  * this program; if not, write to the Free Software Foundation, Inc., 51
17  * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 /**
21  *      The routines in this file are meant to be used as an initial step when
22  *      adding a new db access module. They provide various functions required
23  *      of the db access module using only the store and fetch functions. As
24  *      they need to parse the actual OpenPGP data to work they are a lot
25  *      slower than custom functions however.
26  */
27
28 #include <stdio.h>
29
30 #include "decodekey.h"
31 #include "hash.h"
32 #include "keydb.h"
33 #include "keyid.h"
34 #include "keystructs.h"
35 #include "mem.h"
36 #include "merge.h"
37 #include "openpgp.h"
38 #include "parsekey.h"
39 #include "sendsync.h"
40
41 #ifdef NEED_KEYID2UID
42 /**
43  *      keyid2uid - Takes a keyid and returns the primary UID for it.
44  *      @keyid: The keyid to lookup.
45  */
46 char *generic_keyid2uid(uint64_t keyid)
47 {
48         struct openpgp_publickey *publickey = NULL;
49         struct openpgp_signedpacket_list *curuid = NULL;
50         char buf[1024];
51
52         buf[0]=0;
53         if (config.dbbackend->fetch_key(keyid, &publickey, false) &&
54                         publickey != NULL) {
55                 curuid = publickey->uids;
56                 while (curuid != NULL && buf[0] == 0) {
57                         if (curuid->packet->tag == OPENPGP_PACKET_UID) {
58                                 snprintf(buf, 1023, "%.*s",
59                                                 (int) curuid->packet->length,
60                                                 curuid->packet->data);
61                         }
62                         curuid = curuid -> next;
63                 }
64                 free_publickey(publickey);
65         }
66
67         if (buf[0] == 0) {
68                 return NULL;
69         } else {
70                 return strdup(buf);
71         }
72 }
73 #endif
74
75 #ifdef NEED_GETKEYSIGS
76 /**
77  *      getkeysigs - Gets a linked list of the signatures on a key.
78  *      @keyid: The keyid to get the sigs for.
79  *      @revoked: Is the key revoked?
80  *
81  *      This function gets the list of signatures on a key. Used for key 
82  *      indexing and doing stats bits. If revoked is non-NULL then if the key
83  *      is revoked it's set to true.
84  */
85 struct ll *generic_getkeysigs(uint64_t keyid, bool *revoked)
86 {
87         struct ll *sigs = NULL;
88         struct openpgp_signedpacket_list *uids = NULL;
89         struct openpgp_publickey *publickey = NULL;
90
91         config.dbbackend->fetch_key(keyid, &publickey, false);
92         
93         if (publickey != NULL) {
94                 for (uids = publickey->uids; uids != NULL; uids = uids->next) {
95                         sigs = keysigs(sigs, uids->sigs);
96                 }
97                 if (revoked != NULL) {
98                         *revoked = publickey->revoked;
99                 }
100                 free_publickey(publickey);
101         }
102
103         return sigs;
104 }
105 #endif
106
107 /**
108  *      cached_getkeysigs - Gets the signatures on a key.
109  *      @keyid: The key we want the signatures for.
110  *      
111  *      This function gets the signatures on a key. It's the same as the
112  *      getkeysigs function above except we use the hash module to cache the
113  *      data so if we need it again it's already loaded.
114  */
115 struct ll *generic_cached_getkeysigs(uint64_t keyid)
116 {
117         struct stats_key *key = NULL;
118         struct stats_key *signedkey = NULL;
119         struct ll        *cursig = NULL;
120         struct ll        *sigs = NULL;
121         bool              revoked = false;
122
123         if (keyid == 0)  {
124                 return NULL;
125         }
126
127         key = findinhash(keyid);
128
129         if (key == NULL || key->gotsigs == false) {
130                 sigs = config.dbbackend->getkeysigs(keyid, &revoked);
131                 if (sigs == NULL) {
132                         return NULL;
133                 }
134                 if (key == NULL) {
135                         key = createandaddtohash(keyid);
136                 }
137                 key->sigs = sigs;
138                 key->revoked = revoked;
139                 for (cursig = key->sigs; cursig != NULL;
140                                 cursig = cursig->next) {
141                         signedkey = (struct stats_key *) cursig->object;
142                         signedkey->signs = lladd(signedkey->signs, key);
143                 }
144                 key->gotsigs = true;
145         }
146
147         return key->sigs;
148 }
149
150 #ifdef NEED_GETFULLKEYID
151 /**
152  *      getfullkeyid - Maps a 32bit key id to a 64bit one.
153  *      @keyid: The 32bit keyid.
154  *
155  *      This function maps a 32bit key id to the full 64bit one. It returns the
156  *      full keyid. If the key isn't found a keyid of 0 is returned.
157  */
158 uint64_t generic_getfullkeyid(uint64_t keyid)
159 {
160         struct openpgp_publickey *publickey = NULL;
161
162         if (keyid < 0x100000000LL) {
163                 config.dbbackend->fetch_key(keyid, &publickey, false);
164                 if (publickey != NULL) {
165                         get_keyid(publickey, &keyid);
166                         free_publickey(publickey);
167                         publickey = NULL;
168                 } else {
169                         keyid = 0;
170                 }
171         }
172         
173         return keyid;
174 }
175 #endif
176
177 #ifdef NEED_UPDATEKEYS
178 /**
179  *      update_keys - Takes a list of public keys and updates them in the DB.
180  *      @keys: The keys to update in the DB.
181  *      @sendsync: Should we send a sync mail to our peers.
182  *
183  *      Takes a list of keys and adds them to the database, merging them with
184  *      the key in the database if it's already present there. The key list is
185  *      update to contain the minimum set of updates required to get from what
186  *      we had before to what we have now (ie the set of data that was added to
187  *      the DB). Returns the number of entirely new keys added.
188  */
189 int generic_update_keys(struct openpgp_publickey **keys, bool sendsync)
190 {
191         struct openpgp_publickey *curkey = NULL;
192         struct openpgp_publickey *oldkey = NULL;
193         struct openpgp_publickey *prev = NULL;
194         int newkeys = 0;
195         bool intrans;
196         uint64_t keyid;
197
198         for (curkey = *keys; curkey != NULL; curkey = curkey->next) {
199                 intrans = config.dbbackend->starttrans();
200                 get_keyid(curkey, &keyid);
201                 logthing(LOGTHING_INFO,
202                         "Fetching key 0x%" PRIX64 ", result: %d",
203                         keyid,
204                         config.dbbackend->fetch_key(keyid, &oldkey,
205                                         intrans));
206
207                 /*
208                  * If we already have the key stored in the DB then merge it
209                  * with the new one that's been supplied. Otherwise the key
210                  * we've just got is the one that goes in the DB and also the
211                  * one that we send out.
212                  */
213                 if (oldkey != NULL) {
214                         merge_keys(oldkey, curkey);
215                         if (curkey->sigs == NULL &&
216                                         curkey->uids == NULL &&
217                                         curkey->subkeys == NULL) {
218                                 if (prev == NULL) {
219                                         *keys = curkey->next;
220                                 } else {
221                                         prev->next = curkey->next;
222                                         curkey->next = NULL;
223                                         free_publickey(curkey);
224                                         curkey = prev;
225                                 }
226                         } else {
227                                 prev = curkey;
228                                 logthing(LOGTHING_INFO,
229                                         "Merged key; storing updated key.");
230                                 config.dbbackend->store_key(oldkey, intrans,
231                                         true);
232                         }
233                         free_publickey(oldkey);
234                         oldkey = NULL;
235                 } else {
236                         logthing(LOGTHING_INFO,
237                                 "Storing completely new key.");
238                         config.dbbackend->store_key(curkey, intrans, false);
239                         newkeys++;
240                 }
241                 config.dbbackend->endtrans();
242                 intrans = false;
243         }
244
245         if (sendsync && keys != NULL) {
246                 sendkeysync(*keys);
247         }
248
249         return newkeys;
250 }
251 #endif /* NEED_UPDATEKEYS */