luna - wolfssl/examples/benchmark/tls

   1/* tls_bench.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22
  23/*
  24Example gcc build statement
  25
  26  gcc -lwolfssl -lpthread -o tls_bench tls_bench.c
  27  ./tls_bench
  28
  29Or
  30
  31  #include <examples/benchmark/tls_bench.h>
  32  bench_tls(args);
  33*/
  34
  35#ifdef HAVE_CONFIG_H
  36    #include <config.h>
  37#endif
  38#ifndef WOLFSSL_USER_SETTINGS
  39    #include <wolfssl/options.h>
  40#endif
  41#include <wolfssl/wolfcrypt/settings.h>
  42
  43#undef TEST_OPENSSL_COEXIST /* can't use this option with this example */
  44#undef OPENSSL_COEXIST /* can't use this option with this example */
  45
  46#include <wolfssl/wolfcrypt/types.h>
  47#include <wolfssl/wolfcrypt/wc_port.h>
  48#include <wolfssl/ssl.h>
  49#include <wolfssl/wolfcrypt/hash.h> /* WC_MAX_DIGEST_SIZE */
  50#include <wolfssl/test.h>
  51#include <wolfssl/wolfio.h>
  52#include <examples/benchmark/tls_bench.h>
  53
  54/* force certificate test buffers to be included via headers */
  55#undef  USE_CERT_BUFFERS_2048
  56#define USE_CERT_BUFFERS_2048
  57#undef  USE_CERT_BUFFERS_256
  58#define USE_CERT_BUFFERS_256
  59#include <wolfssl/certs_test.h>
  60
  61#include <stdio.h>
  62#include <stdlib.h>
  63#include <string.h>
  64#include <unistd.h>
  65#include <sys/time.h>
  66#include <errno.h>
  67
  68/* For testing no threading support */
  69#if 0
  70    #undef HAVE_PTHREAD
  71    #define SINGLE_THREADED
  72#endif
  73
  74/* PTHREAD requires server and client enabled */
  75#if !defined(NO_TLS) && \
  76    (defined(NO_WOLFSSL_CLIENT) || defined(NO_WOLFSSL_SERVER))
  77    #if !defined(SINGLE_THREADED)
  78        #ifdef __GNUC__  /* GCC compiler */
  79            #pragma message "PTHREAD requires server and client enabled."
  80        #elif defined(_MSC_VER) /* Microsoft Visual C++ compiler */
  81            #pragma message("PTHREAD requires server and client enabled.")
  82        #else
  83            #warning "PTHREAD requires server and client enabled."
  84        #endif
  85        #define SINGLE_THREADED
  86    #endif
  87#endif
  88
  89/* If both client and server are enabled and single threaded, just disable this example */
  90#if !defined(NO_WOLFSSL_CLIENT) && !defined(NO_WOLFSSL_SERVER) \
  91    && defined(SINGLE_THREADED)
  92    #undef  NO_TLS
  93    #define NO_TLS
  94#endif
  95
  96#if 0
  97#define BENCH_USE_NONBLOCK
  98#endif
  99
 100/* Defaults for configuration parameters */
 101#define BENCH_DEFAULT_HOST  "localhost"
 102#define BENCH_DEFAULT_PORT  11112
 103#define NUM_THREAD_PAIRS    1 /* Thread pairs of server/client */
 104#ifndef BENCH_RUNTIME_SEC
 105    #ifdef BENCH_EMBEDDED
 106        #define BENCH_RUNTIME_SEC   15
 107    #else
 108        #define BENCH_RUNTIME_SEC   1
 109    #endif
 110#endif
 111/* TLS packet size */
 112#ifndef TEST_PACKET_SIZE
 113    #ifdef BENCH_EMBEDDED
 114        #define TEST_PACKET_SIZE    (2 * 1024)
 115    #else
 116        #define TEST_PACKET_SIZE    (16 * 1024)
 117    #endif
 118#endif
 119/* Total bytes to benchmark per connection */
 120#ifndef TEST_MAX_SIZE
 121    #ifdef BENCH_EMBEDDED
 122        #define TEST_MAX_SIZE       (16 * 1024)
 123    #else
 124        #define TEST_MAX_SIZE       (128 * 1024)
 125    #endif
 126#endif
 127
 128#ifdef WOLFSSL_DTLS
 129    #ifdef BENCH_EMBEDDED
 130        /* WOLFSSL_MAX_MTU in internal.h */
 131        #define TEST_DTLS_PACKET_SIZE   (1500)
 132    #else
 133        /* MAX_UDP_SIZE in interna.h */
 134        #define TEST_DTLS_PACKET_SIZE   (8092)
 135    #endif
 136#endif
 137
 138/* In memory transfer buffer maximum size */
 139/* Must be large enough to handle max TLS packet size plus max TLS header MAX_MSG_EXTRA */
 140#define MEM_BUFFER_SZ       (TEST_PACKET_SIZE + 38 + WC_MAX_DIGEST_SIZE)
 141#define SHOW_VERBOSE        0 /* Default output is tab delimited format */
 142
 143#if (!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)) && \
 144    !defined(WOLFCRYPT_ONLY) && !defined(NO_TLS) && defined(USE_WOLFSSL_IO)
 145
 146/* shutdown message - nice signal to server, we are done */
 147static const char* kShutdown = "shutdown";
 148
 149#ifndef NO_WOLFSSL_CLIENT
 150PEDANTIC_EXTENSION static const char* kTestStr =
 151"Biodiesel cupidatat marfa, cliche aute put a bird on it incididunt elit\n"
 152"polaroid. Sunt tattooed bespoke reprehenderit. Sint twee organic id\n"
 153"marfa. Commodo veniam ad esse gastropub. 3 wolf moon sartorial vero,\n"
 154"plaid delectus biodiesel squid +1 vice. Post-ironic keffiyeh leggings\n"
 155"selfies cray fap hoodie, forage anim. Carles cupidatat shoreditch, VHS\n"
 156"small batch meggings kogi dolore food truck bespoke gastropub.\n"
 157"\n"
 158"Terry richardson adipisicing actually typewriter tumblr, twee whatever\n"
 159"four loko you probably haven't heard of them high life. Messenger bag\n"
 160"whatever tattooed deep v mlkshk. Brooklyn pinterest assumenda chillwave\n"
 161"et, banksy ullamco messenger bag umami pariatur direct trade forage.\n"
 162"Typewriter culpa try-hard, pariatur sint brooklyn meggings. Gentrify\n"
 163"food truck next level, tousled irony non semiotics PBR ethical anim cred\n"
 164"readymade. Mumblecore brunch lomo odd future, portland organic terry\n"
 165"richardson elit leggings adipisicing ennui raw denim banjo hella. Godard\n"
 166"mixtape polaroid, pork belly readymade organic cray typewriter helvetica\n"
 167"four loko whatever street art yr farm-to-table.\n"
 168"\n"
 169"Vinyl keytar vice tofu. Locavore you probably haven't heard of them pug\n"
 170"pickled, hella tonx labore truffaut DIY mlkshk elit cosby sweater sint\n"
 171"et mumblecore. Elit swag semiotics, reprehenderit DIY sartorial nisi ugh\n"
 172"nesciunt pug pork belly wayfarers selfies delectus. Ethical hoodie\n"
 173"seitan fingerstache kale chips. Terry richardson artisan williamsburg,\n"
 174"eiusmod fanny pack irony tonx ennui lo-fi incididunt tofu YOLO\n"
 175"readymade. 8-bit sed ethnic beard officia. Pour-over iphone DIY butcher,\n"
 176"ethnic art party qui letterpress nisi proident jean shorts mlkshk\n"
 177"locavore.\n"
 178"\n"
 179"Narwhal flexitarian letterpress, do gluten-free voluptate next level\n"
 180"banh mi tonx incididunt carles DIY. Odd future nulla 8-bit beard ut\n"
 181"cillum pickled velit, YOLO officia you probably haven't heard of them\n"
 182"trust fund gastropub. Nisi adipisicing tattooed, Austin mlkshk 90's\n"
 183"small batch american apparel. Put a bird on it cosby sweater before they\n"
 184"sold out pork belly kogi hella. Street art mollit sustainable polaroid,\n"
 185"DIY ethnic ea pug beard dreamcatcher cosby sweater magna scenester nisi.\n"
 186"Sed pork belly skateboard mollit, labore proident eiusmod. Sriracha\n"
 187"excepteur cosby sweater, anim deserunt laborum eu aliquip ethical et\n"
 188"neutra PBR selvage.\n"
 189"\n"
 190"Raw denim pork belly truffaut, irony plaid sustainable put a bird on it\n"
 191"next level jean shorts exercitation. Hashtag keytar whatever, nihil\n"
 192"authentic aliquip disrupt laborum. Tattooed selfies deserunt trust fund\n"
 193"wayfarers. 3 wolf moon synth church-key sartorial, gastropub leggings\n"
 194"tattooed. Labore high life commodo, meggings raw denim fingerstache pug\n"
 195"trust fund leggings seitan forage. Nostrud ullamco duis, reprehenderit\n"
 196"incididunt flannel sustainable helvetica pork belly pug banksy you\n"
 197"probably haven't heard of them nesciunt farm-to-table. Disrupt nostrud\n"
 198"mollit magna, sriracha sartorial helvetica.\n"
 199"\n"
 200"Nulla kogi reprehenderit, skateboard sustainable duis adipisicing viral\n"
 201"ad fanny pack salvia. Fanny pack trust fund you probably haven't heard\n"
 202"of them YOLO vice nihil. Keffiyeh cray lo-fi pinterest cardigan aliqua,\n"
 203"reprehenderit aute. Culpa tousled williamsburg, marfa lomo actually anim\n"
 204"skateboard. Iphone aliqua ugh, semiotics pariatur vero readymade\n"
 205"organic. Marfa squid nulla, in laborum disrupt laboris irure gastropub.\n"
 206"Veniam sunt food truck leggings, sint vinyl fap.\n"
 207"\n"
 208"Hella dolore pork belly, truffaut carles you probably haven't heard of\n"
 209"them PBR helvetica in sapiente. Fashion axe ugh bushwick american\n"
 210"apparel. Fingerstache sed iphone, jean shorts blue bottle nisi bushwick\n"
 211"flexitarian officia veniam plaid bespoke fap YOLO lo-fi. Blog\n"
 212"letterpress mumblecore, food truck id cray brooklyn cillum ad sed.\n"
 213"Assumenda chambray wayfarers vinyl mixtape sustainable. VHS vinyl\n"
 214"delectus, culpa williamsburg polaroid cliche swag church-key synth kogi\n"
 215"magna pop-up literally. Swag thundercats ennui shoreditch vegan\n"
 216"pitchfork neutra truffaut etsy, sed single-origin coffee craft beer.\n"
 217"\n"
 218"Odio letterpress brooklyn elit. Nulla single-origin coffee in occaecat\n"
 219"meggings. Irony meggings 8-bit, chillwave lo-fi adipisicing cred\n"
 220"dreamcatcher veniam. Put a bird on it irony umami, trust fund bushwick\n"
 221"locavore kale chips. Sriracha swag thundercats, chillwave disrupt\n"
 222"tousled beard mollit mustache leggings portland next level. Nihil esse\n"
 223"est, skateboard art party etsy thundercats sed dreamcatcher ut iphone\n"
 224"swag consectetur et. Irure skateboard banjo, nulla deserunt messenger\n"
 225"bag dolor terry richardson sapiente.\n";
 226#endif
 227
 228#if !defined(NO_DH)
 229
 230#define MIN_DHKEY_BITS      1024
 231
 232#if !defined(NO_WOLFSSL_SERVER)
 233/* dh2048 p */
 234static const unsigned char dhp[] =
 235{
 236    0xb0, 0xa1, 0x08, 0x06, 0x9c, 0x08, 0x13, 0xba, 0x59, 0x06, 0x3c, 0xbc, 0x30,
 237    0xd5, 0xf5, 0x00, 0xc1, 0x4f, 0x44, 0xa7, 0xd6, 0xef, 0x4a, 0xc6, 0x25, 0x27,
 238    0x1c, 0xe8, 0xd2, 0x96, 0x53, 0x0a, 0x5c, 0x91, 0xdd, 0xa2, 0xc2, 0x94, 0x84,
 239    0xbf, 0x7d, 0xb2, 0x44, 0x9f, 0x9b, 0xd2, 0xc1, 0x8a, 0xc5, 0xbe, 0x72, 0x5c,
 240    0xa7, 0xe7, 0x91, 0xe6, 0xd4, 0x9f, 0x73, 0x07, 0x85, 0x5b, 0x66, 0x48, 0xc7,
 241    0x70, 0xfa, 0xb4, 0xee, 0x02, 0xc9, 0x3d, 0x9a, 0x4a, 0xda, 0x3d, 0xc1, 0x46,
 242    0x3e, 0x19, 0x69, 0xd1, 0x17, 0x46, 0x07, 0xa3, 0x4d, 0x9f, 0x2b, 0x96, 0x17,
 243    0x39, 0x6d, 0x30, 0x8d, 0x2a, 0xf3, 0x94, 0xd3, 0x75, 0xcf, 0xa0, 0x75, 0xe6,
 244    0xf2, 0x92, 0x1f, 0x1a, 0x70, 0x05, 0xaa, 0x04, 0x83, 0x57, 0x30, 0xfb, 0xda,
 245    0x76, 0x93, 0x38, 0x50, 0xe8, 0x27, 0xfd, 0x63, 0xee, 0x3c, 0xe5, 0xb7, 0xc8,
 246    0x09, 0xae, 0x6f, 0x50, 0x35, 0x8e, 0x84, 0xce, 0x4a, 0x00, 0xe9, 0x12, 0x7e,
 247    0x5a, 0x31, 0xd7, 0x33, 0xfc, 0x21, 0x13, 0x76, 0xcc, 0x16, 0x30, 0xdb, 0x0c,
 248    0xfc, 0xc5, 0x62, 0xa7, 0x35, 0xb8, 0xef, 0xb7, 0xb0, 0xac, 0xc0, 0x36, 0xf6,
 249    0xd9, 0xc9, 0x46, 0x48, 0xf9, 0x40, 0x90, 0x00, 0x2b, 0x1b, 0xaa, 0x6c, 0xe3,
 250    0x1a, 0xc3, 0x0b, 0x03, 0x9e, 0x1b, 0xc2, 0x46, 0xe4, 0x48, 0x4e, 0x22, 0x73,
 251    0x6f, 0xc3, 0x5f, 0xd4, 0x9a, 0xd6, 0x30, 0x07, 0x48, 0xd6, 0x8c, 0x90, 0xab,
 252    0xd4, 0xf6, 0xf1, 0xe3, 0x48, 0xd3, 0x58, 0x4b, 0xa6, 0xb9, 0xcd, 0x29, 0xbf,
 253    0x68, 0x1f, 0x08, 0x4b, 0x63, 0x86, 0x2f, 0x5c, 0x6b, 0xd6, 0xb6, 0x06, 0x65,
 254    0xf7, 0xa6, 0xdc, 0x00, 0x67, 0x6b, 0xbb, 0xc3, 0xa9, 0x41, 0x83, 0xfb, 0xc7,
 255    0xfa, 0xc8, 0xe2, 0x1e, 0x7e, 0xaf, 0x00, 0x3f, 0x93
 256};
 257
 258/* dh2048 g */
 259static const unsigned char dhg[] =
 260{
 261    0x02,
 262};
 263#endif /* !NO_WOLFSSL_SERVER */
 264#endif /* !NO_DH */
 265
 266#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
 267struct group_info {
 268    word16 group;
 269    const char *name;
 270};
 271
 272static struct group_info groups[] = {
 273    { WOLFSSL_ECC_SECP160K1, "ECC_SECP160K1" },
 274    { WOLFSSL_ECC_SECP160R1, "ECC_SECP160R1" },
 275    { WOLFSSL_ECC_SECP160R2, "ECC_SECP160R2" },
 276    { WOLFSSL_ECC_SECP192K1, "ECC_SECP192K1" },
 277    { WOLFSSL_ECC_SECP192R1, "ECC_SECP192R1" },
 278    { WOLFSSL_ECC_SECP224K1, "ECC_SECP224K1" },
 279    { WOLFSSL_ECC_SECP224R1, "ECC_SECP224R1" },
 280    { WOLFSSL_ECC_SECP256K1, "ECC_SECP256K1" },
 281    { WOLFSSL_ECC_SECP256R1, "ECC_SECP256R1" },
 282    { WOLFSSL_ECC_SECP384R1, "ECC_SECP384R1" },
 283    { WOLFSSL_ECC_SECP521R1, "ECC_SECP521R1" },
 284    { WOLFSSL_ECC_BRAINPOOLP256R1, "ECC_BRAINPOOLP256R1" },
 285    { WOLFSSL_ECC_BRAINPOOLP384R1, "ECC_BRAINPOOLP384R1" },
 286    { WOLFSSL_ECC_BRAINPOOLP512R1, "ECC_BRAINPOOLP512R1" },
 287    { WOLFSSL_ECC_X25519, "ECC_X25519" },
 288    { WOLFSSL_ECC_X448, "ECC_X448" },
 289    { WOLFSSL_ECC_BRAINPOOLP256R1TLS13, "ECC_BRAINPOOLP256R1TLS13" },
 290    { WOLFSSL_ECC_BRAINPOOLP384R1TLS13, "ECC_BRAINPOOLP384R1TLS13" },
 291    { WOLFSSL_ECC_BRAINPOOLP512R1TLS13, "ECC_BRAINPOOLP512R1TLS13" },
 292    { WOLFSSL_FFDHE_2048, "FFDHE_2048" },
 293    { WOLFSSL_FFDHE_3072, "FFDHE_3072" },
 294    { WOLFSSL_FFDHE_4096, "FFDHE_4096" },
 295    { WOLFSSL_FFDHE_6144, "FFDHE_6144" },
 296    { WOLFSSL_FFDHE_8192, "FFDHE_8192" },
 297#ifdef WOLFSSL_HAVE_MLKEM
 298#ifndef WOLFSSL_NO_ML_KEM
 299    #ifndef WOLFSSL_TLS_NO_MLKEM_STANDALONE
 300    { WOLFSSL_ML_KEM_512, "ML_KEM_512" },
 301    { WOLFSSL_ML_KEM_768, "ML_KEM_768" },
 302    { WOLFSSL_ML_KEM_1024, "ML_KEM_1024" },
 303    #endif /* !WOLFSSL_TLS_NO_MLKEM_STANDALONE */
 304    #ifdef WOLFSSL_PQC_HYBRIDS
 305    { WOLFSSL_SECP256R1MLKEM768,   "SecP256r1MLKEM768"   },
 306    { WOLFSSL_SECP384R1MLKEM1024,  "SecP384r1MLKEM1024"  },
 307    { WOLFSSL_X25519MLKEM768, "X25519MLKEM768" },
 308    #endif /* WOLFSSL_PQC_HYBRIDS */
 309    #ifdef WOLFSSL_EXTRA_PQC_HYBRIDS
 310    { WOLFSSL_SECP256R1MLKEM512,   "SecP256r1MLKEM512"   },
 311    { WOLFSSL_SECP384R1MLKEM768,   "SecP384r1MLKEM768"   },
 312    { WOLFSSL_SECP521R1MLKEM1024,  "SecP521r1MLKEM1024"  },
 313    { WOLFSSL_X25519MLKEM512, "X25519MLKEM512" },
 314    { WOLFSSL_X448MLKEM768,   "X448MLKEM768"   },
 315    #endif /* WOLFSSL_EXTRA_PQC_HYBRIDS */
 316#endif
 317#ifdef WOLFSSL_MLKEM_KYBER
 318    { WOLFSSL_KYBER_LEVEL1, "KYBER_LEVEL1" },
 319    { WOLFSSL_KYBER_LEVEL3, "KYBER_LEVEL3" },
 320    { WOLFSSL_KYBER_LEVEL5, "KYBER_LEVEL5" },
 321    { WOLFSSL_P256_KYBER_LEVEL1,   "P256_KYBER_LEVEL1"   },
 322    { WOLFSSL_P384_KYBER_LEVEL3,   "P384_KYBER_LEVEL3"   },
 323    { WOLFSSL_P256_KYBER_LEVEL3,   "P256_KYBER_LEVEL3"   },
 324    { WOLFSSL_P521_KYBER_LEVEL5,   "P521_KYBER_LEVEL5"   },
 325    { WOLFSSL_X25519_KYBER_LEVEL1, "X25519_KYBER_LEVEL1" },
 326    { WOLFSSL_X448_KYBER_LEVEL3,   "X448_KYBER_LEVEL3"   },
 327    { WOLFSSL_X25519_KYBER_LEVEL3, "X25519_KYBER_LEVEL3" },
 328#endif
 329#endif
 330    { 0, NULL }
 331};
 332#endif /* WOLFSSL_TLS13 && HAVE_SUPPORTED_CURVES */
 333
 334#ifndef SINGLE_THREADED
 335typedef struct {
 336    unsigned char buf[MEM_BUFFER_SZ];
 337    int write_bytes;
 338    int write_idx;
 339    int read_bytes;
 340    int read_idx;
 341
 342    COND_TYPE cond;
 343
 344    int done;
 345} memBuf_t;
 346#endif
 347
 348typedef struct {
 349    double connTime;
 350    double rxTime;
 351    double txTime;
 352    int connCount;
 353    int rxTotal;
 354    int txTotal;
 355} stats_t;
 356
 357typedef struct {
 358    int shutdown;
 359    int sockFd;
 360    int ret;
 361} side_t;
 362
 363typedef struct {
 364    const char* cipher;
 365    word16 group;
 366    const char* host;
 367    word32 port;
 368    int packetSize; /* The data payload size in the packet */
 369    int maxSize;
 370    int runTimeSec;
 371    int showPeerInfo;
 372    int showVerbose;
 373#ifndef NO_WOLFSSL_SERVER
 374    int listenFd;
 375#endif
 376#ifdef WOLFSSL_DTLS
 377    int doDTLS;
 378    struct sockaddr_in serverAddr;
 379    struct sockaddr_in clientAddr;
 380#ifndef SINGLE_THREADED
 381    int serverReady;
 382    int clientOrserverOnly;
 383    wolfSSL_Mutex dtls_mutex;
 384    COND_TYPE dtls_cond;
 385#endif
 386#endif
 387    side_t client;
 388    side_t server;
 389
 390#ifndef SINGLE_THREADED
 391    int useLocalMem;
 392
 393    /* client messages to server in memory */
 394    memBuf_t to_server;
 395
 396    /* server messages to client in memory */
 397    memBuf_t to_client;
 398
 399    /* Indicates that the server is ready for connection */
 400    int serverListening;
 401#endif
 402
 403    /* server */
 404    stats_t server_stats;
 405
 406    /* client */
 407    stats_t client_stats;
 408} info_t;
 409
 410/* Global vars for argument parsing */
 411int myoptind = 0;
 412char* myoptarg = NULL;
 413
 414#ifdef WOLFSSL_DTLS
 415int DoneHandShake = 0;
 416#endif
 417
 418
 419#if defined(HAVE_FIPS) && defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION == 5)
 420static int run_all_CAST(void)
 421{
 422    int ret = 0;
 423    int cast_idx = 0;
 424
 425    for (cast_idx = 0; cast_idx < FIPS_CAST_COUNT; cast_idx++) {
 426        if ((ret = wc_RunCast_fips(cast_idx)) != 0) {
 427#ifdef NO_ERROR_STRINGS
 428            fprintf(stderr,
 429                    "ERROR: FIPS CAST failed with return code: %d\n", ret);
 430#else
 431            fprintf(stderr,
 432                    "ERROR: FIPS CAST failed for algorithm: %s\n",
 433                    wc_GetErrorString(ret));
 434#endif
 435            return ret;
 436        }
 437    }
 438
 439    return ret;
 440}
 441#endif /* HAVE_FIPS && HAVE_FIPS_VERSION == 5 */
 442
 443
 444static double gettime_secs(int reset)
 445{
 446    struct timeval tv;
 447    LIBCALL_CHECK_RET(gettimeofday(&tv, 0));
 448    (void)reset;
 449
 450    return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
 451}
 452
 453
 454#ifndef SINGLE_THREADED
 455/* server send callback */
 456static int ServerMemSend(info_t* info, char* buf, int sz)
 457{
 458    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
 459
 460#ifndef BENCH_USE_NONBLOCK
 461    /* check for overflow */
 462    if (info->to_client.write_idx + sz > MEM_BUFFER_SZ) {
 463        THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
 464        fprintf(stderr, "ServerMemSend overflow\n");
 465        return -1;
 466    }
 467#else
 468    if (info->to_client.write_idx + sz > MEM_BUFFER_SZ) {
 469        sz = MEM_BUFFER_SZ - info->to_client.write_idx;
 470    }
 471#endif
 472
 473    XMEMCPY(&info->to_client.buf[info->to_client.write_idx], buf, (size_t)sz);
 474    info->to_client.write_idx += sz;
 475    info->to_client.write_bytes += sz;
 476
 477    THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
 478    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
 479
 480#ifdef BENCH_USE_NONBLOCK
 481    if (sz == 0) {
 482        return WOLFSSL_CBIO_ERR_WANT_WRITE;
 483    }
 484#endif
 485    return sz;
 486}
 487
 488/* server recv callback */
 489static int ServerMemRecv(info_t* info, char* buf, int sz)
 490{
 491    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
 492
 493#ifndef BENCH_USE_NONBLOCK
 494    while (info->to_server.write_idx - info->to_server.read_idx < sz &&
 495            !info->to_client.done) {
 496        THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_server.cond));
 497    }
 498#else
 499    if (info->to_server.write_idx - info->to_server.read_idx < sz) {
 500        sz = info->to_server.write_idx - info->to_server.read_idx;
 501    }
 502#endif
 503
 504    XMEMCPY(buf, &info->to_server.buf[info->to_server.read_idx], (size_t)sz);
 505    info->to_server.read_idx += sz;
 506    info->to_server.read_bytes += sz;
 507
 508    /* if the rx has caught up with pending then reset buffer positions */
 509    if (info->to_server.read_bytes == info->to_server.write_bytes) {
 510        info->to_server.read_bytes = info->to_server.read_idx = 0;
 511        info->to_server.write_bytes = info->to_server.write_idx = 0;
 512    }
 513
 514    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
 515
 516    if (info->to_client.done != 0) {
 517        return -1;
 518    }
 519
 520#ifdef BENCH_USE_NONBLOCK
 521    if (sz == 0) {
 522        return WOLFSSL_CBIO_ERR_WANT_READ;
 523    }
 524#endif
 525    return sz;
 526}
 527
 528/* client send callback */
 529static int ClientMemSend(info_t* info, char* buf, int sz)
 530{
 531    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
 532
 533#ifndef BENCH_USE_NONBLOCK
 534    /* check for overflow */
 535    if (info->to_server.write_idx + sz > MEM_BUFFER_SZ) {
 536        fprintf(stderr, "ClientMemSend overflow %d %d %d\n",
 537            info->to_server.write_idx, sz, MEM_BUFFER_SZ);
 538        THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
 539        return -1;
 540    }
 541#else
 542    if (info->to_server.write_idx + sz > MEM_BUFFER_SZ) {
 543        sz = MEM_BUFFER_SZ - info->to_server.write_idx;
 544    }
 545#endif
 546
 547    XMEMCPY(&info->to_server.buf[info->to_server.write_idx], buf, (size_t)sz);
 548    info->to_server.write_idx += sz;
 549    info->to_server.write_bytes += sz;
 550
 551    THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
 552    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
 553
 554#ifdef BENCH_USE_NONBLOCK
 555    if (sz == 0) {
 556        return WOLFSSL_CBIO_ERR_WANT_WRITE;
 557    }
 558#endif
 559    return sz;
 560}
 561
 562/* client recv callback */
 563static int ClientMemRecv(info_t* info, char* buf, int sz)
 564{
 565    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
 566
 567#ifndef BENCH_USE_NONBLOCK
 568    while (info->to_client.write_idx - info->to_client.read_idx < sz &&
 569            !info->to_server.done) {
 570        THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_client.cond));
 571    }
 572#else
 573    if (info->to_client.write_idx - info->to_client.read_idx < sz) {
 574        sz = info->to_client.write_idx - info->to_client.read_idx;
 575    }
 576#endif
 577
 578    XMEMCPY(buf, &info->to_client.buf[info->to_client.read_idx], (size_t)sz);
 579    info->to_client.read_idx += sz;
 580    info->to_client.read_bytes += sz;
 581
 582    /* if the rx has caught up with pending then reset buffer positions */
 583    if (info->to_client.read_bytes == info->to_client.write_bytes) {
 584        info->to_client.read_bytes = info->to_client.read_idx = 0;
 585        info->to_client.write_bytes = info->to_client.write_idx = 0;
 586    }
 587
 588    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
 589
 590    if (info->to_server.done != 0) {
 591        return -1;
 592    }
 593
 594#ifdef BENCH_USE_NONBLOCK
 595    if (sz == 0) {
 596        return WOLFSSL_CBIO_ERR_WANT_READ;
 597    }
 598#endif
 599    return sz;
 600}
 601#endif /* !SINGLE_THREADED */
 602
 603static int SocketRecv(int sockFd, char* buf, int sz)
 604{
 605    int recvd = (int)recv(sockFd, buf, (size_t)sz, 0);
 606    if (recvd == -1) {
 607        switch (errno) {
 608    #if EAGAIN != SOCKET_EWOULDBLOCK
 609        case EAGAIN: /* EAGAIN == EWOULDBLOCK on some systems, but not others */
 610    #endif
 611        case SOCKET_EWOULDBLOCK:
 612            return WOLFSSL_CBIO_ERR_WANT_READ;
 613        case SOCKET_ECONNRESET:
 614            return WOLFSSL_CBIO_ERR_CONN_RST;
 615        case SOCKET_EINTR:
 616            return WOLFSSL_CBIO_ERR_ISR;
 617        case SOCKET_ECONNREFUSED: /* DTLS case */
 618            return WOLFSSL_CBIO_ERR_WANT_READ;
 619        case SOCKET_ECONNABORTED:
 620            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
 621        default:
 622            return WOLFSSL_CBIO_ERR_GENERAL;
 623        }
 624    }
 625    else if (recvd == 0) {
 626        return WOLFSSL_CBIO_ERR_CONN_CLOSE;
 627    }
 628    return recvd;
 629}
 630
 631static int SocketSend(int sockFd, char* buf, int sz)
 632{
 633    int sent = (int)send(sockFd, buf, (size_t)sz, 0);
 634    if (sent == -1) {
 635        switch (errno) {
 636    #if EAGAIN != SOCKET_EWOULDBLOCK
 637        case EAGAIN: /* EAGAIN == EWOULDBLOCK on some systems, but not others */
 638    #endif
 639        case SOCKET_EWOULDBLOCK:
 640            return WOLFSSL_CBIO_ERR_WANT_READ;
 641        case SOCKET_ECONNRESET:
 642            return WOLFSSL_CBIO_ERR_CONN_RST;
 643        case SOCKET_EINTR:
 644            return WOLFSSL_CBIO_ERR_ISR;
 645        case SOCKET_EPIPE:
 646            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
 647        default:
 648            return WOLFSSL_CBIO_ERR_GENERAL;
 649        }
 650    }
 651    else if (sent == 0) {
 652        return 0;
 653    }
 654    return sent;
 655}
 656#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
 657static int ReceiveFrom(WOLFSSL *ssl, int sd, char *buf, int sz)
 658{
 659    int recvd;
 660    int dtls_timeout = wolfSSL_dtls_get_current_timeout(ssl);
 661    struct sockaddr peer;
 662    socklen_t peerSz = 0;
 663
 664    if (DoneHandShake) {
 665        dtls_timeout = 0;
 666    }
 667
 668    if (!wolfSSL_get_using_nonblock(ssl)) {
 669        struct timeval timeout;
 670        XMEMSET(&timeout, 0, sizeof(timeout));
 671        timeout.tv_sec = dtls_timeout;
 672
 673        if (setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout,
 674                       sizeof(timeout)) != 0) {
 675                fprintf(stderr, "setsockopt rcvtimeo failed\n");
 676        }
 677    }
 678
 679    recvd = (int)recvfrom(sd, buf, (size_t)sz, 0, (SOCKADDR*)&peer, &peerSz);
 680
 681    if (recvd < 0) {
 682        if (errno == SOCKET_EWOULDBLOCK || errno == SOCKET_EAGAIN) {
 683            if (wolfSSL_dtls_get_using_nonblock(ssl)) {
 684                return WOLFSSL_CBIO_ERR_WANT_READ;
 685            }
 686            else {
 687                return WOLFSSL_CBIO_ERR_TIMEOUT;
 688            }
 689        }
 690        else if (errno == SOCKET_ECONNRESET) {
 691            return WOLFSSL_CBIO_ERR_CONN_RST;
 692        }
 693        else if (errno == SOCKET_EINTR) {
 694            return WOLFSSL_CBIO_ERR_ISR;
 695        }
 696        else if (errno == SOCKET_ECONNREFUSED) {
 697            return WOLFSSL_CBIO_ERR_WANT_READ;
 698        }
 699        else {
 700            return WOLFSSL_CBIO_ERR_GENERAL;
 701        }
 702    }
 703    else {
 704        if (recvd == 0) {
 705            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
 706        }
 707    }
 708
 709    return recvd;
 710}
 711#endif /* WOLFSSL_DTLS && !NO_WOLFSSL_SERVER */
 712
 713#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_CLIENT)
 714static int SendTo(int sd, char *buf, int sz, const struct sockaddr *peer,
 715                  socklen_t peerSz)
 716{
 717    int sent;
 718
 719    sent = (int)sendto(sd, buf, (size_t)sz, 0, peer, peerSz);
 720
 721    if (sent < 0) {
 722        if (errno == SOCKET_EWOULDBLOCK || errno == SOCKET_EAGAIN) {
 723            return WOLFSSL_CBIO_ERR_WANT_WRITE;
 724        }
 725        else if (errno == SOCKET_ECONNRESET) {
 726            return WOLFSSL_CBIO_ERR_CONN_RST;
 727        }
 728        else if (errno == SOCKET_EINTR) {
 729            return WOLFSSL_CBIO_ERR_ISR;
 730        }
 731        else if (errno == SOCKET_EPIPE) {
 732            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
 733        }
 734        else {
 735            return WOLFSSL_CBIO_ERR_GENERAL;
 736        }
 737    }
 738
 739    return sent;
 740}
 741
 742static int myDoneHsCb(WOLFSSL* ssl, void* user_ctx)
 743{
 744    (void) ssl;
 745    (void) user_ctx;
 746
 747    DoneHandShake = 1;
 748    return 1;
 749}
 750#endif /* WOLFSSL_DTLS && !NO_WOLFSSL_CLIENT */
 751
 752#ifndef NO_WOLFSSL_SERVER
 753static int ServerSend(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 754{
 755    info_t* info = (info_t*)ctx;
 756    (void)ssl;
 757#ifndef SINGLE_THREADED
 758    if (info->useLocalMem) {
 759        return ServerMemSend(info, buf, sz);
 760    }
 761#endif
 762#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_CLIENT)
 763    if (info->doDTLS) {
 764        return SendTo(info->server.sockFd, buf, sz,
 765            (const struct sockaddr*)&info->clientAddr, sizeof(info->clientAddr));
 766    }
 767    else
 768#endif
 769    {
 770        return SocketSend(info->server.sockFd, buf, sz);
 771    }
 772}
 773static int ServerRecv(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 774{
 775    info_t* info = (info_t*)ctx;
 776    (void)ssl;
 777#ifndef SINGLE_THREADED
 778    if (info->useLocalMem) {
 779        return ServerMemRecv(info, buf, sz);
 780    }
 781#endif
 782#ifdef WOLFSSL_DTLS
 783    if (info->doDTLS) {
 784        return ReceiveFrom(ssl, info->server.sockFd, buf, sz);
 785    }
 786    else
 787#endif
 788    {
 789        return SocketRecv(info->server.sockFd, buf, sz);
 790    }
 791}
 792#endif /* !NO_WOLFSSL_SERVER */
 793
 794#ifndef NO_WOLFSSL_CLIENT
 795static int ClientSend(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 796{
 797    info_t* info = (info_t*)ctx;
 798    (void)ssl;
 799#ifndef SINGLE_THREADED
 800    if (info->useLocalMem) {
 801        return ClientMemSend(info, buf, sz);
 802    }
 803#endif
 804#ifdef WOLFSSL_DTLS
 805    if (info->doDTLS) {
 806        return SendTo(info->client.sockFd, buf, sz,
 807            (const struct sockaddr*)&info->serverAddr, sizeof(info->serverAddr));
 808    }
 809    else
 810#endif
 811    {
 812        return SocketSend(info->client.sockFd, buf, sz);
 813    }
 814}
 815static int ClientRecv(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 816{
 817    info_t* info = (info_t*)ctx;
 818    (void)ssl;
 819#ifndef SINGLE_THREADED
 820    if (info->useLocalMem) {
 821        return ClientMemRecv(info, buf, sz);
 822    }
 823#endif
 824#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
 825    if (info->doDTLS) {
 826        return ReceiveFrom(ssl, info->client.sockFd, buf, sz);
 827    }
 828    else
 829#endif
 830    {
 831        return SocketRecv(info->client.sockFd, buf, sz);
 832    }
 833}
 834#endif /* !NO_WOLFSSL_CLIENT */
 835
 836static void CloseAndCleanupSocket(int* sockFd)
 837{
 838    if (*sockFd != -1) {
 839        close(*sockFd);
 840        *sockFd = -1;
 841    }
 842#ifdef WOLFSSL_DTLS
 843    DoneHandShake = 0;
 844#endif
 845}
 846
 847#ifdef BENCH_USE_NONBLOCK
 848static int SetSocketNonBlocking(int sockFd)
 849{
 850    int flags = fcntl(sockFd, F_GETFL, 0);
 851    if (flags < 0) {
 852        fprintf(stderr, "fcntl get failed\n");
 853        return -1;
 854    }
 855    flags = fcntl(sockFd, F_SETFL, flags | O_NONBLOCK);
 856    if (flags < 0) {
 857        fprintf(stderr, "fcntl set failed\n");
 858        return -1;
 859    }
 860    return 0;
 861}
 862#endif
 863
 864#ifndef NO_WOLFSSL_CLIENT
 865static int SetupSocketAndConnect(info_t* info, const char* host,
 866    word32 port)
 867{
 868    struct sockaddr_in servAddr;
 869    struct hostent* entry;
 870
 871    /* Setup server address */
 872    XMEMSET(&servAddr, 0, sizeof(servAddr));
 873    servAddr.sin_family = AF_INET;
 874    servAddr.sin_port = htons((uint16_t)port);
 875
 876    /* Resolve host */
 877    entry = gethostbyname(host);
 878    if (entry) {
 879        XMEMCPY(&servAddr.sin_addr.s_addr, entry->h_addr_list[0],
 880            (size_t)entry->h_length);
 881    }
 882    else {
 883        servAddr.sin_addr.s_addr = inet_addr(host);
 884    }
 885
 886#ifdef WOLFSSL_DTLS
 887    if (info->doDTLS) {
 888        /* Create the SOCK_DGRAM socket type is implemented on the User
 889        *  Datagram Protocol/Internet Protocol(UDP/IP protocol).*/
 890        if ((info->client.sockFd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 891            fprintf(stderr, "ERROR: failed to create the SOCK_DGRAM socket\n");
 892            return -1;
 893        }
 894        XMEMCPY(&info->serverAddr, &servAddr, sizeof(servAddr));
 895    }
 896    else
 897#endif
 898    {
 899        /* Create a socket that uses an Internet IPv4 address,
 900        * Sets the socket to be stream based (TCP),
 901        * 0 means choose the default protocol. */
 902        if ((info->client.sockFd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
 903            fprintf(stderr, "ERROR: failed to create the socket\n");
 904            return -1;
 905        }
 906
 907        /* Connect to the server */
 908    #ifndef SINGLE_THREADED
 909        while ((info->serverListening == 0) && (info->server.shutdown == 0)) {
 910            if (info->showVerbose) {
 911                fprintf(stderr, "Waiting for server to listen...\n");
 912            }
 913            XSLEEP_MS(1);
 914        }
 915    #endif
 916
 917        if (info->server.shutdown == 1) {
 918            fprintf(stderr, "ERROR: server side has shutdown\n");
 919            return -1;
 920        }
 921
 922        if (connect(info->client.sockFd, (struct sockaddr*)&servAddr,
 923                                                    sizeof(servAddr)) == -1) {
 924            fprintf(stderr, "ERROR: failed to connect\n");
 925            return -1;
 926        }
 927    }
 928
 929#ifdef BENCH_USE_NONBLOCK
 930    if (SetSocketNonBlocking(info->client.sockFd) != 0) {
 931        return -1;
 932    }
 933#endif
 934
 935    if (info->showVerbose) {
 936        fprintf(stderr, "Connected to %s on port %d\n", host, port);
 937    }
 938
 939    return 0;
 940}
 941
 942static int bench_tls_client(info_t* info)
 943{
 944    byte *writeBuf = NULL, *readBuf = NULL;
 945    double start, total = 0;
 946    int ret, readBufSz;
 947    WOLFSSL_CTX* cli_ctx = NULL;
 948    WOLFSSL* cli_ssl = NULL;
 949    int haveShownPeerInfo = 0;
 950    int tls13 = XSTRNCMP(info->cipher, "TLS13", 5) == 0;
 951    int total_sz;
 952
 953    total = gettime_secs(0);
 954
 955    /* set up client */
 956#ifdef WOLFSSL_DTLS
 957    if (info->doDTLS) {
 958        if (tls13) {
 959        #ifdef WOLFSSL_DTLS13
 960            cli_ctx = wolfSSL_CTX_new(wolfDTLSv1_3_client_method());
 961        #endif
 962        }
 963        else {
 964        #ifndef WOLFSSL_NO_TLS12
 965            cli_ctx = wolfSSL_CTX_new(wolfDTLSv1_2_client_method());
 966        #endif
 967        }
 968    }
 969    else
 970#endif
 971    {
 972    #ifdef WOLFSSL_TLS13
 973        if (tls13) {
 974            cli_ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method());
 975        }
 976        else
 977    #endif
 978        {
 979        #if !defined(WOLFSSL_TLS13)
 980            cli_ctx = wolfSSL_CTX_new(wolfSSLv23_client_method());
 981        #elif !defined(WOLFSSL_NO_TLS12)
 982            cli_ctx = wolfSSL_CTX_new(wolfTLSv1_2_client_method());
 983        #endif
 984        }
 985    }
 986
 987    if (cli_ctx == NULL) {
 988        fprintf(stderr, "error creating ctx\n");
 989        ret = MEMORY_E; goto exit;
 990    }
 991
 992#ifndef NO_CERTS
 993#ifdef HAVE_ECC
 994    if (XSTRSTR(info->cipher, "ECDSA")) {
 995        ret = wolfSSL_CTX_load_verify_buffer(cli_ctx, ca_ecc_cert_der_256,
 996            sizeof_ca_ecc_cert_der_256, WOLFSSL_FILETYPE_ASN1);
 997    }
 998    else
 999#endif
1000    {
1001        ret = wolfSSL_CTX_load_verify_buffer(cli_ctx, ca_cert_der_2048,
1002            sizeof_ca_cert_der_2048, WOLFSSL_FILETYPE_ASN1);
1003    }
1004    if (ret != WOLFSSL_SUCCESS) {
1005        fprintf(stderr, "error loading CA\n");
1006        goto exit;
1007    }
1008#endif
1009
1010    wolfSSL_CTX_SetIOSend(cli_ctx, ClientSend);
1011    wolfSSL_CTX_SetIORecv(cli_ctx, ClientRecv);
1012
1013    /* set cipher suite */
1014    ret = wolfSSL_CTX_set_cipher_list(cli_ctx, info->cipher);
1015    if (ret != WOLFSSL_SUCCESS) {
1016        fprintf(stderr, "error setting cipher suite\n");
1017        goto exit;
1018    }
1019
1020#ifndef NO_DH
1021    ret = wolfSSL_CTX_SetMinDhKey_Sz(cli_ctx, MIN_DHKEY_BITS);
1022    if (ret != WOLFSSL_SUCCESS) {
1023        fprintf(stderr, "Error setting minimum DH key size\n");
1024        goto exit;
1025    }
1026#endif
1027
1028#ifndef NO_PSK
1029    wolfSSL_CTX_set_psk_client_callback(cli_ctx, my_psk_client_cb);
1030    #ifdef WOLFSSL_TLS13
1031    #if !defined(WOLFSSL_PSK_TLS13_CB) && !defined(WOLFSSL_PSK_ONE_ID)
1032    wolfSSL_CTX_set_psk_client_cs_callback(cli_ctx, my_psk_client_cs_cb);
1033    #else
1034    wolfSSL_CTX_set_psk_client_tls13_callback(cli_ctx, my_psk_client_tls13_cb);
1035    #endif
1036    #endif
1037    wolfSSL_CTX_set_psk_callback_ctx(cli_ctx, (void*)info->cipher);
1038#endif /* !NO_PSK */
1039
1040
1041    /* Allocate and initialize a packet sized buffer */
1042    writeBuf = (unsigned char*)XMALLOC((size_t)info->packetSize, NULL,
1043        DYNAMIC_TYPE_TMP_BUFFER);
1044    if (writeBuf == NULL) {
1045        fprintf(stderr, "failed to allocate write memory\n");
1046        ret = MEMORY_E; goto exit;
1047    }
1048
1049    /* Allocate read buffer */
1050    readBufSz = info->packetSize;
1051    readBuf = (unsigned char*)XMALLOC((size_t)readBufSz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1052    if (readBuf == NULL) {
1053        fprintf(stderr, "failed to allocate read memory\n");
1054        ret = MEMORY_E; goto exit;
1055    }
1056
1057    /* BENCHMARK CONNECTIONS LOOP */
1058    while (!info->client.shutdown) {
1059        int writeSz = info->packetSize;
1060    #ifdef BENCH_USE_NONBLOCK
1061        int err;
1062    #endif
1063
1064    #ifndef SINGLE_THREADED
1065        if (!info->useLocalMem)
1066    #endif
1067        {
1068            /* Setup socket and connection */
1069            ret = SetupSocketAndConnect(info, info->host, info->port);
1070            if (ret != 0) goto exit;
1071        }
1072
1073        cli_ssl = wolfSSL_new(cli_ctx);
1074        if (cli_ssl == NULL) {
1075            fprintf(stderr, "error creating client object\n");
1076            goto exit;
1077        }
1078
1079#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
1080        if (info->group != 0) {
1081            ret = wolfSSL_UseKeyShare(cli_ssl, info->group);
1082            if (ret != WOLFSSL_SUCCESS) {
1083                fprintf(stderr, "error setting client key share.\n");
1084                goto exit;
1085            }
1086        }
1087#endif
1088
1089#ifdef WOLFSSL_DTLS
1090        if (info->doDTLS) {
1091            ret = wolfSSL_dtls_set_peer(cli_ssl, &info->serverAddr,
1092                                                    sizeof(info->serverAddr));
1093            if (ret != WOLFSSL_SUCCESS) {
1094                fprintf(stderr, "error setting dtls peer\n");
1095                goto exit;
1096            }
1097            ret = wolfSSL_SetHsDoneCb(cli_ssl, myDoneHsCb, NULL);
1098            if (ret != WOLFSSL_SUCCESS) {
1099                fprintf(stderr, "error handshake done callback\n");
1100                goto exit;
1101            }
1102        }
1103#endif
1104        wolfSSL_SetIOReadCtx(cli_ssl, info);
1105        wolfSSL_SetIOWriteCtx(cli_ssl, info);
1106
1107#if !defined(SINGLE_THREADED) && defined(WOLFSSL_DTLS)
1108        /* synchronize with server */
1109        if (info->doDTLS && !info->clientOrserverOnly) {
1110            THREAD_CHECK_RET(wolfSSL_CondStart(&info->dtls_cond));
1111            if (info->serverReady != 1) {
1112                THREAD_CHECK_RET(wolfSSL_CondWait(&info->dtls_cond));
1113            }
1114            /* for next loop */
1115            info->serverReady = 0;
1116            THREAD_CHECK_RET(wolfSSL_CondEnd(&info->dtls_cond));
1117        }
1118#endif
1119        /* perform connect */
1120        start = gettime_secs(1);
1121    #ifndef BENCH_USE_NONBLOCK
1122        ret = wolfSSL_connect(cli_ssl);
1123    #else
1124        do
1125        {
1126            ret = wolfSSL_connect(cli_ssl);
1127            err = wolfSSL_get_error(cli_ssl, ret);
1128        }
1129        while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1130    #endif
1131        start = gettime_secs(0) - start;
1132        if (ret != WOLFSSL_SUCCESS) {
1133            fprintf(stderr, "error connecting client\n");
1134            ret = wolfSSL_get_error(cli_ssl, ret);
1135            goto exit;
1136        }
1137        info->client_stats.connTime += start;
1138        info->client_stats.connCount++;
1139
1140        if ((info->showPeerInfo) && (!haveShownPeerInfo)) {
1141            haveShownPeerInfo = 1;
1142            showPeer(cli_ssl);
1143        }
1144
1145        /* check for run time completion and issue shutdown */
1146        if (gettime_secs(0) - total >= info->runTimeSec) {
1147            info->client.shutdown = 1;
1148
1149            writeSz = (int)XSTRLEN(kShutdown) + 1;
1150            XMEMCPY(writeBuf, kShutdown, (size_t)writeSz); /* include null term */
1151            if (info->showVerbose) {
1152                fprintf(stderr, "Sending shutdown\n");
1153            }
1154
1155            ret = wolfSSL_write(cli_ssl, writeBuf, writeSz);
1156            if (ret < 0) {
1157                fprintf(stderr, "error on client write\n");
1158                ret = wolfSSL_get_error(cli_ssl, ret);
1159                goto exit;
1160            }
1161        }
1162        else {
1163            XMEMSET(writeBuf, 0, (size_t)info->packetSize);
1164            XSTRNCPY((char*)writeBuf, kTestStr, (size_t)info->packetSize);
1165        }
1166
1167        /* write / read echo loop */
1168        ret = 0;
1169        total_sz = 0;
1170        while (ret == 0 && total_sz < info->maxSize && !info->client.shutdown) {
1171            /* write test message to server */
1172            start = gettime_secs(1);
1173        #ifndef BENCH_USE_NONBLOCK
1174            ret = wolfSSL_write(cli_ssl, writeBuf, writeSz);
1175        #else
1176            do {
1177                ret = wolfSSL_write(cli_ssl, writeBuf, writeSz);
1178                err = wolfSSL_get_error(cli_ssl, ret);
1179            }
1180            while (err == WOLFSSL_ERROR_WANT_WRITE);
1181        #endif
1182            info->client_stats.txTime += gettime_secs(0) - start;
1183            if (ret < 0) {
1184                fprintf(stderr, "error on client write\n");
1185                ret = wolfSSL_get_error(cli_ssl, ret);
1186                goto exit;
1187            }
1188            info->client_stats.txTotal += ret;
1189            total_sz += ret;
1190
1191            /* read echo of message from server */
1192            XMEMSET(readBuf, 0, (size_t)readBufSz);
1193            start = gettime_secs(1);
1194        #ifndef BENCH_USE_NONBLOCK
1195            ret = wolfSSL_read(cli_ssl, readBuf, readBufSz);
1196        #else
1197            do {
1198                ret = wolfSSL_read(cli_ssl, readBuf, readBufSz);
1199                err = wolfSSL_get_error(cli_ssl, ret);
1200            }
1201            while (err == WOLFSSL_ERROR_WANT_READ);
1202        #endif
1203            info->client_stats.rxTime += gettime_secs(0) - start;
1204            if (ret < 0) {
1205                fprintf(stderr, "error on client read\n");
1206                ret = wolfSSL_get_error(cli_ssl, ret);
1207                goto exit;
1208            }
1209            info->client_stats.rxTotal += ret;
1210            ret = 0; /* reset return code */
1211
1212            /* validate echo */
1213            if (XMEMCMP((char*)writeBuf, (char*)readBuf, (size_t)writeSz) != 0) {
1214                fprintf(stderr, "echo check failed!\n");
1215                ret = wolfSSL_get_error(cli_ssl, ret);
1216                goto exit;
1217            }
1218        }
1219
1220        CloseAndCleanupSocket(&info->client.sockFd);
1221
1222        wolfSSL_free(cli_ssl);
1223        cli_ssl = NULL;
1224    }
1225
1226exit:
1227
1228    if (ret != 0 && ret != WOLFSSL_SUCCESS) {
1229        fprintf(stderr, "Client Error: %d (%s)\n", ret,
1230            wolfSSL_ERR_reason_error_string((unsigned long)ret));
1231    }
1232
1233    /* clean up */
1234    CloseAndCleanupSocket(&info->client.sockFd);
1235    if (cli_ssl != NULL) {
1236        wolfSSL_free(cli_ssl);
1237    }
1238    if (cli_ctx != NULL) {
1239        wolfSSL_CTX_free(cli_ctx);
1240    }
1241    XFREE(readBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1242    XFREE(writeBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1243    info->client.ret = ret;
1244
1245    (void)tls13;
1246
1247    return ret;
1248}
1249
1250#if !defined(SINGLE_THREADED) && defined(WOLFSSL_THREAD_NO_JOIN)
1251static THREAD_RETURN_NOJOIN WOLFSSL_THREAD_NO_JOIN client_thread(void* args)
1252{
1253    int ret;
1254    info_t* info = (info_t*)args;
1255
1256    ret = bench_tls_client(info);
1257
1258    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
1259    info->to_client.done = 1;
1260    info->client.ret = ret;
1261    THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
1262    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
1263
1264    RETURN_FROM_THREAD_NOJOIN(0);
1265}
1266#endif /* !SINGLE_THREADED */
1267#endif /* !NO_WOLFSSL_CLIENT */
1268
1269
1270#ifndef NO_WOLFSSL_SERVER
1271static int SetupSocketAndListen(int* listenFd, word32 port, int doDTLS)
1272{
1273    struct sockaddr_in servAddr;
1274#if defined(_MSC_VER) || defined(__MINGW32__)
1275    char optval = 1;
1276#else
1277    int optval = 1;
1278#endif
1279#ifndef WOLFSSL_DTLS
1280    (void) doDTLS;
1281#endif
1282    /* Setup server address */
1283    XMEMSET(&servAddr, 0, sizeof(servAddr));
1284    servAddr.sin_family = AF_INET;
1285    servAddr.sin_port = htons((uint16_t)port);
1286    servAddr.sin_addr.s_addr = INADDR_ANY;
1287
1288#ifdef WOLFSSL_DTLS
1289    if (doDTLS) {
1290        /* Create a socket that is implemented on the User Datagram Protocol/
1291        * Interet Protocol(UDP/IP protocol). */
1292        if((*listenFd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
1293            fprintf(stderr, "ERROR: failed to create the socket\n");
1294            return -1;
1295        }
1296    }
1297    else
1298#endif
1299    {
1300        /* Create a socket that uses an Internet IPv4 address,
1301        * Sets the socket to be stream based (TCP),
1302        * 0 means choose the default protocol. */
1303        if ((*listenFd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
1304            fprintf(stderr, "ERROR: failed to create the socket\n");
1305            return -1;
1306        }
1307
1308        /* allow reuse */
1309        if (setsockopt(*listenFd, SOL_SOCKET, SO_REUSEADDR,
1310                    &optval, sizeof(optval)) == -1) {
1311            fprintf(stderr, "setsockopt SO_REUSEADDR failed\n");
1312            return -1;
1313        }
1314
1315        /* Listen for the client. */
1316        if (bind(*listenFd, (struct sockaddr*)&servAddr,
1317                                                    sizeof(servAddr)) == -1) {
1318            fprintf(stderr, "ERROR: failed to bind\n");
1319            return -1;
1320        }
1321    }
1322
1323    if (listen(*listenFd, 5) != 0) {
1324        fprintf(stderr, "ERROR: failed to listen\n");
1325        return -1;
1326    }
1327
1328#ifdef BENCH_USE_NONBLOCK
1329    if (SetSocketNonBlocking(*listenFd) != 0) {
1330        return -1;
1331    }
1332#endif
1333
1334    return 0;
1335}
1336
1337static int SocketWaitClient(info_t* info)
1338{
1339    int connd;
1340    struct sockaddr_in clientAddr;
1341    socklen_t size = sizeof(clientAddr);
1342
1343#ifdef WOLFSSL_DTLS
1344    if (info->doDTLS) {
1345        char msg[64];
1346#ifndef SINGLE_THREADED
1347        if (!info->clientOrserverOnly) {
1348            THREAD_CHECK_RET(wolfSSL_CondStart(&info->dtls_cond));
1349            info->serverReady = 1;
1350            THREAD_CHECK_RET(wolfSSL_CondSignal(&info->dtls_cond));
1351            THREAD_CHECK_RET(wolfSSL_CondEnd(&info->dtls_cond));
1352        }
1353#endif
1354        connd = (int)recvfrom(info->listenFd, (char *)msg, sizeof(msg),
1355            MSG_PEEK, (struct sockaddr*)&clientAddr, &size);
1356        if (connd < -1) {
1357            fprintf(stderr, "ERROR: failed to accept the connection\n");
1358            return -1;
1359        }
1360        XMEMCPY(&info->clientAddr, &clientAddr, sizeof(clientAddr));
1361        info->server.sockFd = info->listenFd;
1362    }
1363    else
1364#endif
1365    {
1366    #ifndef SINGLE_THREADED
1367        info->serverListening = 1;
1368    #endif
1369        if ((connd = accept(info->listenFd, (struct sockaddr*)&clientAddr,
1370                                                                &size)) == -1) {
1371            if (errno == SOCKET_EWOULDBLOCK) {
1372                return -2;
1373            }
1374            fprintf(stderr, "ERROR: failed to accept the connection\n");
1375            return -1;
1376        }
1377        info->server.sockFd = connd;
1378    }
1379
1380    if (info->showVerbose) {
1381        fprintf(stderr, "Got client %d\n", connd);
1382    }
1383
1384    return 0;
1385}
1386static void CloseAndCleanupListenSocket(int* listenFd)
1387{
1388    if (*listenFd != -1) {
1389        close(*listenFd);
1390        *listenFd = -1;
1391    }
1392}
1393
1394static int bench_tls_server(info_t* info)
1395{
1396    byte *readBuf = NULL;
1397    double start;
1398    int ret, len = 0, readBufSz;
1399    WOLFSSL_CTX* srv_ctx = NULL;
1400    WOLFSSL* srv_ssl = NULL;
1401    int tls13 = XSTRNCMP(info->cipher, "TLS13", 5) == 0;
1402    int total_sz;
1403
1404    /* set up server */
1405#ifdef WOLFSSL_DTLS
1406    if (info->doDTLS) {
1407        if (tls13) {
1408        #ifdef WOLFSSL_DTLS13
1409            srv_ctx = wolfSSL_CTX_new(wolfDTLSv1_3_server_method());
1410        #endif
1411        }
1412        else {
1413        #ifndef WOLFSSL_NO_TLS12
1414            srv_ctx = wolfSSL_CTX_new(wolfDTLSv1_2_server_method());
1415        #endif
1416        }
1417    }
1418    else
1419#endif
1420    {
1421    #ifdef WOLFSSL_TLS13
1422        if (tls13) {
1423            srv_ctx = wolfSSL_CTX_new(wolfTLSv1_3_server_method());
1424        }
1425        else
1426    #endif
1427        {
1428        #if !defined(WOLFSSL_TLS13)
1429            srv_ctx = wolfSSL_CTX_new(wolfSSLv23_server_method());
1430        #elif !defined(WOLFSSL_NO_TLS12)
1431            srv_ctx = wolfSSL_CTX_new(wolfTLSv1_2_server_method());
1432        #endif
1433        }
1434    }
1435    if (srv_ctx == NULL) {
1436        fprintf(stderr, "error creating server ctx\n");
1437        ret = MEMORY_E; goto exit;
1438    }
1439
1440#ifndef NO_CERTS
1441#ifdef HAVE_ECC
1442    if (XSTRSTR(info->cipher, "ECDSA")) {
1443        ret = wolfSSL_CTX_use_PrivateKey_buffer(srv_ctx, ecc_key_der_256,
1444            sizeof_ecc_key_der_256, WOLFSSL_FILETYPE_ASN1);
1445    }
1446    else
1447#endif
1448    {
1449        ret = wolfSSL_CTX_use_PrivateKey_buffer(srv_ctx, server_key_der_2048,
1450            sizeof_server_key_der_2048, WOLFSSL_FILETYPE_ASN1);
1451    }
1452    if (ret != WOLFSSL_SUCCESS) {
1453        fprintf(stderr, "error loading server key\n");
1454        goto exit;
1455    }
1456
1457#ifdef HAVE_ECC
1458    if (XSTRSTR(info->cipher, "ECDSA")) {
1459        ret = wolfSSL_CTX_use_certificate_buffer(srv_ctx, serv_ecc_der_256,
1460            sizeof_serv_ecc_der_256, WOLFSSL_FILETYPE_ASN1);
1461    }
1462    else
1463#endif
1464    {
1465        ret = wolfSSL_CTX_use_certificate_buffer(srv_ctx, server_cert_der_2048,
1466            sizeof_server_cert_der_2048, WOLFSSL_FILETYPE_ASN1);
1467    }
1468    if (ret != WOLFSSL_SUCCESS) {
1469        fprintf(stderr, "error loading server cert\n");
1470        goto exit;
1471    }
1472#endif /* !NO_CERTS */
1473
1474    wolfSSL_CTX_SetIOSend(srv_ctx, ServerSend);
1475    wolfSSL_CTX_SetIORecv(srv_ctx, ServerRecv);
1476
1477    /* set cipher suite */
1478    ret = wolfSSL_CTX_set_cipher_list(srv_ctx, info->cipher);
1479    if (ret != WOLFSSL_SUCCESS) {
1480        fprintf(stderr, "error setting cipher suite\n");
1481        goto exit;
1482    }
1483
1484#ifndef NO_DH
1485    ret = wolfSSL_CTX_SetMinDhKey_Sz(srv_ctx, MIN_DHKEY_BITS);
1486    if (ret != WOLFSSL_SUCCESS) {
1487        fprintf(stderr, "Error setting minimum DH key size\n");
1488        goto exit;
1489    }
1490#endif
1491
1492#ifndef NO_PSK
1493    wolfSSL_CTX_set_psk_server_callback(srv_ctx, my_psk_server_cb);
1494    #ifdef WOLFSSL_TLS13
1495    wolfSSL_CTX_set_psk_server_tls13_callback(srv_ctx, my_psk_server_tls13_cb);
1496    #endif
1497#endif /* !NO_PSK */
1498
1499    /* Allocate read buffer */
1500    readBufSz = info->packetSize;
1501    readBuf = (unsigned char*)XMALLOC((size_t)readBufSz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1502    if (readBuf == NULL) {
1503        fprintf(stderr, "failed to allocate read memory\n");
1504        ret = MEMORY_E; goto exit;
1505    }
1506
1507    /* BENCHMARK CONNECTIONS LOOP */
1508    while (!info->server.shutdown) {
1509    #ifdef BENCH_USE_NONBLOCK
1510        int err;
1511    #endif
1512
1513    #ifndef SINGLE_THREADED
1514        if (!info->useLocalMem)
1515    #endif
1516        {
1517            /* Accept client connections */
1518            ret = SocketWaitClient(info);
1519        #ifdef BENCH_USE_NONBLOCK
1520            if (ret == -2) {
1521                XSLEEP_MS(0);
1522                continue;
1523            }
1524        #endif
1525            if (ret != 0) {
1526                goto exit;
1527            }
1528        }
1529
1530        srv_ssl = wolfSSL_new(srv_ctx);
1531        if (srv_ssl == NULL) {
1532            fprintf(stderr, "error creating server object\n");
1533            ret = MEMORY_E; goto exit;
1534        }
1535
1536#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
1537        if (info->group != 0) {
1538            ret = wolfSSL_UseKeyShare(srv_ssl, info->group);
1539            if (ret != WOLFSSL_SUCCESS) {
1540                fprintf(stderr, "error setting server key share.\n");
1541                goto exit;
1542            }
1543        }
1544#endif
1545
1546#ifdef WOLFSSL_DTLS
1547        if (info->doDTLS) {
1548            ret = wolfSSL_dtls_set_peer(srv_ssl, &info->clientAddr,
1549                        sizeof(info->clientAddr));
1550            if (ret != WOLFSSL_SUCCESS) {
1551                fprintf(stderr, "error setting dtls peer\n");
1552                goto exit;
1553            }
1554        }
1555#endif
1556
1557        wolfSSL_SetIOReadCtx(srv_ssl, info);
1558        wolfSSL_SetIOWriteCtx(srv_ssl, info);
1559    #ifndef NO_DH
1560        wolfSSL_SetTmpDH(srv_ssl, dhp, sizeof(dhp), dhg, sizeof(dhg));
1561    #endif
1562
1563        /* accept TLS connection */
1564        start = gettime_secs(1);
1565    #ifndef BENCH_USE_NONBLOCK
1566        ret = wolfSSL_accept(srv_ssl);
1567    #else
1568        do {
1569            ret = wolfSSL_accept(srv_ssl);
1570            err = wolfSSL_get_error(srv_ssl, ret);
1571        }
1572        while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1573    #endif
1574        start = gettime_secs(0) - start;
1575        if (ret != WOLFSSL_SUCCESS) {
1576        #ifndef SINGLE_THREADED
1577            if (info->to_client.done) {
1578                ret = 0; /* done - success */
1579            }
1580            else
1581        #endif
1582            {
1583                fprintf(stderr, "error on server accept\n");
1584                ret = wolfSSL_get_error(srv_ssl, ret);
1585            }
1586            goto exit;
1587        }
1588
1589        info->server_stats.connTime += start;
1590        info->server_stats.connCount++;
1591
1592        /* echo loop */
1593        ret = 0;
1594        total_sz = 0;
1595        while (ret == 0 && total_sz < info->maxSize) {
1596            double rxTime;
1597
1598            /* read message from client */
1599            XMEMSET(readBuf, 0, (size_t)readBufSz);
1600            start = gettime_secs(1);
1601        #ifndef BENCH_USE_NONBLOCK
1602            ret = wolfSSL_read(srv_ssl, readBuf, readBufSz);
1603        #else
1604            do {
1605                ret = wolfSSL_read(srv_ssl, readBuf, readBufSz);
1606                err = wolfSSL_get_error(srv_ssl, ret);
1607            }
1608            while (err == WOLFSSL_ERROR_WANT_READ);
1609        #endif
1610            rxTime = gettime_secs(0) - start;
1611
1612            /* shutdown signals, no more connections for this cipher */
1613            if (XSTRSTR((const char*)readBuf, kShutdown) != NULL) {
1614                info->server.shutdown = 1;
1615                if (info->showVerbose) {
1616                    fprintf(stderr, "Server shutdown done\n");
1617                }
1618                ret = 0; /* success */
1619                break;
1620            }
1621
1622            info->server_stats.rxTime += rxTime;
1623            if (ret < 0) {
1624            #ifndef SINGLE_THREADED
1625                if (info->to_client.done) {
1626                    ret = 0; /* done - success */
1627                }
1628                else
1629            #endif
1630                {
1631                    fprintf(stderr, "error on server read\n");
1632                    ret = wolfSSL_get_error(srv_ssl, ret);
1633                }
1634                goto exit;
1635            }
1636            info->server_stats.rxTotal += ret;
1637            len = ret;
1638            total_sz += ret;
1639
1640            /* write message back to client */
1641            start = gettime_secs(1);
1642        #ifndef BENCH_USE_NONBLOCK
1643            ret = wolfSSL_write(srv_ssl, readBuf, len);
1644        #else
1645            do {
1646                ret = wolfSSL_write(srv_ssl, readBuf, len);
1647                err = wolfSSL_get_error(srv_ssl, ret);
1648            }
1649            while (err == WOLFSSL_ERROR_WANT_WRITE);
1650        #endif
1651            info->server_stats.txTime += gettime_secs(0) - start;
1652            if (ret < 0) {
1653                fprintf(stderr, "error on server write\n");
1654                ret = wolfSSL_get_error(srv_ssl, ret);
1655                goto exit;
1656            }
1657            info->server_stats.txTotal += ret;
1658            ret = 0; /* reset return code */
1659        }
1660
1661        CloseAndCleanupSocket(&info->server.sockFd);
1662
1663        wolfSSL_free(srv_ssl);
1664        srv_ssl = NULL;
1665#ifdef WOLFSSL_DTLS
1666        if (info->doDTLS) {
1667            SetupSocketAndListen(&info->listenFd, info->port, info->doDTLS);
1668        }
1669#endif
1670    }
1671
1672exit:
1673
1674    if (ret != 0 && ret != WOLFSSL_SUCCESS) {
1675        fprintf(stderr, "Server Error: %d (%s)\n", ret,
1676                wolfSSL_ERR_reason_error_string((unsigned long)ret));
1677    }
1678
1679    /* clean up */
1680    CloseAndCleanupSocket(&info->server.sockFd);
1681    if (srv_ssl != NULL) {
1682        wolfSSL_free(srv_ssl);
1683    }
1684    if (srv_ctx != NULL) {
1685        wolfSSL_CTX_free(srv_ctx);
1686    }
1687    XFREE(readBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1688    info->server.ret = ret;
1689
1690    (void)tls13;
1691
1692    return ret;
1693}
1694
1695#if !defined(SINGLE_THREADED) && defined(WOLFSSL_THREAD_NO_JOIN)
1696static THREAD_RETURN_NOJOIN WOLFSSL_THREAD_NO_JOIN server_thread(void* args)
1697{
1698    int ret = 0;
1699    info_t* info = (info_t*)args;
1700
1701    if (!info->useLocalMem) {
1702        /* Setup TLS server listener */
1703#ifdef WOLFSSL_DTLS
1704        ret = SetupSocketAndListen(&info->listenFd, info->port, info->doDTLS);
1705#else
1706        ret = SetupSocketAndListen(&info->listenFd, info->port, 0);
1707#endif
1708    }
1709
1710    if (ret == 0) {
1711        ret = bench_tls_server(info);
1712
1713        if (!info->useLocalMem) {
1714            CloseAndCleanupListenSocket(&info->listenFd);
1715        }
1716    }
1717
1718    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
1719    info->to_server.done = 1;
1720    info->server.ret = ret;
1721    THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
1722    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
1723
1724    RETURN_FROM_THREAD_NOJOIN(0);
1725}
1726#endif /* !SINGLE_THREADED */
1727#endif /* !NO_WOLFSSL_SERVER */
1728
1729
1730static void print_stats(stats_t* wcStat, const char* desc, const char* cipher, const char *group, int verbose)
1731{
1732    if (verbose) {
1733        fprintf(stderr,
1734                "wolfSSL %s Benchmark on %s with group %s:\n"
1735                "\tTotal       : %9d bytes\n"
1736                "\tNum Conns   : %9d\n"
1737                "\tRx Total    : %9.3f ms\n"
1738                "\tTx Total    : %9.3f ms\n"
1739                "\tRx          : %9.3f MB/s\n"
1740                "\tTx          : %9.3f MB/s\n"
1741                "\tConnect     : %9.3f ms\n"
1742                "\tConnect Avg : %9.3f ms\n",
1743                desc,
1744                cipher,
1745                group,
1746                wcStat->txTotal + wcStat->rxTotal,
1747                wcStat->connCount,
1748                wcStat->rxTime * 1000,
1749                wcStat->txTime * 1000,
1750                wcStat->rxTotal / wcStat->rxTime / 1024 / 1024,
1751                wcStat->txTotal / wcStat->txTime / 1024 / 1024,
1752                wcStat->connTime * 1000,
1753                wcStat->connTime * 1000 / wcStat->connCount);
1754    }
1755    else {
1756        fprintf(stderr,
1757                "%-6s  %-33s  %-25s  %11d  %9d  %9.3f  %9.3f  %9.3f  "
1758                "%9.3f  %17.3f  %15.3f\n",
1759                desc,
1760                cipher,
1761                group,
1762                wcStat->txTotal + wcStat->rxTotal,
1763                wcStat->connCount,
1764                wcStat->rxTime * 1000,
1765                wcStat->txTime * 1000,
1766                wcStat->rxTotal / wcStat->rxTime / 1024 / 1024,
1767                wcStat->txTotal / wcStat->txTime / 1024 / 1024,
1768                wcStat->connTime * 1000,
1769                wcStat->connTime * 1000 / wcStat->connCount);
1770    }
1771}
1772
1773static void Usage(void)
1774{
1775    fprintf(stderr, "tls_bench "    LIBWOLFSSL_VERSION_STRING
1776            " NOTE: All files relative to wolfSSL home dir\n");
1777    fprintf(stderr, "-?          Help, print this usage\n");
1778    fprintf(stderr, "-c          Run as client only, no threading and uses sockets\n");
1779    fprintf(stderr, "-s          Run as server only, no threading and uses sockets\n");
1780    fprintf(stderr, "-h          Host (default %s)\n", BENCH_DEFAULT_HOST);
1781    fprintf(stderr, "-P          Port (default %d)\n", BENCH_DEFAULT_PORT);
1782    fprintf(stderr, "-e          List Every cipher suite available\n");
1783    fprintf(stderr, "-i          Show peer info\n");
1784#ifdef WOLFSSL_TLS13
1785    fprintf(stderr, "-g          Run through each of the TLS 1.3 groups that are available\n");
1786#endif
1787    fprintf(stderr, "-l <str>    Cipher suite list (: delimited)\n");
1788    fprintf(stderr, "-t <num>    Time <num> (seconds) to run each test (default %d)\n", BENCH_RUNTIME_SEC);
1789    fprintf(stderr, "-p <num>    The packet size <num> in bytes [1-16kB] (default %d)\n", TEST_PACKET_SIZE);
1790#ifdef WOLFSSL_DTLS
1791    fprintf(stderr, "            In the case of DTLS, [1-8kB] (default %d)\n", TEST_DTLS_PACKET_SIZE);
1792#endif
1793    fprintf(stderr, "-S <num>    The total size <num> in bytes (default %d)\n", TEST_MAX_SIZE);
1794    fprintf(stderr, "-v          Show verbose output\n");
1795#ifdef DEBUG_WOLFSSL
1796    fprintf(stderr, "-d          Enable debug messages\n");
1797#endif
1798#ifndef SINGLE_THREADED
1799    fprintf(stderr, "-T <num>    Number of threaded server/client pairs (default %d)\n", NUM_THREAD_PAIRS);
1800    fprintf(stderr, "-m          Use local memory, not socket\n");
1801#endif
1802#ifdef WOLFSSL_DTLS
1803    fprintf(stderr, "-u          Use DTLS\n");
1804#endif
1805}
1806
1807static void ShowCiphers(void)
1808{
1809    char ciphers[WOLFSSL_CIPHER_LIST_MAX_SIZE];
1810    int ret = wolfSSL_get_ciphers(ciphers, (int)sizeof(ciphers));
1811    if (ret == WOLFSSL_SUCCESS) {
1812        fprintf(stderr, "%s\n", ciphers);
1813    }
1814}
1815
1816#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
1817static int SetupSupportedGroups(int verbose)
1818{
1819    int i;
1820    WOLFSSL_CTX* ctx = NULL;
1821    WOLFSSL* ssl = NULL;
1822    int ret = 0;
1823
1824    if (ret == 0) {
1825#ifdef NO_WOLFSSL_CLIENT
1826        ctx = wolfSSL_CTX_new(wolfTLSv1_3_server_method());
1827#else
1828        ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method());
1829#endif
1830        if (ctx == NULL) {
1831            ret = -1;
1832        }
1833    }
1834
1835    if (ret == 0) {
1836        ssl = wolfSSL_new(ctx);
1837        if (ssl == NULL) {
1838            ret = -1;
1839        }
1840    }
1841
1842    /* Determine which groups are actually supported. */
1843    for (i = 0; groups[i].name != NULL; i++) {
1844        if (ret == 0) {
1845            int uks_ret = wolfSSL_UseKeyShare(ssl, groups[i].group);
1846            if (uks_ret == WOLFSSL_SUCCESS) {
1847                if (verbose) {
1848                    printf("Will benchmark the following group: %s\n",
1849                       groups[i].name);
1850                }
1851            } else if (uks_ret == WC_NO_ERR_TRACE(BAD_FUNC_ARG) ||
1852                       uks_ret == WC_NO_ERR_TRACE(NOT_COMPILED_IN))
1853            {
1854                groups[i].group = 0;
1855                if (verbose) {
1856                    printf("Will NOT benchmark the following group: %s\n",
1857                           groups[i].name);
1858                }
1859            } else {
1860                ret = -1;
1861            }
1862        }
1863    }
1864
1865    if (ssl != NULL) {
1866        wolfSSL_free(ssl);
1867    }
1868    if (ctx != NULL) {
1869        wolfSSL_CTX_free(ctx);
1870    }
1871    return ret;
1872}
1873#endif
1874
1875
1876int bench_tls(void* args)
1877{
1878    int ret = 0;
1879    info_t *theadInfo = NULL, *info;
1880    stats_t cli_comb, srv_comb;
1881    int i;
1882    char *cipher, *next_cipher, *ciphers = NULL;
1883    int     argc = 0;
1884    char**  argv = NULL;
1885    int    ch;
1886
1887    /* Vars configured by command line arguments */
1888    int argRuntimeSec = BENCH_RUNTIME_SEC;
1889    char *argCipherList = NULL;
1890    int argTestPacketSize = TEST_PACKET_SIZE;
1891    int argTestMaxSize = TEST_MAX_SIZE;
1892    int argThreadPairs = NUM_THREAD_PAIRS;
1893    int argShowVerbose = SHOW_VERBOSE;
1894    int argClientOnly = 0;
1895    int argServerOnly = 0;
1896    const char* argHost = BENCH_DEFAULT_HOST;
1897    word32 argPort = BENCH_DEFAULT_PORT;
1898    int argShowPeerInfo = 0;
1899#ifndef SINGLE_THREADED
1900    int doShutdown;
1901#endif
1902#if !defined(NO_WOLFSSL_SERVER) || !defined(SINGLE_THREADED)
1903    int argLocalMem = 0;
1904    int listenFd = -1;
1905#endif
1906#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
1907    int option_p = 0;
1908#endif
1909#ifdef WOLFSSL_DTLS
1910    int doDTLS = 0;
1911#endif
1912#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
1913    int group_index = 0;
1914    int argDoGroups = 0;
1915#endif
1916
1917    if (args != NULL) {
1918        argc = ((func_args*)args)->argc;
1919        argv = ((func_args*)args)->argv;
1920        ((func_args*)args)->return_code = -1; /* error state */
1921    }
1922
1923    /* Initialize wolfSSL */
1924    wolfSSL_Init();
1925
1926#if defined(HAVE_FIPS) && defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION == 5)
1927    /*
1928     * When running benchmarks on FIPS builds, we need to run ALL CASTs up
1929     * front before spawning client/server threads, otherwise there is the
1930     * possibility that both threads try to run a CAST at the same time during
1931     * the handshake. In this scenario, the thread that doesn't win the race
1932     * will not be able to run the CAST, since it returns "busy", which is treated
1933     * as a failure. Running the CASTs up front is a simpler solution than
1934     * implementing an additional layer of synchronization.
1935     */
1936    if ((ret = run_all_CAST()) != 0)
1937    {
1938        fprintf(stderr, "CAST failed. Exiting benchmark\n");
1939        goto exit;
1940    }
1941#endif /* HAVE_FIPS && HAVE_FIPS_VERSION == 5 */
1942
1943    /* Parse command line arguments */
1944    while ((ch = mygetopt(argc, argv, "?" "udeil:p:t:vT:sch:P:mS:g")) != -1) {
1945        switch (ch) {
1946            case '?' :
1947                Usage();
1948                goto exit;
1949
1950            case 's':
1951                argServerOnly = 1;
1952                break;
1953
1954            case 'c':
1955                argClientOnly = 1;
1956                break;
1957
1958            case 'h':
1959                argHost = myoptarg;
1960                break;
1961
1962            case 'P':
1963                argPort = (word32)atoi(myoptarg);
1964                break;
1965
1966            case 'd' :
1967            #ifdef DEBUG_WOLFSSL
1968                wolfSSL_Debugging_ON();
1969            #endif
1970                break;
1971
1972            case 'e' :
1973                ShowCiphers();
1974                goto exit;
1975
1976            case 'g' :
1977#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
1978                argDoGroups = 1;
1979                break;
1980#else
1981                fprintf(stderr, "There are only groups in TLS 1.3\n");
1982                Usage();
1983                ret = MY_EX_USAGE; goto exit;
1984#endif
1985            case 'i' :
1986                argShowPeerInfo = 1;
1987                break;
1988
1989            case 'l' :
1990                argCipherList = myoptarg;
1991                break;
1992
1993            case 'p' :
1994                argTestPacketSize = atoi(myoptarg);
1995                if (argTestPacketSize > (16 * 1024)) {
1996                    fprintf(stderr, "Invalid packet size %d\n", argTestPacketSize);
1997                    Usage();
1998                    ret = MY_EX_USAGE; goto exit;
1999                }
2000            #if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
2001                option_p = 1;
2002            #endif
2003                break;
2004
2005            case 'S' :
2006                argTestMaxSize = atoi(myoptarg);
2007                break;
2008
2009            case 't' :
2010                argRuntimeSec = atoi(myoptarg);
2011                break;
2012
2013            case 'v' :
2014                argShowVerbose = 1;
2015                break;
2016
2017            case 'T' :
2018            #ifndef SINGLE_THREADED
2019                argThreadPairs = atoi(myoptarg);
2020            #endif
2021                break;
2022
2023            case 'm':
2024            #ifndef SINGLE_THREADED
2025                argLocalMem = 1;
2026            #endif
2027                break;
2028            case 'u':
2029            #ifdef WOLFSSL_DTLS
2030                doDTLS = 1;
2031                #ifdef BENCH_USE_NONBLOCK
2032                    fprintf(stderr, "tls_bench hasn't yet supported DTLS "
2033                       "non-blocking mode.\n");
2034                    Usage();
2035                    ret = MY_EX_USAGE; goto exit;
2036                #endif
2037            #endif
2038                break;
2039            default:
2040                Usage();
2041                ret = MY_EX_USAGE; goto exit;
2042        }
2043    }
2044
2045    /* reset for test cases */
2046    myoptind = 0;
2047
2048    if (argCipherList != NULL) {
2049        /* Use the list from CL argument */
2050        cipher = argCipherList;
2051    }
2052    else {
2053        /* Run for each cipher */
2054        ciphers = (char*)XMALLOC(WOLFSSL_CIPHER_LIST_MAX_SIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2055        if (ciphers == NULL) {
2056            goto exit;
2057        }
2058        wolfSSL_get_ciphers(ciphers, WOLFSSL_CIPHER_LIST_MAX_SIZE);
2059        cipher = ciphers;
2060    }
2061
2062#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
2063    if (argDoGroups) {
2064        if (SetupSupportedGroups(argShowVerbose) != 0) {
2065            goto exit;
2066        }
2067    }
2068#endif
2069
2070    /* for server or client side only, only 1 thread is allowed */
2071    if (argServerOnly || argClientOnly) {
2072        argThreadPairs = 1;
2073    }
2074#ifdef SINGLE_THREADED
2075    else {
2076        fprintf(stderr, "Threading is not enabled, so please use -s or -c to indicate side\n");
2077        Usage();
2078        ret = MY_EX_USAGE; goto exit;
2079    }
2080#endif
2081
2082    /* Allocate test info array */
2083    theadInfo = (info_t*)XMALLOC(sizeof(info_t) * (size_t)argThreadPairs, NULL,
2084        DYNAMIC_TYPE_TMP_BUFFER);
2085    if (theadInfo == NULL) {
2086        ret = MEMORY_E; goto exit;
2087    }
2088    XMEMSET(theadInfo, 0, sizeof(info_t) * (size_t)argThreadPairs);
2089
2090#ifndef NO_WOLFSSL_SERVER
2091    /* Use same listen socket to avoid timing issues between client and server */
2092    if (argServerOnly && !argLocalMem) {
2093        /* Setup TLS server listener */
2094#ifdef WOLFSSL_DTLS
2095        ret = SetupSocketAndListen(&listenFd, argPort, doDTLS);
2096#else
2097        ret = SetupSocketAndListen(&listenFd, argPort, 0);
2098#endif
2099        if (ret != 0) {
2100            goto exit;
2101        }
2102    }
2103#endif
2104
2105#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
2106    if (doDTLS) {
2107        if (argLocalMem) {
2108            fprintf(stderr, "tls_bench hasn't yet supported DTLS with local memory.\n");
2109            ret = MY_EX_USAGE; goto exit;
2110        }
2111        if (option_p && argTestPacketSize > TEST_DTLS_PACKET_SIZE){
2112            fprintf(stderr, "Invalid packet size %d\n", argTestPacketSize);
2113            Usage();
2114            ret = MY_EX_USAGE; goto exit;
2115        } else {
2116            /* argTestPacketSize would be default for tcp packet */
2117            if (argTestPacketSize >= TEST_PACKET_SIZE)
2118                argTestPacketSize = TEST_DTLS_PACKET_SIZE;
2119        }
2120    }
2121#endif
2122    fprintf(stderr, "Running TLS Benchmarks...\n");
2123
2124    /* parse by : */
2125    while ((cipher != NULL) && (cipher[0] != '\0')) {
2126#if ! (defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES))
2127        const char *gname = "N/A";
2128#endif
2129        next_cipher = strchr(cipher, ':');
2130        if (next_cipher != NULL) {
2131            cipher[next_cipher - cipher] = '\0';
2132        }
2133
2134        if (argShowVerbose) {
2135            fprintf(stderr, "Cipher: %s\n", cipher);
2136        }
2137
2138#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
2139        for (group_index = 0; groups[group_index].name != NULL; group_index++) {
2140            const char *gname = theadInfo[0].group == 0 ? "N/A"
2141                : groups[group_index].name;
2142
2143            if (argDoGroups && groups[group_index].group == 0) {
2144                /* Skip unsupported group. */
2145                continue;
2146            }
2147#endif
2148            for (i=0; i<argThreadPairs; i++) {
2149                info = &theadInfo[i];
2150                XMEMSET(info, 0, sizeof(info_t));
2151
2152                info->host = argHost;
2153                info->port = argPort + (word32)i; /* threads must have separate ports */
2154                info->cipher = cipher;
2155
2156            #if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
2157                if (argDoGroups && XSTRNCMP(theadInfo[0].cipher, "TLS13", 5) == 0) {
2158                    info->group = groups[group_index].group;
2159                }
2160                else
2161            #endif
2162                {
2163                    info->group = 0;
2164                }
2165
2166                info->packetSize = argTestPacketSize;
2167
2168                info->runTimeSec = argRuntimeSec;
2169                info->maxSize = argTestMaxSize;
2170                info->showPeerInfo = argShowPeerInfo;
2171                info->showVerbose = argShowVerbose;
2172        #ifndef NO_WOLFSSL_SERVER
2173                info->listenFd = listenFd;
2174        #endif
2175                info->client.sockFd = -1;
2176                info->server.sockFd = -1;
2177
2178        #ifdef WOLFSSL_DTLS
2179                info->doDTLS = doDTLS;
2180        #ifndef SINGLE_THREADED
2181                info->serverReady = 0;
2182                if (argServerOnly || argClientOnly) {
2183                    info->clientOrserverOnly = 1;
2184                }
2185        #endif
2186        #endif
2187                if (argClientOnly) {
2188            #if !defined(NO_WOLFSSL_SERVER) && !defined(NO_WOLFSSL_CLIENT) && !defined(SINGLE_THREADED)
2189                    /* to avoid to wait server forever */
2190                    info->serverListening = 1;
2191            #endif
2192            #ifndef NO_WOLFSSL_CLIENT
2193                    ret = bench_tls_client(info);
2194            #endif
2195                }
2196                else if (argServerOnly) {
2197            #ifndef NO_WOLFSSL_SERVER
2198                    ret = bench_tls_server(info);
2199            #endif
2200                }
2201                else {
2202            #if !defined(SINGLE_THREADED) && defined(WOLFSSL_THREAD_NO_JOIN)
2203                    info->useLocalMem = argLocalMem;
2204            #ifdef WOLFSSL_DTLS
2205                    THREAD_CHECK_RET(wc_InitMutex(&info->dtls_mutex));
2206                    THREAD_CHECK_RET(wolfSSL_CondInit(&info->dtls_cond));
2207            #endif
2208                    THREAD_CHECK_RET(wolfSSL_CondInit(&info->to_server.cond));
2209                    THREAD_CHECK_RET(wolfSSL_CondInit(&info->to_client.cond));
2210
2211                    THREAD_CHECK_RET(
2212                        wolfSSL_NewThreadNoJoin(server_thread, info));
2213                    THREAD_CHECK_RET(
2214                        wolfSSL_NewThreadNoJoin(client_thread, info));
2215            #endif
2216                }
2217            }
2218
2219    #ifndef SINGLE_THREADED
2220            /* For threading, wait for completion */
2221            if (!argClientOnly && !argServerOnly) {
2222                /* Wait until threads are marked done */
2223                do {
2224                     doShutdown = 1;
2225
2226                    for (i = 0; i < argThreadPairs; ++i) {
2227                        info = &theadInfo[i];
2228                        if (!info->to_client.done || !info->to_server.done) {
2229                            doShutdown = 0;
2230                            XSLEEP_MS(1000); /* Allow other threads to run */
2231                        }
2232
2233                    }
2234                } while (!doShutdown);
2235                if (argShowVerbose) {
2236                    fprintf(stderr, "Shutdown complete\n");
2237                }
2238            }
2239    #endif /* !SINGLE_THREADED */
2240
2241            if (argShowVerbose) {
2242                /* print results */
2243                for (i = 0; i < argThreadPairs; ++i) {
2244                    info = &theadInfo[i];
2245
2246                    fprintf(stderr, "\nThread %d\n", i);
2247            #ifndef NO_WOLFSSL_SERVER
2248                    if (!argClientOnly) {
2249                        print_stats(&info->server_stats, "Server", info->cipher,
2250                            gname, 1);
2251                    }
2252            #endif
2253            #ifndef NO_WOLFSSL_CLIENT
2254                    if (!argServerOnly) {
2255                        print_stats(&info->client_stats, "Client", info->cipher,
2256                            gname, 1);
2257                    }
2258            #endif
2259                }
2260            }
2261
2262            /* print combined results for more than one thread */
2263            XMEMSET(&cli_comb, 0, sizeof(cli_comb));
2264            XMEMSET(&srv_comb, 0, sizeof(srv_comb));
2265
2266            for (i = 0; i < argThreadPairs; ++i) {
2267                info = &theadInfo[i];
2268
2269                cli_comb.connCount += info->client_stats.connCount;
2270                srv_comb.connCount += info->server_stats.connCount;
2271
2272                cli_comb.connTime += info->client_stats.connTime;
2273                srv_comb.connTime += info->server_stats.connTime;
2274
2275                cli_comb.rxTotal += info->client_stats.rxTotal;
2276                srv_comb.rxTotal += info->server_stats.rxTotal;
2277
2278                cli_comb.rxTime += info->client_stats.rxTime;
2279                srv_comb.rxTime += info->server_stats.rxTime;
2280
2281                cli_comb.txTotal += info->client_stats.txTotal;
2282                srv_comb.txTotal += info->server_stats.txTotal;
2283
2284                cli_comb.txTime += info->client_stats.txTime;
2285                srv_comb.txTime += info->server_stats.txTime;
2286            }
2287
2288            if (argShowVerbose) {
2289                fprintf(stderr, "Totals for %d Threads\n", argThreadPairs);
2290            }
2291            else {
2292                fprintf(stderr, "%-6s  %-33s  %-25s  %11s  %9s  %9s  %9s  %9s  %9s  %17s  %15s\n",
2293                        "Side", "Cipher", "Group", "Total Bytes", "Num Conns", "Rx ms", "Tx ms",
2294                        "Rx MB/s", "Tx MB/s", "Connect Total ms", "Connect Avg ms");
2295        #ifndef NO_WOLFSSL_SERVER
2296                if (!argClientOnly) {
2297                    print_stats(&srv_comb, "Server", theadInfo[0].cipher, gname,
2298                        0);
2299                }
2300        #endif
2301        #ifndef NO_WOLFSSL_CLIENT
2302                if (!argServerOnly) {
2303                    print_stats(&cli_comb, "Client", theadInfo[0].cipher, gname,
2304                        0);
2305                }
2306        #endif
2307            }
2308
2309#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
2310            if (!argDoGroups || theadInfo[0].group == 0) {
2311                /* We only needed to do this once because they don't want to
2312                 * benchmarks groups or this isn't a TLS 1.3 cipher. */
2313                break;
2314            }
2315        }
2316#endif
2317        /* target next cipher */
2318        cipher = (next_cipher != NULL) ? (next_cipher + 1) : NULL;
2319    } /* while */
2320
2321exit:
2322
2323#ifndef NO_WOLFSSL_SERVER
2324    if (argServerOnly && !argLocalMem) {
2325        /* Close server listener */
2326        CloseAndCleanupListenSocket(&listenFd);
2327    }
2328#endif
2329
2330    /* Cleanup the wolfSSL environment */
2331    wolfSSL_Cleanup();
2332
2333    /* Free theadInfo array */
2334    XFREE(theadInfo, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2335
2336    /* Free cipher list */
2337    XFREE(ciphers, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2338
2339    /* Return reporting a success */
2340    if (args) {
2341        ((func_args*)args)->return_code = ret;
2342    }
2343
2344    return ret;
2345}
2346#endif /* (!NO_WOLFSSL_CLIENT || !NO_WOLFSSL_SERVER) && !WOLFCRYPT_ONLY && USE_WOLFSSL_IO */
2347
2348#ifndef NO_MAIN_DRIVER
2349
2350int main(int argc, char** argv)
2351{
2352    func_args args;
2353
2354    args.argc = argc;
2355    args.argv = argv;
2356    args.return_code = 0;
2357
2358#if (!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)) && \
2359    !defined(WOLFCRYPT_ONLY) && !defined(NO_TLS) && defined(USE_WOLFSSL_IO)
2360    bench_tls(&args);
2361#endif
2362
2363    return args.return_code;
2364}
2365
2366#endif /* !NO_MAIN_DRIVER */