static void ec_pre_comp_clear_free(void *pre_)
{
int i;
EC_PRE_COMP *pre = pre_;
if (!pre)
return;
CRYPTO_atomic_add(&pre->references, -1, &i, pre->lock);
if (i > 0)
return;
CRYPTO_thread_cleanup(pre->lock);
if (pre->points) {
EC_POINT **p;
for (p = pre->points; *p != NULL; p++) {
EC_POINT_clear_free(*p);
vigortls_zeroize(p, sizeof *p);
}
free(pre->points);
}
vigortls_zeroize(pre, sizeof *pre);
free(pre);
}
int DSO_free(DSO *dso)
{
int i;
if (dso == NULL) {
DSOerr(DSO_F_DSO_FREE, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (CRYPTO_atomic_add(&dso->references, -1, &i, dso->lock) <= 0)
return 0;
if (i > 0)
return 1;
if ((dso->meth->dso_unload != NULL) && !dso->meth->dso_unload(dso)) {
DSOerr(DSO_F_DSO_FREE, DSO_R_UNLOAD_FAILED);
return 0;
}
if ((dso->meth->finish != NULL) && !dso->meth->finish(dso)) {
DSOerr(DSO_F_DSO_FREE, DSO_R_FINISH_FAILED);
return 0;
}
sk_void_free(dso->meth_data);
free(dso->filename);
free(dso->loaded_filename);
CRYPTO_thread_cleanup(dso->lock);
free(dso);
return 1;
}
int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it)
{
const ASN1_AUX *aux;
int *lck, ret;
CRYPTO_MUTEX **lock;
if ((it->itype != ASN1_ITYPE_SEQUENCE)
&& (it->itype != ASN1_ITYPE_NDEF_SEQUENCE))
return 0;
aux = it->funcs;
if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT))
return 0;
lck = offset2ptr(*pval, aux->ref_offset);
lock = offset2ptr(*pval, aux->ref_lock);
if (op == 0) {
*lck = 1;
*lock = CRYPTO_thread_new();
if (*lock == NULL)
return 0;
return 1;
}
CRYPTO_atomic_add(lck, op, &ret, *lock);
if (ret == 0)
CRYPTO_thread_cleanup(*lock);
return ret;
}
void cleanup()
{
pmesg(LOG_INFO, __FILE__, __LINE__, "Server shutdown\n");
oph_server_is_running = 0;
sleep(1);
mysql_library_end();
soap_destroy(psoap);
soap_end(psoap);
soap_done(psoap);
CRYPTO_thread_cleanup();
if (logfile) {
fclose(logfile);
fclose(stdout);
fclose(stderr);
}
if (oph_server_params)
hashtbl_destroy(oph_server_params);
#ifdef OPH_SERVER_LOCATION
if (oph_server_location)
free(oph_server_location);
#endif
if (orm)
free_oph_rmanager(orm);
if (ophDB)
oph_odb_free_ophidiadb(ophDB);
#if defined(_POSIX_THREADS) || defined(_SC_THREADS)
pthread_mutex_destroy(&global_flag);
pthread_mutex_destroy(&libssh2_flag);
pthread_cond_destroy(&termination_flag);
#endif
oph_tp_end_xml_parser();
}
int main()
{ struct soap soap;
double a, b, result;
/* Init SSL */
soap_ssl_init();
if (CRYPTO_thread_setup())
{ fprintf(stderr, "Cannot setup thread mutex for OpenSSL\n");
exit(1);
}
a = 10.0;
b = 20.0;
/* Init gSOAP context */
soap_init(&soap);
/* The supplied server certificate "server.pem" assumes that the server is
running on 'localhost', so clients can only connect from the same host when
verifying the server's certificate. Use SOAP_SSL_NO_AUTHENTICATION to omit
the authentication of the server and use encryption directly from any site.
To verify the certificates of third-party services, they must provide a
certificate issued by Verisign or another trusted CA. At the client-side,
the capath parameter should point to a directory that contains these
trusted (root) certificates or the cafile parameter should refer to one
file will all certificates. To help you out, the supplied "cacerts.pem"
file contains the certificates issued by various CAs. You should use this
file for the cafile parameter instead of "cacert.pem" to connect to trusted
servers. Note that the client may fail to connect if the server's
credentials have problems (e.g. expired). Use SOAP_SSL_NO_AUTHENTICATION
and set cacert to NULL to encrypt messages if you don't care about the
trustworthyness of the server. Note: setting capath may not work on
Windows.
*/
if (soap_ssl_client_context(&soap,
/* SOAP_SSL_NO_AUTHENTICATION, */ /* for encryption w/o authentication */
/* SOAP_SSL_DEFAULT | SOAP_SSL_SKIP_HOST_CHECK, */ /* if we don't want the host name checks since these will change from machine to machine */
SOAP_SSL_DEFAULT, /* use SOAP_SSL_DEFAULT in production code */
NULL, /* keyfile (cert+key): required only when client must authenticate to server (see SSL docs to create this file) */
NULL, /* password to read the keyfile */
"cacert.pem", /* optional cacert file to store trusted certificates, use cacerts.pem for all public certificates issued by common CAs */
NULL, /* optional capath to directory with trusted certificates */
NULL /* if randfile!=NULL: use a file with random data to seed randomness */
))
{ soap_print_fault(&soap, stderr);
exit(1);
}
soap.connect_timeout = 60; /* try to connect for 1 minute */
soap.send_timeout = soap.recv_timeout = 30; /* if I/O stalls, then timeout after 30 seconds */
if (soap_call_ns__add(&soap, server, "", a, b, &result) == SOAP_OK)
fprintf(stdout, "Result: %f + %f = %f\n", a, b, result);
else
soap_print_fault(&soap, stderr);
soap_destroy(&soap); /* C++ */
soap_end(&soap);
soap_done(&soap);
CRYPTO_thread_cleanup();
return 0;
}
static int luaclose_openssl(lua_State *L)
{
if(atomic_fetch_sub(&init, 1) > 1)
return 0;
#if !defined(LIBRESSL_VERSION_NUMBER)
FIPS_mode_set(0);
#endif
OBJ_cleanup();
EVP_cleanup();
ENGINE_cleanup();
RAND_cleanup();
#if OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(LIBRESSL_VERSION_NUMBER)
SSL_COMP_free_compression_methods();
#endif
COMP_zlib_cleanup();
#if OPENSSL_VERSION_NUMBER < 0x10000000L
ERR_remove_state(0);
#elif OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
ERR_remove_thread_state(NULL);
#endif
#if defined(OPENSSL_THREADS)
CRYPTO_thread_cleanup();
#endif
CRYPTO_set_locking_callback(NULL);
CRYPTO_set_id_callback(NULL);
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
CONF_modules_free();
CONF_modules_unload(1);
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
#if !(defined(OPENSSL_NO_STDIO) || defined(OPENSSL_NO_FP_API))
#if defined(LIBRESSL_VERSION_NUMBER) || OPENSSL_VERSION_NUMBER < 0x10101000L
CRYPTO_mem_leaks_fp(stderr);
#else
if(CRYPTO_mem_leaks_fp(stderr)!=1)
{
fprintf(stderr,
"Please report a bug on https://github.com/zhaozg/lua-openssl."
"And if can, please provide a reproduce method and minimal code.\n"
"\n\tThank You.");
}
#endif
#endif /* OPENSSL_NO_STDIO or OPENSSL_NO_FP_API */
#endif /* OPENSSL_NO_CRYPTO_MDEBUG */
return 0;
}
static void ec_pre_comp_free(void *pre_)
{
int i;
EC_PRE_COMP *pre = pre_;
if (pre == NULL)
return;
CRYPTO_atomic_add(&pre->references, -1, &i, pre->lock);
if (i > 0)
return;
CRYPTO_thread_cleanup(pre->lock);
if (pre->points) {
EC_POINT **p;
for (p = pre->points; *p != NULL; p++)
EC_POINT_free(*p);
free(pre->points);
}
free(pre);
}
int main(int argc, char **argv)
{
static const int count = 10;
pthread_t thread[count];
soap_ssl_init();
if (CRYPTO_thread_setup())
{
fprintf(stderr, "Cannot setup thread mutex for OpenSSL\n");
exit(1);
}
/*for (int i = 0; i < count; ++i)
{
pthread_create(&thread[i], NULL, thread_func, NULL);
}*/
pthread_create(&thread[0], NULL, thread_func, NULL);
pthread_create(&thread[1], NULL, thread_func_1, NULL);
pthread_create(&thread[2], NULL, thread_func_2, NULL);
pthread_create(&thread[3], NULL, thread_func_3, NULL);
pthread_create(&thread[4], NULL, thread_func_4, NULL);
pthread_create(&thread[5], NULL, thread_func_5, NULL);
pthread_create(&thread[6], NULL, thread_func_6, NULL);
pthread_create(&thread[7], NULL, thread_func_7, NULL);
pthread_create(&thread[8], NULL, thread_func_8, NULL);
pthread_create(&thread[9], NULL, thread_func_9, NULL);
while (1)
{
sleep(1);
}
CRYPTO_thread_cleanup();
return 0;
}
