keydb_file.c

   1 /*
   2  * keydb.c - Routines to store and fetch keys.
   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 <errno.h>
  12 #include <fcntl.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17
  18 #include "keydb.h"
  19 #include "keyid.h"
  20 #include "keystructs.h"
  21 #include "ll.h"
  22 #include "mem.h"
  23 #include "parsekey.h"
  24
  25 #define DBDIR "/home/noodles/onak-0.0.1/db"
  26
  27 /**
  28  *      keydb_fetchchar - Fetches a char from a file.
  29  */
  30 static int keydb_fetchchar(void *fd, size_t count, unsigned char *c)
  31 {
  32         return !(read( *(int *) fd, c, count));
  33 }
  34
  35 /**
  36  *      keydb_putchar - Puts a char to a file.
  37  */
  38 static int keydb_putchar(void *fd, unsigned char c)
  39 {
  40         return !(write( *(int *) fd, &c, sizeof(c)));
  41 }
  42
  43 /**
  44  *      initdb - Initialize the key database.
  45  *
  46  *      This is just a no-op for flat file access.
  47  */
  48 void initdb(void)
  49 {
  50 }
  51
  52 /**
  53  *      cleanupdb - De-initialize the key database.
  54  *
  55  *      This is just a no-op for flat file access.
  56  */
  57 void cleanupdb(void)
  58 {
  59 }
  60
  61 /**
  62  *      fetch_key - Given a keyid fetch the key from storage.
  63  *      @keyid: The keyid to fetch.
  64  *      @publickey: A pointer to a structure to return the key in.
  65  *
  66  *      We use the hex representation of the keyid as the filename to fetch the
  67  *      key from. The key is stored in the file as a binary OpenPGP stream of
  68  *      packets, so we can just use read_openpgp_stream() to read the packets
  69  *      in and then parse_keys() to parse the packets into a publickey
  70  *      structure.
  71  */
  72 int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey)
  73 {
  74         struct openpgp_packet_list *packets = NULL;
  75         char keyfile[1024];
  76         int fd = -1;
  77
  78         snprintf(keyfile, 1023, "%s/0x%llX", DBDIR, keyid & 0xFFFFFFFF);
  79         fd = open(keyfile, O_RDONLY); // | O_SHLOCK);
  80
  81         if (fd > -1) {
  82                 read_openpgp_stream(keydb_fetchchar, &fd, &packets);
  83                 parse_keys(packets, publickey);
  84                 close(fd);
  85         }
  86
  87         return (fd > -1);
  88 }
  89
  90 /**
  91  *      store_key - Takes a key and stores it.
  92  *      @publickey: A pointer to the public key to store.
  93  *
  94  *      Again we just use the hex representation of the keyid as the filename
  95  *      to store the key to. We flatten the public key to a list of OpenPGP
  96  *      packets and then use write_openpgp_stream() to write the stream out to
  97  *      the file.
  98  */
  99 int store_key(struct openpgp_publickey *publickey)
 100 {
 101         struct openpgp_packet_list *packets = NULL;
 102         struct openpgp_packet_list *list_end = NULL;
 103         struct openpgp_publickey *next = NULL;
 104         char keyfile[1024];
 105         int fd = -1;
 106
 107         snprintf(keyfile, 1023, "%s/0x%llX", DBDIR,
 108                         get_keyid(publickey) & 0xFFFFFFFF);
 109         fd = open(keyfile, O_WRONLY | O_CREAT, 0664); // | O_EXLOCK);
 110
 111         if (fd > -1) {
 112                 next = publickey -> next;
 113                 publickey -> next = NULL;
 114                 flatten_publickey(publickey, &packets, &list_end);
 115                 publickey -> next = next;
 116
 117                 write_openpgp_stream(keydb_putchar, &fd, packets);
 118                 close(fd);
 119         }
 120
 121         return (fd > -1);
 122 }
 123
 124 /**
 125  *      delete_key - Given a keyid delete the key from storage.
 126  *      @keyid: The keyid to delete.
 127  *
 128  *      This function deletes a public key from whatever storage mechanism we
 129  *      are using. Returns 0 if the key existed.
 130  */
 131 int delete_key(uint64_t keyid)
 132 {
 133         char keyfile[1024];
 134
 135         snprintf(keyfile, 1023, "%s/0x%llX", DBDIR,
 136                         keyid & 0xFFFFFFFF);
 137
 138         return unlink(keyfile);
 139 }
 140
 141 /*
 142  * Include the basic keydb routines.
 143  */
 144 #include "keydb.c"