Commit bdd07c78 authored by Rich Salz's avatar Rich Salz
Browse files

Convert shlibloadtest to new framework 



Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3399)
parent 1d0f116e

test/build.info

+1 −0
Original line number Diff line number Diff line
@@ -329,6 +329,7 @@ INCLUDE_MAIN___test_libtestutil_OLB = /INCLUDE=MAIN 
    PROGRAMS_NO_INST=shlibloadtest

    SOURCE[shlibloadtest]=shlibloadtest.c

    INCLUDE[shlibloadtest]=../include

    DEPEND[shlibloadtest]=libtestutil.a

  ENDIF



  IF[{- $disabled{shared} -}]

test/shlibloadtest.c

+108 −144
Original line number Diff line number Diff line
@@ -11,33 +11,25 @@ 
#include <string.h>

#include <stdlib.h>

#include <openssl/opensslv.h>

#include <openssl/ssl.h>

#include <openssl/ossl_typ.h>

#include "testutil.h"



/* The test is only currently implemented for DSO_DLFCN and DSO_WIN32 */

#if defined(DSO_DLFCN) || defined(DSO_WIN32)



#define SSL_CTX_NEW "SSL_CTX_new"

#define SSL_CTX_FREE "SSL_CTX_free"

#define TLS_METHOD "TLS_method"

#if !defined(DSO_DLFCN) && !defined(DSO_WIN32)

int main(void)

{

    TEST_info("Not implemented on this platform\n");

    return 0;

}



#define ERR_GET_ERROR "ERR_get_error"

#define OPENSSL_VERSION_NUM_FUNC "OpenSSL_version_num"

#else



typedef struct ssl_ctx_st SSL_CTX;

typedef struct ssl_method_st SSL_METHOD;

typedef const SSL_METHOD * (*TLS_method_t)(void);

typedef SSL_CTX * (*SSL_CTX_new_t)(const SSL_METHOD *meth);

typedef void (*SSL_CTX_free_t)(SSL_CTX *);



typedef unsigned long (*ERR_get_error_t)(void);

typedef unsigned long (*OpenSSL_version_num_t)(void);



static TLS_method_t TLS_method;

static SSL_CTX_new_t SSL_CTX_new;

static SSL_CTX_free_t SSL_CTX_free;



static ERR_get_error_t ERR_get_error;

static OpenSSL_version_num_t OpenSSL_version_num;



#ifdef DSO_DLFCN



# include <dlfcn.h>
@@ -49,29 +41,22 @@ typedef void * SHLIB_SYM; 
static int shlib_load(const char *filename, SHLIB *lib)

{

    *lib = dlopen(filename, RTLD_GLOBAL | RTLD_LAZY);



    if (*lib == NULL)

        return 0;



    return 1;

    return *lib == NULL ? 0 : 1;

}



static int shlib_sym(SHLIB lib, const char *symname, SHLIB_SYM *sym)

{

    *sym = dlsym(lib, symname);



    return *sym != NULL;

}



static int shlib_close(SHLIB lib)

{

    if (dlclose(lib) != 0)

        return 0;



    return 1;

    return dlclose(lib) != 0 ? 0 : 1;

}

#endif



#elif defined(DSO_WIN32)

#ifdef DSO_WIN32



# include <windows.h>
@@ -82,150 +67,129 @@ typedef void * SHLIB_SYM; 
static int shlib_load(const char *filename, SHLIB *lib)

{

    *lib = LoadLibraryA(filename);

    if (*lib == NULL)

        return 0;



    return 1;

    return *lib == NULL ? 0 : 1;

}



static int shlib_sym(SHLIB lib, const char *symname, SHLIB_SYM *sym)

{

    *sym = (SHLIB_SYM)GetProcAddress(lib, symname);



    return *sym != NULL;

}



static int shlib_close(SHLIB lib)

{

    if (FreeLibrary(lib) == 0)

        return 0;



    return 1;

    return FreeLibrary(lib) == 0 ? 0 : 1;

}



#endif



