wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-08-01 03:34:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

addressed review comment part 2 moving BY_DIR_xxx functions to internal

Browse Source
This commit is contained in:
Hideki Miyazaki
2021-03-11 16:51:36 +09:00
parent 4650aaf4fb
commit 84368eed3f
5 changed files with 419 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

387
src/internal.c
View File

@@ -31601,6 +31601,393 @@ int wolfSSL_GetMaxRecordSize(WOLFSSL* ssl, int maxFragment)
return maxFragment;
}
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
/* create an instance of WOLFSSL_BY_DIR_HASH structure */
WOLFSSL_BY_DIR_HASH* wolfSSL_BY_DIR_HASH_new(void)
{
WOLFSSL_BY_DIR_HASH* dir_hash;
WOLFSSL_ENTER("wolfSSL_BY_DIR_HASH_new");
dir_hash = (WOLFSSL_BY_DIR_HASH*)XMALLOC(sizeof(WOLFSSL_BY_DIR_HASH), NULL,
DYNAMIC_TYPE_OPENSSL);
if (dir_hash) {
XMEMSET(dir_hash, 0, sizeof(WOLFSSL_BY_DIR_HASH));
}
return dir_hash;
}
/* release a WOLFSSL_BY_DIR_HASH resource */
void wolfSSL_BY_DIR_HASH_free(WOLFSSL_BY_DIR_HASH* dir_hash)
{
if (dir_hash == NULL)
return;
XFREE(dir_hash, NULL, DYNAMIC_TYPE_OPENSSL);
}
/* create an instance of WOLFSSL_STACK for STACK_TYPE_BY_DIR_hash */
WOLFSSL_STACK* wolfSSL_sk_BY_DIR_HASH_new_null(void)
{
WOLFSSL_STACK* sk = wolfSSL_sk_new_node(NULL);
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_new_null");
if (sk) {
sk->type = STACK_TYPE_BY_DIR_hash;
}
return sk;
}
/* returns value less than 0 on fail to match
* On a successful match the priority level found is returned
*/
int wolfSSL_sk_BY_DIR_HASH_find(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk, const WOLFSSL_BY_DIR_HASH* toFind)
{
WOLFSSL_STACK* next;
int i, sz;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_find");
if (sk == NULL || toFind == NULL) {
return WOLFSSL_FAILURE;
}
sz = wolfSSL_sk_BY_DIR_HASH_num(sk);
next = sk;
for (i = 0; i < sz && next != NULL; i++) {
if (next->data.dir_hash->hash_value == toFind->hash_value) {
return sz - i; /* reverse because stack pushed highest on first */
}
next = next->next;
}
return -1;
}
/* return a number of WOLFSSL_BY_DIR_HASH in stack */
int wolfSSL_sk_BY_DIR_HASH_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_num");
if (sk == NULL)
return -1;
return (int)sk->num;
}
/* return WOLFSSL_BY_DIR_HASH instance at i */
WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk, int i)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_value");
for (; sk != NULL && i > 0; i--)
sk = sk->next;
if (i != 0 || sk == NULL)
return NULL;
return sk->data.dir_hash;
}
/* pop WOLFSSL_BY_DIR_HASH instance, and remove its node from stack */
WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk)
{
WOLFSSL_STACK* node;
WOLFSSL_BY_DIR_HASH* hash;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_pop");
if (sk == NULL) {
return NULL;
}
node = sk->next;
hash = sk->data.dir_hash;
if (node != NULL) { /* update sk and remove node from stack */
sk->data.dir_hash = node->data.dir_hash;
sk->next = node->next;
wolfSSL_sk_free_node(node);
}
else { /* last x509 in stack */
sk->data.dir_hash = NULL;
}
if (sk->num > 0) {
sk->num -= 1;
}
return hash;
}
/* release all contents in stack, and then release stack itself. */
/* Second argument is a function pointer to release resouces. */
/* It calls the function to release resouces when t is passed */
/* instead of wolfSSL_BY_DIR_HASH_free(). */
void wolfSSL_sk_BY_DIR_HASH_pop_free(WOLF_STACK_OF(BY_DIR_HASH)* sk,
void (*f) (WOLFSSL_BY_DIR_HASH*))
{
WOLFSSL_STACK* node;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_pop_free");
if (sk == NULL) {
return;
}
/* parse through stack freeing each node */
node = sk->next;
while (node && sk->num > 1) {
WOLFSSL_STACK* tmp = node;
node = node->next;
if (f)
f(tmp->data.dir_hash);
else
wolfSSL_BY_DIR_HASH_free(tmp->data.dir_hash);
tmp->data.dir_hash = NULL;
XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL);
sk->num -= 1;
}
/* free head of stack */
if (sk->num == 1) {
if (f)
f(sk->data.dir_hash);
else
wolfSSL_BY_DIR_HASH_free(sk->data.dir_hash);
sk->data.dir_hash = NULL;
}
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
}
/* release all contents in stack, and then release stack itself */
void wolfSSL_sk_BY_DIR_HASH_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk)
{
wolfSSL_sk_BY_DIR_HASH_pop_free(sk, NULL);
}
/* Adds the WOLFSSL_BY_DIR_HASH to the stack "sk". "sk" takes control of "in" and
* tries to free it when the stack is free'd.
*
* return 1 on success 0 on fail
*/
int wolfSSL_sk_BY_DIR_HASH_push(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk,
WOLFSSL_BY_DIR_HASH* in)
{
WOLFSSL_STACK* node;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_push");
if (sk == NULL || in == NULL) {
return WOLFSSL_FAILURE;
}
/* no previous values in stack */
if (sk->data.dir_hash == NULL) {
sk->data.dir_hash = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
/* stack already has value(s) create a new node and add more */
node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL,
DYNAMIC_TYPE_OPENSSL);
if (node == NULL) {
WOLFSSL_MSG("Memory error");
return WOLFSSL_FAILURE;
}
XMEMSET(node, 0, sizeof(WOLFSSL_STACK));
/* push new obj onto head of stack */
node->data.dir_hash = sk->data.dir_hash;
node->next = sk->next;
node->type = sk->type;
sk->next = node;
sk->data.dir_hash = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
/* create an instance of WOLFSSL_BY_DIR_entry structure */
WOLFSSL_BY_DIR_entry* wolfSSL_BY_DIR_entry_new(void)
{
WOLFSSL_BY_DIR_entry* entry;
WOLFSSL_ENTER("wolfSSL_BY_DIR_entry_new");
entry = (WOLFSSL_BY_DIR_entry*)XMALLOC(sizeof(WOLFSSL_BY_DIR_entry), NULL,
DYNAMIC_TYPE_OPENSSL);
if (entry) {
XMEMSET(entry, 0, sizeof(WOLFSSL_BY_DIR_entry));
}
return entry;
}
/* release a WOLFSSL_BY_DIR_entry resource */
void wolfSSL_BY_DIR_entry_free(WOLFSSL_BY_DIR_entry* entry)
{
WOLFSSL_ENTER("wolfSSL_BY_DIR_entry_free");
if (entry == NULL)
return;
if (entry->hashes) {
wolfSSL_sk_BY_DIR_HASH_free(entry->hashes);
}
if (entry->dir_name != NULL) {
XFREE(entry->dir_name, NULL, DYNAMIC_TYPE_OPENSSL);
}
XFREE(entry, NULL, DYNAMIC_TYPE_OPENSSL);
}
WOLFSSL_STACK* wolfSSL_sk_BY_DIR_entry_new_null(void)
{
WOLFSSL_STACK* sk = wolfSSL_sk_new_node(NULL);
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_new_null");
if (sk) {
sk->type = STACK_TYPE_BY_DIR_entry;
}
return sk;
}
/* return a number of WOLFSSL_BY_DIR_entry in stack */
int wolfSSL_sk_BY_DIR_entry_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_num");
if (sk == NULL)
return -1;
return (int)sk->num;
}
/* return WOLFSSL_BY_DIR_entry instance at i */
WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk, int i)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_value");
for (; sk != NULL && i > 0; i--)
sk = sk->next;
if (i != 0 || sk == NULL)
return NULL;
return sk->data.dir_entry;
}
/* pop WOLFSSL_BY_DIR_entry instance first, and remove its node from stack */
WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk)
{
WOLFSSL_STACK* node;
WOLFSSL_BY_DIR_entry* entry;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_pop");
if (sk == NULL) {
return NULL;
}
node = sk->next;
entry = sk->data.dir_entry;
if (node != NULL) { /* update sk and remove node from stack */
sk->data.dir_entry = node->data.dir_entry;
sk->next = node->next;
wolfSSL_sk_free_node(node);
}
else { /* last x509 in stack */
sk->data.dir_entry = NULL;
}
if (sk->num > 0) {
sk->num -= 1;
}
return entry;
}
/* release all contents in stack, and then release stack itself. */
/* Second argument is a function pointer to release resouces. */
/* It calls the function to release resouces when t is passed */
/* instead of wolfSSL_BY_DIR_entry_free(). */
void wolfSSL_sk_BY_DIR_entry_pop_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk,
void (*f) (WOLFSSL_BY_DIR_entry*))
{
WOLFSSL_STACK* node;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_pop_free");
if (sk == NULL) {
return;
}
/* parse through stack freeing each node */
node = sk->next;
while (node && sk->num > 1) {
WOLFSSL_STACK* tmp = node;
node = node->next;
if (f)
f(tmp->data.dir_entry);
else
wolfSSL_BY_DIR_entry_free(tmp->data.dir_entry);
tmp->data.dir_entry = NULL;
XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL);
sk->num -= 1;
}
/* free head of stack */
if (sk->num == 1) {
if (f)
f(sk->data.dir_entry);
else
wolfSSL_BY_DIR_entry_free(sk->data.dir_entry);
sk->data.dir_entry = NULL;
}
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
}
/* release all contents in stack, and then release stack itself */
void wolfSSL_sk_BY_DIR_entry_free(WOLF_STACK_OF(wolfSSL_BY_DIR_entry) *sk)
{
wolfSSL_sk_BY_DIR_entry_pop_free(sk, NULL);
}
/* Adds the wolfSSL_BY_DIR_entry to the stack "sk". "sk" takes control of "in" and
* tries to free it when the stack is free'd.
*
* return 1 on success 0 on fail
*/
int wolfSSL_sk_BY_DIR_entry_push(WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk,
WOLFSSL_BY_DIR_entry* in)
{
WOLFSSL_STACK* node;
if (sk == NULL || in == NULL) {
return WOLFSSL_FAILURE;
}
/* no previous values in stack */
if (sk->data.dir_entry == NULL) {
sk->data.dir_entry = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
/* stack already has value(s) create a new node and add more */
node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL,
DYNAMIC_TYPE_OPENSSL);
if (node == NULL) {
WOLFSSL_MSG("Memory error");
return WOLFSSL_FAILURE;
}
XMEMSET(node, 0, sizeof(WOLFSSL_STACK));
/* push new obj onto head of stack */
node->data.dir_entry = sk->data.dir_entry;
node->next = sk->next;
node->type = sk->type;
sk->next = node;
sk->data.dir_entry = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
#endif /* OPENSSL_ALL */
#undef ERROR_OUT

386
src/ssl.c
View File

@@ -46360,392 +46360,6 @@ void wolfSSL_sk_SSL_CIPHER_free(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk)
}
}
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
/* create an instance of WOLFSSL_BY_DIR_HASH structure */
WOLFSSL_BY_DIR_HASH* wolfSSL_BY_DIR_HASH_new(void)
{
WOLFSSL_BY_DIR_HASH* dir_hash;
WOLFSSL_ENTER("wolfSSL_BY_DIR_HASH_new");
dir_hash = (WOLFSSL_BY_DIR_HASH*)XMALLOC(sizeof(WOLFSSL_BY_DIR_HASH), NULL,
DYNAMIC_TYPE_OPENSSL);
if (dir_hash) {
XMEMSET(dir_hash, 0, sizeof(WOLFSSL_BY_DIR_HASH));
}
return dir_hash;
}
/* release a WOLFSSL_BY_DIR_HASH resource */
void wolfSSL_BY_DIR_HASH_free(WOLFSSL_BY_DIR_HASH* dir_hash)
{
if (dir_hash == NULL)
return;
XFREE(dir_hash, NULL, DYNAMIC_TYPE_OPENSSL);
}
/* create an instance of WOLFSSL_STACK for STACK_TYPE_BY_DIR_hash */
WOLFSSL_STACK* wolfSSL_sk_BY_DIR_HASH_new_null(void)
{
WOLFSSL_STACK* sk = wolfSSL_sk_new_node(NULL);
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_new_null");
if (sk) {
sk->type = STACK_TYPE_BY_DIR_hash;
}
return sk;
}
/* returns value less than 0 on fail to match
* On a successful match the priority level found is returned
*/
int wolfSSL_sk_BY_DIR_HASH_find(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk, const WOLFSSL_BY_DIR_HASH* toFind)
{
WOLFSSL_STACK* next;
int i, sz;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_find");
if (sk == NULL || toFind == NULL) {
return WOLFSSL_FAILURE;
}
sz = wolfSSL_sk_BY_DIR_HASH_num(sk);
next = sk;
for (i = 0; i < sz && next != NULL; i++) {
if (next->data.dir_hash->hash_value == toFind->hash_value) {
return sz - i; /* reverse because stack pushed highest on first */
}
next = next->next;
}
return -1;
}
/* return a number of WOLFSSL_BY_DIR_HASH in stack */
int wolfSSL_sk_BY_DIR_HASH_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_num");
if (sk == NULL)
return -1;
return (int)sk->num;
}
/* return WOLFSSL_BY_DIR_HASH instance at i */
WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk, int i)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_value");
for (; sk != NULL && i > 0; i--)
sk = sk->next;
if (i != 0 || sk == NULL)
return NULL;
return sk->data.dir_hash;
}
/* pop WOLFSSL_BY_DIR_HASH instance, and remove its node from stack */
WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk)
{
WOLFSSL_STACK* node;
WOLFSSL_BY_DIR_HASH* hash;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_pop");
if (sk == NULL) {
return NULL;
}
node = sk->next;
hash = sk->data.dir_hash;
if (node != NULL) { /* update sk and remove node from stack */
sk->data.dir_hash = node->data.dir_hash;
sk->next = node->next;
wolfSSL_sk_free_node(node);
}
else { /* last x509 in stack */
sk->data.dir_hash = NULL;
}
if (sk->num > 0) {
sk->num -= 1;
}
return hash;
}
/* release all contents in stack, and then release stack itself. */
/* Second argument is a function pointer to release resouces. */
/* It calls the function to release resouces when t is passed */
/* instead of wolfSSL_BY_DIR_HASH_free(). */
void wolfSSL_sk_BY_DIR_HASH_pop_free(WOLF_STACK_OF(BY_DIR_HASH)* sk,
void (*f) (WOLFSSL_BY_DIR_HASH*))
{
WOLFSSL_STACK* node;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_pop_free");
if (sk == NULL) {
return;
}
/* parse through stack freeing each node */
node = sk->next;
while (node && sk->num > 1) {
WOLFSSL_STACK* tmp = node;
node = node->next;
if (f)
f(tmp->data.dir_hash);
else
wolfSSL_BY_DIR_HASH_free(tmp->data.dir_hash);
tmp->data.dir_hash = NULL;
XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL);
sk->num -= 1;
}
/* free head of stack */
if (sk->num == 1) {
if (f)
f(sk->data.dir_hash);
else
wolfSSL_BY_DIR_HASH_free(sk->data.dir_hash);
sk->data.dir_hash = NULL;
}
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
}
/* release all contents in stack, and then release stack itself */
void wolfSSL_sk_BY_DIR_HASH_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk)
{
wolfSSL_sk_BY_DIR_HASH_pop_free(sk, NULL);
}
/* Adds the WOLFSSL_BY_DIR_HASH to the stack "sk". "sk" takes control of "in" and
* tries to free it when the stack is free'd.
*
* return 1 on success 0 on fail
*/
int wolfSSL_sk_BY_DIR_HASH_push(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk,
WOLFSSL_BY_DIR_HASH* in)
{
WOLFSSL_STACK* node;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_HASH_push");
if (sk == NULL || in == NULL) {
return WOLFSSL_FAILURE;
}
/* no previous values in stack */
if (sk->data.dir_hash == NULL) {
sk->data.dir_hash = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
/* stack already has value(s) create a new node and add more */
node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL,
DYNAMIC_TYPE_OPENSSL);
if (node == NULL) {
WOLFSSL_MSG("Memory error");
return WOLFSSL_FAILURE;
}
XMEMSET(node, 0, sizeof(WOLFSSL_STACK));
/* push new obj onto head of stack */
node->data.dir_hash = sk->data.dir_hash;
node->next = sk->next;
node->type = sk->type;
sk->next = node;
sk->data.dir_hash = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
/* create an instance of WOLFSSL_BY_DIR_entry structure */
WOLFSSL_BY_DIR_entry* wolfSSL_BY_DIR_entry_new(void)
{
WOLFSSL_BY_DIR_entry* entry;
WOLFSSL_ENTER("wolfSSL_BY_DIR_entry_new");
entry = (WOLFSSL_BY_DIR_entry*)XMALLOC(sizeof(WOLFSSL_BY_DIR_entry), NULL,
DYNAMIC_TYPE_OPENSSL);
if (entry) {
XMEMSET(entry, 0, sizeof(WOLFSSL_BY_DIR_entry));
}
return entry;
}
/* release a WOLFSSL_BY_DIR_entry resource */
void wolfSSL_BY_DIR_entry_free(WOLFSSL_BY_DIR_entry* entry)
{
WOLFSSL_ENTER("wolfSSL_BY_DIR_entry_free");
if (entry == NULL)
return;
if (entry->hashes) {
wolfSSL_sk_BY_DIR_HASH_free(entry->hashes);
}
if (entry->dir_name != NULL) {
XFREE(entry->dir_name, NULL, DYNAMIC_TYPE_OPENSSL);
}
XFREE(entry, NULL, DYNAMIC_TYPE_OPENSSL);
}
WOLFSSL_STACK* wolfSSL_sk_BY_DIR_entry_new_null(void)
{
WOLFSSL_STACK* sk = wolfSSL_sk_new_node(NULL);
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_new_null");
if (sk) {
sk->type = STACK_TYPE_BY_DIR_entry;
}
return sk;
}
/* return a number of WOLFSSL_BY_DIR_entry in stack */
int wolfSSL_sk_BY_DIR_entry_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_num");
if (sk == NULL)
return -1;
return (int)sk->num;
}
/* return WOLFSSL_BY_DIR_entry instance at i */
WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk, int i)
{
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_value");
for (; sk != NULL && i > 0; i--)
sk = sk->next;
if (i != 0 || sk == NULL)
return NULL;
return sk->data.dir_entry;
}
/* pop WOLFSSL_BY_DIR_entry instance first, and remove its node from stack */
WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk)
{
WOLFSSL_STACK* node;
WOLFSSL_BY_DIR_entry* entry;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_pop");
if (sk == NULL) {
return NULL;
}
node = sk->next;
entry = sk->data.dir_entry;
if (node != NULL) { /* update sk and remove node from stack */
sk->data.dir_entry = node->data.dir_entry;
sk->next = node->next;
wolfSSL_sk_free_node(node);
}
else { /* last x509 in stack */
sk->data.dir_entry = NULL;
}
if (sk->num > 0) {
sk->num -= 1;
}
return entry;
}
/* release all contents in stack, and then release stack itself */
/* it uses function when it is passed */
void wolfSSL_sk_BY_DIR_entry_pop_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk,
void (*f) (WOLFSSL_BY_DIR_entry*))
{
WOLFSSL_STACK* node;
WOLFSSL_ENTER("wolfSSL_sk_BY_DIR_entry_pop_free");
if (sk == NULL) {
return;
}
/* parse through stack freeing each node */
node = sk->next;
while (node && sk->num > 1) {
WOLFSSL_STACK* tmp = node;
node = node->next;
if (f)
f(tmp->data.dir_entry);
else
wolfSSL_BY_DIR_entry_free(tmp->data.dir_entry);
tmp->data.dir_entry = NULL;
XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL);
sk->num -= 1;
}
/* free head of stack */
if (sk->num == 1) {
if (f)
f(sk->data.dir_entry);
else
wolfSSL_BY_DIR_entry_free(sk->data.dir_entry);
sk->data.dir_entry = NULL;
}
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
}
/* release all contents in stack, and then release stack itself */
void wolfSSL_sk_BY_DIR_entry_free(WOLF_STACK_OF(wolfSSL_BY_DIR_entry) *sk)
{
wolfSSL_sk_BY_DIR_entry_pop_free(sk, NULL);
}
/* Adds the wolfSSL_BY_DIR_entry to the stack "sk". "sk" takes control of "in" and
* tries to free it when the stack is free'd.
*
* return 1 on success 0 on fail
*/
int wolfSSL_sk_BY_DIR_entry_push(WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk,
WOLFSSL_BY_DIR_entry* in)
{
WOLFSSL_STACK* node;
if (sk == NULL || in == NULL) {
return WOLFSSL_FAILURE;
}
/* no previous values in stack */
if (sk->data.dir_entry == NULL) {
sk->data.dir_entry = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
/* stack already has value(s) create a new node and add more */
node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL,
DYNAMIC_TYPE_OPENSSL);
if (node == NULL) {
WOLFSSL_MSG("Memory error");
return WOLFSSL_FAILURE;
}
XMEMSET(node, 0, sizeof(WOLFSSL_STACK));
/* push new obj onto head of stack */
node->data.dir_entry = sk->data.dir_entry;
node->next = sk->next;
node->type = sk->type;
sk->next = node;
sk->data.dir_entry = in;
sk->num += 1;
return WOLFSSL_SUCCESS;
}
#endif /* OPENSSL_ALL */
int wolfSSL_sk_X509_INFO_num(const WOLF_STACK_OF(WOLFSSL_X509_INFO) *sk)
{
WOLFSSL_ENTER("wolfSSL_sk_X509_INFO_num");

153
tests/api.c
View File

@@ -25732,138 +25732,6 @@ static void test_wolfSSL_X509_NAME(void)
#endif /* defined(OPENSSL_EXTRA) && !defined(NO_DES3) */
}
static void test_wolfSSL_sk_X509_BY_DIR_HASH(void)
{
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
STACK_OF(WOLFSSL_BY_DIR_HASH) *hash_stack;
WOLFSSL_BY_DIR_HASH *hash1;
WOLFSSL_BY_DIR_HASH *hash2;
WOLFSSL_BY_DIR_HASH *h;
const unsigned long dummy_hash[2] = {
0x12345678,
0x9abcdef0
};
int i, num;
printf(testingFmt, "test_wolfSSL_sk_X509_BY_DIR_HASH");
/* new */
AssertNotNull(hash1 = wolfSSL_BY_DIR_HASH_new());
hash1->hash_value = dummy_hash[0];
AssertNotNull(hash2 = wolfSSL_BY_DIR_HASH_new());
hash2->hash_value = dummy_hash[1];
AssertNotNull(hash_stack = wolfSSL_sk_BY_DIR_HASH_new_null());
/* push */
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_push(NULL, NULL),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_push(NULL, hash1),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_push(hash_stack, NULL),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_push(hash_stack, hash1),
WOLFSSL_SUCCESS);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_push(hash_stack,
hash2), WOLFSSL_SUCCESS);
/* num and value */
AssertIntEQ((num = wolfSSL_sk_BY_DIR_HASH_num(hash_stack)), 2);
for (i = 0; i < num; i++) {
AssertNotNull(h = wolfSSL_sk_BY_DIR_HASH_value(hash_stack, i));
AssertTrue(h->hash_value == dummy_hash[num - i - 1]);
}
/* pop */
AssertNotNull(h = wolfSSL_sk_BY_DIR_HASH_pop(hash_stack));
AssertIntEQ((num = wolfSSL_sk_BY_DIR_HASH_num(hash_stack)), 1);
/* find */
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_find(NULL, NULL),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_find(NULL, hash1),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_find(hash_stack, NULL),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_HASH_push(hash_stack, hash2),
1);
/* free */
wolfSSL_sk_BY_DIR_HASH_free(hash_stack);
printf(resultFmt, passed);
#endif
}
static void test_wolfSSL_sk_X509_BY_DIR(void)
{
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
STACK_OF(WOLFSSL_BY_DIR_entry) *entry_stack;
WOLFSSL_BY_DIR_entry *entry1;
WOLFSSL_BY_DIR_entry *entry2;
WOLFSSL_BY_DIR_entry *ent;
const char* dummy_dir[2] = {
"/hoge/hoge/foo/foo",
"/foo1/hoge2/abc/defg"
};
int i, num;
size_t len;
printf(testingFmt, "test_wolfSSL_X509_sk_BY_DIR");
/* new */
AssertNotNull(entry1 = wolfSSL_BY_DIR_entry_new());
len = XSTRLEN(dummy_dir[0]);
entry1->dir_name = (char*)XMALLOC(len + 1, NULL, DYNAMIC_TYPE_OPENSSL);
AssertNotNull(entry1->dir_name);
XMEMSET(entry1->dir_name, 0, len + 1);
XSTRNCPY(entry1->dir_name, dummy_dir[0], len + 1);
AssertNotNull(entry2 = wolfSSL_BY_DIR_entry_new());
len = XSTRLEN(dummy_dir[1]);
entry2->dir_name = (char*)XMALLOC(len + 1, NULL, DYNAMIC_TYPE_OPENSSL);
AssertNotNull(entry2->dir_name);
XMEMSET(entry2->dir_name, 0, len + 1);
XSTRNCPY(entry2->dir_name, dummy_dir[1], len + 1);
AssertNotNull(entry_stack = wolfSSL_sk_BY_DIR_entry_new_null());
/* push */
AssertIntEQ(wolfSSL_sk_BY_DIR_entry_push(NULL, NULL),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_entry_push(NULL, entry1),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_entry_push(entry_stack, NULL),
WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_sk_BY_DIR_entry_push(entry_stack, entry1),
WOLFSSL_SUCCESS);
AssertIntEQ(wolfSSL_sk_BY_DIR_entry_push(entry_stack,
entry2), WOLFSSL_SUCCESS);
/* num and value */
AssertIntEQ((num = wolfSSL_sk_BY_DIR_entry_num(entry_stack)), 2);
for (i = 0; i < num; i++) {
AssertNotNull(ent = wolfSSL_sk_BY_DIR_entry_value(entry_stack, i));
len = XSTRLEN(dummy_dir[num - i - 1]);
AssertTrue(XSTRLEN(ent->dir_name) == len);
AssertIntEQ(XSTRNCMP(ent->dir_name, dummy_dir[num - i - 1], len), 0);
}
/* pop */
AssertNotNull(ent = wolfSSL_sk_BY_DIR_entry_pop(entry_stack));
AssertIntEQ((len = wolfSSL_sk_BY_DIR_entry_num(entry_stack)), 1);
wolfSSL_BY_DIR_entry_free(ent);
/* free */
wolfSSL_sk_BY_DIR_entry_free(entry_stack);
printf(resultFmt, passed);
#endif
}
#ifndef NO_BIO
static void test_wolfSSL_X509_INFO(void)
{
@@ -28177,12 +28045,10 @@ static void test_wolfSSL_X509_LOOKUP_ctrl_hash_dir(void)
char *p;
X509_STORE* str;
X509_LOOKUP* lookup;
WOLFSSL_BY_DIR_entry *dir;
WOLFSSL_STACK* sk = NULL;
int num = 0, len, total_len, i;
int len, total_len, i;
(void) sk;
(void) num;
printf(testingFmt, "test_wolfSSL_X509_LOOKUP_ctrl_hash_dir()");
@@ -28203,13 +28069,6 @@ static void test_wolfSSL_X509_LOOKUP_ctrl_hash_dir(void)
AssertIntEQ(X509_LOOKUP_ctrl(lookup, X509_L_ADD_DIR, "./",
SSL_FILETYPE_PEM,NULL), 1);
AssertNotNull(sk = lookup->dirs->dir_entry);
AssertIntEQ((num = wolfSSL_sk_BY_DIR_entry_num(sk)), 1);
dir = wolfSSL_sk_BY_DIR_entry_value(sk, 0);
AssertIntEQ(XSTRLEN((const char*)dir->dir_name), XSTRLEN("./"));
AssertIntEQ(XMEMCMP(dir->dir_name, "./",
XSTRLEN((const char*)dir->dir_name)), 0);
/* free store */
X509_STORE_free(str);
@@ -28230,14 +28089,6 @@ static void test_wolfSSL_X509_LOOKUP_ctrl_hash_dir(void)
AssertIntEQ(X509_LOOKUP_ctrl(lookup, X509_L_ADD_DIR, CertCrl_path,
SSL_FILETYPE_PEM,NULL), 1);
AssertNotNull(sk = lookup->dirs->dir_entry);
AssertIntEQ((num = wolfSSL_sk_BY_DIR_entry_num(sk)), MAX_DIR);
for(i = 0; i<num; i++) {
dir = wolfSSL_sk_BY_DIR_entry_value(sk, i);
AssertIntEQ(XSTRLEN((const char*)dir->dir_name), XSTRLEN(paths[i]));
AssertIntEQ(XMEMCMP(dir->dir_name, paths[i],
XSTRLEN((const char*)dir->dir_name)), 0);
}
X509_STORE_free(str);
@@ -42057,8 +41908,6 @@ void ApiTest(void)
#ifndef NO_BIO
test_wolfSSL_X509_INFO();
#endif
test_wolfSSL_sk_X509_BY_DIR_HASH();
test_wolfSSL_sk_X509_BY_DIR();
test_wolfSSL_X509_subject_name_hash();
test_wolfSSL_X509_issuer_name_hash();
test_wolfSSL_X509_check_host();

31
wolfssl/internal.h
View File

@@ -4824,6 +4824,37 @@ WOLFSSL_LOCAL void FreeKey(WOLFSSL* ssl, int type, void** pKey);
WOLFSSL_LOCAL int LoadCrlCertByIssuer(WOLFSSL_X509_STORE* store,
X509_NAME* issuer, int Type);
#endif
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
WOLFSSL_LOCAL WOLFSSL_BY_DIR_HASH* wolfSSL_BY_DIR_HASH_new(void);
WOLFSSL_LOCAL void wolfSSL_BY_DIR_HASH_free(WOLFSSL_BY_DIR_HASH* dir_hash);
WOLFSSL_LOCAL WOLFSSL_STACK* wolfSSL_sk_BY_DIR_HASH_new_null(void);
WOLFSSL_LOCAL int wolfSSL_sk_BY_DIR_HASH_find(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk, const WOLFSSL_BY_DIR_HASH* toFind);
WOLFSSL_LOCAL int wolfSSL_sk_BY_DIR_HASH_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk);
WOLFSSL_LOCAL WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk, int i);
WOLFSSL_LOCAL WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk);
WOLFSSL_LOCAL void wolfSSL_sk_BY_DIR_HASH_pop_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk,
void (*f) (WOLFSSL_BY_DIR_HASH*));
WOLFSSL_LOCAL void wolfSSL_sk_BY_DIR_HASH_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk);
WOLFSSL_LOCAL int wolfSSL_sk_BY_DIR_HASH_push(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk,
WOLFSSL_BY_DIR_HASH* in);
/* WOLFSSL_BY_DIR_entry stuff */
WOLFSSL_LOCAL WOLFSSL_BY_DIR_entry* wolfSSL_BY_DIR_entry_new(void);
WOLFSSL_LOCAL void wolfSSL_BY_DIR_entry_free(WOLFSSL_BY_DIR_entry* entry);
WOLFSSL_LOCAL WOLFSSL_STACK* wolfSSL_sk_BY_DIR_entry_new_null(void);
WOLFSSL_LOCAL int wolfSSL_sk_BY_DIR_entry_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk);
WOLFSSL_LOCAL WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk, int i);
WOLFSSL_LOCAL WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk);
WOLFSSL_LOCAL void wolfSSL_sk_BY_DIR_entry_pop_free(WOLF_STACK_OF(wolfSSL_BY_DIR_entry)* sk,
void (*f) (WOLFSSL_BY_DIR_entry*));
WOLFSSL_LOCAL void wolfSSL_sk_BY_DIR_entry_free(WOLF_STACK_OF(wolfSSL_BY_DIR_entry) *sk);
WOLFSSL_LOCAL int wolfSSL_sk_BY_DIR_entry_push(WOLF_STACK_OF(wolfSSL_BY_DIR_entry)* sk,
WOLFSSL_BY_DIR_entry* in);
#endif /* OPENSSL_ALL && !NO_FILESYSTEM && !NO_WOLFSSL_DIR */
#ifdef __cplusplus
} /* extern "C" */

