�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%2Ftests%2F'>tests</a>/</p><hr><h3>✏️ Editing: suites.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* suites.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
 */


#include &lt;tests/unit.h&gt;

#ifdef NO_INLINE
    #include &lt;wolfssl/wolfcrypt/misc.h&gt;
#else
    #define WOLFSSL_MISC_INCLUDED
    #include &lt;wolfcrypt/src/misc.c&gt;
#endif

#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;wolfssl/ssl.h&gt;

#if defined(HAVE_ECC) &amp;&amp; defined(FP_ECC) &amp;&amp; defined(HAVE_THREAD_LS) \
                      &amp;&amp; (defined(NO_MAIN_DRIVER) || defined(HAVE_STACK_SIZE))
#include &lt;wolfssl/wolfcrypt/ecc.h&gt;
#endif

#include &lt;wolfssl/wolfcrypt/memory.h&gt; /* for LARGEST_MEM_BUCKET */

#define MAX_ARGS 40
#define MAX_COMMAND_SZ 240
#ifdef WOLFSSL_TLS13
    #define MAX_SUITE_SZ 200
#else
    #define MAX_SUITE_SZ 80
#endif
#define NOT_BUILT_IN (-123)
#if defined(NO_OLD_TLS) || !defined(WOLFSSL_ALLOW_SSLV3) || \
    !defined(WOLFSSL_ALLOW_TLSV10)
    #define VERSION_TOO_OLD (-124)
#endif

#include &quot;examples/client/client.h&quot;
#include &quot;examples/server/server.h&quot;

#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    !defined(NO_TLS) &amp;&amp; !defined(SINGLE_THREADED)
static WOLFSSL_CTX* cipherSuiteCtx = NULL;
static char nonblockFlag[] = &quot;-N&quot;;
static char noVerifyFlag[] = &quot;-d&quot;;
static char disableEMSFlag[] = &quot;-n&quot;;
static char flagSep[] = &quot; &quot;;
#if !defined(USE_WINDOWS_API) &amp;&amp; !defined(WOLFSSL_TIRTOS)
    static char portFlag[] = &quot;-p&quot;;
    static char svrPort[] = &quot;0&quot;;
#endif
static char intTestFlag[] = &quot;-H&quot;;
static char forceDefCipherListFlag[] = &quot;defCipherList&quot;;
static char exitWithRetFlag[] = &quot;exitWithRet&quot;;
static char disableDHPrimeTest[] = &quot;-2&quot;;

#ifdef WOLFSSL_ASYNC_CRYPT
    static int devId = INVALID_DEVID;
#endif


#ifdef VERSION_TOO_OLD
static int GetTlsVersion(const char* line)
{
    int version = -1;
    const char* find = &quot;-v &quot;;
    const char* begin = strstr(line, find);

    if (begin) {
        begin += 3;
        if (*begin == &#039;d&#039; || *begin == &#039;e&#039;)
            begin += 2;

        version = atoi(begin);
    }
    return version;
}

#ifndef WOLFSSL_ALLOW_SSLV3
/* if the protocol version is sslv3 return 1, else 0 */
static int IsSslVersion(const char* line)
{
    int version = GetTlsVersion(line);
    return (version == 0) ? 1 : 0;
}
#endif /* !WOLFSSL_ALLOW_SSLV3 */

#ifndef WOLFSSL_ALLOW_TLSV10
/* if the protocol version is TLSv1.0 return 1, else 0 */
static int IsTls10Version(const char* line)
{
    int version = GetTlsVersion(line);
    return (version == 1) ? 1 : 0;
}
#endif /* !WOLFSSL_ALLOW_TLSV10 */

#ifdef NO_OLD_TLS
/* if the protocol version is less than tls 1.2 return 1, else 0 */
static int IsOldTlsVersion(const char* line)
{
    int version = GetTlsVersion(line);
    return (version &lt; 3) ? 1 : 0;
}
#endif /* NO_OLD_TLS */
#endif /* VERSION_TOO_OLD */


/* if the cipher suite on line is valid store in suite and return 1, else 0 */
static int IsValidCipherSuite(const char* line, char *suite, size_t suite_spc)
{
    int  found = 0;
    int  valid = 0;

    const char* find = &quot;-l &quot;;
    const char* begin = strstr(line, find);
    const char* end;

    if (suite_spc &lt; MAX_SUITE_SZ+1)
        return 0;

    suite[0] = &#039;\0&#039;;

    if (begin) {
        begin += 3;

        end = XSTRSTR(begin, &quot; &quot;);

        if (end) {
            long len = end - begin;
            if (len &gt; MAX_SUITE_SZ) {
                printf(&quot;suite too long!\n&quot;);
                return 0;
            }
            XMEMCPY(suite, begin, (size_t) len);
            suite[len] = &#039;\0&#039;;
        }
        else
            XSTRNCPY(suite, begin, MAX_SUITE_SZ);

        suite[MAX_SUITE_SZ] = &#039;\0&#039;;
        found = 1;
    }

    if (found) {
        if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite) == WOLFSSL_SUCCESS)
            valid = 1;
    }

    return valid;
}

