Make BIO_get_new_index thread-safe with atomics, add test coverage

Author: kojo1

src/bio.c

@@ -2126,16 +2126,34 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on)
 #endif
 
 /* Return a new BIO type index, or WOLFSSL_FATAL_ERROR when exhausted.
- * Not thread-safe. */
+ * Thread-safe when atomic operations are available (like OpenSSL's
+ * BIO_get_new_index()); otherwise falls back to a plain counter. */
 int wolfSSL_BIO_get_new_index(void)
 {
+#if !defined(SINGLE_THREADED) && defined(WOLFSSL_ATOMIC_OPS) && \
+    defined(WOLFSSL_ATOMIC_INITIALIZER)
+    static wolfSSL_Atomic_Int wolfssl_bio_type_index =
+        WOLFSSL_ATOMIC_INITIALIZER(WOLFSSL_BIO_TYPE_START);
+    int idx = (int)wolfSSL_Atomic_Int_AddFetch(&wolfssl_bio_type_index, 1);
+
+    if (idx > 0xff) {
+        /* Back out the increment so repeated calls once exhausted cannot
+         * eventually wrap the counter. Concurrent failed calls each undo
+         * only their own increment, so no valid index is handed out twice. */
+        (void)wolfSSL_Atomic_Int_SubFetch(&wolfssl_bio_type_index, 1);
+        return WOLFSSL_FATAL_ERROR;
+    }
+
+    return idx;
+#else
     static int wolfssl_bio_type_index = WOLFSSL_BIO_TYPE_START;
 
     if (wolfssl_bio_type_index >= 0xff) {
         return WOLFSSL_FATAL_ERROR;
     }
 
     return ++wolfssl_bio_type_index;
+#endif
 }
 
 /* creates a new custom WOLFSSL_BIO_METHOD */

tests/api/test_ossl_bio.c

@@ -1899,5 +1899,40 @@ int test_wolfSSL_BIO_get_init(void)
     return EXPECT_RESULT();
 }
 
+int test_wolfSSL_BIO_get_new_index(void)
+{
+    EXPECT_DECLS;
+#if defined(OPENSSL_EXTRA)
+    BIO_METHOD* method = NULL;
+    BIO* bio = NULL;
+    int idx = 0;
+    int prev;
+
+    /* First call hands out BIO_TYPE_START + 1, later calls increment by
+     * one. The index counter is process-global, so this test drains it
+     * completely; it must stay the only consumer in the test suite. */
+    ExpectIntEQ(prev = BIO_get_new_index(), BIO_TYPE_START + 1);
+
+    /* A returned index is usable as a custom method type. */
+    ExpectNotNull(method = BIO_meth_new(prev, "new_index_test"));
+    ExpectNotNull(bio = BIO_new(method));
+    ExpectIntEQ(BIO_method_type(bio), prev);
+    BIO_free(bio);
+    BIO_meth_free(method);
+
+    /* Monotonic by one up to the last valid index 0xff, then
+     * WOLFSSL_FATAL_ERROR once exhausted. */
+    while (EXPECT_SUCCESS() && (idx = BIO_get_new_index()) > 0) {
+        ExpectIntEQ(idx, prev + 1);
+        prev = idx;
+    }
+    ExpectIntEQ(prev, 0xff);
+    ExpectIntEQ(idx, WOLFSSL_FATAL_ERROR);
+    /* Exhaustion is sticky. */
+    ExpectIntEQ(BIO_get_new_index(), WOLFSSL_FATAL_ERROR);
+#endif
+    return EXPECT_RESULT();
+}
+
 #endif /* !NO_BIO */
 

tests/api/test_ossl_bio.h

@@ -49,6 +49,7 @@ int test_wolfSSL_BIO_set_conn_hostname(void);
 int test_wolfSSL_BIO_ctrl_pending_chain(void);
 int test_wolfSSL_BIO_meth_type_large(void);
 int test_wolfSSL_BIO_get_init(void);
+int test_wolfSSL_BIO_get_new_index(void);
 
 #define TEST_OSSL_BIO_DECLS                                       \
     TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_gets),           \
@@ -70,7 +71,8 @@ int test_wolfSSL_BIO_get_init(void);
     TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_set_conn_hostname), \
     TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_ctrl_pending_chain), \
     TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_meth_type_large), \
-    TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_get_init)
+    TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_get_init),       \
+    TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_get_new_index)
 
 #define TEST_OSSL_BIO_TLS_DECLS                                   \
     TEST_DECL_GROUP("ossl_bio_tls", test_wolfSSL_BIO_connect),    \