�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2F'>extra</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2Fwolfssl%2F'>wolfssl</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2Fwolfssl%2Fwolfssl%2F'>wolfssl</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2Fwolfssl%2Fwolfssl%2Ftestsuite%2F'>testsuite</a>/</p><hr><h3>✏️ Editing: testsuite.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* testsuite.c
 *
 * Copyright (C) 2006-2024 wolfSSL Inc.
 *
 * This file is part of wolfSSL.
 *
 * wolfSSL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * wolfSSL is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
 */


#ifdef HAVE_CONFIG_H
    #include &lt;config.h&gt;
#endif

#ifndef WOLFSSL_USER_SETTINGS
    #include &lt;wolfssl/options.h&gt;
#endif
#include &lt;wolfssl/wolfcrypt/settings.h&gt;

#undef TEST_OPENSSL_COEXIST /* can&#039;t use this option with this example */
#undef OPENSSL_COEXIST /* can&#039;t use this option with this example */

#include &lt;wolfssl/wolfcrypt/types.h&gt;

#include &lt;wolfssl/ssl.h&gt;
#include &lt;wolfssl/test.h&gt;
#include &lt;wolfcrypt/test/test.h&gt;


#ifndef SINGLE_THREADED

#ifdef OPENSSL_EXTRA
#include &lt;wolfssl/openssl/ssl.h&gt;
#endif
#include &lt;wolfssl/wolfcrypt/sha256.h&gt;
#include &lt;wolfssl/wolfcrypt/ecc.h&gt;

#include &lt;examples/echoclient/echoclient.h&gt;
#include &lt;examples/echoserver/echoserver.h&gt;
#include &lt;examples/server/server.h&gt;
#include &lt;examples/client/client.h&gt;

#include &quot;tests/utils.h&quot;

#ifndef NO_SHA256
void file_test(const char* file, byte* check);
#endif

#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    !defined(NO_TLS)

#ifdef HAVE_STACK_SIZE
static THREAD_RETURN simple_test(func_args *args);
#else
static void simple_test(func_args *args);
#endif
static int test_tls(func_args* server_args);
#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    defined(HAVE_CRL) &amp;&amp; defined(HAVE_CRL_MONITOR)
static int test_crl_monitor(void);
#endif
static void show_ciphers(void);
static void cleanup_output(void);
static int validate_cleanup_output(void);

enum {
    NUMARGS = 3
};

static const char *outputName;
#endif

int myoptind = 0;
char* myoptarg = NULL;

#ifndef NO_TESTSUITE_MAIN_DRIVER

    static int testsuite_test(int argc, char** argv);

    int main(int argc, char** argv)
    {
        return testsuite_test(argc, argv);
    }

#endif /* NO_TESTSUITE_MAIN_DRIVER */

#ifdef HAVE_STACK_SIZE
/* Wrap TLS echo client to free thread locals. */
static void *echoclient_test_wrapper(void* args) {
    echoclient_test(args);

#if defined(HAVE_ECC) &amp;&amp; defined(FP_ECC) &amp;&amp; defined(HAVE_THREAD_LS)
    wc_ecc_fp_free();  /* free per thread cache */
#endif

    return (void *)0;
}
#endif

