Rename lots of *_intern or *_internal function to int_*

[openssl.git] / crypto / init.c

diff --git a/crypto/init.c b/crypto/init.c
index fad7a85b824c8c3f7f2dbd08e75092715083b3aa..1802d0029c305e8e077d132d6b20561ed4714d00 100644 (file)
--- a/crypto/init.c
+++ b/crypto/init.c
@@ -58,18 +58,16 @@
 #include <internal/threads.h>
 #include <internal/cryptlib_int.h>
 #include <openssl/err.h>
-#include <openssl/rand.h>
+#include <internal/rand.h>
+#include <internal/bio.h>
 #include <openssl/evp.h>
 #include <internal/evp_int.h>
 #include <internal/conf.h>
 #include <internal/async.h>
-#ifndef OPENSSL_NO_ENGINE
 #include <internal/engine.h>
-#endif
-#ifndef OPENSSL_NO_COMP
-#include <openssl/comp.h>
-#endif
+#include <internal/comp.h>
 #include <internal/err.h>
+#include <internal/objects.h>
 #include <stdlib.h>
 #include <assert.h>
 
@@ -146,9 +144,9 @@ static void ossl_init_load_crypto_strings(void)
 #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT)
 # ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_strings: "
-                    "err_load_crypto_strings_intern()\n");
+                    "int_err_load_crypto_strings()\n");
 # endif
-    err_load_crypto_strings_intern();
+    int_err_load_crypto_strings();
 #endif
     load_crypto_strings_inited = 1;
 }
@@ -163,9 +161,9 @@ static void ossl_init_add_all_ciphers(void)
 #ifndef OPENSSL_NO_AUTOALGINIT
 # ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_ciphers: "
-                    "openssl_add_all_ciphers_internal()\n");
+                    "int_openssl_add_all_ciphers()\n");
 # endif
-    openssl_add_all_ciphers_internal();
+    int_openssl_add_all_ciphers();
 # ifndef OPENSSL_NO_ENGINE
 #  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
     ENGINE_setup_bsd_cryptodev();
@@ -184,9 +182,9 @@ static void ossl_init_add_all_digests(void)
 #ifndef OPENSSL_NO_AUTOALGINIT
 # ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_digests: "
-                    "openssl_add_all_digests_internal()\n");
+                    "int_openssl_add_all_digests()\n");
 # endif
-    openssl_add_all_digests_internal();
+    int_openssl_add_all_digests();
 # ifndef OPENSSL_NO_ENGINE
 #  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
     ENGINE_setup_bsd_cryptodev();
@@ -208,23 +206,22 @@ static void ossl_init_config(void)
 {
 #ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr,
-            "OPENSSL_INIT: ossl_init_config: openssl_config_internal(%s)\n",
+            "OPENSSL_INIT: ossl_init_config: int_openssl_config(%s)\n",
             config_filename==NULL?"NULL":config_filename);
 #endif
-    openssl_config_internal(config_filename);
+    int_openssl_config(config_filename);
     config_inited = 1;
 }
 static void ossl_init_no_config(void)
 {
 #ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr,
-            "OPENSSL_INIT: ossl_init_config: openssl_no_config_internal()\n");
+            "OPENSSL_INIT: ossl_init_config: int_openssl_no_config()\n");
 #endif
-    openssl_no_config_internal();
+    int_openssl_no_config();
     config_inited = 1;
 }
 
-#ifndef OPENSSL_NO_ASYNC
 static CRYPTO_ONCE async = CRYPTO_ONCE_STATIC_INIT;
 static int async_inited = 0;
 static void ossl_init_async(void)
@@ -235,7 +232,6 @@ static void ossl_init_async(void)
     async_init();
     async_inited = 1;
 }
-#endif
 
 #ifndef OPENSSL_NO_ENGINE
 static CRYPTO_ONCE engine_openssl = CRYPTO_ONCE_STATIC_INIT;
@@ -243,9 +239,9 @@ static void ossl_init_engine_openssl(void)
 {
 # ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_openssl: "
-                    "engine_load_openssl_internal()\n");
+                    "int_engine_load_openssl()\n");
 # endif
-    engine_load_openssl_internal();
+    int_engine_load_openssl();
 }
 # if !defined(OPENSSL_NO_HW) && \
     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
@@ -254,9 +250,9 @@ static void ossl_init_engine_cryptodev(void)
 {
 #  ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_cryptodev: "
-                    "engine_load_cryptodev_internal()\n");
+                    "int_engine_load_cryptodev()\n");
 #  endif
-    engine_load_cryptodev_internal();
+    int_engine_load_cryptodev();
 }
 # endif
 
@@ -266,9 +262,9 @@ static void ossl_init_engine_rdrand(void)
 {
 #  ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_rdrand: "
-                    "engine_load_rdrand_internal()\n");
+                    "int_engine_load_rdrand()\n");
 #  endif
-    engine_load_rdrand_internal();
+    int_engine_load_rdrand();
 }
 # endif
 static CRYPTO_ONCE engine_dynamic = CRYPTO_ONCE_STATIC_INIT;
@@ -276,9 +272,9 @@ static void ossl_init_engine_dynamic(void)
 {
 # ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dynamic: "
-                    "engine_load_dynamic_internal()\n");
+                    "int_engine_load_dynamic()\n");
 # endif
-    engine_load_dynamic_internal();
+    int_engine_load_dynamic();
 }
 # ifndef OPENSSL_NO_STATIC_ENGINE
 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