#ifdef WOLFSSL_HAVE_KYBER
static int IsKyberLevelAvailable(const char* line)
{
    int available = 0;
    const char* find = &quot;--pqc &quot;;
    const char* begin = strstr(line, find);
    const char* end;

    if (begin != NULL) {
        begin += 6;
        end = XSTRSTR(begin, &quot; &quot;);

    #ifndef WOLFSSL_NO_ML_KEM
        if ((size_t)end - (size_t)begin == 10) {
        #ifndef WOLFSSL_NO_ML_KEM_512
            if (XSTRNCMP(begin, &quot;ML_KEM_512&quot;, 10) == 0) {
                available = 1;
            }
        #endif
        #ifndef WOLFSSL_NO_ML_KEM_768
            if (XSTRNCMP(begin, &quot;ML_KEM_768&quot;, 10) == 0) {
                available = 1;
            }
        #endif
        }
        #ifndef WOLFSSL_NO_ML_KEM_1024
        if ((size_t)end - (size_t)begin == 11) {
            if (XSTRNCMP(begin, &quot;ML_KEM_1024&quot;, 11) == 0) {
                available = 1;
            }
        }
        #endif
    #endif
    #ifdef WOLFSSL_KYBER_ORIGINAL
        if ((size_t)end - (size_t)begin == 12) {
        #ifndef WOLFSSL_NO_KYBER512
            if (XSTRNCMP(begin, &quot;KYBER_LEVEL1&quot;, 12) == 0) {
                available = 1;
            }
        #endif
        #ifndef WOLFSSL_NO_KYBER768
            if (XSTRNCMP(begin, &quot;KYBER_LEVEL3&quot;, 12) == 0) {
                available = 1;
            }
        #endif
        #ifndef WOLFSSL_NO_KYBER1024
            if (XSTRNCMP(begin, &quot;KYBER_LEVEL5&quot;, 12) == 0) {
                available = 1;
            }
        #endif
        }
    #endif
    }

    return (begin == NULL) || available;
}
#endif

static int IsValidCert(const char* line)
{
    int ret = 1;
#if !defined(NO_FILESYSTEM) &amp;&amp; !defined(NO_CERTS)
    WOLFSSL_CTX* ctx;
    size_t i;
    const char* begin;
    char cert[80];
#ifdef WOLFSSL_STATIC_MEMORY
    FILE* fStream = NULL;
    long chkSz = 0;
#endif

    begin = XSTRSTR(line, &quot;-c &quot;);
    if (begin == NULL)
        return 1;

    begin += 3;
    for (i = 0; i &lt; sizeof(cert) - 1 &amp;&amp; *begin != &#039; &#039; &amp;&amp; *begin != &#039;\0&#039;; i++)
        cert[i] = *(begin++);
    cert[i] = &#039;\0&#039;;
#ifdef WOLFSSL_STATIC_MEMORY
    fStream = XFOPEN(cert, &quot;rb&quot;);
    if (fStream == NULL) {
        printf(&quot;Failed to open file %s\n&quot;, cert);
        printf(&quot;Invalid cert, skipping test\n&quot;);
        return 0;
    } else {
        printf(&quot;Successfully opened file\n&quot;);
    }

    XFSEEK(fStream, 0L, SEEK_END);
    chkSz = XFTELL(fStream);
    XFCLOSE(fStream);
    if (chkSz &gt; LARGEST_MEM_BUCKET) {
        printf(&quot;File is larger than largest bucket, skipping this test\n&quot;);
        return 0;
    }
#endif

    ctx = wolfSSL_CTX_new(wolfSSLv23_server_method_ex(NULL));
    if (ctx == NULL)
        return 0;
    ret = wolfSSL_CTX_use_certificate_chain_file(ctx, cert) == WOLFSSL_SUCCESS;
    wolfSSL_CTX_free(ctx);
#endif /* !NO_FILESYSTEM &amp;&amp; !NO_CERTS */

    (void)line;

    return ret;
}

static int IsValidCA(const char* line)
{
    int ret = 1;
#if !defined(NO_FILESYSTEM) &amp;&amp; !defined(NO_CERTS)
    WOLFSSL_CTX* ctx;
    size_t i;
    const char* begin;
    char cert[80];

    begin = XSTRSTR(line, &quot;-A &quot;);
    if (begin == NULL)
        return 1;

    begin += 3;
    for (i = 0; i &lt; sizeof(cert) - 1 &amp;&amp; *begin != &#039; &#039; &amp;&amp; *begin != &#039;\0&#039;; i++)
        cert[i] = *(begin++);
    cert[i] = &#039;\0&#039;;

    ctx = wolfSSL_CTX_new(wolfSSLv23_server_method_ex(NULL));
    if (ctx == NULL)
        return 0;
    ret = wolfSSL_CTX_use_certificate_chain_file(ctx, cert) == WOLFSSL_SUCCESS;
    wolfSSL_CTX_free(ctx);
#endif /* !NO_FILESYSTEM &amp;&amp; !NO_CERTS */

    (void)line;

    return ret;
}

#ifdef WOLFSSL_NO_CLIENT_AUTH
static int IsClientAuth(const char* line, int* reqClientCert)
{
    const char* begin;

    begin = XSTRSTR(line, &quot;-H verifyFail&quot;);
    if (begin != NULL) {
        return 1;
    }

    begin = XSTRSTR(line, &quot;-d&quot;);
    if (begin != NULL) {
        *reqClientCert = 0;
    }
    else {
        *reqClientCert = 1;
    }

    return 0;
}
#endif

#ifdef NO_CERTS
static int IsUsingCert(const char* line)
{
    return XSTRSTR(line, &quot;-c &quot;) != NULL;
}
#endif

#if defined(NO_CERTS) || defined(WOLFSSL_NO_CLIENT_AUTH)
static int IsNoClientCert(const char* line)
{
    const char* begin;

    begin = XSTRSTR(line, &quot;-x&quot;);
    if (begin != NULL) {
        return 1;
    }

    return 0;
}
#endif

static int execute_test_case(int svr_argc, char** svr_argv,
                             int cli_argc, char** cli_argv,
                             int addNoVerify, int addNonBlocking,
                             int addDisableEMS, int forceSrvDefCipherList,
                             int forceCliDefCipherList)
{
#if defined(WOLFSSL_TIRTOS) || defined(WOLFSSL_SRTP)
    func_args cliArgs = {0, NULL, 0, NULL, NULL, NULL};
    func_args svrArgs = {0, NULL, 0, NULL, NULL, NULL};
#else
    func_args cliArgs = {cli_argc, cli_argv, 0, NULL, NULL};
    func_args svrArgs = {svr_argc, svr_argv, 0, NULL, NULL};
#endif

    tcp_ready   ready;
    THREAD_TYPE serverThread;
    char        commandLine[MAX_COMMAND_SZ];
    char        cipherSuite[MAX_SUITE_SZ+1];
    int         i;
    size_t      added;
    static      int tests = 1;
#if !defined(USE_WINDOWS_API) &amp;&amp; !defined(WOLFSSL_TIRTOS)
    static char portNumber[8];
#endif
    int         cliTestShouldFail = 0, svrTestShouldFail = 0;
#ifdef WOLFSSL_NO_CLIENT_AUTH
    int         reqClientCert;
#endif

#if defined(WOLFSSL_SRTP) &amp;&amp; defined(WOLFSSL_COND)
    srtp_test_helper srtp_helper;
#endif

#if defined(WOLFSSL_TIRTOS) || defined(WOLFSSL_SRTP)
    cliArgs.argc = cli_argc;
    cliArgs.argv = cli_argv;
    svrArgs.argc = svr_argc;
    svrArgs.argv = svr_argv;
#endif

    /* Is Valid Cipher and Version Checks */
    /* build command list for the Is checks below */
    commandLine[0] = &#039;\0&#039;;
    added = 0;
    for (i = 0; i &lt; svrArgs.argc; i++) {
        added += XSTRLEN(svr_argv[i]) + 2;
        if (added &gt;= MAX_COMMAND_SZ) {
            printf(&quot;server command line too long\n&quot;);
            break;
        }
        XSTRLCAT(commandLine, svr_argv[i], sizeof commandLine);
        XSTRLCAT(commandLine, flagSep, sizeof commandLine);
    }
    if (IsValidCipherSuite(commandLine, cipherSuite, sizeof cipherSuite) == 0) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;cipher suite %s not supported in build\n&quot;, cipherSuite);
        #endif
        return NOT_BUILT_IN;
    }
#ifdef WOLFSSL_HAVE_KYBER
    if (!IsKyberLevelAvailable(commandLine)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;Kyber level not supported in build: %s\n&quot;, commandLine);
        #endif
        return NOT_BUILT_IN;
    }
