X-Git-Url: https://the.earth.li/gitweb/?a=blobdiff_plain;f=keydb_pg.c;h=0b58d28f6e753e4d1563db777105da0b8a9b99b3;hb=adc800dbc424a1e246dd4a82a0c2e88eeda25531;hp=76129fa0b1565be42a39d46de3176e4cb097828b;hpb=42dbc6b5efa87e868116549c5932ab62cf716568;p=onak.git diff --git a/keydb_pg.c b/keydb_pg.c index 76129fa..0b58d28 100644 --- a/keydb_pg.c +++ b/keydb_pg.c @@ -1,16 +1,24 @@ /* * keydb_pg.c - Routines to store and fetch keys in a PostGres database. * - * Jonathan McDowell + * Copyright 2002-2004 Jonathan McDowell * - * Copyright 2002 Project Purple + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . */ #include #include -//#include -//#include #include #include #include @@ -23,69 +31,36 @@ #include "hash.h" #include "keydb.h" #include "keyid.h" -#include "keyindex.h" +#include "decodekey.h" #include "keystructs.h" +#include "log.h" #include "mem.h" #include "onak-conf.h" #include "parsekey.h" -/** - * dbconn - our connection to the database. - */ -static PGconn *dbconn = NULL; +struct pg_fc_ctx { + PGconn *dbconn; + int fd; +}; /** * keydb_fetchchar - Fetches a char from a file. */ -static int keydb_fetchchar(void *fd, size_t count, unsigned char *c) +static int keydb_fetchchar(void *_ctx, size_t count, void *c) { - return (!lo_read(dbconn, *(int *) fd, c, count)); -} + struct pg_fc_ctx *ctx = (struct pg_fc_ctx *) _ctx; -/** - * keydb_putchar - Puts a char to a file. - */ -static int keydb_putchar(void *fd, size_t count, unsigned char *c) -{ - return !(lo_write(dbconn, *(int *) fd, c, count)); + return (!lo_read(ctx->dbconn, ctx->fd, (char *) c, count)); } /** - * initdb - Initialize the key database. - * - * This function should be called before any of the other functions in - * this file are called in order to allow the DB to be initialized ready - * for access. + * keydb_putchar - Puts a char to a file. */ -void initdb(void) +static int keydb_putchar(void *_ctx, size_t count, void *c) { - dbconn = PQsetdbLogin(config.pg_dbhost, // host - NULL, // port - NULL, // options - NULL, // tty - config.pg_dbname, // database - config.pg_dbuser, //login - config.pg_dbpass); // password + struct pg_fc_ctx *ctx = (struct pg_fc_ctx *) _ctx; - if (PQstatus(dbconn) == CONNECTION_BAD) { - fprintf(stderr, "Connection to database failed.\n"); - fprintf(stderr, "%s\n", PQerrorMessage(dbconn)); - PQfinish(dbconn); - dbconn = NULL; - exit(1); - } -} - -/** - * cleanupdb - De-initialize the key database. - * - * This function should be called upon program exit to allow the DB to - * cleanup after itself. - */ -void cleanupdb(void) -{ - PQfinish(dbconn); - dbconn = NULL; + return !(lo_write(ctx->dbconn, ctx->fd, (char *) c, count)); } /** @@ -95,8 +70,9 @@ void cleanupdb(void) * 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) +static bool pg_starttrans(struct onak_dbctx *dbctx) { + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; result = PQexec(dbconn, "BEGIN"); @@ -110,8 +86,9 @@ bool starttrans(void) * * Ends a transaction. */ -void endtrans(void) +static void pg_endtrans(struct onak_dbctx *dbctx) { + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; result = PQexec(dbconn, "COMMIT"); @@ -121,7 +98,7 @@ void endtrans(void) } /** - * fetch_key - Given a keyid fetch the key from storage. + * fetch_key_id - 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. @@ -132,16 +109,20 @@ void endtrans(void) * in and then parse_keys() to parse the packets into a publickey * structure. */ -int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, bool intrans) +static int pg_fetch_key_id(struct onak_dbctx *dbctx, + uint64_t keyid, + struct openpgp_publickey **publickey, + bool intrans) { struct openpgp_packet_list *packets = NULL; + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; char *oids = NULL; char statement[1024]; - int fd = -1; int i = 0; int numkeys = 0; Oid key_oid; + struct pg_fc_ctx fcctx; if (!intrans) { result = PQexec(dbconn, "BEGIN"); @@ -150,12 +131,13 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, bool intrans if (keyid > 0xFFFFFFFF) { snprintf(statement, 1023, - "SELECT keydata FROM onak_keys WHERE keyid = '%llX'", + "SELECT keydata FROM onak_keys WHERE keyid = '%" + PRIX64 "'", keyid); } else { snprintf(statement, 1023, "SELECT keydata FROM onak_keys WHERE keyid " - "LIKE '%%%llX'", + "LIKE '%%%" PRIX64 "'", keyid); } result = PQexec(dbconn, statement); @@ -166,18 +148,22 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, bool intrans oids = PQgetvalue(result, i, 0); key_oid = (Oid) atoi(oids); - fd = lo_open(dbconn, key_oid, INV_READ); - if (fd < 0) { - fprintf(stderr, "Can't open large object.\n"); + fcctx.fd = lo_open(dbconn, key_oid, INV_READ); + if (fcctx.fd < 0) { + logthing(LOGTHING_ERROR, + "Can't open large object."); } else { - read_openpgp_stream(keydb_fetchchar, &fd, - &packets); + fcctx.dbconn = dbconn; + read_openpgp_stream(keydb_fetchchar, &fcctx, + &packets, 0); parse_keys(packets, publickey); - lo_close(dbconn, fd); + lo_close(dbconn, fcctx.fd); + free_packet_list(packets); + packets = NULL; } } } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { - fprintf(stderr, "Problem retrieving key from DB.\n"); + logthing(LOGTHING_ERROR, "Problem retrieving key from DB."); } PQclear(result); @@ -197,24 +183,27 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, bool intrans * 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) +static int pg_fetch_key_text(struct onak_dbctx *dbctx, + const char *search, + struct openpgp_publickey **publickey) { struct openpgp_packet_list *packets = NULL; + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; char *oids = NULL; char statement[1024]; - int fd = -1; int i = 0; int numkeys = 0; Oid key_oid; char *newsearch = NULL; + struct pg_fc_ctx fcctx; result = PQexec(dbconn, "BEGIN"); PQclear(result); newsearch = malloc(strlen(search) * 2 + 1); memset(newsearch, 0, strlen(search) * 2 + 1); - PQescapeString(newsearch, search, strlen(search)); + PQescapeStringConn(dbconn, newsearch, search, strlen(search), NULL); snprintf(statement, 1023, "SELECT DISTINCT onak_keys.keydata FROM onak_keys, " "onak_uids WHERE onak_keys.keyid = onak_uids.keyid " @@ -230,18 +219,23 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) oids = PQgetvalue(result, i, 0); key_oid = (Oid) atoi(oids); - fd = lo_open(dbconn, key_oid, INV_READ); - if (fd < 0) { - fprintf(stderr, "Can't open large object.\n"); + fcctx.fd = lo_open(dbconn, key_oid, INV_READ); + if (fcctx.fd < 0) { + logthing(LOGTHING_ERROR, + "Can't open large object."); } else { - read_openpgp_stream(keydb_fetchchar, &fd, - &packets); + fcctx.dbconn = dbconn; + read_openpgp_stream(keydb_fetchchar, &fcctx, + &packets, + 0); parse_keys(packets, publickey); - lo_close(dbconn, fd); + lo_close(dbconn, fcctx.fd); + free_packet_list(packets); + packets = NULL; } } } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { - fprintf(stderr, "Problem retrieving key from DB.\n"); + logthing(LOGTHING_ERROR, "Problem retrieving key from DB."); } PQclear(result); @@ -251,6 +245,78 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) return (numkeys); } +/** + * 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. + */ +static int pg_delete_key(struct onak_dbctx *dbctx, uint64_t keyid, bool intrans) +{ + PGconn *dbconn = (PGconn *) dbctx->priv; + PGresult *result = NULL; + char *oids = NULL; + char statement[1024]; + int found = 1; + int i; + Oid key_oid; + + if (!intrans) { + result = PQexec(dbconn, "BEGIN"); + PQclear(result); + } + + snprintf(statement, 1023, + "SELECT keydata FROM onak_keys WHERE keyid = '%" + PRIX64 "'", + keyid); + result = PQexec(dbconn, statement); + + if (PQresultStatus(result) == PGRES_TUPLES_OK) { + found = 0; + i = PQntuples(result); + while (i > 0) { + oids = PQgetvalue(result, i-1, 0); + key_oid = (Oid) atoi(oids); + lo_unlink(dbconn, key_oid); + i--; + } + PQclear(result); + + snprintf(statement, 1023, + "DELETE FROM onak_keys WHERE keyid = '%" PRIX64 "'", + keyid); + result = PQexec(dbconn, statement); + PQclear(result); + + snprintf(statement, 1023, + "DELETE FROM onak_sigs WHERE signee = '%" PRIX64 "'", + keyid); + result = PQexec(dbconn, statement); + PQclear(result); + + snprintf(statement, 1023, + "DELETE FROM onak_uids WHERE keyid = '%" PRIX64 "'", + keyid); + result = PQexec(dbconn, statement); + } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { + logthing(LOGTHING_ERROR, + "Problem retrieving key (%" PRIX64 + ") from DB.", + keyid); + } + + PQclear(result); + + if (!intrans) { + result = PQexec(dbconn, "COMMIT"); + PQclear(result); + } + return (found); +} + /** * store_key - Takes a key and stores it. * @publickey: A pointer to the public key to store. @@ -263,26 +329,35 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) * the file. If update is true then we delete the old key first, otherwise * we trust that it doesn't exist. */ -int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) +static int pg_store_key(struct onak_dbctx *dbctx, + struct openpgp_publickey *publickey, bool intrans, + bool update) { struct openpgp_packet_list *packets = NULL; struct openpgp_packet_list *list_end = NULL; struct openpgp_publickey *next = NULL; struct openpgp_signedpacket_list *curuid = NULL; + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; char statement[1024]; Oid key_oid; - int fd; char **uids = NULL; char *primary = NULL; char *safeuid = NULL; int i; + uint64_t keyid; + struct pg_fc_ctx fcctx; if (!intrans) { result = PQexec(dbconn, "BEGIN"); PQclear(result); } + if (get_keyid(publickey, &keyid) != ONAK_E_OK) { + logthing(LOGTHING_ERROR, "Couldn't find key ID for key."); + return 0; + } + /* * Delete the key if we already have it. * @@ -292,7 +367,7 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) * it definitely needs updated. */ if (update) { - delete_key(get_keyid(publickey), true); + pg_delete_key(dbctx, keyid, true); } next = publickey->next; @@ -302,23 +377,26 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) key_oid = lo_creat(dbconn, INV_READ | INV_WRITE); if (key_oid == 0) { - fprintf(stderr, "Can't create key OID\n"); + logthing(LOGTHING_ERROR, "Can't create key OID"); } else { - fd = lo_open(dbconn, key_oid, INV_WRITE); - write_openpgp_stream(keydb_putchar, &fd, packets); - lo_close(dbconn, fd); + fcctx.fd = lo_open(dbconn, key_oid, INV_WRITE); + fcctx.dbconn = dbconn; + write_openpgp_stream(keydb_putchar, &fcctx, packets); + lo_close(dbconn, fcctx.fd); } + free_packet_list(packets); + packets = NULL; snprintf(statement, 1023, "INSERT INTO onak_keys (keyid, keydata) VALUES " - "('%llX', '%d')", - get_keyid(publickey), + "('%" PRIX64 "', '%d')", + keyid, key_oid); result = PQexec(dbconn, statement); if (PQresultStatus(result) != PGRES_COMMAND_OK) { - fprintf(stderr, "Problem storing key in DB.\n"); - fprintf(stderr, "%s\n", PQresultErrorMessage(result)); + logthing(LOGTHING_ERROR, "Problem storing key in DB."); + logthing(LOGTHING_ERROR, "%s", PQresultErrorMessage(result)); } PQclear(result); @@ -328,14 +406,14 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) safeuid = malloc(strlen(uids[i]) * 2 + 1); if (safeuid != NULL) { memset(safeuid, 0, strlen(uids[i]) * 2 + 1); - PQescapeString(safeuid, uids[i], - strlen(uids[i])); + PQescapeStringConn(dbconn, safeuid, uids[i], + strlen(uids[i]), NULL); snprintf(statement, 1023, "INSERT INTO onak_uids " "(keyid, uid, pri) " - "VALUES ('%llX', '%s', '%c')", - get_keyid(publickey), + "VALUES ('%" PRIX64 "', '%s', '%c')", + keyid, safeuid, (uids[i] == primary) ? 't' : 'f'); result = PQexec(dbconn, statement); @@ -349,8 +427,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) } if (PQresultStatus(result) != PGRES_COMMAND_OK) { - fprintf(stderr, "Problem storing key in DB.\n"); - fprintf(stderr, "%s\n", + logthing(LOGTHING_ERROR, + "Problem storing key in DB."); + logthing(LOGTHING_ERROR, "%s", PQresultErrorMessage(result)); } /* @@ -367,9 +446,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) packets = packets->next) { snprintf(statement, 1023, "INSERT INTO onak_sigs (signer, signee) " - "VALUES ('%llX', '%llX')", + "VALUES ('%" PRIX64 "', '%" PRIX64 "')", sig_keyid(packets->packet), - get_keyid(publickey)); + keyid); result = PQexec(dbconn, statement); PQclear(result); } @@ -383,86 +462,20 @@ 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, bool intrans) -{ - PGresult *result = NULL; - char *oids = NULL; - char statement[1024]; - int found = 1; - int i; - Oid key_oid; - - if (!intrans) { - result = PQexec(dbconn, "BEGIN"); - PQclear(result); - } - - snprintf(statement, 1023, - "SELECT keydata FROM onak_keys WHERE keyid = '%llX'", - keyid); - result = PQexec(dbconn, statement); - - if (PQresultStatus(result) == PGRES_TUPLES_OK) { - found = 0; - i = PQntuples(result); - while (i > 0) { - oids = PQgetvalue(result, i-1, 0); - key_oid = (Oid) atoi(oids); - lo_unlink(dbconn, key_oid); - i--; - } - PQclear(result); - - snprintf(statement, 1023, - "DELETE FROM onak_keys WHERE keyid = '%llX'", - keyid); - result = PQexec(dbconn, statement); - PQclear(result); - - snprintf(statement, 1023, - "DELETE FROM onak_sigs WHERE signee = '%llX'", - keyid); - result = PQexec(dbconn, statement); - PQclear(result); - - snprintf(statement, 1023, - "DELETE FROM onak_uids WHERE keyid = '%llX'", - keyid); - result = PQexec(dbconn, statement); - } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { - fprintf(stderr, "Problem retrieving key (%llX) from DB.\n", - keyid); - } - - PQclear(result); - - if (!intrans) { - result = PQexec(dbconn, "COMMIT"); - PQclear(result); - } - return (found); -} - /** * keyid2uid - Takes a keyid and returns the primary UID for it. * @keyid: The keyid to lookup. */ -char *keyid2uid(uint64_t keyid) +static char *pg_keyid2uid(struct onak_dbctx *dbctx, uint64_t keyid) { + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; char statement[1024]; char *uid = NULL; snprintf(statement, 1023, - "SELECT uid FROM onak_uids WHERE keyid = '%llX' AND pri = 't'", + "SELECT uid FROM onak_uids WHERE keyid = '%" PRIX64 + "' AND pri = 't'", keyid); result = PQexec(dbconn, statement); @@ -477,7 +490,9 @@ char *keyid2uid(uint64_t keyid) PQntuples(result) >= 1) { uid = strdup(PQgetvalue(result, 0, 0)); } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { - fprintf(stderr, "Problem retrieving key (%llX) from DB.\n", + logthing(LOGTHING_ERROR, + "Problem retrieving key (%" PRIX64 + ") from DB.", keyid); } @@ -489,19 +504,23 @@ char *keyid2uid(uint64_t keyid) /** * getkeysigs - Gets a linked list of the signatures on a key. * @keyid: The keyid to get the sigs for. + * @revoked: If the key is revoked. * * This function gets the list of signatures on a key. Used for key * indexing and doing stats bits. */ -struct ll *getkeysigs(uint64_t keyid) +static struct ll *pg_getkeysigs(struct onak_dbctx *dbctx, + uint64_t keyid, bool *revoked) { struct ll *sigs = NULL; + PGconn *dbconn = (PGconn *) dbctx->priv; PGresult *result = NULL; uint64_t signer; char statement[1024]; - int i = 0; + int i, j; int numsigs = 0; bool intrans = false; + char *str; if (!intrans) { result = PQexec(dbconn, "BEGIN"); @@ -509,18 +528,30 @@ struct ll *getkeysigs(uint64_t keyid) } snprintf(statement, 1023, - "SELECT signer FROM onak_sigs WHERE signee = '%llX'", + "SELECT DISTINCT signer FROM onak_sigs WHERE signee = '%" + PRIX64 "'", keyid); result = PQexec(dbconn, statement); if (PQresultStatus(result) == PGRES_TUPLES_OK) { numsigs = PQntuples(result); for (i = 0; i < numsigs; i++) { - signer = strtol(PQgetvalue(result, i, 0), NULL, 16); + j = 0; + signer = 0; + str = PQgetvalue(result, i, 0); + while (str[j] != 0) { + signer <<= 4; + if (str[j] >= '0' && str[j] <= '9') { + signer += str[j] - '0'; + } else { + signer += str[j] - 'A' + 10; + } + j++; + } sigs = lladd(sigs, createandaddtohash(signer)); } } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { - fprintf(stderr, "Problem retrieving key from DB.\n"); + logthing(LOGTHING_ERROR, "Problem retrieving key from DB."); } PQclear(result); @@ -529,11 +560,154 @@ struct ll *getkeysigs(uint64_t keyid) result = PQexec(dbconn, "COMMIT"); PQclear(result); } + + /* + * TODO: What do we do about revocations? We don't have the details + * stored in a separate table, so we'd have to grab the key and decode + * it, which we're trying to avoid by having a signers table. + */ + if (revoked != NULL) { + *revoked = false; + } + return sigs; } +/** + * iterate_keys - call a function once for each key in the db. + * @iterfunc: The function to call. + * @ctx: A context pointer + * + * Calls iterfunc once for each key in the database. ctx is passed + * unaltered to iterfunc. This function is intended to aid database dumps + * and statistic calculations. + * + * Returns the number of keys we iterated over. + */ +static int pg_iterate_keys(struct onak_dbctx *dbctx, + void (*iterfunc)(void *ctx, + struct openpgp_publickey *key), void *ctx) +{ + struct openpgp_packet_list *packets = NULL; + struct openpgp_publickey *key = NULL; + PGconn *dbconn = (PGconn *) dbctx->priv; + PGresult *result = NULL; + char *oids = NULL; + int i = 0; + int numkeys = 0; + Oid key_oid; + struct pg_fc_ctx fcctx; + + result = PQexec(dbconn, "SELECT keydata FROM onak_keys;"); + + if (PQresultStatus(result) == PGRES_TUPLES_OK) { + numkeys = PQntuples(result); + for (i = 0; i < numkeys; i++) { + oids = PQgetvalue(result, i, 0); + key_oid = (Oid) atoi(oids); + + fcctx.fd = lo_open(dbconn, key_oid, INV_READ); + if (fcctx.fd < 0) { + logthing(LOGTHING_ERROR, + "Can't open large object."); + } else { + fcctx.dbconn = dbconn; + read_openpgp_stream(keydb_fetchchar, &fcctx, + &packets, 0); + parse_keys(packets, &key); + lo_close(dbconn, fcctx.fd); + + iterfunc(ctx, key); + + free_publickey(key); + key = NULL; + free_packet_list(packets); + packets = NULL; + } + } + } else if (PQresultStatus(result) != PGRES_TUPLES_OK) { + logthing(LOGTHING_ERROR, "Problem retrieving key from DB."); + } + + PQclear(result); + + return (numkeys); +} + /* * Include the basic keydb routines. */ #define NEED_GETFULLKEYID 1 +#define NEED_UPDATEKEYS 1 +#define NEED_GET_FP 1 #include "keydb.c" + +/** + * cleanupdb - De-initialize the key database. + * + * This function should be called upon program exit to allow the DB to + * cleanup after itself. + */ +static void pg_cleanupdb(struct onak_dbctx *dbctx) +{ + PGconn *dbconn = (PGconn *) dbctx->priv; + + PQfinish(dbconn); + dbconn = NULL; + + free(dbctx); +} + +/** + * initdb - Initialize the key database. + * + * This function should be called before any of the other functions in + * this file are called in order to allow the DB to be initialized ready + * for access. + */ +struct onak_dbctx *keydb_pg_init(struct onak_db_config *dbcfg, bool readonly) +{ + struct onak_dbctx *dbctx; + PGconn *dbconn; + + dbctx = malloc(sizeof(struct onak_dbctx)); + if (dbctx == NULL) { + return NULL; + } + dbctx->config = dbcfg; + + dbconn = PQsetdbLogin(dbcfg->hostname, // host + NULL, // port + NULL, // options + NULL, // tty + dbcfg->location, // database + dbcfg->username, //login + dbcfg->password); // password + + if (PQstatus(dbconn) == CONNECTION_BAD) { + logthing(LOGTHING_CRITICAL, "Connection to database failed."); + logthing(LOGTHING_CRITICAL, "%s", PQerrorMessage(dbconn)); + PQfinish(dbconn); + dbconn = NULL; + exit(1); + } + + dbctx->priv = dbconn; + + dbctx->cleanupdb = pg_cleanupdb; + dbctx->starttrans = pg_starttrans; + dbctx->endtrans = pg_endtrans; + dbctx->fetch_key_id = pg_fetch_key_id; + dbctx->fetch_key_fp = generic_fetch_key_fp; + dbctx->fetch_key_text = pg_fetch_key_text; + dbctx->store_key = pg_store_key; + dbctx->update_keys = generic_update_keys; + dbctx->delete_key = pg_delete_key; + dbctx->getkeysigs = pg_getkeysigs; + dbctx->cached_getkeysigs = generic_cached_getkeysigs; + dbctx->keyid2uid = pg_keyid2uid; + dbctx->getfullkeyid = generic_getfullkeyid; + dbctx->iterate_keys = pg_iterate_keys; + + return dbctx; +}