int testsuite_test(int argc, char** argv)
{
#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    !defined(NO_TLS) &amp;&amp; \
    (!defined(WOLF_CRYPTO_CB_ONLY_RSA) &amp;&amp; !defined(WOLF_CRYPTO_CB_ONLY_ECC))
    func_args server_args;

    tcp_ready ready;
#if !defined(NETOS)
    THREAD_TYPE serverThread;

    int ret;
#endif

#ifndef USE_WINDOWS_API
    const char *tempDir = NULL;
    char tempName[128];
    int tempName_len;
    int tempName_Xnum;
#else
    char tempName[] = &quot;fnXXXXXX&quot;;
    const int tempName_len = 8;
    const int tempName_Xnum = 6;
#endif
#ifdef HAVE_STACK_SIZE
    void *serverThreadStackContext = NULL;
#endif

#ifndef USE_WINDOWS_API
#ifdef XGETENV
    tempDir = XGETENV(&quot;TMPDIR&quot;);
    if (tempDir == NULL)
#endif
    {
        tempDir = &quot;/tmp&quot;;
    }
    XSTRLCPY(tempName, tempDir, sizeof(tempName));
    XSTRLCAT(tempName, &quot;/testsuite-output-XXXXXX&quot;, sizeof(tempName));
    tempName_len = (int)XSTRLEN(tempName);
    tempName_Xnum = 6;
#endif /* !USE_WINDOWS_API */

#ifdef HAVE_WNR
    if (wc_InitNetRandom(wnrConfig, NULL, 5000) != 0) {
        err_sys(&quot;Whitewood netRandom global config failed&quot;);
        return -1237;
    }
#endif /* HAVE_WNR */

    StartTCP();

    server_args.argc = argc;
    server_args.argv = argv;

    wolfSSL_Init();
#if defined(DEBUG_WOLFSSL) &amp;&amp; !defined(HAVE_VALGRIND)
    wolfSSL_Debugging_ON();
#endif

#if !defined(WOLFSSL_TIRTOS)
    ChangeToWolfRoot();
#endif

#ifdef WOLFSSL_TIRTOS
    fdOpenSession(Task_self());
#endif

    server_args.signal = &amp;ready;
    InitTcpReady(&amp;ready);

#ifndef NO_CRYPT_TEST
    /* wc_ test */
    #ifdef HAVE_STACK_SIZE
        StackSizeCheck(&amp;server_args, wolfcrypt_test);
    #else
        wolfcrypt_test(&amp;server_args);
    #endif
    if (server_args.return_code != 0) return server_args.return_code;
#endif

    /* Simple wolfSSL client server test */
    #ifdef HAVE_STACK_SIZE
        StackSizeCheck(&amp;server_args, (THREAD_RETURN (*)(void *))simple_test);
    #else
        simple_test(&amp;server_args);
    #endif
    if (server_args.return_code != 0) return server_args.return_code;
#if !defined(NETOS)
    /* Echo input wolfSSL client server test */
    #ifdef HAVE_STACK_SIZE
        StackSizeCheck_launch(&amp;server_args, echoserver_test, &amp;serverThread,
                              &amp;serverThreadStackContext);
    #else
        start_thread(echoserver_test, &amp;server_args, &amp;serverThread);
    #endif

    /* Create unique file name */
    outputName = mymktemp(tempName, tempName_len, tempName_Xnum);
    if (outputName == NULL) {
        printf(&quot;Could not create unique file name&quot;);
        return EXIT_FAILURE;
    }

    ret = test_tls(&amp;server_args);
    if (ret != 0) {
        cleanup_output();
        return ret;
    }

    /* Server won&#039;t quit unless TLS test has worked. */
#ifdef HAVE_STACK_SIZE
    fputs(&quot;reaping echoserver_test: &quot;, stdout);
    StackSizeCheck_reap(serverThread, serverThreadStackContext);
#else
    join_thread(serverThread);
#endif
    if (server_args.return_code != 0) {
        cleanup_output();
        return server_args.return_code;
    }

#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    defined(HAVE_CRL) &amp;&amp; defined(HAVE_CRL_MONITOR)
    ret = test_crl_monitor();
    if (ret != 0) {
        cleanup_output();
        return ret;
    }
#endif

#endif /* !NETOS */

    show_ciphers();

#if !defined(NETOS)
    ret = validate_cleanup_output();
    if (ret != 0)
        return EXIT_FAILURE;
#endif

    wolfSSL_Cleanup();
    FreeTcpReady(&amp;ready);

#ifdef WOLFSSL_TIRTOS
    fdCloseSession(Task_self());
#endif

#ifdef HAVE_WNR
    if (wc_FreeNetRandom() &lt; 0)
        err_sys(&quot;Failed to free netRandom context&quot;);
#endif /* HAVE_WNR */

    printf(&quot;\nAll tests passed!\n&quot;);

#else
    (void)argc;
    (void)argv;
#endif /* !NO_WOLFSSL_SERVER &amp;&amp; !NO_WOLFSSL_CLIENT */

    return EXIT_SUCCESS;
}