#endif
    if (!IsValidCert(commandLine)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;certificate %s not supported in build\n&quot;, commandLine);
        #endif
        return NOT_BUILT_IN;
    }

#ifndef WOLFSSL_ALLOW_SSLV3
    if (IsSslVersion(commandLine) == 1) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;protocol version on line %s is too old\n&quot;, commandLine);
        #endif
        return VERSION_TOO_OLD;
    }
#endif
#ifndef WOLFSSL_ALLOW_TLSV10
    if (IsTls10Version(commandLine) == 1) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;protocol version on line %s is too old\n&quot;, commandLine);
        #endif
        return VERSION_TOO_OLD;
    }
#endif
#ifdef NO_OLD_TLS
    if (IsOldTlsVersion(commandLine) == 1) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;protocol version on line %s is too old\n&quot;, commandLine);
        #endif
        return VERSION_TOO_OLD;
    }
#endif
#ifdef WOLFSSL_NO_CLIENT_AUTH
    if (IsClientAuth(commandLine, &amp;reqClientCert)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;client auth on line %s not supported in build\n&quot;,
                   commandLine);
        #endif
        return NOT_BUILT_IN;
    }
#endif
#ifdef NO_CERTS
    if (IsUsingCert(commandLine)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;certificate %s not supported in build\n&quot;, commandLine);
        #endif
        return NOT_BUILT_IN;
    }
#endif

    /* Build Server Command */
    if (addNoVerify) {
        printf(&quot;repeating test with client cert request off\n&quot;);
        if (svrArgs.argc &gt;= MAX_ARGS)
            printf(&quot;server command line too long\n&quot;);
        else
            svr_argv[svrArgs.argc++] = noVerifyFlag;
    }
    if (addNonBlocking) {
        printf(&quot;repeating test with non blocking on\n&quot;);
        if (svrArgs.argc &gt;= MAX_ARGS)
            printf(&quot;server command line too long\n&quot;);
        else
            svr_argv[svrArgs.argc++] = nonblockFlag;
    }
    #if !defined(USE_WINDOWS_API) &amp;&amp; !defined(WOLFSSL_TIRTOS)
        /* add port */
        if (svrArgs.argc + 2 &gt; MAX_ARGS)
            printf(&quot;cannot add the magic port number flag to server\n&quot;);
        else {
            svr_argv[svrArgs.argc++] = portFlag;
            svr_argv[svrArgs.argc++] = svrPort;
        }
    #endif
    if (forceSrvDefCipherList) {
        if (svrArgs.argc + 2 &gt; MAX_ARGS)
            printf(&quot;cannot add the force def cipher list flag to server\n&quot;);
        else {
            svr_argv[svrArgs.argc++] = intTestFlag;
            svr_argv[svrArgs.argc++] = forceDefCipherListFlag;
        }
    }
#ifdef TEST_PK_PRIVKEY
    svr_argv[svrArgs.argc++] = (char*)&quot;-P&quot;;
#endif


    /* update server flags list */
    commandLine[0] = &#039;\0&#039;;
    added = 0;
    for (i = 0; i &lt; svrArgs.argc; i++) {
        added += XSTRLEN(svr_argv[i]) + 2;
        if (added &gt;= MAX_COMMAND_SZ) {
            printf(&quot;server command line too long\n&quot;);
            break;
        }
        XSTRLCAT(commandLine, svr_argv[i], sizeof commandLine);
        XSTRLCAT(commandLine, flagSep, sizeof commandLine);
    }
    printf(&quot;trying server command line[%d]: %s\n&quot;, tests, commandLine);

    tests++; /* test count */

    /* determine based on args if this test is expected to fail */
    if (XSTRSTR(commandLine, exitWithRetFlag) != NULL) {
        svrTestShouldFail = 1;
    }

    InitTcpReady(&amp;ready);

