security-and-privacy/gnupg
security-and-privacy
/
gnupg
mirror of git://git.gnupg.org/gnupg.git
1
0
Fork 0
Code Releases Activity

gpg: Use more descriptive names. 

* g10/keyring.c (KR_NAME): Rename this...
(KR_RESOURCE): ... to this.  Update users.
(struct keyring_name): Rename this...
(struct keyring_resource): ... to this.  Update users.
(struct off_item): Rename this...
(struct key_present): ... to this.  Update users.
(OffsetHashTable): Rename this...
(key_present_hash_t): ... to this.  Update users.
(kr_offtbl): Rename this...
(key_present_hash): ... to this.  Update users.
(kr_offtbl_ready): Rename this...
(key_present_hash_ready): ... to this.  Update users.
(KEY_PRESENT_HASH_BUCKETS): New define.  Replace use of literals
with this.
(new_offset_item): Rename this...
(key_present_value_new): ... to this.  Update users.
(release_offset_items): Drop dead code.
(new_offset_hash_table): Rename this...
(key_present_hash_new): ... to this.  Update users.
(release_offset_hash_table): Drop dead code.
(lookup_offset_hash_table): Rename this...
(key_present_hash_lookup): ... to this.  Update users.
(update_offset_hash_table): Rename this...
(key_present_hash_update): ... to this.  Drop unused parameter off.
Update users.
(update_offset_hash_table_from_kb): Rename this...
(key_present_hash_update_from_kb): ... to this.  Drop unused parameter
off.  Update users.

--
Signed-off-by: Neal H. Walfield <neal@g10code.com>
This commit is contained in:
Neal H. Walfield 2015-12-14 14:32:37 +01:00
parent 4ee881bff4
commit 0ea186db64
1 changed files with 99 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
g10/keyring.c
View File

