keydb.c

   1 /*
   2  * keydb.c - Routines for DB access that just use store/fetch.
   3  *
   4  * Jonathan McDowell <noodles@earth.li>
   5  *
   6  * Copyright 2002 Project Purple
   7  *
   8  * $Id: keydb.c,v 1.10 2003/06/08 21:11:00 noodles Exp $
   9  */
  10
  11 /**
  12  *      The routines in this file are meant to be used as an initial step when
  13  *      adding a new db access module. They provide various functions required
  14  *      of the db access module using only the store and fetch functions. As
  15  *      they need to parse the actual OpenPGP data to work they are a lot
  16  *      slower than custom functions however.
  17  */
  18
  19 #include <stdio.h>
  20
  21 #include "decodekey.h"
  22 #include "hash.h"
  23 #include "keydb.h"
  24 #include "keyid.h"
  25 #include "keystructs.h"
  26 #include "mem.h"
  27 #include "parsekey.h"
  28
  29 #ifdef NEED_KEYID2UID
  30 /**
  31  *      keyid2uid - Takes a keyid and returns the primary UID for it.
  32  *      @keyid: The keyid to lookup.
  33  */
  34 char *keyid2uid(uint64_t keyid)
  35 {
  36         struct openpgp_publickey *publickey = NULL;
  37         struct openpgp_signedpacket_list *curuid = NULL;
  38         char buf[1024];
  39
  40         buf[0]=0;
  41         if (fetch_key(keyid, &publickey, false) && publickey != NULL) {
  42                 curuid = publickey->uids;
  43                 while (curuid != NULL && buf[0] == 0) {
  44                         if (curuid->packet->tag == 13) {
  45                                 snprintf(buf, 1023, "%.*s",
  46                                                 (int) curuid->packet->length,
  47                                                 curuid->packet->data);
  48                         }
  49                         curuid = curuid -> next;
  50                 }
  51                 free_publickey(publickey);
  52         }
  53
  54         if (buf[0] == 0) {
  55                 return NULL;
  56         } else {
  57                 return strdup(buf);
  58         }
  59 }
  60 #endif
  61
  62 #ifdef NEED_GETKEYSIGS
  63 /**
  64  *      getkeysigs - Gets a linked list of the signatures on a key.
  65  *      @keyid: The keyid to get the sigs for.
  66  *      @revoked: Is the key revoked?
  67  *
  68  *      This function gets the list of signatures on a key. Used for key
  69  *      indexing and doing stats bits. If revoked is non-NULL then if the key
  70  *      is revoked it's set to true.
  71  */
  72 struct ll *getkeysigs(uint64_t keyid, bool *revoked)
  73 {
  74         struct ll *sigs = NULL;
  75         struct openpgp_signedpacket_list *uids = NULL;
  76         struct openpgp_publickey *publickey = NULL;
  77
  78         fetch_key(keyid, &publickey, false);
  79
  80         if (publickey != NULL) {
  81                 for (uids = publickey->uids; uids != NULL; uids = uids->next) {
  82                         sigs = keysigs(sigs, uids->sigs);
  83                 }
  84                 if (revoked != NULL) {
  85                         *revoked = (publickey->revocations != NULL);
  86                 }
  87                 free_publickey(publickey);
  88         }
  89
  90         return sigs;
  91 }
  92 #endif
  93
  94 /**
  95  *      cached_getkeysigs - Gets the signatures on a key.
  96  *      @keyid: The key we want the signatures for.
  97  *
  98  *      This function gets the signatures on a key. It's the same as the
  99  *      getkeysigs function above except we use the hash module to cache the
 100  *      data so if we need it again it's already loaded.
 101  */
 102 struct ll *cached_getkeysigs(uint64_t keyid)
 103 {
 104         struct stats_key *key = NULL;
 105         struct stats_key *signedkey = NULL;
 106         struct ll        *cursig = NULL;
 107         bool              revoked = false;
 108
 109         if (keyid == 0)  {
 110                 return NULL;
 111         }
 112
 113         key = createandaddtohash(keyid);
 114
 115         if (key->gotsigs == false) {
 116                 key->sigs = getkeysigs(key->keyid, &revoked);
 117                 key->revoked = revoked;
 118                 for (cursig = key->sigs; cursig != NULL;
 119                                 cursig = cursig->next) {
 120                         signedkey = (struct stats_key *) cursig->object;
 121                         signedkey->signs = lladd(signedkey->signs, key);
 122                 }
 123                 key->gotsigs = true;
 124         }
 125
 126         return key->sigs;
 127 }
 128
 129 #ifdef NEED_GETFULLKEYID
 130 /**
 131  *      getfullkeyid - Maps a 32bit key id to a 64bit one.
 132  *      @keyid: The 32bit keyid.
 133  *
 134  *      This function maps a 32bit key id to the full 64bit one. It returns the
 135  *      full keyid. If the key isn't found a keyid of 0 is returned.
 136  */
 137 uint64_t getfullkeyid(uint64_t keyid)
 138 {
 139         struct openpgp_publickey *publickey = NULL;
 140
 141         if (keyid < 0x100000000LL) {
 142                 fetch_key(keyid, &publickey, false);
 143                 if (publickey != NULL) {
 144                         keyid = get_keyid(publickey);
 145                         free_publickey(publickey);
 146                         publickey = NULL;
 147                 } else {
 148                         keyid = 0;
 149                 }
 150         }
 151
 152         return keyid;
 153 }
 154 #endif