32
wolfssl/ssl.h
View File

@@ -3851,38 +3851,6 @@ WOLFSSL_API int wolfSSL_sk_CONF_VALUE_push(WOLF_STACK_OF(WOLFSSL_CONF_VALUE)* sk
WOLFSSL_CONF_VALUE* val);
#endif /* OPENSSL_ALL || HAVE_STUNNEL || WOLFSSL_NGINX || WOLFSSL_HAPROXY || OPENSSL_EXTRA || HAVE_LIGHTY */
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
WOLFSSL_API WOLFSSL_BY_DIR_HASH* wolfSSL_BY_DIR_HASH_new(void);
WOLFSSL_API void wolfSSL_BY_DIR_HASH_free(WOLFSSL_BY_DIR_HASH* dir_hash);
WOLFSSL_API WOLFSSL_STACK* wolfSSL_sk_BY_DIR_HASH_new_null(void);
WOLFSSL_API int wolfSSL_sk_BY_DIR_HASH_find(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk, const WOLFSSL_BY_DIR_HASH* toFind);
WOLFSSL_API int wolfSSL_sk_BY_DIR_HASH_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk);
WOLFSSL_API WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk, int i);
WOLFSSL_API WOLFSSL_BY_DIR_HASH* wolfSSL_sk_BY_DIR_HASH_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk);
WOLFSSL_API void wolfSSL_sk_BY_DIR_HASH_pop_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk,
void (*f) (WOLFSSL_BY_DIR_HASH*));
WOLFSSL_API void wolfSSL_sk_BY_DIR_HASH_free(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH) *sk);
WOLFSSL_API int wolfSSL_sk_BY_DIR_HASH_push(WOLF_STACK_OF(WOLFSSL_BY_DIR_HASH)* sk,
WOLFSSL_BY_DIR_HASH* in);
/* WOLFSSL_BY_DIR_entry stuff */
WOLFSSL_API WOLFSSL_BY_DIR_entry* wolfSSL_BY_DIR_entry_new(void);
WOLFSSL_API void wolfSSL_BY_DIR_entry_free(WOLFSSL_BY_DIR_entry* entry);
WOLFSSL_API WOLFSSL_STACK* wolfSSL_sk_BY_DIR_entry_new_null(void);
WOLFSSL_API int wolfSSL_sk_BY_DIR_entry_num(const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk);
WOLFSSL_API WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_value(
const WOLF_STACK_OF(WOLFSSL_BY_DIR_entry) *sk, int i);
WOLFSSL_API WOLFSSL_BY_DIR_entry* wolfSSL_sk_BY_DIR_entry_pop(
WOLF_STACK_OF(WOLFSSL_BY_DIR_entry)* sk);
WOLFSSL_API void wolfSSL_sk_BY_DIR_entry_pop_free(WOLF_STACK_OF(wolfSSL_BY_DIR_entry)* sk,
void (*f) (WOLFSSL_BY_DIR_entry*));
WOLFSSL_API void wolfSSL_sk_BY_DIR_entry_free(WOLF_STACK_OF(wolfSSL_BY_DIR_entry) *sk);
WOLFSSL_API int wolfSSL_sk_BY_DIR_entry_push(WOLF_STACK_OF(wolfSSL_BY_DIR_entry)* sk,
WOLFSSL_BY_DIR_entry* in);
#endif /* OPENSSL_ALL && !NO_FILESYSTEM && !NO_WOLFSSL_DIR */
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
WOLFSSL_API WOLFSSL_ASN1_BIT_STRING* wolfSSL_ASN1_BIT_STRING_new(void);
WOLFSSL_API void wolfSSL_ASN1_BIT_STRING_free(WOLFSSL_ASN1_BIT_STRING*);