# define CRYPTO_FIRST_OPT    "-crypto_first"

# define SSL_FIRST_OPT       "-ssl_first"

# define JUST_CRYPTO_OPT     "-just_crypto"



enum test_types_en {

typedef enum test_types_en {

    CRYPTO_FIRST,

    SSL_FIRST,

    JUST_CRYPTO

};

} TEST_TYPE;



int main(int argc, char **argv)

static TEST_TYPE test_type;

static const char *path_crypto;

static const char *path_ssl;



static int test_lib(void)

{

    SHLIB ssllib = SHLIB_INIT, cryptolib = SHLIB_INIT;

    SHLIB ssllib = SHLIB_INIT;

    SHLIB cryptolib = SHLIB_INIT;

    SSL_CTX *ctx;

    union {

        void (*func)(void);

        SHLIB_SYM sym;

    } tls_method_sym, ssl_ctx_new_sym, ssl_ctx_free_sym, err_get_error_sym,

    openssl_version_num_sym;

    enum test_types_en test_type;

    int i;

    } symbols[3];

    TLS_method_t myTLS_method;

    SSL_CTX_new_t mySSL_CTX_new;

    SSL_CTX_free_t mySSL_CTX_free;

    ERR_get_error_t myERR_get_error;

    OpenSSL_version_num_t myOpenSSL_version_num;

    int result = 0;



    switch (test_type) {

    case JUST_CRYPTO:

        if (!TEST_true(shlib_load(path_crypto, &cryptolib)))

            goto end;

        break;

    case CRYPTO_FIRST:

        if (!TEST_true(shlib_load(path_crypto, &cryptolib))

                || !TEST_true(shlib_load(path_ssl, &ssllib)))

            goto end;

    case SSL_FIRST:

        if (!TEST_true(shlib_load(path_ssl, &ssllib))

                || !TEST_true(shlib_load(path_crypto, &cryptolib)))

            goto end;

        break;

    }



    if (test_type != JUST_CRYPTO) {

        if (!TEST_true(shlib_sym(ssllib, "TLS_method", &symbols[0].sym))

                || !TEST_true(shlib_sym(ssllib, "SSL_CTX_new", &symbols[1].sym))

                || !TEST_true(shlib_sym(ssllib, "SSL_CTX_free", &symbols[2].sym)))

            goto end;

        myTLS_method = (TLS_method_t)symbols[0].func;

        mySSL_CTX_new = (SSL_CTX_new_t)symbols[1].func;

        mySSL_CTX_free = (SSL_CTX_free_t)symbols[2].func;

        if (!TEST_ptr(ctx = mySSL_CTX_new(myTLS_method())))

            goto end;

        mySSL_CTX_free(ctx);

    }



    if (!TEST_true(shlib_sym(cryptolib, "ERR_get_error", &symbols[0].sym))

            || !TEST_true(shlib_sym(cryptolib, "OpenSSL_version_num",

                                    &symbols[1].sym)))

        goto end;

    myERR_get_error = (ERR_get_error_t)symbols[0].func;

    if (!TEST_int_eq(myERR_get_error(), 0))

        goto end;

    myOpenSSL_version_num = (OpenSSL_version_num_t)symbols[1].func;

    if (!TEST_int_eq(myOpenSSL_version_num(), OPENSSL_VERSION_NUMBER))

        goto end;



    switch (test_type) {

    case JUST_CRYPTO:

        if (!TEST_true(shlib_close(cryptolib)))

            goto end;

        break;

    case CRYPTO_FIRST:

        if (!TEST_true(shlib_close(cryptolib))

                || !TEST_true(shlib_close(ssllib)))

            goto end;

    case SSL_FIRST:

        if (!TEST_true(shlib_close(ssllib))

                || !TEST_true(shlib_close(cryptolib)))

            goto end;

        break;

    }



    result = 1;

end:

    return result;

}



int test_main(int argc, char **argv)