@ -37,49 +37,31 @@
#include "main.h" /*for check_key_signature()*/
#include "i18n.h"
/* off_item is a funny named for an object used to keep track of known
* keys. The idea was to use the offset to seek to the known keyblock, but
* this is not possible if more than one process is using the keyring.
*/
struct off_item {
struct off_item *next;
u32 kid[2];
/*off_t off;*/
};
typedef struct off_item **OffsetHashTable;
typedef struct keyring_name *KR_NAME;
struct keyring_name
typedef struct keyring_resource *KR_RESOURCE;
struct keyring_resource
{
struct keyring_name *next;
struct keyring_resource *next;
int read_only;
dotlock_t lockhd;
int is_locked;
int did_full_scan;
char fname[1];
};
typedef struct keyring_name const * CONST_KR_NAME;
static KR_NAME kr_names;
static int active_handles;
static OffsetHashTable kr_offtbl;
static int kr_offtbl_ready;
typedef struct keyring_resource const * CONST_KR_RESOURCE;
static KR_RESOURCE kr_resources;
struct keyring_handle
{
CONST_KR_NAME resource;
CONST_KR_RESOURCE resource;
struct {
CONST_KR_NAME kr;
CONST_KR_RESOURCE kr;
IOBUF iobuf;
int eof;
int error;
} current;
struct {
CONST_KR_NAME kr;
CONST_KR_RESOURCE kr;
off_t offset;
size_t pk_no;
size_t uid_no;
@ -91,96 +73,96 @@ struct keyring_handle
} word_match;
};
/* The number of extant handles. */
static int active_handles;
static int do_copy (int mode, const char *fname, KBNODE root,
off_t start_offset, unsigned int n_packets );
static struct off_item *
new_offset_item (void)
/* We keep a cache of entries that we have entered in the DB. This
includes not only public keys, but also subkeys.
Note: we'd like to keep the offset of the items that are present,
however, this doesn't work, because another concurrent GnuPG
process could modify the keyring. */
struct key_present {
struct key_present *next;
u32 kid[2];
};
/* For the hash table, we use separate chaining with linked lists.
This means that we have an array of N linked lists (buckets), which
is indexed by KEYID[1] mod N. Elements present in the keyring will
be on the list; elements not present in the keyring will not be on
the list.
Note: since the hash table stores both present and not present
information, it cannot be used until we complete a full scan of the
keyring. This is indicated by key_present_hash_ready. */
typedef struct key_present **key_present_hash_t;
static key_present_hash_t key_present_hash;
static int key_present_hash_ready;
#define KEY_PRESENT_HASH_BUCKETS 2048
/* Allocate a new value for a key present hash table. */
static struct key_present *
key_present_value_new (void)
{
struct off_item *k;
struct key_present *k;
k = xmalloc_clear (sizeof *k);
return k;
}
#if 0
static void
release_offset_items (struct off_item *k)
/* Allocate a new key present hash table. */
static key_present_hash_t
key_present_hash_new (void)
{
struct off_item *k2;
struct key_present **tbl;
for (; k; k = k2)
{
k2 = k->next;
xfree (k);
}
}
#endif
static OffsetHashTable
new_offset_hash_table (void)
{
struct off_item **tbl;
tbl = xmalloc_clear (2048 * sizeof *tbl);
tbl = xmalloc_clear (KEY_PRESENT_HASH_BUCKETS * sizeof *tbl);
return tbl;
}
#if 0
static void
release_offset_hash_table (OffsetHashTable tbl)
/* Return whether the value described by KID if it is in the hash
table. Otherwise, return NULL. */
static struct key_present *
key_present_hash_lookup (key_present_hash_t tbl, u32 *kid)
{
int i;
struct key_present *k;
if (!tbl)
return;
for (i=0; i < 2048; i++)
release_offset_items (tbl[i]);
xfree (tbl);
}
#endif
static struct off_item *
lookup_offset_hash_table (OffsetHashTable tbl, u32 *kid)
{
struct off_item *k;
for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
for (k = tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))]; k; k = k->next)
if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
return k;
return NULL;
}
/* Add the key to the hash table TBL if it is not already present. */
static void
update_offset_hash_table (OffsetHashTable tbl, u32 *kid, off_t off)
key_present_hash_update (key_present_hash_t tbl, u32 *kid)
{
struct off_item *k;
struct key_present *k;
(void)off;
for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
for (k = tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))]; k; k = k->next)
{
if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
{
/*k->off = off;*/
return;
}
return;
}
k = new_offset_item ();
k = key_present_value_new ();
k->kid[0] = kid[0];
k->kid[1] = kid[1];
/*k->off = off;*/
k->next = tbl[(kid[1] & 0x07ff)];
tbl[(kid[1] & 0x07ff)] = k;
k->next = tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))];
tbl[(kid[1] % (KEY_PRESENT_HASH_BUCKETS - 1))] = k;
}
/* Add all the keys (public and subkeys) present in the keyblock to
the hash TBL. */
static void
update_offset_hash_table_from_kb (OffsetHashTable tbl, KBNODE node, off_t off)
key_present_hash_update_from_kb (key_present_hash_t tbl, KBNODE node)
{
for (; node; node = node->next)
{
@ -189,11 +171,11 @@ update_offset_hash_table_from_kb (OffsetHashTable tbl, KBNODE node, off_t off)
{
u32 aki[2];
keyid_from_pk (node->pkt->pkt.public_key, aki);
update_offset_hash_table (tbl, aki, off);
key_present_hash_update (tbl, aki);
}
}
}
/*
* Register a filename for plain keyring files. ptr is set to a
* pointer to be used to create a handles etc, or the already-issued
@ -203,12 +185,13 @@ update_offset_hash_table_from_kb (OffsetHashTable tbl, KBNODE node, off_t off)
int
keyring_register_filename (const char *fname, int read_only, void **ptr)
{
KR_NAME kr;
KR_RESOURCE kr;
if (active_handles)
BUG (); /* We don't allow that */
/* There are open handles. */
BUG ();
for (kr=kr_names; kr; kr = kr->next)
for (kr=kr_resources; kr; kr = kr->next)
{
if (same_file_p (kr->fname, fname))
{
@ -227,12 +210,12 @@ keyring_register_filename (const char *fname, int read_only, void **ptr)
kr->is_locked = 0;
kr->did_full_scan = 0;
/* keep a list of all issued pointers */
kr->next = kr_names;
kr_names = kr;
kr->next = kr_resources;
kr_resources = kr;
/* create the offset table the first time a function here is used */
if (!kr_offtbl)
kr_offtbl = new_offset_hash_table ();
if (!key_present_hash)
key_present_hash = key_present_hash_new ();
*ptr=kr;
@ -242,7 +225,7 @@ keyring_register_filename (const char *fname, int read_only, void **ptr)
int
keyring_is_writable (void *token)
{
KR_NAME r = token;
KR_RESOURCE r = token;
return r? (r->read_only || !access (r->fname, W_OK)) : 0;
}
@ -256,7 +239,7 @@ KEYRING_HANDLE
keyring_new (void *token)
{
KEYRING_HANDLE hd;
KR_NAME resource = token;
KR_RESOURCE resource = token;
assert (resource);
@ -317,14 +300,14 @@ keyring_get_resource_name (KEYRING_HANDLE hd)
int
keyring_lock (KEYRING_HANDLE hd, int yes)
{
KR_NAME kr;
KR_RESOURCE kr;
int rc = 0;
(void)hd;
if (yes) {
/* first make sure the lock handles are created */
for (kr=kr_names; kr; kr = kr->next) {
for (kr=kr_resources; kr; kr = kr->next) {
if (!keyring_is_writable(kr))
continue;
if (!kr->lockhd) {
@ -339,7 +322,7 @@ keyring_lock (KEYRING_HANDLE hd, int yes)
return rc;
/* and now set the locks */
for (kr=kr_names; kr; kr = kr->next) {
for (kr=kr_resources; kr; kr = kr->next) {
if (!keyring_is_writable(kr))
continue;
if (kr->is_locked)
@ -354,7 +337,7 @@ keyring_lock (KEYRING_HANDLE hd, int yes)
}
if (rc || !yes) {
for (kr=kr_names; kr; kr = kr->next) {
for (kr=kr_resources; kr; kr = kr->next) {
if (!keyring_is_writable(kr))
continue;
if (!kr->is_locked)
@ -588,9 +571,9 @@ keyring_update_keyblock (KEYRING_HANDLE hd, KBNODE kb)
rc = do_copy (3, hd->found.kr->fname, kb,
hd->found.offset, hd->found.n_packets );
if (!rc) {
if (kr_offtbl)
if (key_present_hash)
{
update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
key_present_hash_update_from_kb (key_present_hash, kb);
}
/* better reset the found info */
hd->found.kr = NULL;
@ -634,9 +617,9 @@ keyring_insert_keyblock (KEYRING_HANDLE hd, KBNODE kb)
/* do the insert */
rc = do_copy (1, fname, kb, 0, 0 );
if (!rc && kr_offtbl)
if (!rc && key_present_hash)
{
update_offset_hash_table_from_kb (kr_offtbl, kb, 0);
key_present_hash_update_from_kb (key_present_hash, kb);
}
return rc;
@ -981,7 +964,7 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
int pk_no, uid_no;
int initial_skip;
int scanned_from_start;
int use_offtbl;
int use_key_present_hash;
PKT_user_id *uid = NULL;
PKT_public_key *pk = NULL;
u32 aki[2];
@ -1038,13 +1021,13 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
return rc;
}
use_offtbl = !!kr_offtbl;
if (!use_offtbl)
use_key_present_hash = !!key_present_hash;
if (!use_key_present_hash)
{
if (DBG_LOOKUP)
log_debug ("%s: no offset table.\n", __func__);
}
else if (!kr_offtbl_ready)
else if (!key_present_hash_ready)
{
if (DBG_LOOKUP)
log_debug ("%s: initializing offset table. (need_keyid: %d => 1)\n",
@ -1053,12 +1036,12 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
}
else if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID)
{
struct off_item *oi;
struct key_present *oi;
if (DBG_LOOKUP)
log_debug ("%s: look up by long key id, checking cache\n", __func__);
oi = lookup_offset_hash_table (kr_offtbl, desc[0].u.kid);
oi = key_present_hash_lookup (key_present_hash, desc[0].u.kid);
if (!oi)
{ /* We know that we don't have this key */
if (DBG_LOOKUP)
@ -1153,8 +1136,10 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
if (need_keyid)
keyid_from_pk (pk, aki);
if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
update_offset_hash_table (kr_offtbl, aki, main_offset);
if (use_key_present_hash
&& !key_present_hash_ready
&& scanned_from_start)
key_present_hash_update (key_present_hash, aki);
}
else if (pkt.pkttype == PKT_USER_ID)
{
@ -1258,12 +1243,14 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
hd->current.eof = 1;
/* if we scanned all keyrings, we are sure that
* all known key IDs are in our offtbl, mark that. */
if (use_offtbl && !kr_offtbl_ready && scanned_from_start)
if (use_key_present_hash
&& !key_present_hash_ready
&& scanned_from_start)
{
KR_NAME kr;
KR_RESOURCE kr;
/* First set the did_full_scan flag for this keyring. */
for (kr=kr_names; kr; kr = kr->next)
for (kr=kr_resources; kr; kr = kr->next)
{
if (hd->resource == kr)
{
@ -1273,13 +1260,13 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
}
/* Then check whether all flags are set and if so, mark the
offtbl ready */
for (kr=kr_names; kr; kr = kr->next)
for (kr=kr_resources; kr; kr = kr->next)
{
if (!kr->did_full_scan)
break;
}
if (!kr)
kr_offtbl_ready = 1;
key_present_hash_ready = 1;
}
}
else