#include <string.h>
#include <unistd.h>
+#include "charfuncs.h"
#include "keydb.h"
#include "keyid.h"
#include "keyindex.h"
#include "keystructs.h"
+#include "log.h"
#include "mem.h"
-#include "onak_conf.h"
+#include "onak-conf.h"
#include "parsekey.h"
#define KEYDB_KEYID_BYTES 4
*/
static DB_ENV db2_env;
-/*
- * Shared with CGI buffer stuff...
- */
-struct db2_get_ctx {
- char *buffer;
- int offset;
- int size;
-};
-
-/**
- * keydb_fetchchar - Fetches a char from a buffer.
- */
-int keydb_fetchchar(void *ctx, int count, unsigned char *c)
-{
- struct db2_get_ctx *buf = NULL;
- int i;
-
- buf = (struct db2_get_ctx *) ctx;
- for (i = 0; i < count; i++) {
- c[i] = buf->buffer[buf->offset++];
- }
-
- return (((buf->offset) == (buf->size)) ? 1 : 0);
-}
-
-/**
- * keydb_putchar - Puts a char to a file.
- */
-static int keydb_putchar(void *fd, unsigned char c)
-{
-// return !(lo_write(dbconn, *(int *) fd, &c, sizeof(c)));
- return 1;
-}
-
DB *keydb(DBT *key)
{
/*
int i;
int ret;
char keydbname[20];
+ char buf[1024];
+ FILE *numdb = NULL;
+
+ snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir);
+ numdb = fopen(buf, "r");
+ if (numdb != NULL) {
+ if (fgets(buf, sizeof(buf), numdb) != NULL) {
+ db2_numdb = atoi(buf);
+ }
+ fclose(numdb);
+ } else {
+ logthing(LOGTHING_ERROR, "Couldn't open num_keydb: %s",
+ strerror(errno));
+ }
memset(&db2_env, 0, sizeof(db2_env));
*/
db2_env.mp_size = 20 * 1024 * 1024;
- ret = db_appinit(config.db2_dbpath, NULL,
+ ret = db_appinit(config.db_dir, NULL,
&db2_env, DB_INIT_MPOOL|DB_INIT_LOCK);
if (!ret) {
db2_keydbfiles = (DB **) malloc(sizeof (DB *) * db2_numdb);
&db2_env, &keydbinfo,
&db2_keydbfiles[i]);
if (ret) {
- fprintf(stderr, "Error opening db file %d (errno %d)\n",
+ logthing(LOGTHING_CRITICAL,
+ "Error opening db file %d (errno %d)",
i, ret);
exit(1);
}
}
} else {
- fprintf(stderr, "Error initializing db (%d).\n", ret);
+ logthing(LOGTHING_CRITICAL, "Error initializing db (%d).",
+ ret);
exit(1);
}
}
db_appexit(&db2_env);
}
+/**
+ * starttrans - Start a transaction.
+ *
+ * Start a transaction. Intended to be used if we're about to perform many
+ * operations on the database to help speed it all up, or if we want
+ * something to only succeed if all relevant operations are successful.
+ */
+bool starttrans(void)
+{
+ return true;
+}
+
+/**
+ * endtrans - End a transaction.
+ *
+ * Ends a transaction.
+ */
+void endtrans(void)
+{
+ return;
+}
+
/**
* fetch_key - Given a keyid fetch the key from storage.
* @keyid: The keyid to fetch.
* @publickey: A pointer to a structure to return the key in.
+ * @intrans: If we're already in a transaction.
*
* We use the hex representation of the keyid as the filename to fetch the
* key from. The key is stored in the file as a binary OpenPGP stream of
* in and then parse_keys() to parse the packets into a publickey
* structure.
*/
-int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey)
+int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
+ bool intrans)
{
struct openpgp_packet_list *packets = NULL;
int ret;
DBT key, data;
char id[KEYDB_KEYID_BYTES];
- struct db2_get_ctx fetchbuf;
+ struct buffer_ctx fetchbuf;
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
ret = (*(keydb(&key)->get))(keydb(&key), NULL, &key, &data, 0);
if (ret == 0) {
- //do stuff with data.
fetchbuf.buffer = data.data;
fetchbuf.offset = 0;
fetchbuf.size = data.size;
- read_openpgp_stream(keydb_fetchchar, &fetchbuf, &packets);
+ read_openpgp_stream(buffer_fetchchar, &fetchbuf, &packets);
parse_keys(packets, publickey);
+ free_packet_list(packets);
+ packets = NULL;
}
return (!ret);
}
+/**
+ * fetch_key_text - Trys to find the keys that contain the supplied text.
+ * @search: The text to search for.
+ * @publickey: A pointer to a structure to return the key in.
+ *
+ * This function searches for the supplied text and returns the keys that
+ * contain it.
+ */
+int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
+{
+ return 0;
+}
+
/**
* store_key - Takes a key and stores it.
* @publickey: A pointer to the public key to store.
+ * @intrans: If we're already in a transaction.
+ * @update: If true the key exists and should be updated.
*
* Again we just use the hex representation of the keyid as the filename
* to store the key to. We flatten the public key to a list of OpenPGP
* packets and then use write_openpgp_stream() to write the stream out to
* the file.
*/
-int store_key(struct openpgp_publickey *publickey)
+int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
{
return 0;
}
/**
* delete_key - Given a keyid delete the key from storage.
* @keyid: The keyid to delete.
+ * @intrans: If we're already in a transaction.
*
* This function deletes a public key from whatever storage mechanism we
* are using. Returns 0 if the key existed.
*/
-int delete_key(uint64_t keyid)
+int delete_key(uint64_t keyid, bool intrans)
{
return (1);
}
+/**
+ * dumpdb - dump the key database
+ * @filenamebase: The base filename to use for the dump.
+ *
+ * Dumps the database into one or more files, which contain pure OpenPGP
+ * that can be reimported into onak or gpg. filenamebase provides a base
+ * file name for the dump; several files may be created, all of which will
+ * begin with this string and then have a unique number and a .pgp
+ * extension.
+ * */
+int dumpdb(char *filenamebase)
+{
+ return 0;
+}
+
+
/*
* Include the basic keydb routines.
*/
#define NEED_KEYID2UID 1
#define NEED_GETKEYSIGS 1
+#define NEED_GETFULLKEYID 1
#include "keydb.c"
projects / onak.git / blobdiff