#if defined(WOLFSSL_SRTP) &amp;&amp; defined(WOLFSSL_COND)
    srtp_helper_init(&amp;srtp_helper);
    cliArgs.srtp_helper = &amp;srtp_helper;
    svrArgs.srtp_helper = &amp;srtp_helper;
#endif

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

    /* start server */
    svrArgs.signal = &amp;ready;
    start_thread(server_test, &amp;svrArgs, &amp;serverThread);
    wait_tcp_ready(&amp;svrArgs);


    /* Build Client Command */
    if (addNonBlocking) {
        if (cliArgs.argc &gt;= MAX_ARGS)
            printf(&quot;cannot add the non block flag to client\n&quot;);
        else
            cli_argv[cliArgs.argc++] = nonblockFlag;
    }
    if (addDisableEMS) {
        printf(&quot;repeating test without extended master secret\n&quot;);
        if (cliArgs.argc &gt;= MAX_ARGS)
            printf(&quot;cannot add the disable EMS flag to client\n&quot;);
        else
            cli_argv[cliArgs.argc++] = disableEMSFlag;
    }
#if !defined(USE_WINDOWS_API) &amp;&amp; !defined(WOLFSSL_TIRTOS)
    if (ready.port != 0) {
        if (cliArgs.argc + 2 &gt; MAX_ARGS)
            printf(&quot;cannot add the magic port number flag to client\n&quot;);
        else {
            (void)snprintf(portNumber, sizeof(portNumber), &quot;%d&quot;,
                           (int)ready.port);
            cli_argv[cliArgs.argc++] = portFlag;
            cli_argv[cliArgs.argc++] = portNumber;
        }
    }
#endif
    if (forceCliDefCipherList) {
        if (cliArgs.argc + 2 &gt; MAX_ARGS)
            printf(&quot;cannot add the force def cipher list flag to client\n&quot;);
        else {
            cli_argv[cliArgs.argc++] = intTestFlag;
            cli_argv[cliArgs.argc++] = forceDefCipherListFlag;
        }
    }
#ifdef TEST_PK_PRIVKEY
    cli_argv[cliArgs.argc++] = (char*)&quot;-P&quot;;
#endif

    commandLine[0] = &#039;\0&#039;;
    added = 0;
    for (i = 0; i &lt; cliArgs.argc; i++) {
        added += XSTRLEN(cli_argv[i]) + 2;
        if (added &gt;= MAX_COMMAND_SZ) {
            printf(&quot;client command line too long\n&quot;);
            break;
        }
        XSTRLCAT(commandLine, cli_argv[i], sizeof commandLine);
        XSTRLCAT(commandLine, flagSep, sizeof commandLine);
    }
    if (!IsValidCA(commandLine)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;certificate %s not supported in build\n&quot;, commandLine);
        #endif
        return NOT_BUILT_IN;
    }
#ifdef WOLFSSL_NO_CLIENT_AUTH
    if (reqClientCert &amp;&amp; IsNoClientCert(commandLine)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;client auth on line %s not supported in build\n&quot;,
                   commandLine);
        #endif
        return NOT_BUILT_IN;
    }
#endif
#ifdef NO_CERTS
    if (IsNoClientCert(commandLine)) {
        #ifdef DEBUG_SUITE_TESTS
            printf(&quot;certificate %s not supported in build\n&quot;, commandLine);
        #endif
        return NOT_BUILT_IN;
    }
#endif
    printf(&quot;trying client command line[%d]: %s\n&quot;, tests, commandLine);
    tests++;

    /* determine based on args if this test is expected to fail */
    if (XSTRSTR(commandLine, exitWithRetFlag) != NULL) {
        cliTestShouldFail = 1;
    }

    /* start client */
    client_test(&amp;cliArgs);

    /* verify results */
    if ((cliArgs.return_code != 0 &amp;&amp; cliTestShouldFail == 0) ||
        (cliArgs.return_code == 0 &amp;&amp; cliTestShouldFail != 0)) {
        printf(&quot;client_test failed %d %s\n&quot;, cliArgs.return_code,
            cliTestShouldFail ? &quot;(should fail)&quot; : &quot;&quot;);
        XEXIT(EXIT_FAILURE);
    }

    join_thread(serverThread);
    if ((svrArgs.return_code != 0 &amp;&amp; svrTestShouldFail == 0) ||
        (svrArgs.return_code == 0 &amp;&amp; svrTestShouldFail != 0)) {
        printf(&quot;server_test failed %d %s\n&quot;, svrArgs.return_code,
            svrTestShouldFail ? &quot;(should fail)&quot; : &quot;&quot;);
        XEXIT(EXIT_FAILURE);
    }

#ifdef WOLFSSL_TIRTOS
    fdCloseSession(Task_self());
#endif
    FreeTcpReady(&amp;ready);

#if defined (WOLFSSL_SRTP) &amp;&amp; defined(WOLFSSL_COND)
    srtp_helper_free(&amp;srtp_helper);
#endif

    /* only run the first test for expected failure cases */
    /* the example server/client are not designed to handle expected failure in
        all cases, such as non-blocking, etc... */
    if (svrTestShouldFail || cliTestShouldFail) {
        return NOT_BUILT_IN;
    }

    return 0;
}