#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    defined(HAVE_CRL) &amp;&amp; defined(HAVE_CRL_MONITOR)
#define CRL_MONITOR_TEST_ROUNDS 6
#define CRL_MONITOR_REM_FILE_ATTEMPTS 20

static int test_crl_monitor(void)
{
    func_args server_args;
    func_args client_args;
    THREAD_TYPE serverThread;
    tcp_ready ready;
    char buf[128];
    char tmpDir[16];
    char rounds[4];
    char portNum[8];
    const char* serverArgv[] = {
        &quot;testsuite&quot;,
        &quot;-A&quot;, &quot;certs/ca-cert.pem&quot;,
        &quot;--crl-dir&quot;, tmpDir,
        &quot;-C&quot;, rounds,
        &quot;--quieter&quot;,
        &quot;-x&quot;,
        &quot;-p&quot;, &quot;0&quot;
    };
    const char* clientArgv[] = {
        &quot;testsuite&quot;,
        &quot;-C&quot;,
        &quot;-c&quot;, &quot;certs/server-cert.pem&quot;,
        &quot;-k&quot;, &quot;certs/server-key.pem&quot;,
        &quot;--quieter&quot;,
        &quot;-H&quot;, &quot;exitWithRet&quot;,
        &quot;-p&quot;, portNum
    };
    int ret = -1;
    int i = -1, j;

    printf(&quot;\nRunning CRL monitor test\n&quot;);

    (void)XSNPRINTF(rounds, sizeof(rounds), &quot;%d&quot;, CRL_MONITOR_TEST_ROUNDS);

    XMEMSET(&amp;server_args, 0, sizeof(func_args));
    XMEMSET(&amp;client_args, 0, sizeof(func_args));

    /* Create temp dir */
    if (create_tmp_dir(tmpDir, sizeof(tmpDir) - 1) == NULL) {
        fprintf(stderr, &quot;Failed to create tmp dir&quot;);
        goto cleanup;
    }

    server_args.argv = (char**)serverArgv;
    server_args.argc = sizeof(serverArgv) / sizeof(*serverArgv);
    client_args.signal = server_args.signal = &amp;ready;
    client_args.argv = (char**)clientArgv;
    client_args.argc = sizeof(clientArgv) / sizeof(*clientArgv);

    InitTcpReady(&amp;ready);
    start_thread(server_test, &amp;server_args, &amp;serverThread);
    wait_tcp_ready(&amp;server_args);
    (void)XSNPRINTF(portNum, sizeof(portNum), &quot;%d&quot;, server_args.signal-&gt;port);

    for (i = 0; i &lt; CRL_MONITOR_TEST_ROUNDS; i++) {
        int expectFail;
        if (i % 2 == 0) {

            /* succeed on even rounds */
            (void)XSNPRINTF(buf, sizeof(buf), &quot;%s/%s&quot;, tmpDir, &quot;crl.pem&quot;);
            if (STAGE_FILE(&quot;certs/crl/crl.pem&quot;, buf) != 0) {
                fprintf(stderr, &quot;[%d] Failed to copy file to %s\n&quot;, i, buf);
                goto cleanup;
            }
            (void)XSNPRINTF(buf, sizeof(buf), &quot;%s/%s&quot;, tmpDir, &quot;crl.revoked&quot;);
            /* The monitor can be holding the file handle and this will cause
             * the remove call to fail. Let&#039;s give the monitor a some time to
             * finish up. */
            for (j = 0; j &lt; CRL_MONITOR_REM_FILE_ATTEMPTS; j++) {
                /* i == 0 since there is nothing to delete in the first round */
                if (i == 0 || rem_file(buf) == 0)
                    break;
                XSLEEP_MS(100);
            }
            if (j == CRL_MONITOR_REM_FILE_ATTEMPTS) {
                fprintf(stderr, &quot;[%d] Failed to remove file %s\n&quot;, i, buf);
                goto cleanup;
            }
            expectFail = 0;
        }
        else {
            /* fail on odd rounds */
            (void)XSNPRINTF(buf, sizeof(buf), &quot;%s/%s&quot;, tmpDir, &quot;crl.revoked&quot;);
            if (STAGE_FILE(&quot;certs/crl/crl.revoked&quot;, buf) != 0) {
                fprintf(stderr, &quot;[%d] Failed to copy file to %s\n&quot;, i, buf);
                goto cleanup;
            }
            (void)XSNPRINTF(buf, sizeof(buf), &quot;%s/%s&quot;, tmpDir, &quot;crl.pem&quot;);
            /* The monitor can be holding the file handle and this will cause
             * the remove call to fail. Let&#039;s give the monitor a some time to
             * finish up. */
            for (j = 0; j &lt; CRL_MONITOR_REM_FILE_ATTEMPTS; j++) {
                if (rem_file(buf) == 0)
                    break;
                XSLEEP_MS(100);
            }
            if (j == CRL_MONITOR_REM_FILE_ATTEMPTS) {
                fprintf(stderr, &quot;[%d] Failed to remove file %s\n&quot;, i, buf);
                goto cleanup;
            }
            expectFail = 1;
        }
        /* Give server a moment to register the file change */
        XSLEEP_MS(100);

        client_args.return_code = 0;
        client_test(&amp;client_args);

        if (!expectFail) {
            if (client_args.return_code != 0) {
                fprintf(stderr, &quot;[%d] Incorrect return %d\n&quot;, i,
                        client_args.return_code);
                goto cleanup;
            }
        }
        else {
            if (client_args.return_code == 0) {
                fprintf(stderr, &quot;[%d] Expected failure\n&quot;, i);
                goto cleanup;
            }
        }
    }

    join_thread(serverThread);
    ret = 0;
cleanup:
    if (ret != 0 &amp;&amp; i &gt;= 0)
        fprintf(stderr, &quot;test_crl_monitor failed on iteration %d\n&quot;, i);
    (void)XSNPRINTF(buf, sizeof(buf), &quot;%s/%s&quot;, tmpDir, &quot;crl.pem&quot;);
    rem_file(buf);
    (void)XSNPRINTF(buf, sizeof(buf), &quot;%s/%s&quot;, tmpDir, &quot;crl.revoked&quot;);
    rem_file(buf);
    (void)rem_dir(tmpDir);
    return ret;
}
#endif

