return b;
}
-void destroy_prefix_method()
+void destroy_prefix_method(void)
{
BIO_meth_free(prefix_method);
prefix_method = NULL;
dc->columns = (80 - 1) / dc->width;
}
-static int apps_startup()
+static int apps_startup(void)
{
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
return 1;
}
-static void apps_shutdown()
+static void apps_shutdown(void)
{
destroy_ui_method();
destroy_prefix_method();
}
-static char *make_config_name()
+static char *make_config_name(void)
{
const char *t;
size_t len;
return bio_type_lock != NULL;
}
-int BIO_get_new_index()
+int BIO_get_new_index(void)
{
static CRYPTO_REF_COUNT bio_count = BIO_TYPE_START;
int newval;
def_load
};
-CONF_METHOD *NCONF_default()
+CONF_METHOD *NCONF_default(void)
{
return &default_method;
}
-CONF_METHOD *NCONF_WIN32()
+CONF_METHOD *NCONF_WIN32(void)
{
return &WIN32_method;
}
*/
static void ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX* ctx);
-static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new()
+static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new(void)
{
CTLOG_STORE_LOAD_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
return 1;
}
-void ENGINE_register_all_ciphers()
+void ENGINE_register_all_ciphers(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_DH()
+void ENGINE_register_all_DH(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_digests()
+void ENGINE_register_all_digests(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_DSA()
+void ENGINE_register_all_DSA(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_EC()
+void ENGINE_register_all_EC(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_pkey_meths()
+void ENGINE_register_all_pkey_meths(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_RAND()
+void ENGINE_register_all_RAND(void)
{
ENGINE *e;
return 1;
}
-void ENGINE_register_all_RSA()
+void ENGINE_register_all_RSA(void)
{
ENGINE *e;
#endif /* IMPLEMENTED */
}
-int CRYPTO_secure_malloc_done()
+int CRYPTO_secure_malloc_done(void)
{
#ifdef IMPLEMENTED
if (secure_mem_used == 0) {
return 0;
}
-int CRYPTO_secure_malloc_initialized()
+int CRYPTO_secure_malloc_initialized(void)
{
#ifdef IMPLEMENTED
return secure_mem_initialized;
#endif /* IMPLEMENTED */
}
-size_t CRYPTO_secure_used()
+size_t CRYPTO_secure_used(void)
{
#ifdef IMPLEMENTED
return secure_mem_used;
return 0;
}
-static void sh_done()
+static void sh_done(void)
{
OPENSSL_free(sh.freelist);
OPENSSL_free(sh.bittable);
#include "internal/poly1305.h"
#include "poly1305_local.h"
-size_t Poly1305_ctx_size ()
+size_t Poly1305_ctx_size(void)
{
return sizeof(struct poly1305_context);
}
}
}
-void drbg_delete_thread_state()
+void drbg_delete_thread_state(void)
{
RAND_DRBG *drbg;
OPENSSL_secure_clear_free(out, outlen);
}
-void rand_fork()
+void rand_fork(void)
{
rand_fork_count++;
}
&& ossl_store_file_loader_init();
}
-int ossl_store_init_once()
+int ossl_store_init_once(void)
{
if (!RUN_ONCE(&store_init, do_store_init)) {
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INIT_ONCE, ERR_R_MALLOC_FAILURE);
/* TS_RESP_CTX management functions. */
-TS_RESP_CTX *TS_RESP_CTX_new()
+TS_RESP_CTX *TS_RESP_CTX_new(void)
{
TS_RESP_CTX *ctx;
return a->type;
}
-X509_OBJECT *X509_OBJECT_new()
+X509_OBJECT *X509_OBJECT_new(void)
{
X509_OBJECT *ret = OPENSSL_zalloc(sizeof(*ret));
OPENSSL_free(item);
}
-pqueue *pqueue_new()
+pqueue *pqueue_new(void)
{
pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
unsigned int wctr;
};
-static const BIO_METHOD *bio_f_async_filter()
+static const BIO_METHOD *bio_f_async_filter(void)
{
if (methods_async == NULL) {
methods_async = BIO_meth_new(BIO_TYPE_ASYNC_FILTER, "Async filter");
return 1;
}
-static int test_ASYNC_init_thread()
+static int test_ASYNC_init_thread(void)
{
ASYNC_JOB *job1 = NULL, *job2 = NULL, *job3 = NULL;
int funcret1, funcret2, funcret3;
return 1;
}
-static int test_ASYNC_start_job()
+static int test_ASYNC_start_job(void)
{
ASYNC_JOB *job = NULL;
int funcret;
return 1;
}
-static int test_ASYNC_get_current_job()
+static int test_ASYNC_get_current_job(void)
{
ASYNC_JOB *job = NULL;
int funcret;
return 1;
}
-static int test_ASYNC_WAIT_CTX_get_all_fds()
+static int test_ASYNC_WAIT_CTX_get_all_fds(void)
{
ASYNC_JOB *job = NULL;
int funcret;
return 1;
}
-static int test_ASYNC_block_pause()
+static int test_ASYNC_block_pause(void)
{
ASYNC_JOB *job = NULL;
int funcret;
return result;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_default_cipherlist_implicit);
ADD_TEST(test_default_cipherlist_explicit);
}
/* Resets all drbg hook contexts */
-static void reset_drbg_hook_ctx()
+static void reset_drbg_hook_ctx(void)
{
reset_hook_ctx(&master_ctx);
reset_hook_ctx(&public_ctx);
return ret;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(run_mtu_tests);
return 1;
}
#endif
-int setup_tests()
+int setup_tests(void)
{
#ifndef OPENSSL_NO_SOCK
ADD_ALL_TESTS(dtls_listen_test, (int)OSSL_NELEM(testpackets));
/*
* Is the key type an unsupported algorithm?
*/
-static int key_unsupported()
+static int key_unsupported(void)
{
long err = ERR_peek_error();
int st;
} MYOBJ;
-static MYOBJ *MYOBJ_new()
+static MYOBJ *MYOBJ_new(void)
{
static int count = 0;
MYOBJ *obj = OPENSSL_malloc(sizeof(*obj));
# include <openssl/$name.h>
#endif
-int main()
+int main(void)
{
return 0;
}
#include "handshake_helper.h"
#include "testutil.h"
-HANDSHAKE_RESULT *HANDSHAKE_RESULT_new()
+HANDSHAKE_RESULT *HANDSHAKE_RESULT_new(void)
{
HANDSHAKE_RESULT *ret;
return 1;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_ALL_TESTS(test_mdc2, OSSL_NELEM(tests));
return 1;
CTS128_TEST_VECTOR(64),
};
-static AES_KEY *cts128_encrypt_key_schedule()
+static AES_KEY *cts128_encrypt_key_schedule(void)
{
static int init_key = 1;
static AES_KEY ks;
return &ks;
}
-static AES_KEY *cts128_decrypt_key_schedule()
+static AES_KEY *cts128_decrypt_key_schedule(void)
{
static int init_key = 1;
static AES_KEY ks;
}
#endif
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_kdf_tls1_prf);
ADD_TEST(test_kdf_hkdf);
return good;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_asn1_meths);
ADD_TEST(test_pkey_meths);
size_t OPENSSL_ia32_rdrand_bytes(unsigned char *buf, size_t len);
size_t OPENSSL_ia32_rdseed_bytes(unsigned char *buf, size_t len);
-void OPENSSL_cpuid_setup();
+void OPENSSL_cpuid_setup(void);
extern unsigned int OPENSSL_ia32cap_P[4];
return testresult;
}
-static int sanity_check_rdrand_bytes()
+static int sanity_check_rdrand_bytes(void)
{
return sanity_check_bytes(OPENSSL_ia32_rdrand_bytes, 1000, 0, 10, 10);
}
-static int sanity_check_rdseed_bytes()
+static int sanity_check_rdseed_bytes(void)
{
/*-
* RDSEED may take many retries to succeed; note that this is effectively
return sanity_check_bytes(OPENSSL_ia32_rdseed_bytes, 1000, 1, 10000, 10);
}
-int setup_tests() {
+int setup_tests(void)
+{
OPENSSL_cpuid_setup();
int have_rdseed = (OPENSSL_ia32cap_P[2] & (1 << 18)) != 0;
#else
-int setup_tests()
+int setup_tests(void)
{
return 1;
}
return 1;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_ssl_cert_table);
return 1;
{ "SessionTicketAppData", &parse_server_session_ticket_app_data },
};
-SSL_TEST_CTX *SSL_TEST_CTX_new()
+SSL_TEST_CTX *SSL_TEST_CTX_new(void)
{
SSL_TEST_CTX *ret;
*/
static const char **cipher_list = NULL;
-static int setup_cipher_list()
+static int setup_cipher_list(void)
{
SSL_CTX *ctx = NULL;
SSL *ssl = NULL;
return 1;
}
-static int verify_serverinfo()
+static int verify_serverinfo(void)
{
if (serverinfo_sct != serverinfo_sct_seen)
return -1;
* $ openssl dhparam -C -noout -dsaparam 1024
* (The third function has been renamed to avoid name conflicts.)
*/
-static DH *get_dh512()
+static DH *get_dh512(void)
{
static unsigned char dh512_p[] = {
0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
return dh;
}
-static DH *get_dh1024()
+static DH *get_dh1024(void)
{
static unsigned char dh1024_p[] = {
0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
return dh;
}
-static DH *get_dh1024dsa()
+static DH *get_dh1024dsa(void)
{
static unsigned char dh1024_p[] = {
0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
return 1;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_ALL_TESTS(test_offset, OSSL_NELEM(tests));
return 1;
static BIO_METHOD *method_watchccs = NULL;
-static const BIO_METHOD *bio_f_watchccs_filter()
+static const BIO_METHOD *bio_f_watchccs_filter(void)
{
if (method_watchccs == NULL) {
method_watchccs = BIO_meth_new(BIO_TYPE_WATCHCCS_FILTER,
return ret;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_handshake_secrets);
return 1;
{set_altname_email, "set rfc822Name", 0, 1},
};
-static X509 *make_cert()
+static X509 *make_cert(void)
{
X509 *crt = NULL;
return good;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_standard_exts);
return 1;
return ret;
}
-int setup_tests()
+int setup_tests(void)
{
ADD_TEST(test_x509_cmp_time_current);
ADD_ALL_TESTS(test_x509_cmp_time, OSSL_NELEM(x509_cmp_tests));