static void test_harness(void* vargs)
{
    func_args* args = (func_args*)vargs;
    char* script;
    long  sz, len;
    int   cliMode = 0;   /* server or client command flag, server first */
    int   ret;
    FILE* file;
    char* svrArgs[MAX_ARGS];
    int   svrArgsSz;
    char* cliArgs[MAX_ARGS];
    int   cliArgsSz;
    char* cursor;
    char* comment;
    char  lastChar = &#039;\0&#039;;
    int   do_it = 0;
    const char* fname = &quot;tests/test.conf&quot;;
    const char* addArgs = NULL;

    if (args-&gt;argc == 1) {
        printf(&quot;notice: using default file %s\n&quot;, fname);
    }
    else if (args-&gt;argc == 3) {
        addArgs = args-&gt;argv[2];
    }
    else if (args-&gt;argc &gt; 3) {
        printf(&quot;usage: harness [FILE] [ARG]\n&quot;);
        args-&gt;return_code = 1;
        return;
    }

    if (args-&gt;argc &gt;= 2) {
        fname = args-&gt;argv[1];
    }

    file = fopen(fname, &quot;rb&quot;);
    if (file == NULL) {
        fprintf(stderr, &quot;unable to open %s\n&quot;, fname);
        args-&gt;return_code = 1;
        return;
    }
    if (fseek(file, 0, SEEK_END) &lt; 0) {
        fprintf(stderr, &quot;error %d fseeking %s\n&quot;, errno, fname);
        fclose(file);
        args-&gt;return_code = 1;
        return;
    }
    sz = ftell(file);
    if (sz &lt;= 0) {
        fprintf(stderr, &quot;%s is empty\n&quot;, fname);
        fclose(file);
        args-&gt;return_code = 1;
        return;
    }
    if (fseek(file, 0, SEEK_SET) &lt; 0) {
        fprintf(stderr, &quot;error %d fseeking %s\n&quot;, errno, fname);
        fclose(file);
        args-&gt;return_code = 1;
        return;
    }

    script = (char*)malloc((size_t)(sz+1));
    if (script == 0) {
        fprintf(stderr, &quot;unable to allocate script buffer\n&quot;);
        fclose(file);
        args-&gt;return_code = 1;
        return;
    }

    len = (long) fread(script, 1, (size_t)sz, file);
    if (len != sz) {
        fprintf(stderr, &quot;read error\n&quot;);
        fclose(file);
        free(script);
        args-&gt;return_code = 1;
        return;
    }

    fclose(file);
    script[sz] = 0;

    cursor = script;
    svrArgsSz = 1;
    svrArgs[0] = args-&gt;argv[0];
    cliArgsSz = 1;
    cliArgs[0] = args-&gt;argv[0];

    while (cursor &amp;&amp; *cursor != 0) {
        switch (*cursor) {
            case &#039;\n&#039;:
                /* A blank line triggers test case execution or switches
                   to client mode if we don&#039;t have the client command yet */
                if (lastChar != &#039;\n&#039; &amp;&amp; (cliArgsSz &gt; 1 || svrArgsSz &gt; 1)) {
                    if (cliMode == 0)
                        cliMode = 1;  /* switch to client mode processing */
                    else
                        do_it = 1;    /* Do It, we have server and client */
                }
            #ifdef DEBUG_SUITE_TESTS
                else {
                    /* skip extra new-lines */
                    printf(&quot;skipping extra new line\n&quot;);
                }
            #endif
                lastChar = *cursor;
                cursor++;
                break;
            case &#039;#&#039;:
                lastChar = *cursor;
                /* Ignore lines that start with a # */
                comment = XSTRSEP(&amp;cursor, &quot;\n&quot;);
            #ifdef DEBUG_SUITE_TESTS
                printf(&quot;%s\n&quot;, comment);
            #else
                (void)comment;
            #endif
                break;
            case &#039;-&#039;:
            default:
                /* Parameters start with a -. They end in either a newline
                 * or a space. Capture until either, save in Args list. */
                lastChar = *cursor;
                if (cliMode)
                    cliArgs[cliArgsSz++] = XSTRSEP(&amp;cursor, &quot; \n&quot;);
                else
                    svrArgs[svrArgsSz++] = XSTRSEP(&amp;cursor, &quot; \n&quot;);
                if (cursor == NULL || *cursor == &#039;\0&#039;) /* eof */
                    do_it = 1;
                break;
        }

        if (svrArgsSz == MAX_ARGS || cliArgsSz == MAX_ARGS) {
            fprintf(stderr, &quot;too many arguments, forcing test run\n&quot;);
            do_it = 1;
        }

        if (do_it) {
            /* additional arguments processing */
            if (cliArgsSz+2 &lt; MAX_ARGS &amp;&amp; svrArgsSz+2 &lt; MAX_ARGS) {
                if (addArgs == NULL || XSTRSTR(addArgs, &quot;doDH&quot;) == NULL) {
                    /* The `-2` disable DH prime check is added to all tests by default */
                    cliArgs[cliArgsSz++] = disableDHPrimeTest;
                    svrArgs[svrArgsSz++] = disableDHPrimeTest;
                }
                if (addArgs &amp;&amp; XSTRSTR(addArgs, &quot;expFail&quot;)) {
                    /* Tests should expect to fail */
                    cliArgs[cliArgsSz++] = intTestFlag;
                    cliArgs[cliArgsSz++] = exitWithRetFlag;
                    svrArgs[svrArgsSz++] = intTestFlag;
                    svrArgs[svrArgsSz++] = exitWithRetFlag;
                }
            }

            ret = execute_test_case(svrArgsSz, svrArgs,
                                    cliArgsSz, cliArgs, 0, 0, 0, 0, 0);
            /* don&#039;t repeat if not supported in build */
            if (ret == 0) {
                /* test with default cipher list on server side */
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 0, 0, 0, 1, 0);
                /* test with default cipher list on client side */
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 0, 0, 0, 0, 1);

                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 0, 1, 0, 0, 0);
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 1, 0, 0, 0, 0);
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 1, 1, 0, 0, 0);
#ifdef HAVE_EXTENDED_MASTER
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 0, 0, 1, 0, 0);
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 0, 1, 1, 0, 0);
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 1, 0, 1, 0, 0);
                execute_test_case(svrArgsSz, svrArgs,
                                  cliArgsSz, cliArgs, 1, 1, 1, 0, 0);
