2 * keydb_db3.c - Routines to store and fetch keys in a DB3 database.
4 * Jonathan McDowell <noodles@earth.li>
6 * Copyright 2002 Project Purple
21 #include "charfuncs.h"
25 #include "keystructs.h"
27 #include "onak-conf.h"
31 * dbconn - our connection to the key database.
33 static DB *dbconn = NULL;
36 * worddb - our connection to the word database.
38 static DB *worddb = NULL;
41 * makewordlist - Takes a string and splits it into a set of unique words.
42 * @wordlist: The current word list.
43 * @words: The string to split and add.
45 * We take words and split it on non alpha numeric characters. These get
46 * added to the word list if they're not already present. If the wordlist
47 * is NULL then we start a new list, otherwise it's search for already
48 * added words. Note that words is modified in the process of scanning.
50 * Returns the new word list.
52 struct ll *makewordlist(struct ll *wordlist, char *word)
58 * Walk through the words string, spliting on non alphanumerics and
59 * then checking if the word already exists in the list. If not then
63 while (end != NULL && *end != 0) {
65 while (*start != 0 && !isalnum(*start)) {
69 while (*end != 0 && isalnum(*end)) {
73 if (end - start > 1) {
79 if (llfind(wordlist, start,
81 wordlist = lladd(wordlist,
91 * initdb - Initialize the key database.
93 * This function should be called before any of the other functions in
94 * this file are called in order to allow the DB to be initialized ready
102 strcpy(buf, config.db2_dbpath);
103 strcat(buf, "/keydb.db");
105 ret = db_create(&dbconn, NULL, 0);
107 fprintf(stderr, "db_create: %s\n", db_strerror(ret));
111 ret = dbconn->open(dbconn, buf, NULL, DB_HASH,
115 dbconn->err(dbconn, ret, "%s", buf);
119 strcpy(buf, config.db2_dbpath);
120 strcat(buf, "/worddb");
122 ret = db_create(&worddb, NULL, 0);
124 fprintf(stderr, "db_create: %s\n", db_strerror(ret));
127 ret = worddb->set_flags(worddb, DB_DUP);
129 ret = worddb->open(worddb, buf, NULL, DB_BTREE,
133 worddb->err(worddb, ret, "%s", buf);
141 * cleanupdb - De-initialize the key database.
143 * This function should be called upon program exit to allow the DB to
144 * cleanup after itself.
148 worddb->close(worddb, 0);
150 dbconn->close(dbconn, 0);
155 * starttrans - Start a transaction.
157 * Start a transaction. Intended to be used if we're about to perform many
158 * operations on the database to help speed it all up, or if we want
159 * something to only succeed if all relevant operations are successful.
161 bool starttrans(void)
167 * endtrans - End a transaction.
169 * Ends a transaction.
177 * fetch_key - Given a keyid fetch the key from storage.
178 * @keyid: The keyid to fetch.
179 * @publickey: A pointer to a structure to return the key in.
180 * @intrans: If we're already in a transaction.
182 * We use the hex representation of the keyid as the filename to fetch the
183 * key from. The key is stored in the file as a binary OpenPGP stream of
184 * packets, so we can just use read_openpgp_stream() to read the packets
185 * in and then parse_keys() to parse the packets into a publickey
188 int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
191 struct openpgp_packet_list *packets = NULL;
195 struct buffer_ctx fetchbuf;
197 memset(&key, 0, sizeof(key));
198 memset(&data, 0, sizeof(data));
203 key.size = sizeof(keyid);
207 ret = dbconn->get(dbconn,
214 fetchbuf.buffer = data.data;
216 fetchbuf.size = data.size;
217 read_openpgp_stream(buffer_fetchchar, &fetchbuf,
219 parse_keys(packets, publickey);
221 } else if (ret != DB_NOTFOUND) {
222 dbconn->err(dbconn, ret, "Problem retrieving key");
228 int worddb_cmp(const char *d1, const char *d2)
230 return memcmp(d1, d2, 12);
234 * fetch_key_text - Trys to find the keys that contain the supplied text.
235 * @search: The text to search for.
236 * @publickey: A pointer to a structure to return the key in.
238 * This function searches for the supplied text and returns the keys that
241 int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
249 char *searchtext = NULL;
250 struct ll *wordlist = NULL;
251 struct ll *curword = NULL;
252 struct ll *keylist = NULL;
253 struct ll *newkeylist = NULL;
256 searchtext = strdup(search);
257 wordlist = makewordlist(wordlist, searchtext);
260 ret = worddb->cursor(worddb,
265 for (curword = wordlist; curword != NULL; curword = curword->next) {
266 memset(&key, 0, sizeof(key));
267 memset(&data, 0, sizeof(data));
268 key.data = curword->object;
269 key.size = strlen(curword->object);
270 data.flags = DB_DBT_MALLOC;
271 ret = cursor->c_get(cursor,
275 while (ret == 0 && strncmp(key.data, curword->object,
277 ((char *) curword->object)[key.size] == 0) {
279 for (i = 4; i < 12; i++) {
281 keyid += ((unsigned char *)
285 if (keylist == NULL ||
286 llfind(keylist, data.data,
287 worddb_cmp) != NULL) {
288 newkeylist = lladd(newkeylist, data.data);
293 ret = cursor->c_get(cursor,
298 llfree(keylist, free);
299 keylist = newkeylist;
303 for (newkeylist = keylist; newkeylist != NULL;
304 newkeylist = newkeylist->next) {
307 for (i = 4; i < 12; i++) {
309 keyid += ((unsigned char *)
310 newkeylist->object)[i];
313 numkeys += fetch_key(keyid,
317 llfree(keylist, free);
322 ret = cursor->c_close(cursor);
329 * store_key - Takes a key and stores it.
330 * @publickey: A pointer to the public key to store.
331 * @intrans: If we're already in a transaction.
332 * @update: If true the key exists and should be updated.
334 * Again we just use the hex representation of the keyid as the filename
335 * to store the key to. We flatten the public key to a list of OpenPGP
336 * packets and then use write_openpgp_stream() to write the stream out to
337 * the file. If update is true then we delete the old key first, otherwise
338 * we trust that it doesn't exist.
340 int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
342 struct openpgp_packet_list *packets = NULL;
343 struct openpgp_packet_list *list_end = NULL;
344 struct openpgp_publickey *next = NULL;
347 struct buffer_ctx storebuf;
352 char *primary = NULL;
353 unsigned char worddb_data[12];
354 struct ll *wordlist = NULL;
355 struct ll *curword = NULL;
357 keyid = get_keyid(publickey);
360 * Delete the key if we already have it.
362 * TODO: Can we optimize this perhaps? Possibly when other data is
363 * involved as well? I suspect this is easiest and doesn't make a lot
364 * of difference though - the largest chunk of data is the keydata and
365 * it definitely needs updated.
368 delete_key(keyid, true);
372 * Convert the key to a flat set of binary data.
374 next = publickey->next;
375 publickey->next = NULL;
376 flatten_publickey(publickey, &packets, &list_end);
377 publickey->next = next;
380 storebuf.size = 8192;
381 storebuf.buffer = malloc(8192);
383 write_openpgp_stream(buffer_putchar, &storebuf, packets);
386 * Now we have the key data store it in the DB; the keyid is the key.
388 memset(&key, 0, sizeof(key));
389 memset(&data, 0, sizeof(data));
391 key.size = sizeof(keyid);
393 data.size = storebuf.offset;
394 data.data = storebuf.buffer;
396 ret = dbconn->put(dbconn,
402 dbconn->err(dbconn, ret, "Problem storing key");
406 * Walk through our uids storing the words into the db with the keyid.
408 uids = keyuids(publickey, &primary);
410 for (i = 0; ret == 0 && uids[i] != NULL; i++) {
411 wordlist = makewordlist(wordlist, uids[i]);
414 for (curword = wordlist; curword != NULL;
415 curword = curword->next) {
416 memset(&key, 0, sizeof(key));
417 memset(&data, 0, sizeof(data));
418 key.data = curword->object;
419 key.size = strlen(key.data);
420 data.data = worddb_data;
421 data.size = sizeof(worddb_data);
424 * Our data is the key creation time followed by the
427 worddb_data[ 0] = publickey->publickey->data[1];
428 worddb_data[ 1] = publickey->publickey->data[2];
429 worddb_data[ 2] = publickey->publickey->data[3];
430 worddb_data[ 3] = publickey->publickey->data[4];
431 worddb_data[ 4] = (keyid >> 56) & 0xFF;
432 worddb_data[ 5] = (keyid >> 48) & 0xFF;
433 worddb_data[ 6] = (keyid >> 40) & 0xFF;
434 worddb_data[ 7] = (keyid >> 32) & 0xFF;
435 worddb_data[ 8] = (keyid >> 24) & 0xFF;
436 worddb_data[ 9] = (keyid >> 16) & 0xFF;
437 worddb_data[10] = (keyid >> 8) & 0xFF;
438 worddb_data[11] = keyid & 0xFF;
439 ret = worddb->put(worddb,
445 worddb->err(worddb, ret,
446 "Problem storing key");
451 * Free our UID and word lists.
453 llfree(wordlist, NULL);
454 for (i = 0; uids[i] != NULL; i++) {
466 * delete_key - Given a keyid delete the key from storage.
467 * @keyid: The keyid to delete.
468 * @intrans: If we're already in a transaction.
470 * This function deletes a public key from whatever storage mechanism we
471 * are using. Returns 0 if the key existed.
473 int delete_key(uint64_t keyid, bool intrans)
475 struct openpgp_publickey *publickey = NULL;
481 char *primary = NULL;
482 unsigned char worddb_data[12];
483 struct ll *wordlist = NULL;
484 struct ll *curword = NULL;
488 fetch_key(keyid, &publickey, intrans);
491 * Walk through the uids removing the words from the worddb.
493 if (publickey != NULL) {
494 uids = keyuids(publickey, &primary);
497 for (i = 0; ret == 0 && uids[i] != NULL; i++) {
498 wordlist = makewordlist(wordlist, uids[i]);
501 ret = worddb->cursor(worddb,
506 for (curword = wordlist; curword != NULL;
507 curword = curword->next) {
508 memset(&key, 0, sizeof(key));
509 memset(&data, 0, sizeof(data));
510 key.data = curword->object;
511 key.size = strlen(key.data);
512 data.data = worddb_data;
513 data.size = sizeof(worddb_data);
516 * Our data is the key creation time followed by the
519 worddb_data[ 0] = publickey->publickey->data[1];
520 worddb_data[ 1] = publickey->publickey->data[2];
521 worddb_data[ 2] = publickey->publickey->data[3];
522 worddb_data[ 3] = publickey->publickey->data[4];
523 worddb_data[ 4] = (keyid >> 56) & 0xFF;
524 worddb_data[ 5] = (keyid >> 48) & 0xFF;
525 worddb_data[ 6] = (keyid >> 40) & 0xFF;
526 worddb_data[ 7] = (keyid >> 32) & 0xFF;
527 worddb_data[ 8] = (keyid >> 24) & 0xFF;
528 worddb_data[ 9] = (keyid >> 16) & 0xFF;
529 worddb_data[10] = (keyid >> 8) & 0xFF;
530 worddb_data[11] = keyid & 0xFF;
532 ret = cursor->c_get(cursor,
537 ret = cursor->c_del(cursor, 0);
541 worddb->err(worddb, ret,
542 "Problem deleting word.");
545 ret = cursor->c_close(cursor);
549 * Free our UID and word lists.
551 llfree(wordlist, NULL);
552 for (i = 0; uids[i] != NULL; i++) {
558 free_publickey(publickey);
563 key.size = sizeof(keyid);
570 return (ret == DB_NOTFOUND);
574 * Include the basic keydb routines.
576 #define NEED_GETFULLKEYID 1
577 #define NEED_GETKEYSIGS 1
578 #define NEED_KEYID2UID 1