{

    if (argc != 4) {

        printf("Unexpected number of arguments\n");

        return 1;

        TEST_error("Unexpected number of arguments");

        return EXIT_FAILURE;

    }



    if (strcmp(argv[1], CRYPTO_FIRST_OPT) == 0) {

    if (strcmp(argv[1], "-crypto_first") == 0) {

        test_type = CRYPTO_FIRST;

    } else if (strcmp(argv[1], SSL_FIRST_OPT) == 0) {

    } else if (strcmp(argv[1], "-ssl_first") == 0) {

        test_type = SSL_FIRST;

    } else if (strcmp(argv[1], JUST_CRYPTO_OPT) == 0) {

    } else if (strcmp(argv[1], "-just_crypto") == 0) {

        test_type = JUST_CRYPTO;

    } else {

        printf("Unrecognised argument\n");

        return 1;

        TEST_error("Unrecognised argument");

        return EXIT_FAILURE;

    }

    path_crypto = argv[2];

    path_ssl = argv[3];



    for (i = 0; i < 2; i++) {

        if ((i == 0 && (test_type == CRYPTO_FIRST

                       || test_type == JUST_CRYPTO))

               || (i == 1 && test_type == SSL_FIRST)) {

            if (!shlib_load(argv[2], &cryptolib)) {

                printf("Unable to load libcrypto\n");

                return 1;

            }

        }

        if ((i == 0 && test_type == SSL_FIRST)

                || (i == 1 && test_type == CRYPTO_FIRST)) {

            if (!shlib_load(argv[3], &ssllib)) {

                printf("Unable to load libssl\n");

                return 1;

            }

        }

    }



    if (test_type != JUST_CRYPTO) {

        if (!shlib_sym(ssllib, TLS_METHOD, &tls_method_sym.sym)

                || !shlib_sym(ssllib, SSL_CTX_NEW, &ssl_ctx_new_sym.sym)

                || !shlib_sym(ssllib, SSL_CTX_FREE, &ssl_ctx_free_sym.sym)) {

            printf("Unable to load ssl symbols\n");

            return 1;

        }



        TLS_method = (TLS_method_t)tls_method_sym.func;

        SSL_CTX_new = (SSL_CTX_new_t)ssl_ctx_new_sym.func;

        SSL_CTX_free = (SSL_CTX_free_t)ssl_ctx_free_sym.func;



        ctx = SSL_CTX_new(TLS_method());

        if (ctx == NULL) {

            printf("Unable to create SSL_CTX\n");

            return 1;

        }

        SSL_CTX_free(ctx);

    }



    if (!shlib_sym(cryptolib, ERR_GET_ERROR, &err_get_error_sym.sym)

            || !shlib_sym(cryptolib, OPENSSL_VERSION_NUM_FUNC,

                          &openssl_version_num_sym.sym)) {

        printf("Unable to load crypto symbols\n");

        return 1;

    }



    ERR_get_error = (ERR_get_error_t)err_get_error_sym.func;

    OpenSSL_version_num = (OpenSSL_version_num_t)openssl_version_num_sym.func;



    if (ERR_get_error() != 0) {

        printf("Unexpected error in error queue\n");

        return 1;

    }



    if (OpenSSL_version_num() != OPENSSL_VERSION_NUMBER) {

        printf("Unexpected library version loaded\n");

        return 1;

    }



    for (i = 0; i < 2; i++) {

        if ((i == 0 && test_type == CRYPTO_FIRST)

                || (i == 1 && test_type == SSL_FIRST)) {

            if (!shlib_close(ssllib)) {

                printf("Unable to close libssl\n");

                return 1;

            }

        }

        if ((i == 0 && (test_type == SSL_FIRST

                       || test_type == JUST_CRYPTO))

                || (i == 1 && test_type == CRYPTO_FIRST)) {

            if (!shlib_close(cryptolib)) {

                printf("Unable to close libcrypto\n");

                return 1;

            }

        }

    }



    printf("Success\n");

    return 0;

}

#else

int main(void)

{

    printf("Test not implemented on this platform\n");

    return 0;

    ADD_TEST(test_lib);

    return run_tests(argv[0]);

}

#endif