#endif
            }
            svrArgsSz = 1;
            cliArgsSz = 1;
            cliMode   = 0;
            do_it     = 0;
        }
    }

    free(script);
    args-&gt;return_code = 0;
}
#endif /* !NO_WOLFSSL_SERVER &amp;&amp; !NO_WOLFSSL_CLIENT */


int SuiteTest(int argc, char** argv)
{
#if !defined(NO_WOLFSSL_SERVER) &amp;&amp; !defined(NO_WOLFSSL_CLIENT) &amp;&amp; \
    !defined(NO_TLS) &amp;&amp; !defined(SINGLE_THREADED) &amp;&amp; \
    !defined(WOLF_CRYPTO_CB_ONLY_RSA) &amp;&amp; !defined(WOLF_CRYPTO_CB_ONLY_ECC)
    func_args args;
    char argv0[3][80];
    char* myArgv[3];

    printf(&quot; Begin Cipher Suite Tests\n&quot;);

    /* setup */
    myArgv[0] = argv0[0];
    myArgv[1] = argv0[1];
    myArgv[2] = argv0[2];
    args.argv = myArgv;
    XSTRLCPY(argv0[0], &quot;SuiteTest&quot;, sizeof(argv0[0]));

#ifdef WOLFSSL_STATIC_MEMORY
    byte memory[200000];
#endif

    cipherSuiteCtx = wolfSSL_CTX_new(wolfSSLv23_client_method());
    if (cipherSuiteCtx == NULL) {
        printf(&quot;can&#039;t get cipher suite ctx\n&quot;);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

    /* load in static memory buffer if enabled */
#ifdef WOLFSSL_STATIC_MEMORY
    if (wolfSSL_CTX_load_static_memory(&amp;cipherSuiteCtx, NULL,
                                                   memory, sizeof(memory), 0, 1)
            != WOLFSSL_SUCCESS) {
        printf(&quot;unable to load static memory and create ctx&quot;);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif

#ifdef WOLFSSL_ASYNC_CRYPT
    if (wolfAsync_DevOpen(&amp;devId) &lt; 0) {
        printf(&quot;Async device open failed&quot;);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    wolfSSL_CTX_SetDevId(cipherSuiteCtx, devId);
#endif /* WOLFSSL_ASYNC_CRYPT */

    /* support for custom command line tests */
    if (argc &gt; 1) {
        /* Examples:
            ./tests/unit.test tests/test-altchains.conf
            ./tests/unit.test tests/test-fails.conf expFail
            ./tests/unit.test tests/test-dhprime.conf doDH
        */
        args.argc = argc;
        args.argv = argv;
        test_harness(&amp;args);
        if (args.return_code != 0) {
            printf(&quot;error from script %d\n&quot;, args.return_code);
            args.return_code = EXIT_FAILURE;
        }
        goto exit;
    }

    /* default case */
    args.argc = 1;
    printf(&quot;starting default cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

    /* any extra cases will need another argument */
    args.argc = 2;

#ifdef WOLFSSL_OLDTLS_SHA2_CIPHERSUITES
    /* SHA-2 cipher suites in old TLS versions */
    XSTRLCPY(argv0[1], &quot;tests/test-sha2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting SHA-2 cipher suite in old TLS versions tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif

#ifdef WOLFSSL_TLS13
    /* add TLSv13 extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #ifdef HAVE_ECC
    /* add TLSv13 ECC extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-ecc.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 ECC extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
    #ifndef WOLFSSL_NO_TLS12
    /* add TLSv13 downgrade tests */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-down.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 Downgrade extra tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
    #ifdef HAVE_PQC
    /* add TLSv13 pq tests */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-pq.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 post-quantum groups tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #ifdef HAVE_LIBOQS
    /* add TLSv13 pq tests */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-pq-2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 post-quantum groups tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
    #endif
    #ifdef HAVE_PQC
    /* add TLSv13 pq tests */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-pq.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 post-quantum groups tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #ifdef HAVE_LIBOQS
    /* add TLSv13 pq tests */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-pq-2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLSv13 post-quantum groups tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
    #endif
    #if defined(HAVE_PQC) &amp;&amp; defined(WOLFSSL_DTLS13)
    /* add DTLSv13 pq tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls13-pq.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting DTLSv13 post-quantum groups tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #ifdef WOLFSSL_DTLS_CH_FRAG
    /* add DTLSv13 pq frag tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls13-pq-frag.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting DTLSv13 post-quantum groups tests with fragmentation\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
    #ifdef HAVE_LIBOQS
    /* add DTLSv13 pq 2 tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls13-pq-2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting DTLSv13 post-quantum 2 groups tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #ifdef WOLFSSL_DTLS_CH_FRAG
    /* add DTLSv13 pq 2 frag tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls13-pq-2-frag.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting DTLSv13 post-quantum 2 groups tests with fragmentation\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
    #endif
    #endif
#endif
#if defined(WC_RSA_PSS) &amp;&amp; (!defined(HAVE_FIPS) || \
     (defined(HAVE_FIPS_VERSION) &amp;&amp; (HAVE_FIPS_VERSION &gt; 2))) &amp;&amp; \
     (!defined(HAVE_SELFTEST) || (defined(HAVE_SELFTEST_VERSION) &amp;&amp; \
                      (HAVE_SELFTEST_VERSION &gt; 2)))
    /* add RSA-PSS certificate cipher suite tests */
    XSTRLCPY(argv0[1], &quot;tests/test-rsapss.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting RSA-PSS extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#if defined(HAVE_CURVE25519) &amp;&amp; defined(HAVE_ED25519) &amp;&amp; \
    defined(HAVE_ED25519_SIGN) &amp;&amp; defined(HAVE_ED25519_VERIFY) &amp;&amp; \
    defined(HAVE_ED25519_KEY_IMPORT) &amp;&amp; defined(HAVE_ED25519_KEY_EXPORT)
    /* add ED25519 certificate cipher suite tests */
    XSTRLCPY(argv0[1], &quot;tests/test-ed25519.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting ED25519 extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#if defined(HAVE_CURVE448) &amp;&amp; defined(HAVE_ED448) &amp;&amp; \
    defined(HAVE_ED448_SIGN) &amp;&amp; defined(HAVE_ED448_VERIFY) &amp;&amp; \
    defined(HAVE_ED448_KEY_IMPORT) &amp;&amp; defined(HAVE_ED448_KEY_EXPORT)
    /* add ED448 certificate cipher suite tests */
    XSTRLCPY(argv0[1], &quot;tests/test-ed448.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting ED448 extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#if defined(HAVE_ECC) &amp;&amp; defined(WOLFSSL_SHA512) &amp;&amp; \
    (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES))
    /* add P-521 certificate cipher suite tests */
    XSTRLCPY(argv0[1], &quot;tests/test-p521.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting P-521 extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#if defined(HAVE_ECC) &amp;&amp; !defined(NO_SHA256) &amp;&amp; defined(WOLFSSL_CUSTOM_CURVES) &amp;&amp; \
    defined(HAVE_ECC_KOBLITZ) &amp;&amp; defined(HAVE_ECC_BRAINPOOL) &amp;&amp; \
        /* Intel QuickAssist and Cavium Nitrox do not support custom curves */ \
        !defined(HAVE_INTEL_QA) &amp;&amp; !defined(HAVE_CAVIUM_V) &amp;&amp; \
        /* only supported with newer ASN template code */ \
        defined(WOLFSSL_ASN_TEMPLATE)

    /* TLS non-NIST curves (Koblitz / Brainpool) */
    XSTRLCPY(argv0[1], &quot;tests/test-ecc-cust-curves.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLS test of non-NIST curves (Koblitz / Brainpool)\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#ifdef WOLFSSL_DTLS
    /* add dtls extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    /* add dtls grouping tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-group.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls message grouping tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    /* add dtls session resumption tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-resume.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls session resumption tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#ifdef HAVE_SECURE_RENEGOTIATION
    /* add dtls renegotiation tests */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-reneg-client.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls secure renegotiation client tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-reneg-server.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls secure renegotiation server tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#ifdef WOLFSSL_DTLS_MTU
    /* Add dtls different MTU size tests.
     * These also use grouping to force wolfSSL to
     * bounce off the MTU limit more */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-mtu.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls MTU tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif

    /* Add dtls downgrade test */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-downgrade.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls downgrade tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

#ifdef WOLFSSL_OLDTLS_SHA2_CIPHERSUITES
    /* add dtls extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-sha2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls extra cipher suite tests - old TLS sha-2 cs\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#ifndef WOLFSSL_NO_DTLS_SIZE_CHECK
    /* failure tests */
    args.argc = 3;
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-fails.conf&quot;, sizeof(argv0[1]));
    XSTRLCPY(argv0[2], &quot;expFail&quot;, sizeof(argv0[2])); /* tests are expected to fail */
    printf(&quot;starting dtls tests that expect failure\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    XSTRLCPY(argv0[2], &quot;&quot;, sizeof(argv0[2]));
#endif
#ifdef WOLFSSL_EXTRA_ALERTS
    /* failure tests */
    args.argc = 3;
    XSTRLCPY(argv0[1], &quot;tests/test-dtls-fails-cipher.conf&quot;, sizeof(argv0[1]));
    XSTRLCPY(argv0[2], &quot;expFail&quot;, sizeof(argv0[2])); /* tests are expected to fail */
    printf(&quot;starting dtls cipher mismatch tests that expect failure\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    XSTRLCPY(argv0[2], &quot;&quot;, sizeof(argv0[2]));
#endif

#ifdef WOLFSSL_SRTP
    args.argc = 2;
    strcpy(argv0[1], &quot;tests/test-dtls-srtp.conf&quot;);
    printf(&quot;starting dtls srtp suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

    /* failure tests */
    args.argc = 3;
    strcpy(argv0[1], &quot;tests/test-dtls-srtp-fails.conf&quot;);
    strcpy(argv0[2], &quot;expFail&quot;); /* tests are expected to fail */
    printf(&quot;starting dtls srtp profile mismatch tests that expect failure\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    strcpy(argv0[2], &quot;&quot;);
#endif

#ifdef WOLFSSL_DTLS13
    args.argc = 2;
    strcpy(argv0[1], &quot;tests/test-dtls13.conf&quot;);
    printf(&quot;starting DTLSv1.3 suite\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

#ifndef WOLFSSL_NO_TLS12
    args.argc = 2;
    strcpy(argv0[1], &quot;tests/test-dtls13-downgrade.conf&quot;);
    printf(&quot;starting DTLSv1.3 suite - downgrade\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    args.argc = 3;
    strcpy(argv0[1], &quot;tests/test-dtls13-downgrade-fails.conf&quot;);
    strcpy(argv0[2], &quot;expFail&quot;);
    printf(&quot;starting DTLSv1.3 suite - downgrade - (expFails)\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    args.argc = 2;
    XMEMSET(argv0[2], 0, sizeof(argv0[2]));
#endif /* WOLFSSL_NO_TLS12 */

#ifndef NO_PSK
    XSTRLCPY(argv0[1], &quot;tests/test-dtls13-psk.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting DTLS 1.3 psk suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif /* NO_PSK */

#ifdef WOLFSSL_DTLS_CID
    XSTRLCPY(argv0[1], &quot;tests/test-dtls13-cid.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting DTLS 1.3 ConnectionID suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif /* WOLFSSL_DTLS_CID */

#endif /* WOLFSSL_DTLS13 */

#endif
#ifdef WOLFSSL_SCTP
    /* add dtls-sctp extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-sctp.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls-sctp extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#ifdef WOLFSSL_OLDTLS_SHA2_CIPHERSUITES
    /* add dtls-sctp extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-sctp-sha2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls-sctp extra cipher suite tests - old TLS sha-2 cs\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#endif
#ifndef WC_STRICT_SIG
#if !defined(NO_RSA) &amp;&amp; defined(HAVE_ECC) /* testing mixed ECC/RSA cert */
    /* add extra signature test suites */
    XSTRLCPY(argv0[1], &quot;tests/test-sig.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting sig extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif /* !NO__RSA and HAVE_ECC */
#endif /* !WC_STRICT_SIG */
#if defined(WOLFSSL_SM2) &amp;&amp; defined(WOLFSSL_SM3) &amp;&amp; \
    (defined(WOLFSSL_SM4_GCM) || defined(WOLFSSL_SM4_CCM))
    /* add SM2/SM3/SM4 test suites */
    XSTRLCPY(argv0[1], &quot;tests/test-sm2.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting SM2/SM3/SM4 cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif
#ifndef NO_PSK
    #ifndef WOLFSSL_NO_TLS12
        #if !defined(NO_RSA) || defined(HAVE_ECC)
        /* add psk cipher suites */
        XSTRLCPY(argv0[1], &quot;tests/test-psk.conf&quot;, sizeof(argv0[1]));
        printf(&quot;starting psk cipher suite tests\n&quot;);
        test_harness(&amp;args);
        if (args.return_code != 0) {
            printf(&quot;error from script %d\n&quot;, args.return_code);
            args.return_code = EXIT_FAILURE;
            goto exit;
        }
        #endif
    #endif
    #ifdef WOLFSSL_TLS13
    /* add psk extra suites */
    XSTRLCPY(argv0[1], &quot;tests/test-tls13-psk.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting TLS 1.3 psk no identity extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
#endif
#if defined(WOLFSSL_ENCRYPTED_KEYS) &amp;&amp; !defined(NO_DES3) &amp;&amp; !defined(NO_MD5) &amp;&amp;\
    !defined(NO_SHA)
    /* test encrypted keys */
    XSTRLCPY(argv0[1], &quot;tests/test-enckeys.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting encrypted keys extra cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif

#ifdef HAVE_MAX_FRAGMENT
    /* Max fragment cipher suite tests */
    XSTRLCPY(argv0[1], &quot;tests/test-maxfrag.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting max fragment cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

    #ifdef WOLFSSL_DTLS
    XSTRLCPY(argv0[1], &quot;tests/test-maxfrag-dtls.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting dtls max fragment cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
    #endif
#endif

#ifdef WOLFSSL_ALT_CERT_CHAINS
    /* tests for alt chains */
    XSTRLCPY(argv0[1], &quot;tests/test-altchains.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting certificate alternate chain cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#else
    /* tests for chains */
    XSTRLCPY(argv0[1], &quot;tests/test-chains.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting certificate chain cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif

#ifdef WOLFSSL_TRUST_PEER_CERT
    /* tests for trusted peer cert */
    XSTRLCPY(argv0[1], &quot;tests/test-trustpeer.conf&quot;, sizeof(argv0[1]));
    printf(&quot;starting trusted peer certificate cipher suite tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }
#endif

    /* tests for dh prime */
    args.argc = 3;
    XSTRLCPY(argv0[1], &quot;tests/test-dhprime.conf&quot;, sizeof(argv0[1]));
    XSTRLCPY(argv0[2], &quot;doDH&quot;, sizeof(argv0[2])); /* add DH prime flag */
    printf(&quot;starting dh prime tests\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

    /* failure tests */
    args.argc = 3;
    XSTRLCPY(argv0[1], &quot;tests/test-fails.conf&quot;, sizeof(argv0[1]));
    XSTRLCPY(argv0[2], &quot;expFail&quot;, sizeof(argv0[2])); /* tests are expected to fail */
    printf(&quot;starting tests that expect failure\n&quot;);
    test_harness(&amp;args);
    if (args.return_code != 0) {
        printf(&quot;error from script %d\n&quot;, args.return_code);
        args.return_code = EXIT_FAILURE;
        goto exit;
    }

exit:

    if (args.return_code == 0)
        printf(&quot;\n Success -- All results as expected.\n&quot;);

    printf(&quot; End Cipher Suite Tests\n&quot;);

    wolfSSL_CTX_free(cipherSuiteCtx);
    wolfSSL_Cleanup();

#if defined(HAVE_ECC) &amp;&amp; defined(FP_ECC) &amp;&amp; defined(HAVE_THREAD_LS) \
                      &amp;&amp; (defined(NO_MAIN_DRIVER) || defined(HAVE_STACK_SIZE))
    wc_ecc_fp_free();  /* free per thread cache */
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
    wolfAsync_DevClose(&amp;devId);
#endif

    return args.return_code;
#else
    (void)argc;
    (void)argv;
    return NOT_COMPILED_IN;
#endif /* !NO_WOLFSSL_SERVER &amp;&amp; !NO_WOLFSSL_CLIENT &amp;&amp; !NO_TLS */
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2Fwolfssl%2Fwolfssl%2Ftests'>🔙 Back</a></p>