if (async) {
SSL_CTX_set_mode(ctx, SSL_MODE_ASYNC);
- ASYNC_init(1, 0, 0);
}
if (!config_ctx(cctx, ssl_args, ctx, jpake_secret == NULL))
print_stuff(bio_c_out, con, 1);
SSL_free(con);
}
- if (async) {
- ASYNC_cleanup(1);
- }
#if !defined(OPENSSL_NO_NEXTPROTONEG)
OPENSSL_free(next_proto.data);
#endif
if (async) {
SSL_CTX_set_mode(ctx, SSL_MODE_ASYNC);
- ASYNC_init(1, 0, 0);
}
#ifndef OPENSSL_NO_SRTP
bio_s_out = NULL;
BIO_free(bio_s_msg);
bio_s_msg = NULL;
- if (async) {
- ASYNC_cleanup(1);
- }
return (ret);
}
return 0;
}
-int async_local_init(void)
-{
- return 0;
-}
-
void async_local_cleanup(void)
{
}
# define async_set_ctx(nctx) 0
-# define async_get_ctx() ((async_ctx *)NULL)
+# define async_arch_get_ctx() ((async_ctx *)NULL)
# define async_fibre_swapcontext(o,n,r) 0
# define async_fibre_makecontext(c) 0
# define async_fibre_free(f)
return 1;
}
-int async_local_init(void)
-{
- if (!async_set_ctx(NULL) || ! async_set_pool(NULL))
- return 0;
-
- return 1;
-}
-
void async_local_cleanup(void)
{
}
} async_fibre;
# define async_set_ctx(nctx) (pthread_setspecific(posixctx , (nctx)) == 0)
-# define async_get_ctx() ((async_ctx *)pthread_getspecific(posixctx))
+# define async_arch_get_ctx() ((async_ctx *)pthread_getspecific(posixctx))
# define async_set_pool(p) (pthread_setspecific(posixpool , (p)) == 0)
# define async_get_pool() ((async_pool *)pthread_getspecific(posixpool))
static DWORD asyncwinpool = 0;
static DWORD asyncwinctx = 0;
-static DWORD asyncwindispatch = 0;
void async_start_func(void);
{
asyncwinpool = TlsAlloc();
asyncwinctx = TlsAlloc();
- asyncwindispatch = TlsAlloc();
- if (asyncwinpool == TLS_OUT_OF_INDEXES || asyncwinctx == TLS_OUT_OF_INDEXES
- || asyncwindispatch == TLS_OUT_OF_INDEXES) {
+ if (asyncwinpool == TLS_OUT_OF_INDEXES
+ || asyncwinctx == TLS_OUT_OF_INDEXES) {
if (asyncwinpool != TLS_OUT_OF_INDEXES) {
TlsFree(asyncwinpool);
}
if (asyncwinctx != TLS_OUT_OF_INDEXES) {
TlsFree(asyncwinctx);
}
- if (asyncwindispatch != TLS_OUT_OF_INDEXES) {
- TlsFree(asyncwindispatch);
- }
return 0;
}
return 1;
}
-int async_local_init(void)
-{
- return (TlsSetValue(asyncwinpool, NULL) != 0)
- && (TlsSetValue(asyncwinctx, NULL) != 0)
- && (TlsSetValue(asyncwindispatch, NULL) != 0);
-}
-
void async_local_cleanup(void)
{
- async_ctx *ctx = async_get_ctx();
+ async_ctx *ctx = async_arch_get_ctx();
if (ctx != NULL) {
async_fibre *fibre = &ctx->dispatcher;
if(fibre != NULL && fibre->fibre != NULL && fibre->converted) {
{
TlsFree(asyncwinpool);
TlsFree(asyncwinctx);
- TlsFree(asyncwindispatch);
asyncwinpool = 0;
asyncwinctx = 0;
- asyncwindispatch = 0;
}
int async_fibre_init_dispatcher(async_fibre *fibre)
{
LPVOID dispatcher;
- dispatcher = (LPVOID)TlsGetValue(asyncwindispatch);
- if (dispatcher == NULL) {
- fibre->fibre = ConvertThreadToFiber(NULL);
- if (fibre->fibre == NULL) {
- fibre->converted = 0;
- fibre->fibre = GetCurrentFiber();
- if (fibre->fibre == NULL)
- return 0;
- } else {
- fibre->converted = 1;
- }
- if (TlsSetValue(asyncwindispatch, (LPVOID)fibre->fibre) == 0)
+ fibre->fibre = ConvertThreadToFiber(NULL);
+ if (fibre->fibre == NULL) {
+ fibre->converted = 0;
+ fibre->fibre = GetCurrentFiber();
+ if (fibre->fibre == NULL)
return 0;
} else {
- fibre->fibre = dispatcher;
+ fibre->converted = 1;
}
+
return 1;
}
return TlsSetValue(asyncwinpool, (LPVOID)pool) != 0;
}
-async_ctx *async_get_ctx(void)
+async_ctx *async_arch_get_ctx(void)
{
return (async_ctx *)TlsGetValue(asyncwinctx);
}
((c)->fibre = CreateFiber(0, async_start_func_win, 0))
# define async_fibre_free(f) (DeleteFiber((f)->fibre))
-async_ctx *async_get_ctx(void);
+async_ctx *async_arch_get_ctx(void);
int async_set_ctx(async_ctx *ctx);
int async_fibre_init_dispatcher(async_fibre *fibre);
#include "async_locl.h"
#include <openssl/err.h>
+#include <internal/cryptlib_int.h>
#include <string.h>
#define ASYNC_JOB_RUNNING 0
return NULL;
}
+static async_ctx *async_get_ctx(void)
+{
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ASYNC, NULL);
+ return async_arch_get_ctx();
+}
+
static int async_ctx_free(void)
{
async_ctx *ctx;
void async_start_func(void)
{
ASYNC_JOB *job;
+ async_ctx *ctx = async_get_ctx();
while (1) {
/* Run the job */
- job = async_get_ctx()->currjob;
+ job = ctx->currjob;
job->ret = job->func(job->funcargs);
/* Stop the job */
job->status = ASYNC_JOB_STOPPING;
if (!async_fibre_swapcontext(&job->fibrectx,
- &async_get_ctx()->dispatcher, 1)) {
+ &ctx->dispatcher, 1)) {
/*
* Should not happen. Getting here will close the thread...can't do
* much about it
int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
void *args, size_t size)
{
- if (async_get_ctx() == NULL && async_ctx_new() == NULL) {
+ async_ctx *ctx = async_get_ctx();
+ if (ctx == NULL)
+ ctx = async_ctx_new();
+ if (ctx == NULL) {
return ASYNC_ERR;
}
if (*job) {
- async_get_ctx()->currjob = *job;
+ ctx->currjob = *job;
}
for (;;) {
- if (async_get_ctx()->currjob != NULL) {
- if (async_get_ctx()->currjob->status == ASYNC_JOB_STOPPING) {
- *ret = async_get_ctx()->currjob->ret;
- async_release_job(async_get_ctx()->currjob);
- async_get_ctx()->currjob = NULL;
+ if (ctx->currjob != NULL) {
+ if (ctx->currjob->status == ASYNC_JOB_STOPPING) {
+ *ret = ctx->currjob->ret;
+ async_release_job(ctx->currjob);
+ ctx->currjob = NULL;
*job = NULL;
return ASYNC_FINISH;
}
- if (async_get_ctx()->currjob->status == ASYNC_JOB_PAUSING) {
- *job = async_get_ctx()->currjob;
- async_get_ctx()->currjob->status = ASYNC_JOB_PAUSED;
- async_get_ctx()->currjob = NULL;
+ if (ctx->currjob->status == ASYNC_JOB_PAUSING) {
+ *job = ctx->currjob;
+ ctx->currjob->status = ASYNC_JOB_PAUSED;
+ ctx->currjob = NULL;
return ASYNC_PAUSE;
}
- if (async_get_ctx()->currjob->status == ASYNC_JOB_PAUSED) {
- async_get_ctx()->currjob = *job;
+ if (ctx->currjob->status == ASYNC_JOB_PAUSED) {
+ ctx->currjob = *job;
/* Resume previous job */
- if (!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
- &async_get_ctx()->currjob->fibrectx, 1)) {
+ if (!async_fibre_swapcontext(&ctx->dispatcher,
+ &ctx->currjob->fibrectx, 1)) {
ASYNCerr(ASYNC_F_ASYNC_START_JOB,
ASYNC_R_FAILED_TO_SWAP_CONTEXT);
goto err;
/* Should not happen */
ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_INTERNAL_ERROR);
- async_release_job(async_get_ctx()->currjob);
- async_get_ctx()->currjob = NULL;
+ async_release_job(ctx->currjob);
+ ctx->currjob = NULL;
*job = NULL;
return ASYNC_ERR;
}
/* Start a new job */
- if ((async_get_ctx()->currjob = async_get_pool_job()) == NULL) {
+ if ((ctx->currjob = async_get_pool_job()) == NULL) {
return ASYNC_NO_JOBS;
}
if (args != NULL) {
- async_get_ctx()->currjob->funcargs = OPENSSL_malloc(size);
- if (async_get_ctx()->currjob->funcargs == NULL) {
+ ctx->currjob->funcargs = OPENSSL_malloc(size);
+ if (ctx->currjob->funcargs == NULL) {
ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_MALLOC_FAILURE);
- async_release_job(async_get_ctx()->currjob);
- async_get_ctx()->currjob = NULL;
+ async_release_job(ctx->currjob);
+ ctx->currjob = NULL;
return ASYNC_ERR;
}
- memcpy(async_get_ctx()->currjob->funcargs, args, size);
+ memcpy(ctx->currjob->funcargs, args, size);
} else {
- async_get_ctx()->currjob->funcargs = NULL;
+ ctx->currjob->funcargs = NULL;
}
- async_get_ctx()->currjob->func = func;
- if (!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
- &async_get_ctx()->currjob->fibrectx, 1)) {
+ ctx->currjob->func = func;
+ if (!async_fibre_swapcontext(&ctx->dispatcher,
+ &ctx->currjob->fibrectx, 1)) {
ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
goto err;
}
}
err:
- async_release_job(async_get_ctx()->currjob);
- async_get_ctx()->currjob = NULL;
+ async_release_job(ctx->currjob);
+ ctx->currjob = NULL;
*job = NULL;
return ASYNC_ERR;
}
int ASYNC_pause_job(void)
{
ASYNC_JOB *job;
+ async_ctx *ctx = async_get_ctx();
- if (async_get_ctx() == NULL
- || async_get_ctx()->currjob == NULL
- || async_get_ctx()->blocked) {
+ if (ctx == NULL
+ || ctx->currjob == NULL
+ || ctx->blocked) {
/*
* Could be we've deliberately not been started within a job so this is
* counted as success.
return 1;
}
- job = async_get_ctx()->currjob;
+ job = ctx->currjob;
job->status = ASYNC_JOB_PAUSING;
if (!async_fibre_swapcontext(&job->fibrectx,
- &async_get_ctx()->dispatcher, 1)) {
+ &ctx->dispatcher, 1)) {
ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
return 0;
}
} while (job);
}
-int ASYNC_init(int init_thread, size_t max_size, size_t init_size)
+int async_init(void)
{
if (!async_global_init())
return 0;
- if (init_thread)
- return ASYNC_init_thread(max_size, init_size);
-
return 1;
}
return 0;
}
- if (!async_local_init()) {
- ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INIT_FAILED);
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ASYNC, NULL);
+ if (!ossl_init_thread_start(OPENSSL_INIT_THREAD_ASYNC)) {
+ ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
return 0;
}
+
pool = OPENSSL_zalloc(sizeof *pool);
if (pool == NULL) {
ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
async_free_pool_internal(async_get_pool());
}
-void ASYNC_cleanup(int cleanupthread)
-{
- /*
- * We don't actually have any global cleanup at the moment so just cleanup
- * the thread
- */
- if (cleanupthread)
- ASYNC_cleanup_thread();
-}
-
ASYNC_JOB *ASYNC_get_current_job(void)
{
async_ctx *ctx;
void ASYNC_block_pause(void)
{
- if (async_get_ctx() == NULL
- || async_get_ctx()->currjob == NULL) {
+ async_ctx *ctx = async_get_ctx();
+ if (ctx == NULL || ctx->currjob == NULL) {
/*
* We're not in a job anyway so ignore this
*/
return;
}
- async_get_ctx()->blocked++;
+ ctx->blocked++;
}
void ASYNC_unblock_pause(void)
{
- if (async_get_ctx() == NULL
- || async_get_ctx()->currjob == NULL) {
+ async_ctx *ctx = async_get_ctx();
+ if (ctx == NULL || ctx->currjob == NULL) {
/*
* We're not in a job anyway so ignore this
*/
return;
}
- if(async_get_ctx()->blocked > 0)
- async_get_ctx()->blocked--;
+ if(ctx->blocked > 0)
+ ctx->blocked--;
}
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
-#include <openssl/async.h>
+#include <internal/async.h>
#include <openssl/crypto.h>
typedef struct async_ctx_st async_ctx;
};
int async_global_init(void);
-int async_local_init(void);
void async_local_cleanup(void);
void async_global_cleanup(void);
void async_start_func(void);
#include <openssl/objects.h>
#include <openssl/comp.h>
#include <openssl/err.h>
+#include <internal/cryptlib_int.h>
#include "comp_lcl.h"
COMP_METHOD *COMP_zlib(void);
zlib_loaded++;
if (zlib_loaded)
meth = &zlib_stateful_method;
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ZLIB, NULL);
}
}
#endif
#include <stdio.h>
#include <openssl/crypto.h>
#include "internal/cryptlib.h"
-#include <openssl/conf.h>
+#include <internal/conf.h>
#include <openssl/dso.h>
#include <openssl/x509.h>
#include <openssl/asn1.h>
static int openssl_configured = 0;
void OPENSSL_config(const char *config_name)
+{
+ const OPENSSL_INIT_SETTINGS settings[2] = {
+ { OPENSSL_INIT_SET_CONF_FILENAME, .value.type_string = config_name },
+ { OPENSSL_INIT_SET_END, .value.type_int = 0 }
+ };
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_LOAD_CONFIG,
+ (const OPENSSL_INIT_SETTINGS *)&settings);
+}
+
+void openssl_config_internal(const char *config_name)
{
if (openssl_configured)
return;
openssl_configured = 1;
}
-void OPENSSL_no_config()
+void openssl_no_config_internal(void)
{
openssl_configured = 1;
}
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
*/
-#include "internal/cryptlib.h"
+#include "internal/cryptlib_int.h"
#include <openssl/safestack.h>
#if defined(__i386) || defined(__i386__) || defined(_M_IX86) || \
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
+ ossl_init_thread_stop(
+ (struct thread_local_inits_st *)ossl_init_get_thread_local(0));
break;
case DLL_PROCESS_DETACH:
break;
*/
#include <openssl/objects.h>
-#include <openssl/engine.h>
+#include <internal/engine.h>
#include <openssl/evp.h>
#include <openssl/bn.h>
+#include <openssl/crypto.h>
#if (defined(__unix__) || defined(unix)) && !defined(USG) && \
(defined(OpenBSD) || defined(__FreeBSD__))
#ifndef HAVE_CRYPTODEV
-void ENGINE_load_cryptodev(void)
+void engine_load_cryptodev_internal(void)
{
/* This is a NOP on platforms without /dev/crypto */
return;
#endif
static int cryptodev_ctrl(ENGINE *e, int cmd, long i, void *p,
void (*f) (void));
-void ENGINE_load_cryptodev(void);
+void engine_load_cryptodev_internal(void);
static const ENGINE_CMD_DEFN cryptodev_defns[] = {
{0, NULL, NULL, 0}
return (1);
}
-void ENGINE_load_cryptodev(void)
+void engine_load_cryptodev_internal(void)
{
ENGINE *engine = ENGINE_new();
int fd;
#include "eng_int.h"
#include <openssl/dso.h>
+#include <openssl/crypto.h>
/*
* Shared libraries implementing ENGINEs for use by the "dynamic" ENGINE
return ret;
}
-void ENGINE_load_dynamic(void)
+void engine_load_dynamic_internal(void)
{
ENGINE *toadd = engine_dynamic();
if (!toadd)
# define HEADER_ENGINE_INT_H
# include "internal/cryptlib.h"
-/* Take public definitions from engine.h */
-# include <openssl/engine.h>
+# include <internal/engine.h>
#ifdef __cplusplus
extern "C" {
#include <stdio.h>
#include <openssl/crypto.h>
#include "internal/cryptlib.h"
-#include <openssl/engine.h>
+#include <internal/engine.h>
#include <openssl/dso.h>
#include <openssl/pem.h>
#include <openssl/evp.h>
return ret;
}
-void ENGINE_load_openssl(void)
+void engine_load_openssl_internal(void)
{
ENGINE *toadd = engine_openssl();
if (!toadd)
#include <stdio.h>
#include <string.h>
-#include <openssl/engine.h>
+#include <internal/engine.h>
#include <openssl/rand.h>
#include <openssl/err.h>
+#include <openssl/crypto.h>
#if (defined(__i386) || defined(__i386__) || defined(_M_IX86) || \
defined(__x86_64) || defined(__x86_64__) || \
return ret;
}
-void ENGINE_load_rdrand(void)
+void engine_load_rdrand_internal(void)
{
extern unsigned int OPENSSL_ia32cap_P[];
}
}
#else
-void ENGINE_load_rdrand(void)
+void engine_load_rdrand_internal(void)
{
}
#endif
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
-#include "internal/cryptlib.h"
+#include <internal/cryptlib_int.h>
#include <openssl/lhash.h>
#include <openssl/crypto.h>
#include <openssl/buffer.h>
* the first one that we just replaced.
*/
ERR_STATE_free(tmpp);
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_LOAD_CRYPTO_STRINGS,
+ NULL);
+ /* Ignore failures from this */
+ ossl_init_thread_start(OPENSSL_INIT_THREAD_ERR_STATE);
}
return ret;
}
*/
#include <stdio.h>
+#include <internal/err.h>
#include <openssl/asn1.h>
#include <openssl/bn.h>
#ifndef OPENSSL_NO_EC
#include <internal/ct_int.h>
#include <openssl/async.h>
-void ERR_load_crypto_strings(void)
+void err_load_crypto_strings_intern(void)
{
#ifdef OPENSSL_FIPS
FIPS_set_error_callbacks(ERR_put_error, ERR_add_error_vdata);
GENERAL=Makefile
LIB=$(TOP)/libcrypto.a
-LIBSRC= encode.c digest.c evp_enc.c evp_key.c evp_acnf.c evp_cnf.c \
+LIBSRC= encode.c digest.c evp_enc.c evp_key.c evp_cnf.c \
e_des.c e_bf.c e_idea.c e_des3.c e_camellia.c\
e_rc4.c e_aes.c names.c e_seed.c \
e_xcbc_d.c e_rc2.c e_cast.c e_rc5.c \
m_md5_sha1.c m_mdc2.c m_ripemd.c \
p_open.c p_seal.c p_sign.c p_verify.c p_lib.c p_enc.c p_dec.c \
bio_md.c bio_b64.c bio_enc.c evp_err.c e_null.c \
- c_all.c c_allc.c c_alld.c evp_lib.c bio_ok.c \
+ c_allc.c c_alld.c evp_lib.c bio_ok.c \
evp_pkey.c evp_pbe.c p5_crpt.c p5_crpt2.c scrypt.c \
e_old.c pmeth_lib.c pmeth_fn.c pmeth_gn.c m_sigver.c \
e_aes_cbc_hmac_sha1.c e_aes_cbc_hmac_sha256.c e_rc4_hmac_md5.c \
e_chacha20_poly1305.c cmeth_lib.c
-LIBOBJ= encode.o digest.o evp_enc.o evp_key.o evp_acnf.o evp_cnf.o \
+LIBOBJ= encode.o digest.o evp_enc.o evp_key.o evp_cnf.o \
e_des.o e_bf.o e_idea.o e_des3.o e_camellia.o\
e_rc4.o e_aes.o names.o e_seed.o \
e_xcbc_d.o e_rc2.o e_cast.o e_rc5.o \
m_md5_sha1.o m_mdc2.o m_ripemd.o \
p_open.o p_seal.o p_sign.o p_verify.o p_lib.o p_enc.o p_dec.o \
bio_md.o bio_b64.o bio_enc.o evp_err.o e_null.o \
- c_all.o c_allc.o c_alld.o evp_lib.o bio_ok.o \
+ c_allc.o c_alld.o evp_lib.o bio_ok.o \
evp_pkey.o evp_pbe.o p5_crpt.o p5_crpt2.o scrypt.o \
e_old.o pmeth_lib.o pmeth_fn.o pmeth_gn.o m_sigver.o \
e_aes_cbc_hmac_sha1.o e_aes_cbc_hmac_sha256.o e_rc4_hmac_md5.o \
+++ /dev/null
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to. The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code. The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- * "This product includes cryptographic software written by
- * Eric Young (eay@cryptsoft.com)"
- * The word 'cryptographic' can be left out if the rouines from the library
- * being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- * the apps directory (application code) you must include an acknowledgement:
- * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed. i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-#include <stdio.h>
-#include "internal/cryptlib.h"
-#include <openssl/evp.h>
-#ifndef OPENSSL_NO_ENGINE
-# include <openssl/engine.h>
-#endif
-
-void OPENSSL_add_all_algorithms_noconf(void)
-{
- /*
- * For the moment OPENSSL_cpuid_setup does something
- * only on IA-32, but we reserve the option for all
- * platforms...
- */
- OPENSSL_cpuid_setup();
- OpenSSL_add_all_ciphers();
- OpenSSL_add_all_digests();
-#ifndef OPENSSL_NO_ENGINE
-# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
- ENGINE_setup_bsd_cryptodev();
-# endif
-#endif
-}
#include <stdio.h>
#include "internal/cryptlib.h"
#include <openssl/evp.h>
+#include <internal/evp_int.h>
#include <openssl/pkcs12.h>
#include <openssl/objects.h>
-void OpenSSL_add_all_ciphers(void)
+void openssl_add_all_ciphers_internal(void)
{
#ifndef OPENSSL_NO_DES
#include <stdio.h>
#include "internal/cryptlib.h"
#include <openssl/evp.h>
+#include <internal/evp_int.h>
#include <openssl/pkcs12.h>
#include <openssl/objects.h>
-void OpenSSL_add_all_digests(void)
+void openssl_add_all_digests_internal(void)
{
#ifndef OPENSSL_NO_MD4
EVP_add_digest(EVP_md4());
{
const EVP_CIPHER *cp;
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
+
cp = (const EVP_CIPHER *)OBJ_NAME_get(name, OBJ_NAME_TYPE_CIPHER_METH);
return (cp);
}
{
const EVP_MD *cp;
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
+
cp = (const EVP_MD *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
return (cp);
}
void *arg)
{
struct doall_cipher dc;
+
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
+
dc.fn = fn;
dc.arg = arg;
OBJ_NAME_do_all(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
void *x), void *arg)
{
struct doall_cipher dc;
+
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
+
dc.fn = fn;
dc.arg = arg;
OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
void *arg)
{
struct doall_md dc;
+
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
+
dc.fn = fn;
dc.arg = arg;
OBJ_NAME_do_all(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
void *x), void *arg)
{
struct doall_md dc;
+
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
+
dc.fn = fn;
dc.arg = arg;
OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
--- /dev/null
+/*
+ * Written by Matt Caswell for the OpenSSL project
+ */
+/* ====================================================================
+ * Copyright (c) 2015 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * licensing@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+#include <openssl/async.h>
+
+int async_init(void);
+
/*
- * Written by Stephen Henson (steve@openssl.org) for the OpenSSL project
- * 2001.
+ * Written by Matt Caswell for the OpenSSL project
*/
/* ====================================================================
- * Copyright (c) 2001 The OpenSSL Project. All rights reserved.
+ * Copyright (c) 2015 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
*
*/
-#include "internal/cryptlib.h"
-#include <openssl/evp.h>
#include <openssl/conf.h>
-/*
- * Load all algorithms and configure OpenSSL. This function is called
- * automatically when OPENSSL_LOAD_CONF is set.
- */
+void openssl_config_internal(const char *config_name);
+void openssl_no_config_internal(void);
-void OPENSSL_add_all_algorithms_conf(void)
-{
- OPENSSL_add_all_algorithms_noconf();
- OPENSSL_config(NULL);
-}
--- /dev/null
+/* ====================================================================
+ * Copyright (c) 2016 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * licensing@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+#include <openssl/engine.h>
+
+void engine_load_openssl_internal(void);
+void engine_load_cryptodev_internal(void);
+void engine_load_rdrand_internal(void);
+void engine_load_dynamic_internal(void);
+void engine_load_padlock_internal(void);
+void engine_load_capi_internal(void);
+void engine_load_dasync_internal(void);
--- /dev/null
+/*
+ * Written by Matt Caswell for the OpenSSL project.
+ */
+/* ====================================================================
+ * Copyright (c) 2016 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+void err_load_crypto_strings_intern(void);
int save_parameters;
STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
} /* EVP_PKEY */ ;
+
+
+void openssl_add_all_ciphers_internal(void);
+void openssl_add_all_digests_internal(void);
#include <internal/cryptlib_int.h>
#include <openssl/err.h>
#include <openssl/evp.h>
-#if 0
#include <internal/evp_int.h>
#include <internal/conf.h>
#include <internal/async.h>
#include <internal/engine.h>
-#endif
-#include <openssl/conf.h>
-#include <openssl/async.h>
-#include <openssl/engine.h>
#include <openssl/comp.h>
-#if 0
#include <internal/err.h>
-#endif
#include <stdlib.h>
/* Implement "once" functionality */
fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_strings: "
"err_load_crypto_strings_intern()\n");
# endif
-#if 0
err_load_crypto_strings_intern();
-#endif
#endif
load_crypto_strings_inited = 1;
}
fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_ciphers: "
"openssl_add_all_ciphers_internal()\n");
# endif
-#if 0
openssl_add_all_ciphers_internal();
-#endif
# ifndef OPENSSL_NO_ENGINE
# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
ENGINE_setup_bsd_cryptodev();
fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_digests: "
"openssl_add_all_digests_internal()\n");
# endif
-#if 0
openssl_add_all_digests_internal();
-#endif
# ifndef OPENSSL_NO_ENGINE
# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
ENGINE_setup_bsd_cryptodev();
"OPENSSL_INIT: ossl_init_config: openssl_config_internal(%s)\n",
config_filename==NULL?"NULL":config_filename);
#endif
-#if 0
openssl_config_internal(config_filename);
-#endif
config_inited = 1;
}
static void ossl_init_no_config(void)
fprintf(stderr,
"OPENSSL_INIT: ossl_init_config: openssl_no_config_internal()\n");
#endif
-#if 0
openssl_no_config_internal();
-#endif
config_inited = 1;
}
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ossl_init_async: async_init()\n");
#endif
-#if 0
async_init();
-#endif
async_inited = 1;
}
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_openssl: "
"engine_load_openssl_internal()\n");
# endif
-#if 0
engine_load_openssl_internal();
-#endif
engine_inited = 1;
}
# if !defined(OPENSSL_NO_HW) && \
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_cryptodev: "
"engine_load_cryptodev_internal()\n");
# endif
-#if 0
engine_load_cryptodev_internal();
-#endif
engine_inited = 1;
}
# endif
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_rdrand: "
"engine_load_rdrand_internal()\n");
# endif
-#if 0
engine_load_rdrand_internal();
-#endif
engine_inited = 1;
}
# endif
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dynamic: "
"engine_load_dynamic_internal()\n");
# endif
-#if 0
engine_load_dynamic_internal();
-#endif
engine_inited = 1;
}
# ifndef OPENSSL_NO_STATIC_ENGINE
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_padlock: "
"engine_load_padlock_internal()\n");
# endif
-#if 0
engine_load_padlock_internal();
-#endif
engine_inited = 1;
}
# endif
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_capi: "
"engine_load_capi_internal()\n");
# endif
-#if 0
engine_load_capi_internal();
-#endif
engine_inited = 1;
}
# endif
fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dasync: "
"engine_load_dasync_internal()\n");
# endif
-#if 0
engine_load_dasync_internal();
-#endif
engine_inited = 1;
}
# endif
"comp",
"fips",
"fips2",
-#if CRYPTO_NUM_LOCKS != 41
+ "init",
+#if CRYPTO_NUM_LOCKS != 42
# error "Inconsistency between crypto.h and cryptlib.c"
#endif
};
static int cert_select_dialog(ENGINE *e, SSL *ssl, STACK_OF(X509) *certs);
# endif
+void engine_load_capi_internal(void);
+
typedef PCCERT_CONTEXT(WINAPI *CERTDLG) (HCERTSTORE, HWND, LPCWSTR,
LPCWSTR, DWORD, DWORD, void *);
typedef HWND(WINAPI *GETCONSWIN) (void);
return ret;
}
-void ENGINE_load_capi(void)
+void engine_load_capi_internal(void)
{
/* Copied from eng_[openssl|dyn].c */
ENGINE *toadd = engine_capi();
IMPLEMENT_DYNAMIC_CHECK_FN()
# else
-void ENGINE_load_capi(void)
+void engine_load_capi_internal(void);
+void engine_load_capi_internal(void)
{
}
# endif
#include <openssl/evp.h>
#include <openssl/async.h>
#include <openssl/bn.h>
+#include <openssl/crypto.h>
#define DASYNC_LIB_NAME "DASYNC"
#include "e_dasync_err.c"
static int dasync_destroy(ENGINE *e);
static int dasync_init(ENGINE *e);
static int dasync_finish(ENGINE *e);
-void ENGINE_load_dasync(void);
+void engine_load_dasync_internal(void);
/* Set up digests. Just SHA1 for now */
return ret;
}
-void ENGINE_load_dasync(void)
+void engine_load_dasync_internal(void)
{
ENGINE *toadd = engine_dasync();
if (!toadd)
#include <openssl/evp.h>
#include <openssl/modes.h>
#include <openssl/aes.h>
+#include <openssl/crypto.h>
#define OSSLTEST_LIB_NAME "OSSLTEST"
#include "e_ossltest_err.c"
# endif
# ifdef OPENSSL_NO_DYNAMIC_ENGINE
-
-void ENGINE_load_padlock(void)
+void engine_load_padlock_internal(void);
+void engine_load_padlock_internal(void)
{
/* On non-x86 CPUs it just returns. */
# ifdef COMPILE_HW_PADLOCK
#define ASYNC_PAUSE 2
#define ASYNC_FINISH 3
-int ASYNC_init(int init_thread, size_t max_size, size_t init_size);
-void ASYNC_cleanup(int cleanupthread);
int ASYNC_init_thread(size_t max_size, size_t init_size);
void ASYNC_cleanup_thread(void);
int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out);
void OPENSSL_config(const char *config_name);
-void OPENSSL_no_config(void);
+#define OPENSSL_no_config() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_NO_LOAD_CONFIG, NULL)
/*
* New conf code. The semantics are different from the functions above. If
/* ====================================================================
- * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
+ * Copyright (c) 1998-2016 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
# define CRYPTO_LOCK_COMP 38
# define CRYPTO_LOCK_FIPS 39
# define CRYPTO_LOCK_FIPS2 40
-# define CRYPTO_NUM_LOCKS 41
+# define CRYPTO_LOCK_INIT 41
+# define CRYPTO_NUM_LOCKS 42
# define CRYPTO_LOCK 1
# define CRYPTO_UNLOCK 2
/* Retrieve an engine from the list by its unique "id" value. */
ENGINE *ENGINE_by_id(const char *id);
/* Add all the built-in engines. */
-void ENGINE_load_openssl(void);
-void ENGINE_load_dynamic(void);
+#define ENGINE_load_openssl() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_OPENSSL, NULL)
+#define ENGINE_load_dynamic() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_DYNAMIC, NULL)
# ifndef OPENSSL_NO_STATIC_ENGINE
-void ENGINE_load_4758cca(void);
-void ENGINE_load_aep(void);
-void ENGINE_load_atalla(void);
-void ENGINE_load_chil(void);
-void ENGINE_load_cswift(void);
-void ENGINE_load_nuron(void);
-void ENGINE_load_sureware(void);
-void ENGINE_load_ubsec(void);
-void ENGINE_load_padlock(void);
-void ENGINE_load_capi(void);
-void ENGINE_load_dasync(void);
+# define ENGINE_load_padlock() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_PADLOCK, NULL)
+#define ENGINE_load_capi() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_CAPI, NULL)
+#define ENGINE_load_dasync() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_DASYNC, NULL)
# endif
-void ENGINE_load_cryptodev(void);
-void ENGINE_load_rdrand(void);
+#define ENGINE_load_cryptodev() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
+#define ENGINE_load_rdrand() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ENGINE_RDRAND, NULL)
void ENGINE_load_builtin_engines(void);
/*
void ERR_load_strings(int lib, ERR_STRING_DATA str[]);
void ERR_unload_strings(int lib, ERR_STRING_DATA str[]);
void ERR_load_ERR_strings(void);
-void ERR_load_crypto_strings(void);
+
+#define ERR_load_crypto_strings() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
+
void ERR_free_strings(void);
void ERR_remove_thread_state(const CRYPTO_THREADID *tid);
const EVP_CIPHER *EVP_seed_ofb(void);
# endif
-void OPENSSL_add_all_algorithms_noconf(void);
-void OPENSSL_add_all_algorithms_conf(void);
+# define OPENSSL_add_all_algorithms_conf() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS \
+ | OPENSSL_INIT_ADD_ALL_DIGESTS \
+ | OPENSSL_INIT_LOAD_CONFIG, NULL)
+# define OPENSSL_add_all_algorithms_noconf() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS \
+ OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
# ifdef OPENSSL_LOAD_CONF
# define OpenSSL_add_all_algorithms() \
- OPENSSL_add_all_algorithms_conf()
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS \
+ | OPENSSL_INIT_ADD_ALL_DIGESTS \
+ | OPENSSL_INIT_LOAD_CONFIG, NULL)
# else
# define OpenSSL_add_all_algorithms() \
- OPENSSL_add_all_algorithms_noconf()
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS \
+ | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
# endif
-void OpenSSL_add_all_ciphers(void);
-void OpenSSL_add_all_digests(void);
+# define OpenSSL_add_all_ciphers() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL)
+# define OpenSSL_add_all_digests() \
+ OPENSSL_INIT_crypto_library_start(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
int EVP_add_cipher(const EVP_CIPHER *cipher);
int EVP_add_digest(const EVP_MD *digest);
# define OCSP_SINGLERESP_get_ext_by_critical OCSP_SINGLERESP_get_ext_by_crit
/* Hack some long EVP names */
-# undef OPENSSL_add_all_algorithms_noconf
-# define OPENSSL_add_all_algorithms_noconf OPENSSL_add_all_algo_noconf
-# undef OPENSSL_add_all_algorithms_conf
-# define OPENSSL_add_all_algorithms_conf OPENSSL_add_all_algo_conf
# undef EVP_PKEY_meth_set_verify_recover
# define EVP_PKEY_meth_set_verify_recover EVP_PKEY_meth_set_vrfy_recover
return 1;
}
-static int test_ASYNC_init()
+static int test_ASYNC_init_thread()
{
ASYNC_JOB *job1 = NULL, *job2 = NULL, *job3 = NULL;
int funcret1, funcret2, funcret3;
- if ( !ASYNC_init(1, 2, 0)
+ if ( !ASYNC_init_thread(2, 0)
|| ASYNC_start_job(&job1, &funcret1, only_pause, NULL, 0)
!= ASYNC_PAUSE
|| ASYNC_start_job(&job2, &funcret2, only_pause, NULL, 0)
|| funcret1 != 1
|| funcret2 != 1
|| funcret3 != 1) {
- fprintf(stderr, "test_ASYNC_init() failed\n");
- ASYNC_cleanup(1);
+ fprintf(stderr, "test_ASYNC_init_thread() failed\n");
+ ASYNC_cleanup_thread();
return 0;
}
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 1;
}
ctr = 0;
- if ( !ASYNC_init(1, 1, 0)
+ if ( !ASYNC_init_thread(1, 0)
|| ASYNC_start_job(&job, &funcret, add_two, NULL, 0) != ASYNC_PAUSE
|| ctr != 1
|| ASYNC_start_job(&job, &funcret, add_two, NULL, 0) != ASYNC_FINISH
|| ctr != 2
|| funcret != 2) {
fprintf(stderr, "test_ASYNC_start_job() failed\n");
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 0;
}
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 1;
}
currjob = NULL;
- if ( !ASYNC_init(1, 1, 0)
+ if ( !ASYNC_init_thread(1, 0)
|| ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
!= ASYNC_PAUSE
|| currjob != job
!= ASYNC_FINISH
|| funcret != 1) {
fprintf(stderr, "test_ASYNC_get_current_job() failed\n");
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 0;
}
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 1;
}
int funcret;
OSSL_ASYNC_FD fd;
- if ( !ASYNC_init(1, 1, 0)
+ if ( !ASYNC_init_thread(1, 0)
|| ASYNC_start_job(&job, &funcret, wake, NULL, 0)
!= ASYNC_PAUSE
|| (fd = ASYNC_get_wait_fd(job)) < 0
!= ASYNC_FINISH
|| funcret != 1) {
fprintf(stderr, "test_ASYNC_get_wait_fd() failed\n");
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 0;
}
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 1;
}
ASYNC_JOB *job = NULL;
int funcret;
- if ( !ASYNC_init(1, 1, 0)
+ if ( !ASYNC_init_thread(1, 0)
|| ASYNC_start_job(&job, &funcret, blockpause, NULL, 0)
!= ASYNC_PAUSE
|| ASYNC_start_job(&job, &funcret, blockpause, NULL, 0)
!= ASYNC_FINISH
|| funcret != 1) {
fprintf(stderr, "test_ASYNC_block_pause() failed\n");
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 0;
}
- ASYNC_cleanup(1);
+ ASYNC_cleanup_thread();
return 1;
}
CRYPTO_set_mem_debug(1);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
- if ( !test_ASYNC_init()
+ if ( !test_ASYNC_init_thread()
|| !test_ASYNC_start_job()
|| !test_ASYNC_get_current_job()
|| !test_ASYNC_get_wait_fd()
ERR_load_PROXY_strings 243 1_1_0 NOEXIST::FUNCTION:
ERR_load_RSA_strings 244 1_1_0 EXIST::FUNCTION:RSA
ERR_load_X509_strings 245 1_1_0 EXIST::FUNCTION:
-ERR_load_crypto_strings 246 1_1_0 EXIST::FUNCTION:
+ERR_load_crypto_strings 246 1_1_0 NOEXIST::FUNCTION:
ERR_load_strings 247 1_1_0 EXIST::FUNCTION:
ERR_peek_error 248 1_1_0 EXIST::FUNCTION:
ERR_peek_error_line 249 1_1_0 EXIST::FUNCTION:
SHA_Init 506 1_1_0 NOEXIST::FUNCTION:
SHA_Update 507 1_1_0 NOEXIST::FUNCTION:
OpenSSL_add_all_algorithms 508 1_1_0 NOEXIST::FUNCTION:
-OpenSSL_add_all_ciphers 509 1_1_0 EXIST::FUNCTION:
-OpenSSL_add_all_digests 510 1_1_0 EXIST::FUNCTION:
+OpenSSL_add_all_ciphers 509 1_1_0 NOEXIST::FUNCTION:
+OpenSSL_add_all_digests 510 1_1_0 NOEXIST::FUNCTION:
TXT_DB_create_index 511 1_1_0 EXIST::FUNCTION:
TXT_DB_free 512 1_1_0 EXIST::FUNCTION:
TXT_DB_get_by_index 513 1_1_0 EXIST::FUNCTION:
X509_print_ex 2544 1_1_0 EXIST::FUNCTION:
OCSP_ONEREQ_get1_ext_d2i 2545 1_1_0 EXIST::FUNCTION:
ENGINE_register_all_RAND 2546 1_1_0 EXIST::FUNCTION:ENGINE
-ENGINE_load_dynamic 2547 1_1_0 EXIST::FUNCTION:ENGINE
+ENGINE_load_dynamic 2547 1_1_0 NOEXIST::FUNCTION:
PBKDF2PARAM_it 2548 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
PBKDF2PARAM_it 2548 1_1_0 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
EXTENDED_KEY_USAGE_new 2549 1_1_0 EXIST::FUNCTION:
UI_dup_input_boolean 2614 1_1_0 EXIST::FUNCTION:
PKCS12_add_CSPName_asc 2615 1_1_0 EXIST::FUNCTION:
EC_POINT_is_at_infinity 2616 1_1_0 EXIST::FUNCTION:EC
-ENGINE_load_cryptodev 2617 1_1_0 EXIST::FUNCTION:ENGINE
+ENGINE_load_cryptodev 2617 1_1_0 NOEXIST::FUNCTION:
DSO_convert_filename 2618 1_1_0 EXIST::FUNCTION:
POLICYQUALINFO_it 2619 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
POLICYQUALINFO_it 2619 1_1_0 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
UI_add_error_string 2633 1_1_0 EXIST::FUNCTION:
KRB5_CHECKSUM_free 2634 1_1_0 NOEXIST::FUNCTION:
OCSP_REQUEST_get_ext 2635 1_1_0 EXIST::FUNCTION:
-ENGINE_load_ubsec 2636 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_ubsec 2636 1_1_0 NOEXIST::FUNCTION:
ENGINE_register_all_digests 2637 1_1_0 EXIST::FUNCTION:ENGINE
PKEY_USAGE_PERIOD_it 2638 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
PKEY_USAGE_PERIOD_it 2638 1_1_0 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
_ossl_old_des_crypt 2654 1_1_0 NOEXIST::FUNCTION:
ASN1_item_i2d 2655 1_1_0 EXIST::FUNCTION:
EVP_DecryptFinal_ex 2656 1_1_0 EXIST::FUNCTION:
-ENGINE_load_openssl 2657 1_1_0 EXIST::FUNCTION:ENGINE
+ENGINE_load_openssl 2657 1_1_0 NOEXIST::FUNCTION:
ENGINE_get_cmd_defns 2658 1_1_0 EXIST::FUNCTION:ENGINE
ENGINE_set_load_privkey_function 2659 1_1_0 EXIST:!VMS:FUNCTION:ENGINE
ENGINE_set_load_privkey_fn 2659 1_1_0 EXIST:VMS:FUNCTION:ENGINE
AES_set_encrypt_key 3024 1_1_0 EXIST::FUNCTION:AES
OCSP_resp_count 3025 1_1_0 EXIST::FUNCTION:
KRB5_CHECKSUM_new 3026 1_1_0 NOEXIST::FUNCTION:
-ENGINE_load_cswift 3027 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_cswift 3027 1_1_0 NOEXIST::FUNCTION:
OCSP_onereq_get0_id 3028 1_1_0 EXIST::FUNCTION:
ENGINE_set_default_ciphers 3029 1_1_0 EXIST::FUNCTION:ENGINE
NOTICEREF_it 3030 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
i2d_EXTENDED_KEY_USAGE 3052 1_1_0 EXIST::FUNCTION:
i2d_OCSP_SIGNATURE 3053 1_1_0 EXIST::FUNCTION:
asn1_enc_save 3054 1_1_0 NOEXIST::FUNCTION:
-ENGINE_load_nuron 3055 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_nuron 3055 1_1_0 NOEXIST::FUNCTION:
_ossl_old_des_pcbc_encrypt 3056 1_1_0 NOEXIST::FUNCTION:
PKCS12_MAC_DATA_it 3057 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
PKCS12_MAC_DATA_it 3057 1_1_0 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
i2d_KRB5_CHECKSUM 3072 1_1_0 NOEXIST::FUNCTION:
ENGINE_set_table_flags 3073 1_1_0 EXIST::FUNCTION:ENGINE
AES_options 3074 1_1_0 EXIST::FUNCTION:AES
-ENGINE_load_chil 3075 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_chil 3075 1_1_0 NOEXIST::FUNCTION:
OCSP_id_cmp 3076 1_1_0 EXIST::FUNCTION:
OCSP_BASICRESP_new 3077 1_1_0 EXIST::FUNCTION:
OCSP_REQUEST_get_ext_by_NID 3078 1_1_0 EXIST::FUNCTION:
OCSP_CRLID_it 3127 1_1_0 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
i2d_KRB5_AUTHENTBODY 3128 1_1_0 NOEXIST::FUNCTION:
OCSP_REQUEST_get_ext_count 3129 1_1_0 EXIST::FUNCTION:
-ENGINE_load_atalla 3130 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_atalla 3130 1_1_0 NOEXIST::FUNCTION:
X509_NAME_it 3131 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
X509_NAME_it 3131 1_1_0 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
USERNOTICE_it 3132 1_1_0 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
DES_read_password 3207 1_1_0 EXIST::FUNCTION:DES
UI_UTIL_read_pw 3208 1_1_0 EXIST::FUNCTION:
UI_UTIL_read_pw_string 3209 1_1_0 EXIST::FUNCTION:
-ENGINE_load_aep 3210 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
-ENGINE_load_sureware 3211 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
-OPENSSL_add_all_algorithms_noconf 3212 1_1_0 EXIST:!VMS:FUNCTION:
-OPENSSL_add_all_algo_noconf 3212 1_1_0 EXIST:VMS:FUNCTION:
-OPENSSL_add_all_algorithms_conf 3213 1_1_0 EXIST:!VMS:FUNCTION:
-OPENSSL_add_all_algo_conf 3213 1_1_0 EXIST:VMS:FUNCTION:
+ENGINE_load_aep 3210 1_1_0 NOEXIST::FUNCTION:
+ENGINE_load_sureware 3211 1_1_0 NOEXIST::FUNCTION:
+OPENSSL_add_all_algo_noconf 3212 1_1_0 NOEXIST::FUNCTION:
+OPENSSL_add_all_algorithms_noconf 3212 1_1_0 NOEXIST::FUNCTION:
+OPENSSL_add_all_algo_conf 3213 1_1_0 NOEXIST::FUNCTION:
+OPENSSL_add_all_algorithms_conf 3213 1_1_0 NOEXIST::FUNCTION:
OPENSSL_load_builtin_modules 3214 1_1_0 EXIST::FUNCTION:
AES_ofb128_encrypt 3215 1_1_0 EXIST::FUNCTION:AES
AES_ctr128_encrypt 3216 1_1_0 NOEXIST::FUNCTION:
AES_cfb128_encrypt 3217 1_1_0 EXIST::FUNCTION:AES
-ENGINE_load_4758cca 3218 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_4758cca 3218 1_1_0 NOEXIST::FUNCTION:
_ossl_096_des_random_seed 3219 1_1_0 NOEXIST::FUNCTION:
EVP_aes_256_ofb 3220 1_1_0 EXIST::FUNCTION:AES
EVP_aes_192_ofb 3221 1_1_0 EXIST::FUNCTION:AES
EVP_aes_192_cfb128 3225 1_1_0 EXIST::FUNCTION:AES
CONF_modules_free 3226 1_1_0 EXIST::FUNCTION:
NCONF_default 3227 1_1_0 EXIST::FUNCTION:
-OPENSSL_no_config 3228 1_1_0 EXIST::FUNCTION:
+OPENSSL_no_config 3228 1_1_0 NOEXIST::FUNCTION:
NCONF_WIN32 3229 1_1_0 EXIST::FUNCTION:
ASN1_UNIVERSALSTRING_new 3230 1_1_0 EXIST::FUNCTION:
EVP_des_ede_ecb 3231 1_1_0 EXIST::FUNCTION:DES
STORE_meth_set_modify_fn 3530 1_1_0 NOEXIST::FUNCTION:
STORE_method_set_modify_function 3530 1_1_0 NOEXIST::FUNCTION:
STORE_parse_attrs_next 3531 1_1_0 NOEXIST::FUNCTION:
-ENGINE_load_padlock 3532 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_padlock 3532 1_1_0 NOEXIST::FUNCTION:
EC_GROUP_set_curve_name 3533 1_1_0 EXIST::FUNCTION:EC
X509_CERT_PAIR_it 3534 1_1_0 NOEXIST::FUNCTION:
STORE_meth_get_revoke_fn 3535 1_1_0 NOEXIST::FUNCTION:
ENGINE_get_ssl_client_cert_function 4045 1_1_0 EXIST:!VMS:FUNCTION:ENGINE
ENGINE_get_ssl_client_cert_fn 4045 1_1_0 EXIST:VMS:FUNCTION:ENGINE
ENGINE_load_ssl_client_cert 4046 1_1_0 EXIST::FUNCTION:ENGINE
-ENGINE_load_capi 4047 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_capi 4047 1_1_0 NOEXIST::FUNCTION:
OPENSSL_isservice 4048 1_1_0 EXIST::FUNCTION:
FIPS_dsa_sig_decode 4049 1_1_0 NOEXIST::FUNCTION:
EVP_CIPHER_CTX_clear_flags 4050 1_1_0 EXIST::FUNCTION:
EVP_aes_128_cbc_hmac_sha1 4637 1_1_0 EXIST::FUNCTION:AES
CRYPTO_gcm128_tag 4638 1_1_0 EXIST::FUNCTION:
CRYPTO_ccm128_encrypt_ccm64 4639 1_1_0 EXIST::FUNCTION:
-ENGINE_load_rdrand 4640 1_1_0 EXIST::FUNCTION:ENGINE
+ENGINE_load_rdrand 4640 1_1_0 NOEXIST::FUNCTION:
CRYPTO_ccm128_setiv 4641 1_1_0 EXIST::FUNCTION:
CRYPTO_nistcts128_encrypt_block 4642 1_1_0 EXIST::FUNCTION:
CRYPTO_gcm128_aad 4643 1_1_0 EXIST::FUNCTION:
X509_aux_print 5009 1_1_0 EXIST::FUNCTION:STDIO
TS_RESP_CTX_set_signer_digest 5010 1_1_0 EXIST::FUNCTION:
TS_CONF_set_signer_digest 5011 1_1_0 EXIST::FUNCTION:
-ENGINE_load_dasync 5012 1_1_0 EXIST::FUNCTION:ENGINE,STATIC_ENGINE
+ENGINE_load_dasync 5012 1_1_0 NOEXIST::FUNCTION:
ASYNC_pause_job 5013 1_1_0 EXIST::FUNCTION:
ASYNC_start_job 5014 1_1_0 EXIST::FUNCTION:
ASYNC_init_thread 5015 1_1_0 EXIST::FUNCTION:
ERR_load_ASYNC_strings 5021 1_1_0 EXIST::FUNCTION:
ASYNC_unblock_pause 5022 1_1_0 EXIST::FUNCTION:
ASYNC_block_pause 5023 1_1_0 EXIST::FUNCTION:
-ASYNC_cleanup 5024 1_1_0 EXIST::FUNCTION:
-ASYNC_init 5025 1_1_0 EXIST::FUNCTION:
+ASYNC_cleanup 5024 1_1_0 NOEXIST::FUNCTION:
+ASYNC_init 5025 1_1_0 NOEXIST::FUNCTION:
EVP_MD_CTX_ctrl 5026 1_1_0 EXIST::FUNCTION:
EVP_md5_sha1 5027 1_1_0 EXIST::FUNCTION:MD5
CRYPTO_free_ex_index 5028 1_1_0 EXIST::FUNCTION:
projects / openssl.git / commitdiff