Chiebot-Mirror
/
boringssl
mirror of https://gitee.com/mirrors/boringssl.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Prefix internal LHASH functions.

Browse Source 
lh_new is a very short name to be claiming.

Change-Id: I529f5063f9afae56fdb532ae4f4b91bb807322f6
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/48206
Reviewed-by: Adam Langley <agl@google.com>
chromium-5359
David Benjamin 3 years ago
parent 7f85116bed
commit ec8c67dfbc
7 changed files with 87 additions and 87 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      crypto/conf/conf.c
  2. 117
      crypto/lhash/internal.h
  3. 40
      crypto/lhash/lhash.c
  4. 6
      crypto/lhash/lhash_test.cc
  5. 2
      crypto/mem.c
  6. 4
      crypto/obj/obj.c
  7. 3
      include/openssl/mem.h

2
crypto/conf/conf.c
Unescape View File

@ -82,7 +82,7 @@ struct conf_st {
#define MAX_CONF_VALUE_LENGTH 65536
static uint32_t conf_value_hash(const CONF_VALUE *v) {
return (lh_strhash(v->section) << 2) ^ lh_strhash(v->name);
return (OPENSSL_strhash(v->section) << 2) ^ OPENSSL_strhash(v->name);
}
static int conf_value_cmp(const CONF_VALUE *a, const CONF_VALUE *b) {

117
crypto/lhash/internal.h
Unescape View File

@ -80,8 +80,8 @@ extern "C" {
//
// Although note that the hash table will contain /pointers/ to |foo|.
//
// A macro will be defined for each of the lh_* functions below. For
// LHASH_OF(foo), the macros would be lh_foo_new, lh_foo_num_items etc.
// A macro will be defined for each of the |OPENSSL_lh_*| functions below. For
// |LHASH_OF(foo)|, the macros would be |lh_foo_new|, |lh_foo_num_items| etc.
// lhash_cmp_func is a comparison function that returns a value equal, or not
@ -107,55 +107,54 @@ typedef uint32_t (*lhash_hash_func_helper)(lhash_hash_func func, const void *a);
typedef struct lhash_st _LHASH;
// lh_new returns a new, empty hash table or NULL on error.
OPENSSL_EXPORT _LHASH *lh_new(lhash_hash_func hash, lhash_cmp_func comp);
// OPENSSL_lh_new returns a new, empty hash table or NULL on error.
OPENSSL_EXPORT _LHASH *OPENSSL_lh_new(lhash_hash_func hash,
lhash_cmp_func comp);
// lh_free frees the hash table itself but none of the elements. See
// |lh_doall|.
OPENSSL_EXPORT void lh_free(_LHASH *lh);
// OPENSSL_lh_free frees the hash table itself but none of the elements. See
// |OPENSSL_lh_doall|.
OPENSSL_EXPORT void OPENSSL_lh_free(_LHASH *lh);
// lh_num_items returns the number of items in |lh|.
OPENSSL_EXPORT size_t lh_num_items(const _LHASH *lh);
// OPENSSL_lh_num_items returns the number of items in |lh|.
OPENSSL_EXPORT size_t OPENSSL_lh_num_items(const _LHASH *lh);
// lh_retrieve finds an element equal to |data| in the hash table and returns
// it. If no such element exists, it returns NULL.
OPENSSL_EXPORT void *lh_retrieve(const _LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func);
// OPENSSL_lh_retrieve finds an element equal to |data| in the hash table and
// returns it. If no such element exists, it returns NULL.
OPENSSL_EXPORT void *OPENSSL_lh_retrieve(const _LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func);
// lh_retrieve_key finds an element matching |key|, given the specified hash and
// comparison function. This differs from |lh_retrieve| in that the key may be a
// different type than the values stored in |lh|. |key_hash| and |cmp_key| must
// be compatible with the functions passed into |lh_new|.
OPENSSL_EXPORT void *lh_retrieve_key(const _LHASH *lh, const void *key,
uint32_t key_hash,
int (*cmp_key)(const void *key,
const void *value));
// OPENSSL_lh_retrieve_key finds an element matching |key|, given the specified
// hash and comparison function. This differs from |OPENSSL_lh_retrieve| in that
// the key may be a different type than the values stored in |lh|. |key_hash|
// and |cmp_key| must be compatible with the functions passed into
// |OPENSSL_lh_new|.
OPENSSL_EXPORT void *OPENSSL_lh_retrieve_key(const _LHASH *lh, const void *key,
uint32_t key_hash,
int (*cmp_key)(const void *key,
const void *value));
// lh_insert inserts |data| into the hash table. If an existing element is
// equal to |data| (with respect to the comparison function) then |*old_data|
// OPENSSL_lh_insert inserts |data| into the hash table. If an existing element
// is equal to |data| (with respect to the comparison function) then |*old_data|
// will be set to that value and it will be replaced. Otherwise, or in the
// event of an error, |*old_data| will be set to NULL. It returns one on
// success or zero in the case of an allocation error.
OPENSSL_EXPORT int lh_insert(_LHASH *lh, void **old_data, void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func);
OPENSSL_EXPORT int OPENSSL_lh_insert(_LHASH *lh, void **old_data, void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func);
// lh_delete removes an element equal to |data| from the hash table and returns
// it. If no such element is found, it returns NULL.
OPENSSL_EXPORT void *lh_delete(_LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func);
// OPENSSL_lh_delete removes an element equal to |data| from the hash table and
// returns it. If no such element is found, it returns NULL.
OPENSSL_EXPORT void *OPENSSL_lh_delete(_LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func);
// lh_doall_arg calls |func| on each element of the hash table and also passes
// |arg| as the second argument.
// OPENSSL_lh_doall_arg calls |func| on each element of the hash table and also
// passes |arg| as the second argument.
// TODO(fork): rename this
OPENSSL_EXPORT void lh_doall_arg(_LHASH *lh, void (*func)(void *, void *),
void *arg);
// lh_strhash is the default hash function which processes NUL-terminated
// strings.
OPENSSL_EXPORT uint32_t lh_strhash(const char *c);
OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
void (*func)(void *, void *),
void *arg);
#define DEFINE_LHASH_OF(type) \
DECLARE_LHASH_OF(type) \
@ -173,26 +172,25 @@ OPENSSL_EXPORT uint32_t lh_strhash(const char *c);
return ((lhash_##type##_hash_func)func)((const type *)a); \
} \
\
OPENSSL_INLINE LHASH_OF(type) * \
lh_##type##_new(lhash_##type##_hash_func hash, \
lhash_##type##_cmp_func comp) { \
return (LHASH_OF(type) *)lh_new((lhash_hash_func)hash, \
(lhash_cmp_func)comp); \
OPENSSL_INLINE LHASH_OF(type) *lh_##type##_new( \
lhash_##type##_hash_func hash, lhash_##type##_cmp_func comp) { \
return (LHASH_OF(type) *)OPENSSL_lh_new((lhash_hash_func)hash, \
(lhash_cmp_func)comp); \
} \
\
OPENSSL_INLINE void lh_##type##_free(LHASH_OF(type) *lh) { \
lh_free((_LHASH *)lh); \
OPENSSL_lh_free((_LHASH *)lh); \
} \
\
OPENSSL_INLINE size_t lh_##type##_num_items(const LHASH_OF(type) *lh) { \
return lh_num_items((const _LHASH *)lh); \
return OPENSSL_lh_num_items((const _LHASH *)lh); \
} \
\
OPENSSL_INLINE type *lh_##type##_retrieve(const LHASH_OF(type) *lh, \
const type *data) { \
return (type *)lh_retrieve((const _LHASH *)lh, data, \
lh_##type##_call_hash_func, \
lh_##type##_call_cmp_func); \
return (type *)OPENSSL_lh_retrieve((const _LHASH *)lh, data, \
lh_##type##_call_hash_func, \
lh_##type##_call_cmp_func); \
} \
\
typedef struct { \
@ -210,24 +208,25 @@ OPENSSL_EXPORT uint32_t lh_strhash(const char *c);
const LHASH_OF(type) *lh, const void *key, uint32_t key_hash, \
int (*cmp_key)(const void *key, const type *value)) { \
LHASH_CMP_KEY_##type cb = {cmp_key, key}; \
return (type *)lh_retrieve_key((const _LHASH *)lh, &cb, key_hash, \
lh_##type##_call_cmp_key); \
return (type *)OPENSSL_lh_retrieve_key((const _LHASH *)lh, &cb, key_hash, \
lh_##type##_call_cmp_key); \
} \
\
OPENSSL_INLINE int lh_##type##_insert(LHASH_OF(type) *lh, type **old_data, \
type *data) { \
void *old_data_void = NULL; \
int ret = \
lh_insert((_LHASH *)lh, &old_data_void, data, \
lh_##type##_call_hash_func, lh_##type##_call_cmp_func); \
int ret = OPENSSL_lh_insert((_LHASH *)lh, &old_data_void, data, \
lh_##type##_call_hash_func, \
lh_##type##_call_cmp_func); \
*old_data = (type *)old_data_void; \
return ret; \
} \
\
OPENSSL_INLINE type *lh_##type##_delete(LHASH_OF(type) *lh, \
const type *data) { \
return (type *)lh_delete((_LHASH *)lh, data, lh_##type##_call_hash_func, \
lh_##type##_call_cmp_func); \
return (type *)OPENSSL_lh_delete((_LHASH *)lh, data, \
lh_##type##_call_hash_func, \
lh_##type##_call_cmp_func); \
} \
\
typedef struct { \
@ -249,13 +248,13 @@ OPENSSL_EXPORT uint32_t lh_strhash(const char *c);
OPENSSL_INLINE void lh_##type##_doall(LHASH_OF(type) *lh, \
void (*func)(type *)) { \
LHASH_DOALL_##type cb = {func, NULL, NULL}; \
lh_doall_arg((_LHASH *)lh, lh_##type##_call_doall, &cb); \
OPENSSL_lh_doall_arg((_LHASH *)lh, lh_##type##_call_doall, &cb); \
} \
\
OPENSSL_INLINE void lh_##type##_doall_arg( \
LHASH_OF(type) *lh, void (*func)(type *, void *), void *arg) { \
LHASH_DOALL_##type cb = {NULL, func, arg}; \
lh_doall_arg((_LHASH *)lh, lh_##type##_call_doall_arg, &cb); \
OPENSSL_lh_doall_arg((_LHASH *)lh, lh_##type##_call_doall_arg, &cb); \
}

40
crypto/lhash/lhash.c
Unescape View File

@ -103,7 +103,7 @@ struct lhash_st {
lhash_hash_func hash;
};
_LHASH *lh_new(lhash_hash_func hash, lhash_cmp_func comp) {
_LHASH *OPENSSL_lh_new(lhash_hash_func hash, lhash_cmp_func comp) {
_LHASH *ret = OPENSSL_malloc(sizeof(_LHASH));
if (ret == NULL) {
return NULL;
@ -123,7 +123,7 @@ _LHASH *lh_new(lhash_hash_func hash, lhash_cmp_func comp) {
return ret;
}
void lh_free(_LHASH *lh) {
void OPENSSL_lh_free(_LHASH *lh) {
if (lh == NULL) {
return;
}
@ -140,7 +140,7 @@ void lh_free(_LHASH *lh) {
OPENSSL_free(lh);
}
size_t lh_num_items(const _LHASH *lh) { return lh->num_items; }
size_t OPENSSL_lh_num_items(const _LHASH *lh) { return lh->num_items; }
// get_next_ptr_and_hash returns a pointer to the pointer that points to the
// item equal to |data|. In other words, it searches for an item equal to |data|
@ -186,16 +186,18 @@ static LHASH_ITEM **get_next_ptr_by_key(const _LHASH *lh, const void *key,
return ret;
}
void *lh_retrieve(const _LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func) {
void *OPENSSL_lh_retrieve(const _LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func) {
LHASH_ITEM **next_ptr =
get_next_ptr_and_hash(lh, NULL, data, call_hash_func, call_cmp_func);
return *next_ptr == NULL ? NULL : (*next_ptr)->data;
}
void *lh_retrieve_key(const _LHASH *lh, const void *key, uint32_t key_hash,
int (*cmp_key)(const void *key, const void *value)) {
void *OPENSSL_lh_retrieve_key(const _LHASH *lh, const void *key,
uint32_t key_hash,
int (*cmp_key)(const void *key,
const void *value)) {
LHASH_ITEM **next_ptr = get_next_ptr_by_key(lh, key, key_hash, cmp_key);
return *next_ptr == NULL ? NULL : (*next_ptr)->data;
}
@ -263,9 +265,9 @@ static void lh_maybe_resize(_LHASH *lh) {
}
}
int lh_insert(_LHASH *lh, void **old_data, void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func) {
int OPENSSL_lh_insert(_LHASH *lh, void **old_data, void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func) {
uint32_t hash;
LHASH_ITEM **next_ptr, *item;
@ -298,9 +300,9 @@ int lh_insert(_LHASH *lh, void **old_data, void *data,
return 1;
}
void *lh_delete(_LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func) {
void *OPENSSL_lh_delete(_LHASH *lh, const void *data,
lhash_hash_func_helper call_hash_func,
lhash_cmp_func_helper call_cmp_func) {
LHASH_ITEM **next_ptr, *item, *ret;
next_ptr =
@ -322,7 +324,7 @@ void *lh_delete(_LHASH *lh, const void *data,
return ret;
}
void lh_doall_arg(_LHASH *lh, void (*func)(void *, void *), void *arg) {
void OPENSSL_lh_doall_arg(_LHASH *lh, void (*func)(void *, void *), void *arg) {
if (lh == NULL) {
return;
}
@ -349,11 +351,3 @@ void lh_doall_arg(_LHASH *lh, void (*func)(void *, void *), void *arg) {
// resizing is done here.
lh_maybe_resize(lh);
}
uint32_t lh_strhash(const char *c) {
if (c == NULL) {
return 0;
}
return OPENSSL_hash32(c, strlen(c));
}

6
crypto/lhash/lhash_test.cc
Unescape View File

@ -25,6 +25,8 @@
#include <utility>
#include <vector>
#include <openssl/mem.h>
#include <gtest/gtest.h>
#include "internal.h"
@ -60,7 +62,7 @@ static const char *Lookup(
TEST(LHashTest, Basic) {
std::unique_ptr<LHASH_OF(char), FreeLHASH_OF_char> lh(
lh_char_new(lh_strhash, strcmp));
lh_char_new(OPENSSL_strhash, strcmp));
ASSERT_TRUE(lh);
// lh is expected to store a canonical instance of each string. dummy_lh
@ -118,7 +120,7 @@ TEST(LHashTest, Basic) {
// Do the same lookup with |lh_char_retrieve_key|.
value = lh_char_retrieve_key(
lh.get(), &key, lh_strhash(key.get()),
lh.get(), &key, OPENSSL_strhash(key.get()),
[](const void *key_ptr, const char *data) -> int {
const char *key_data =
reinterpret_cast<const std::unique_ptr<char[]> *>(key_ptr)

2
crypto/mem.c
Unescape View File

@ -247,6 +247,8 @@ uint32_t OPENSSL_hash32(const void *ptr, size_t len) {
return h;
}
uint32_t OPENSSL_strhash(const char *s) { return OPENSSL_hash32(s, strlen(s)); }
size_t OPENSSL_strnlen(const char *s, size_t len) {
for (size_t i = 0; i < len; i++) {
if (s[i] == 0) {

4
crypto/obj/obj.c
Unescape View File

@ -485,7 +485,7 @@ static int cmp_data(const ASN1_OBJECT *a, const ASN1_OBJECT *b) {
}
static uint32_t hash_short_name(const ASN1_OBJECT *obj) {
return lh_strhash(obj->sn);
return OPENSSL_strhash(obj->sn);
}
static int cmp_short_name(const ASN1_OBJECT *a, const ASN1_OBJECT *b) {
@ -493,7 +493,7 @@ static int cmp_short_name(const ASN1_OBJECT *a, const ASN1_OBJECT *b) {
}
static uint32_t hash_long_name(const ASN1_OBJECT *obj) {
return lh_strhash(obj->ln);
return OPENSSL_strhash(obj->ln);
}
static int cmp_long_name(const ASN1_OBJECT *a, const ASN1_OBJECT *b) {

3
include/openssl/mem.h
Unescape View File

@ -101,6 +101,9 @@ OPENSSL_EXPORT int CRYPTO_memcmp(const void *a, const void *b, size_t len);
// OPENSSL_hash32 implements the 32 bit, FNV-1a hash.
OPENSSL_EXPORT uint32_t OPENSSL_hash32(const void *ptr, size_t len);
// OPENSSL_strhash calls |OPENSSL_hash32| on the NUL-terminated string |s|.
OPENSSL_EXPORT uint32_t OPENSSL_strhash(const char *s);
// OPENSSL_strdup has the same behaviour as strdup(3).
OPENSSL_EXPORT char *OPENSSL_strdup(const char *s);

Write Preview
Loading…
Cancel
Save