@@ -287,9 +283,9 @@ static void ossl_init_engine_padlock(void)
 {
 #   ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_padlock: "
-                    "engine_load_padlock_internal()\n");
+                    "int_engine_load_padlock()\n");
 #   endif
-    engine_load_padlock_internal();
+    int_engine_load_padlock();
 }
 #  endif
 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
@@ -298,9 +294,9 @@ static void ossl_init_engine_capi(void)
 {
 #   ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_capi: "
-                    "engine_load_capi_internal()\n");
+                    "int_engine_load_capi()\n");
 #   endif
-    engine_load_capi_internal();
+    int_engine_load_capi();
 }
 #  endif
 static CRYPTO_ONCE engine_dasync = CRYPTO_ONCE_STATIC_INIT;
@@ -308,9 +304,9 @@ static void ossl_init_engine_dasync(void)
 {
 # ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dasync: "
-                    "engine_load_dasync_internal()\n");
+                    "int_engine_load_dasync()\n");
 # endif
-    engine_load_dasync_internal();
+    int_engine_load_dasync();
 }
 #  if !defined(OPENSSL_NO_AFALGENG)
 static CRYPTO_ONCE engine_afalg = CRYPTO_ONCE_STATIC_INIT;
@@ -318,9 +314,9 @@ static void ossl_init_engine_afalg(void)
 {
 #   ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_afalg: "
-                    "engine_load_afalg_internal()\n");
+                    "int_engine_load_afalg()\n");
 #   endif
-    engine_load_afalg_internal();
+    int_engine_load_afalg();
 }
 #  endif
 # endif
@@ -343,7 +339,6 @@ static void ossl_init_thread_stop(struct thread_local_inits_st *locals)
     if (locals == NULL)
         return;
 
-#ifndef OPENSSL_NO_ASYNC
     if (locals->async) {
 #ifdef OPENSSL_INIT_DEBUG
         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
@@ -351,7 +346,6 @@ static void ossl_init_thread_stop(struct thread_local_inits_st *locals)
 #endif
         ASYNC_cleanup_thread();
     }
-#endif
 
     if (locals->err_state) {
 #ifdef OPENSSL_INIT_DEBUG
@@ -435,13 +429,12 @@ void OPENSSL_cleanup(void)
     if (zlib_inited) {
 #ifdef OPENSSL_INIT_DEBUG
         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                        "COMP_zlib_cleanup()\n");
+                        "int_comp_zlib_cleanup()\n");
 #endif
-        COMP_zlib_cleanup();
+        int_comp_zlib_cleanup();
     }
 #endif
 
-#ifndef OPENSSL_NO_ASYNC
     if (async_inited) {
 # ifdef OPENSSL_INIT_DEBUG
         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
@@ -449,54 +442,55 @@ void OPENSSL_cleanup(void)
 # endif
         async_deinit();
     }
-#endif
 
     if (load_crypto_strings_inited) {
 #ifdef OPENSSL_INIT_DEBUG
         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                        "ERR_free_strings()\n");
+                        "int_err_free_strings()\n");
 #endif
-        ERR_free_strings();
+        int_err_free_strings();
     }
 
     CRYPTO_THREAD_cleanup_local(&threadstopkey);
 
 #ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "RAND_cleanup()\n");
+                    "int_rand_cleanup()\n");
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "CONF_modules_free()\n");
+                    "int_conf_modules_free()\n");
 #ifndef OPENSSL_NO_ENGINE
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "ENGINE_cleanup()\n");
+                    "int_engine_cleanup()\n");
 #endif
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "CRYPTO_cleanup_all_ex_data()\n");
+                    "int_crypto_cleanup_all_ex_data()\n");
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "BIO_sock_cleanup()\n");
+                    "int_bio_sock_cleanup()\n");
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "EVP_cleanup()\n");
+                    "int_evp_cleanup()\n");
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
-                    "OBJ_cleanup()\n");
+                    "int_obj_cleanup()\n");
 #endif
     /*
      * Note that cleanup order is important:
-     * - RAND_cleanup could call an ENINGE's RAND cleanup function so must be
-     * called before ENGINE_cleanup()
+     * - rand_cleanup_intern could call an ENINGE's RAND cleanup function so
+     * must be called before int_engine_cleanup()
      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
-     * - CONF_modules_free() can end up in ENGINE code so must be called before
-     * ENGINE_cleanup()
+     * - int_conf_modules_free() can end up in ENGINE code so must be called
+     * before int_engine_cleanup()
      */
-    RAND_cleanup();
-    CONF_modules_free();
+    int_rand_cleanup();
+    int_conf_modules_free();
 #ifndef OPENSSL_NO_ENGINE
-    ENGINE_cleanup();
+    int_engine_cleanup();
+#endif
+    int_crypto_cleanup_all_ex_data();
+#ifndef OPENSSL_NO_SOCK
+    int_bio_sock_cleanup();
 #endif
-    CRYPTO_cleanup_all_ex_data();
-    BIO_sock_cleanup();
-    EVP_cleanup();
-    OBJ_cleanup();
+    int_evp_cleanup();
+    int_obj_cleanup();
     base_inited = 0;
 }
 
@@ -567,11 +561,10 @@ int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
             return 0;
     }
 
-#ifndef OPENSSL_NO_ASYNC
     if ((opts & OPENSSL_INIT_ASYNC)
             && !CRYPTO_THREAD_run_once(&async, ossl_init_async))
         return 0;
-#endif
+
 #ifndef OPENSSL_NO_ENGINE
     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
             && !CRYPTO_THREAD_run_once(&engine_openssl,