Convert shlibloadtest to new framework
authorRich Salz <rsalz@openssl.org>
Fri, 5 May 2017 21:39:13 +0000 (17:39 -0400)
committerRich Salz <rsalz@openssl.org>
Fri, 12 May 2017 18:30:08 +0000 (14:30 -0400)
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3399)

test/build.info
test/shlibloadtest.c

index da7620c..42dc1d6 100644 (file)
@@ -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} -}]
index 6f220ba..0a4d5f7 100644 (file)
 #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>
 
-typedef void * SHLIB;
-typedef void * SHLIB_SYM;
+typedef void *SHLIB;
+typedef void *SHLIB_SYM;
 # define SHLIB_INIT NULL
 
 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>
 
 typedef HINSTANCE SHLIB;
-typedef void * SHLIB_SYM;
+typedef void *SHLIB_SYM;
 # define SHLIB_INIT 0
 
 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);
+        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;
-
-    if (argc != 4) {
-        printf("Unexpected number of arguments\n");
-        return 1;
-    }
-
-    if (strcmp(argv[1], CRYPTO_FIRST_OPT) == 0) {
-        test_type = CRYPTO_FIRST;
-    } else if (strcmp(argv[1], SSL_FIRST_OPT) == 0) {
-            test_type = SSL_FIRST;
-    } else if (strcmp(argv[1], JUST_CRYPTO_OPT) == 0) {
-            test_type = JUST_CRYPTO;
-    } else {
-        printf("Unrecognised argument\n");
-        return 1;
-    }
-
-    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;
-            }
-        }
+    } 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 (!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 (!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 (!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;
+    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;
     }
 
-    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;
-    }
+    result = 1;
+end:
+    return result;
+}
 
-    if (OpenSSL_version_num() != OPENSSL_VERSION_NUMBER) {
-        printf("Unexpected library version loaded\n");
-        return 1;
+int test_main(int argc, char **argv)
+{
+    if (argc != 4) {
+        TEST_error("Unexpected number of arguments");
+        return EXIT_FAILURE;
     }
 
-    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;
-            }
-        }
+    if (strcmp(argv[1], "-crypto_first") == 0) {
+        test_type = CRYPTO_FIRST;
+    } else if (strcmp(argv[1], "-ssl_first") == 0) {
+        test_type = SSL_FIRST;
+    } else if (strcmp(argv[1], "-just_crypto") == 0) {
+        test_type = JUST_CRYPTO;
+    } else {
+        TEST_error("Unrecognised argument");
+        return EXIT_FAILURE;
     }
+    path_crypto = argv[2];
+    path_ssl = argv[3];
 
-    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