addressed review comment part 2 moving BY_DIR_xxx functions to internal

src/internal.c

@@ -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

src/ssl.c

@@ -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");

tests/api.c

@@ -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();

wolfssl/internal.h

@@ -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" */

wolfssl/ssl.h

@@ -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*);