#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    !defined(NO_TLS) &amp;&amp; \
   (!defined(WOLF_CRYPTO_CB_ONLY_RSA) &amp;&amp; !defined(WOLF_CRYPTO_CB_ONLY_ECC))
/* Perform a basic TLS handshake.
 *
 * First connection to echo a file.
 * Second to tell TLS server to quit.
 *
 * @param [in,out] server_args   Object sent to server thread.
 * @return  0 on success.
 * @return  echoclient error return code on failure.
 */
static int test_tls(func_args* server_args)
{
    func_args echo_args;
    char* myArgv[NUMARGS];
    char arg[3][128];

    printf(&quot;\nRunning TLS test\n&quot;);

    /* Set up command line arguments for echoclient to send input file
     * and write echoed data to temporary output file. */
    myArgv[0] = arg[0];
    myArgv[1] = arg[1];
    myArgv[2] = arg[2];

    echo_args.argc = 3;
    echo_args.argv = myArgv;

    XSTRLCPY(arg[0], &quot;testsuite&quot;, sizeof(arg[0]));
    XSTRLCPY(arg[1], &quot;input&quot;, sizeof(arg[1]));
    XSTRLCPY(arg[2], outputName, sizeof(arg[2]));

    /* Share the signal, it has the new port number in it. */
    echo_args.signal = server_args-&gt;signal;

    /* Ready to execute client - wait for server to be ready. */
    wait_tcp_ready(server_args);

    /* Do a client TLS connection. */
#ifdef HAVE_STACK_SIZE
    fputs(&quot;echoclient_test #1: &quot;, stdout);
    StackSizeCheck(&amp;echo_args, echoclient_test_wrapper);
#else
    echoclient_test(&amp;echo_args);
#endif
    if (echo_args.return_code != 0)
        return echo_args.return_code;

#ifdef WOLFSSL_DTLS
    /* Ensure server is ready for UDP data. */
    wait_tcp_ready(server_args);
#endif

    /* Next client connection - send quit to shutdown server. */
    echo_args.argc = 2;
    XSTRLCPY(arg[1], &quot;quit&quot;, sizeof(arg[1]));

    /* Do a client TLS connection. */
#ifdef HAVE_STACK_SIZE
    fputs(&quot;echoclient_test #2: &quot;, stdout);
    StackSizeCheck(&amp;echo_args, echoclient_test_wrapper);
#else
    echoclient_test(&amp;echo_args);
#endif
    if (echo_args.return_code != 0)
        return echo_args.return_code;

    return 0;
}

/* Show cipher suites available. */
static void show_ciphers(void)
{
    char ciphers[WOLFSSL_CIPHER_LIST_MAX_SIZE];
    XMEMSET(ciphers, 0, sizeof(ciphers));
    wolfSSL_get_ciphers(ciphers, sizeof(ciphers)-1);
    printf(&quot;ciphers = %s\n&quot;, ciphers);
}

/* Cleanup temporary output file. */
static void cleanup_output(void)
{
    remove(outputName);
}

/* Validate output equals input using a hash. Remove temporary output file.
 *
 * @return  0 on success.
 * @return  1 on failure.
 */
static int validate_cleanup_output(void)
{
#ifndef NO_SHA256
    byte input[WC_SHA256_DIGEST_SIZE];
    byte output[WC_SHA256_DIGEST_SIZE];

    file_test(&quot;input&quot;,  input);
    file_test(outputName, output);
#endif
    cleanup_output();
#ifndef NO_SHA256
    if (memcmp(input, output, sizeof(input)) != 0)
        return 1;
#endif
    return 0;
}

/* Simple server.
 *
 * @param [in] args  Object for server data in thread.
 * @return  Return code.
 */
#ifdef HAVE_STACK_SIZE
static THREAD_RETURN simple_test(func_args* args)
#else
static void simple_test(func_args* args)
#endif
{
    THREAD_TYPE serverThread;

    int i;

    func_args svrArgs;
    char *svrArgv[9];
    char argvs[9][32];

    func_args cliArgs;
    char *cliArgv[NUMARGS];
    char argvc[3][32];

    printf(&quot;\nRunning simple test\n&quot;);

    for (i = 0; i &lt; 9; i++)
        svrArgv[i] = argvs[i];
    for (i = 0; i &lt; 3; i++)
        cliArgv[i] = argvc[i];

    XSTRLCPY(argvs[0], &quot;SimpleServer&quot;, sizeof(argvs[0]));
    svrArgs.argc = 1;
    svrArgs.argv = svrArgv;
    svrArgs.return_code = 0;
    #if !defined(USE_WINDOWS_API) &amp;&amp; !defined(WOLFSSL_SNIFFER)  &amp;&amp; \
                                     !defined(WOLFSSL_TIRTOS)
        XSTRLCPY(argvs[svrArgs.argc++], &quot;-p&quot;, sizeof(argvs[svrArgs.argc]));
        XSTRLCPY(argvs[svrArgs.argc++], &quot;0&quot;, sizeof(argvs[svrArgs.argc]));
    #endif
    /* Set the last arg later, when it is known. */

    args-&gt;return_code = 0;
    svrArgs.signal = args-&gt;signal;
    start_thread(server_test, &amp;svrArgs, &amp;serverThread);
    wait_tcp_ready(&amp;svrArgs);

    /* Setting the actual port number. */
    XSTRLCPY(argvc[0], &quot;SimpleClient&quot;, sizeof(argvc[0]));
    cliArgs.argv = cliArgv;
    cliArgs.return_code = 0;
#ifndef USE_WINDOWS_API
    cliArgs.argc = NUMARGS;
    XSTRLCPY(argvc[1], &quot;-p&quot;, sizeof(argvc[1]));
    (void)snprintf(argvc[2], sizeof(argvc[2]), &quot;%d&quot;, (int)svrArgs.signal-&gt;port);
#else
    cliArgs.argc = 1;
#endif

    client_test(&amp;cliArgs);
    if (cliArgs.return_code != 0) {
        args-&gt;return_code = cliArgs.return_code;
    #ifdef HAVE_STACK_SIZE
        return (THREAD_RETURN)0;
    #else
        return;
    #endif
    }
    join_thread(serverThread);
    if (svrArgs.return_code != 0) args-&gt;return_code = svrArgs.return_code;
#ifdef HAVE_STACK_SIZE
    return (THREAD_RETURN)0;
#endif
}
#endif /* !NO_WOLFSSL_SERVER &amp;&amp; !NO_WOLFSSL_CLIENT */

#ifndef NO_SHA256
/* Create SHA-256 hash of the file based on filename.
 *
 * @param [in]  file   Name of file.
 * @param [out] check  Buffer to hold SHA-256 hash.
 */
void file_test(const char* file, byte* check)
{
    FILE* f;
    int   i = 0, j, ret;
    wc_Sha256   sha256;
    byte  buf[1024];
    byte  shasum[WC_SHA256_DIGEST_SIZE];

    ret = wc_InitSha256(&amp;sha256);
    if (ret != 0) {
        printf(&quot;Can&#039;t wc_InitSha256 %d\n&quot;, ret);
        return;
    }
    if( !( f = fopen( file, &quot;rb&quot; ) )) {
        printf(&quot;Can&#039;t open %s\n&quot;, file);
        return;
    }
    while( ( i = (int)fread(buf, 1, sizeof(buf), f )) &gt; 0 ) {
        if (ferror(f)) {
            printf(&quot;I/O error reading %s\n&quot;, file);
            fclose(f);
            return;
        }
        ret = wc_Sha256Update(&amp;sha256, buf, (word32)i);
        if (ret != 0) {
            printf(&quot;Can&#039;t wc_Sha256Update %d\n&quot;, ret);
            fclose(f);
            return;
        }
        if (feof(f))
            break;
    }

    ret = wc_Sha256Final(&amp;sha256, shasum);
    wc_Sha256Free(&amp;sha256);

    if (ret != 0) {
        printf(&quot;Can&#039;t wc_Sha256Final %d\n&quot;, ret);
        fclose(f);
        return;
    }

    XMEMCPY(check, shasum, sizeof(shasum));

    for(j = 0; j &lt; WC_SHA256_DIGEST_SIZE; ++j )
        printf( &quot;%02x&quot;, shasum[j] );

    printf(&quot;  %s\n&quot;, file);

    fclose(f);
}
#endif

#else /* SINGLE_THREADED */


int myoptind = 0;
char* myoptarg = NULL;


int main(int argc, char** argv)
{
    func_args wolfcrypt_test_args;

    wolfcrypt_test_args.argc = argc;
    wolfcrypt_test_args.argv = argv;

    wolfSSL_Init();
    ChangeToWolfRoot();

    /* No TLS - only doing cryptographic algorithm testing. */
    wolfcrypt_test(&amp;wolfcrypt_test_args);
    if (wolfcrypt_test_args.return_code != 0)
        return wolfcrypt_test_args.return_code;

    wolfSSL_Cleanup();
    printf(&quot;\nAll tests passed!\n&quot;);
    return EXIT_SUCCESS;
}


#endif /* SINGLE_THREADED */

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2Fwolfssl%2Fwolfssl%2Ftestsuite'>🔙 Back</a></p>