keydb_db2.c

   1 /*
   2  * keydb_db2.c - Routines to store and fetch keys in a DB2 file (a la pksd)
   3  *
   4  * Jonathan McDowell <noodles@earth.li>
   5  *
   6  * Copyright 2002 Project Purple
   7  */
   8
   9 #include <sys/types.h>
  10 #include <sys/uio.h>
  11 #include <db2/db.h>
  12 #include <errno.h>
  13 #include <fcntl.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <unistd.h>
  18
  19 #include "charfuncs.h"
  20 #include "keydb.h"
  21 #include "keyid.h"
  22 #include "keyindex.h"
  23 #include "keystructs.h"
  24 #include "log.h"
  25 #include "mem.h"
  26 #include "onak-conf.h"
  27 #include "parsekey.h"
  28
  29 #define KEYDB_KEYID_BYTES 4
  30
  31 /**
  32  *      db2_numdb - The number of database files we have.
  33  */
  34 static int db2_numdb = 16;
  35
  36 /**
  37  *      db2_keydbfiles - An array of DB structs for our key database files.
  38  */
  39 static DB **db2_keydbfiles = NULL;
  40
  41 /**
  42  *      db2_env - Database environment variable.
  43  */
  44 static DB_ENV db2_env;
  45
  46 DB *keydb(DBT *key)
  47 {
  48         /*
  49          * keyid's are 8 bytes, msb first.  so start from the end.  use 16
  50          * bits, since that's enough to divide by any small number of db files.
  51          */
  52         unsigned char *keydata = (unsigned char *) key->data;
  53         unsigned long keyidnum;
  54
  55         keyidnum = (keydata[KEYDB_KEYID_BYTES-2]<<8)|keydata[KEYDB_KEYID_BYTES-1];
  56         return(db2_keydbfiles[keyidnum % db2_numdb]);
  57 }
  58
  59 /**
  60  *      initdb - Initialize the key database.
  61  *
  62  *      This function should be called before any of the other functions in
  63  *      this file are called in order to allow the DB to be initialized ready
  64  *      for access.
  65  */
  66 void initdb(void)
  67 {
  68         DB_INFO keydbinfo;
  69         int i;
  70         int ret;
  71         char keydbname[20];
  72         char buf[1024];
  73         FILE *numdb = NULL;
  74
  75         snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir);
  76         numdb = fopen(buf, "r");
  77         if (numdb != NULL) {
  78                 if (fgets(buf, sizeof(buf), numdb) != NULL) {
  79                         db2_numdb = atoi(buf);
  80                 }
  81                 fclose(numdb);
  82         } else {
  83                 logthing(LOGTHING_ERROR, "Couldn't open num_keydb: %s",
  84                                 strerror(errno));
  85         }
  86
  87         memset(&db2_env, 0, sizeof(db2_env));
  88
  89         /*
  90          * Tunable param. Just using what pksd does for the moment. Bigger uses
  91          * more memory but improves performance. Bigger than physical memory
  92          * makes no sense.
  93          */
  94         db2_env.mp_size = 20 * 1024 * 1024;
  95
  96         ret = db_appinit(config.db_dir, NULL,
  97                         &db2_env, DB_INIT_MPOOL|DB_INIT_LOCK);
  98         if (!ret) {
  99                 db2_keydbfiles = (DB **) malloc(sizeof (DB *) * db2_numdb);
 100                 memset(&keydbinfo, 0, sizeof(keydbinfo));
 101                 keydbinfo.db_pagesize = 8192;
 102                 for (i = 0; i < db2_numdb; i++) {
 103                         db2_keydbfiles[i] = NULL;
 104                         snprintf(keydbname, 19, "keydb%03d", i);
 105                         ret = db_open(keydbname, DB_HASH, DB_RDONLY, 0644,
 106                                         &db2_env, &keydbinfo,
 107                                         &db2_keydbfiles[i]);
 108                         if (ret) {
 109                                 logthing(LOGTHING_CRITICAL,
 110                                         "Error opening db file %d (errno %d)",
 111                                         i, ret);
 112                                 exit(1);
 113                         }
 114                 }
 115         } else {
 116                 logthing(LOGTHING_CRITICAL, "Error initializing db (%d).",
 117                                 ret);
 118                 exit(1);
 119         }
 120 }
 121
 122 /**
 123  *      cleanupdb - De-initialize the key database.
 124  *
 125  *      This function should be called upon program exit to allow the DB to
 126  *      cleanup after itself.
 127  */
 128 void cleanupdb(void)
 129 {
 130         int i;
 131
 132         for (i = 0; i < db2_numdb; i++) {
 133                 if (db2_keydbfiles[i] != NULL) {
 134                         (*(db2_keydbfiles[i]->close))(db2_keydbfiles[i], 0);
 135                         db2_keydbfiles[i] = NULL;
 136                 }
 137         }
 138
 139         db_appexit(&db2_env);
 140 }
 141
 142 /**
 143  *      starttrans - Start a transaction.
 144  *
 145  *      Start a transaction. Intended to be used if we're about to perform many
 146  *      operations on the database to help speed it all up, or if we want
 147  *      something to only succeed if all relevant operations are successful.
 148  */
 149 bool starttrans(void)
 150 {
 151         return true;
 152 }
 153
 154 /**
 155  *      endtrans - End a transaction.
 156  *
 157  *      Ends a transaction.
 158  */
 159 void endtrans(void)
 160 {
 161         return;
 162 }
 163
 164 /**
 165  *      fetch_key - Given a keyid fetch the key from storage.
 166  *      @keyid: The keyid to fetch.
 167  *      @publickey: A pointer to a structure to return the key in.
 168  *      @intrans: If we're already in a transaction.
 169  *
 170  *      We use the hex representation of the keyid as the filename to fetch the
 171  *      key from. The key is stored in the file as a binary OpenPGP stream of
 172  *      packets, so we can just use read_openpgp_stream() to read the packets
 173  *      in and then parse_keys() to parse the packets into a publickey
 174  *      structure.
 175  */
 176 int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
 177                 bool intrans)
 178 {
 179         struct openpgp_packet_list *packets = NULL;
 180         int ret;
 181         DBT key, data;
 182         char id[KEYDB_KEYID_BYTES];
 183         struct buffer_ctx fetchbuf;
 184
 185         memset(&key, 0, sizeof(key));
 186         memset(&data, 0, sizeof(data));
 187
 188         id[0] = (keyid >> 24) & 0xFF;
 189         id[1] = (keyid >> 16) & 0xFF;
 190         id[2] = (keyid >> 8) & 0xFF;
 191         id[3] = keyid & 0xFF;
 192
 193         key.data = id;
 194         key.size = KEYDB_KEYID_BYTES;
 195
 196         ret = (*(keydb(&key)->get))(keydb(&key), NULL, &key, &data, 0);
 197         if (ret == 0) {
 198                 fetchbuf.buffer = data.data;
 199                 fetchbuf.offset = 0;
 200                 fetchbuf.size = data.size;
 201                 read_openpgp_stream(buffer_fetchchar, &fetchbuf, &packets);
 202                 parse_keys(packets, publickey);
 203                 free_packet_list(packets);
 204                 packets = NULL;
 205         }
 206
 207         return (!ret);
 208 }
 209
 210 /**
 211  *      fetch_key_text - Trys to find the keys that contain the supplied text.
 212  *      @search: The text to search for.
 213  *      @publickey: A pointer to a structure to return the key in.
 214  *
 215  *      This function searches for the supplied text and returns the keys that
 216  *      contain it.
 217  */
 218 int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
 219 {
 220         return 0;
 221 }
 222
 223 /**
 224  *      store_key - Takes a key and stores it.
 225  *      @publickey: A pointer to the public key to store.
 226  *      @intrans: If we're already in a transaction.
 227  *      @update: If true the key exists and should be updated.
 228  *
 229  *      Again we just use the hex representation of the keyid as the filename
 230  *      to store the key to. We flatten the public key to a list of OpenPGP
 231  *      packets and then use write_openpgp_stream() to write the stream out to
 232  *      the file.
 233  */
 234 int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
 235 {
 236         return 0;
 237 }
 238
 239 /**
 240  *      delete_key - Given a keyid delete the key from storage.
 241  *      @keyid: The keyid to delete.
 242  *      @intrans: If we're already in a transaction.
 243  *
 244  *      This function deletes a public key from whatever storage mechanism we
 245  *      are using. Returns 0 if the key existed.
 246  */
 247 int delete_key(uint64_t keyid, bool intrans)
 248 {
 249         return (1);
 250 }
 251
 252 /**
 253  *      dumpdb - dump the key database
 254  *      @filenamebase: The base filename to use for the dump.
 255  *
 256  *      Dumps the database into one or more files, which contain pure OpenPGP
 257  *      that can be reimported into onak or gpg. filenamebase provides a base
 258  *      file name for the dump; several files may be created, all of which will
 259  *      begin with this string and then have a unique number and a .pgp
 260  *      extension.
 261  *          */
 262 int dumpdb(char *filenamebase)
 263 {
 264         return 0;
 265 }
 266
 267
 268 /*
 269  * Include the basic keydb routines.
 270  */
 271 #define NEED_KEYID2UID 1
 272 #define NEED_GETKEYSIGS 1
 273 #define NEED_GETFULLKEYID 1
 274 #include "keydb.c"