/*

 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.

 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved

 * Copyright 2005 Nokia. All rights reserved.

 *

 * Licensed under the OpenSSL license (the "License").  You may not use

 * this file except in compliance with the License.  You can obtain a copy

 * in the file LICENSE in the source distribution or at

 * https://www.openssl.org/source/license.html

 */

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#if defined(_WIN32)

/* Included before async.h to avoid some warnings */

# include <windows.h>

#endif

#include <openssl/e_os2.h>

#include <openssl/async.h>

#include <openssl/ssl.h>

#ifndef OPENSSL_NO_SOCK

/*

 * With IPv6, it looks like Digital has mixed up the proper order of

 * recursive header file inclusion, resulting in the compiler complaining

 * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is

 * needed to have fileno() declared correctly...  So let's define u_int

 */

#if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)

# define __U_INT

typedef unsigned int u_int;

#endif

#include <openssl/bn.h>

#include "apps.h"

#include "progs.h"

#include <openssl/err.h>

#include <openssl/pem.h>

#include <openssl/x509.h>

#include <openssl/ssl.h>

#include <openssl/rand.h>

#include <openssl/ocsp.h>

#ifndef OPENSSL_NO_DH

# include <openssl/dh.h>

#endif

#ifndef OPENSSL_NO_RSA

# include <openssl/rsa.h>

#endif

#ifndef OPENSSL_NO_SRP

# include <openssl/srp.h>

#endif

#include "s_apps.h"

#include "timeouts.h"

#ifdef CHARSET_EBCDIC

#include <openssl/ebcdic.h>

#endif

#include "internal/sockets.h"

static int not_resumable_sess_cb(SSL *s, int is_forward_secure);

static int sv_body(int s, int stype, int prot, unsigned char *context);

static int www_body(int s, int stype, int prot, unsigned char *context);

static int rev_body(int s, int stype, int prot, unsigned char *context);

static void close_accept_socket(void);

static int init_ssl_connection(SSL *s);

static void print_stats(BIO *bp, SSL_CTX *ctx);

static int generate_session_id(SSL *ssl, unsigned char *id,

                               unsigned int *id_len);

static void init_session_cache_ctx(SSL_CTX *sctx);

static void free_sessions(void);

#ifndef OPENSSL_NO_DH

static DH *load_dh_param(const char *dhfile);

#endif

static void print_connection_info(SSL *con);

static const int bufsize = 16 * 1024;

static int accept_socket = -1;

#define TEST_CERT       "server.pem"

#define TEST_CERT2      "server2.pem"

static int s_nbio = 0;

static int s_nbio_test = 0;

static int s_crlf = 0;

static SSL_CTX *ctx = NULL;

static SSL_CTX *ctx2 = NULL;

static int www = 0;

static BIO *bio_s_out = NULL;

static BIO *bio_s_msg = NULL;

static int s_debug = 0;

static int s_tlsextdebug = 0;

static int s_msg = 0;

static int s_quiet = 0;

static int s_ign_eof = 0;

static int s_brief = 0;

static char *keymatexportlabel = NULL;

static int keymatexportlen = 20;

static int async = 0;

static const char *session_id_prefix = NULL;

#ifndef OPENSSL_NO_DTLS

static int enable_timeouts = 0;

static long socket_mtu;

#endif

/*

 * We define this but make it always be 0 in no-dtls builds to simplify the

 * code.

 */

static int dtlslisten = 0;

static int stateless = 0;

static int early_data = 0;

static SSL_SESSION *psksess = NULL;

static char *psk_identity = "Client_identity";

char *psk_key = NULL;           /* by default PSK is not used */

#ifndef OPENSSL_NO_PSK

static unsigned int psk_server_cb(SSL *ssl, const char *identity,

                                  unsigned char *psk,

                                  unsigned int max_psk_len)

{

    long key_len = 0;

    unsigned char *key;

    if (s_debug)

        BIO_printf(bio_s_out, "psk_server_cb\n");

    if (identity == NULL) {

        BIO_printf(bio_err, "Error: client did not send PSK identity\n");

        goto out_err;

    }

    if (s_debug)

        BIO_printf(bio_s_out, "identity_len=%d identity=%s\n",

                   (int)strlen(identity), identity);

    /* here we could lookup the given identity e.g. from a database */

    if (strcmp(identity, psk_identity) != 0) {

        BIO_printf(bio_s_out, "PSK warning: client identity not what we expected"

                   " (got '%s' expected '%s')\n", identity, psk_identity);

    } else {

      if (s_debug)

        BIO_printf(bio_s_out, "PSK client identity found\n");

    }

    /* convert the PSK key to binary */

    key = OPENSSL_hexstr2buf(psk_key, &key_len);

    if (key == NULL) {

        BIO_printf(bio_err, "Could not convert PSK key '%s' to buffer\n",

                   psk_key);

        return 0;

    }

    if (key_len > (int)max_psk_len) {

        BIO_printf(bio_err,

                   "psk buffer of callback is too small (%d) for key (%ld)\n",

                   max_psk_len, key_len);

        OPENSSL_free(key);

        return 0;

    }

    memcpy(psk, key, key_len);

    OPENSSL_free(key);

    if (s_debug)

        BIO_printf(bio_s_out, "fetched PSK len=%ld\n", key_len);

    return key_len;

 out_err:

    if (s_debug)

        BIO_printf(bio_err, "Error in PSK server callback\n");

    (void)BIO_flush(bio_err);

    (void)BIO_flush(bio_s_out);

    return 0;

}

#endif

static int psk_find_session_cb(SSL *ssl, const unsigned char *identity,

                               size_t identity_len, SSL_SESSION **sess)

{

    SSL_SESSION *tmpsess = NULL;

    unsigned char *key;

    long key_len;

    const SSL_CIPHER *cipher = NULL;

    if (strlen(psk_identity) != identity_len

            || memcmp(psk_identity, identity, identity_len) != 0) {

        *sess = NULL;

        return 1;

    }

    if (psksess != NULL) {

        SSL_SESSION_up_ref(psksess);

        *sess = psksess;

        return 1;

    }

    key = OPENSSL_hexstr2buf(psk_key, &key_len);

    if (key == NULL) {

        BIO_printf(bio_err, "Could not convert PSK key '%s' to buffer\n",

                   psk_key);

        return 0;

    }

    /* We default to SHA256 */

    cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id);

    if (cipher == NULL) {

        BIO_printf(bio_err, "Error finding suitable ciphersuite\n");

        OPENSSL_free(key);

        return 0;

    }

    tmpsess = SSL_SESSION_new();

    if (tmpsess == NULL

            || !SSL_SESSION_set1_master_key(tmpsess, key, key_len)

            || !SSL_SESSION_set_cipher(tmpsess, cipher)

            || !SSL_SESSION_set_protocol_version(tmpsess, SSL_version(ssl))) {

        OPENSSL_free(key);

        return 0;

    }

    OPENSSL_free(key);

    *sess = tmpsess;

    return 1;

}

#ifndef OPENSSL_NO_SRP

/* This is a context that we pass to callbacks */

typedef struct srpsrvparm_st {

    char *login;

    SRP_VBASE *vb;

    SRP_user_pwd *user;

} srpsrvparm;

static srpsrvparm srp_callback_parm;

/*

 * This callback pretends to require some asynchronous logic in order to

 * obtain a verifier. When the callback is called for a new connection we

 * return with a negative value. This will provoke the accept etc to return

 * with an LOOKUP_X509. The main logic of the reinvokes the suspended call

 * (which would normally occur after a worker has finished) and we set the

 * user parameters.

 */

static int ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)

{

    srpsrvparm *p = (srpsrvparm *) arg;

    int ret = SSL3_AL_FATAL;

    if (p->login == NULL && p->user == NULL) {

        p->login = SSL_get_srp_username(s);

        BIO_printf(bio_err, "SRP username = \"%s\"\n", p->login);

        return -1;

    }

    if (p->user == NULL) {

        BIO_printf(bio_err, "User %s doesn't exist\n", p->login);

        goto err;

    }

    if (SSL_set_srp_server_param

        (s, p->user->N, p->user->g, p->user->s, p->user->v,

         p->user->info) < 0) {

        *ad = SSL_AD_INTERNAL_ERROR;

        goto err;

    }

    BIO_printf(bio_err,

               "SRP parameters set: username = \"%s\" info=\"%s\" \n",

               p->login, p->user->info);

    ret = SSL_ERROR_NONE;

 err:

    SRP_user_pwd_free(p->user);

    p->user = NULL;

    p->login = NULL;

    return ret;

}

#endif

static int local_argc = 0;

static char **local_argv;

#ifdef CHARSET_EBCDIC

static int ebcdic_new(BIO *bi);

static int ebcdic_free(BIO *a);

static int ebcdic_read(BIO *b, char *out, int outl);

static int ebcdic_write(BIO *b, const char *in, int inl);

static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr);

static int ebcdic_gets(BIO *bp, char *buf, int size);

static int ebcdic_puts(BIO *bp, const char *str);

# define BIO_TYPE_EBCDIC_FILTER  (18|0x0200)

static BIO_METHOD *methods_ebcdic = NULL;

/* This struct is "unwarranted chumminess with the compiler." */

typedef struct {

    size_t alloced;

    char buff[1];

} EBCDIC_OUTBUFF;

static const BIO_METHOD *BIO_f_ebcdic_filter()

{

    if (methods_ebcdic == NULL) {

        methods_ebcdic = BIO_meth_new(BIO_TYPE_EBCDIC_FILTER,

                                      "EBCDIC/ASCII filter");

        if (methods_ebcdic == NULL

            || !BIO_meth_set_write(methods_ebcdic, ebcdic_write)

            || !BIO_meth_set_read(methods_ebcdic, ebcdic_read)

            || !BIO_meth_set_puts(methods_ebcdic, ebcdic_puts)

            || !BIO_meth_set_gets(methods_ebcdic, ebcdic_gets)

            || !BIO_meth_set_ctrl(methods_ebcdic, ebcdic_ctrl)

            || !BIO_meth_set_create(methods_ebcdic, ebcdic_new)

            || !BIO_meth_set_destroy(methods_ebcdic, ebcdic_free))

            return NULL;

    }

    return methods_ebcdic;

}

static int ebcdic_new(BIO *bi)

{

    EBCDIC_OUTBUFF *wbuf;

    wbuf = app_malloc(sizeof(*wbuf) + 1024, "ebcdic wbuf");

    wbuf->alloced = 1024;

    wbuf->buff[0] = '\0';

    BIO_set_data(bi, wbuf);

    BIO_set_init(bi, 1);

    return 1;

}

static int ebcdic_free(BIO *a)

{

    EBCDIC_OUTBUFF *wbuf;

    if (a == NULL)

        return 0;

    wbuf = BIO_get_data(a);

    OPENSSL_free(wbuf);

    BIO_set_data(a, NULL);

    BIO_set_init(a, 0);

    return 1;

}

static int ebcdic_read(BIO *b, char *out, int outl)

{

    int ret = 0;

    BIO *next = BIO_next(b);

    if (out == NULL || outl == 0)

        return 0;

    if (next == NULL)

        return 0;

    ret = BIO_read(next, out, outl);

    if (ret > 0)

        ascii2ebcdic(out, out, ret);

    return ret;

}

static int ebcdic_write(BIO *b, const char *in, int inl)

{

    EBCDIC_OUTBUFF *wbuf;

    BIO *next = BIO_next(b);

    int ret = 0;

    int num;

    if ((in == NULL) || (inl <= 0))

        return 0;

    if (next == NULL)

        return 0;

    wbuf = (EBCDIC_OUTBUFF *) BIO_get_data(b);

    if (inl > (num = wbuf->alloced)) {

        num = num + num;        /* double the size */

        if (num < inl)

            num = inl;

        OPENSSL_free(wbuf);

        wbuf = app_malloc(sizeof(*wbuf) + num, "grow ebcdic wbuf");

        wbuf->alloced = num;

        wbuf->buff[0] = '\0';

        BIO_set_data(b, wbuf);

    }

    ebcdic2ascii(wbuf->buff, in, inl);

    ret = BIO_write(next, wbuf->buff, inl);

    return ret;

}

static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)

{

    long ret;

    BIO *next = BIO_next(b);

    if (next == NULL)

        return 0;

    switch (cmd) {

    case BIO_CTRL_DUP:

        ret = 0L;

        break;

    default:

        ret = BIO_ctrl(next, cmd, num, ptr);

        break;

    }

    return ret;

}

static int ebcdic_gets(BIO *bp, char *buf, int size)

{

    int i, ret = 0;

    BIO *next = BIO_next(bp);

    if (next == NULL)

        return 0;

/*      return(BIO_gets(bp->next_bio,buf,size));*/

    for (i = 0; i < size - 1; ++i) {

        ret = ebcdic_read(bp, &buf[i], 1);

        if (ret <= 0)

            break;

        else if (buf[i] == '\n') {

            ++i;

            break;

        }

    }

    if (i < size)

        buf[i] = '\0';

    return (ret < 0 && i == 0) ? ret : i;

}

static int ebcdic_puts(BIO *bp, const char *str)

{

    if (BIO_next(bp) == NULL)

        return 0;

    return ebcdic_write(bp, str, strlen(str));

}

#endif

/* This is a context that we pass to callbacks */

typedef struct tlsextctx_st {

    char *servername;

    BIO *biodebug;

    int extension_error;

} tlsextctx;

static int ssl_servername_cb(SSL *s, int *ad, void *arg)

{

    tlsextctx *p = (tlsextctx *) arg;

    const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);

    if (servername != NULL && p->biodebug != NULL) {

        const char *cp = servername;

        unsigned char uc;

        BIO_printf(p->biodebug, "Hostname in TLS extension: \"");

        while ((uc = *cp++) != 0)

            BIO_printf(p->biodebug,

                       isascii(uc) && isprint(uc) ? "%c" : "\\x%02x", uc);

        BIO_printf(p->biodebug, "\"\n");

    }

    if (p->servername == NULL)

        return SSL_TLSEXT_ERR_NOACK;

    if (servername != NULL) {

        if (strcasecmp(servername, p->servername))

            return p->extension_error;

        if (ctx2 != NULL) {

            BIO_printf(p->biodebug, "Switching server context.\n");

            SSL_set_SSL_CTX(s, ctx2);

        }

    }

    return SSL_TLSEXT_ERR_OK;

}

/* Structure passed to cert status callback */

typedef struct tlsextstatusctx_st {

    int timeout;

    /* File to load OCSP Response from (or NULL if no file) */

    char *respin;

    /* Default responder to use */

    char *host, *path, *port;

    int use_ssl;

    int verbose;

} tlsextstatusctx;

static tlsextstatusctx tlscstatp = { -1 };

#ifndef OPENSSL_NO_OCSP

/*

 * Helper function to get an OCSP_RESPONSE from a responder. This is a

 * simplified version. It examines certificates each time and makes one OCSP

 * responder query for each request. A full version would store details such as

 * the OCSP certificate IDs and minimise the number of OCSP responses by caching

 * them until they were considered "expired".

 */

static int get_ocsp_resp_from_responder(SSL *s, tlsextstatusctx *srctx,

                                        OCSP_RESPONSE **resp)

{

    char *host = NULL, *port = NULL, *path = NULL;

    int use_ssl;

    STACK_OF(OPENSSL_STRING) *aia = NULL;

    X509 *x = NULL;

    X509_STORE_CTX *inctx = NULL;

    X509_OBJECT *obj;

    OCSP_REQUEST *req = NULL;

    OCSP_CERTID *id = NULL;

    STACK_OF(X509_EXTENSION) *exts;

    int ret = SSL_TLSEXT_ERR_NOACK;

    int i;

    /* Build up OCSP query from server certificate */

    x = SSL_get_certificate(s);

    aia = X509_get1_ocsp(x);

    if (aia != NULL) {

        if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),

                            &host, &port, &path, &use_ssl)) {

            BIO_puts(bio_err, "cert_status: can't parse AIA URL\n");

            goto err;

        }

        if (srctx->verbose)

            BIO_printf(bio_err, "cert_status: AIA URL: %s\n",

                       sk_OPENSSL_STRING_value(aia, 0));

    } else {

        if (srctx->host == NULL) {

            BIO_puts(bio_err,

                     "cert_status: no AIA and no default responder URL\n");

            goto done;

        }

        host = srctx->host;

        path = srctx->path;

        port = srctx->port;

        use_ssl = srctx->use_ssl;

    }

    inctx = X509_STORE_CTX_new();

    if (inctx == NULL)

        goto err;

    if (!X509_STORE_CTX_init(inctx,

                             SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),

                             NULL, NULL))

        goto err;

    obj = X509_STORE_CTX_get_obj_by_subject(inctx, X509_LU_X509,

                                            X509_get_issuer_name(x));

    if (obj == NULL) {

        BIO_puts(bio_err, "cert_status: Can't retrieve issuer certificate.\n");

        goto done;

    }

    id = OCSP_cert_to_id(NULL, x, X509_OBJECT_get0_X509(obj));

    X509_OBJECT_free(obj);

    if (id == NULL)

        goto err;

    req = OCSP_REQUEST_new();

    if (req == NULL)

        goto err;

    if (!OCSP_request_add0_id(req, id))

        goto err;

    id = NULL;

    /* Add any extensions to the request */

    SSL_get_tlsext_status_exts(s, &exts);

    for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {

        X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);

        if (!OCSP_REQUEST_add_ext(req, ext, -1))

            goto err;

    }

    *resp = process_responder(req, host, path, port, use_ssl, NULL,

                             srctx->timeout);

    if (*resp == NULL) {

        BIO_puts(bio_err, "cert_status: error querying responder\n");

        goto done;

    }

    ret = SSL_TLSEXT_ERR_OK;

    goto done;

 err:

    ret = SSL_TLSEXT_ERR_ALERT_FATAL;

 done:

    /*

     * If we parsed aia we need to free; otherwise they were copied and we

     * don't

     */

    if (aia != NULL) {

        OPENSSL_free(host);

        OPENSSL_free(path);

        OPENSSL_free(port);

        X509_email_free(aia);

    }

    OCSP_CERTID_free(id);

    OCSP_REQUEST_free(req);

    X509_STORE_CTX_free(inctx);

    return ret;

}

/*

 * Certificate Status callback. This is called when a client includes a

 * certificate status request extension. The response is either obtained from a

 * file, or from an OCSP responder.

 */

static int cert_status_cb(SSL *s, void *arg)

{

    tlsextstatusctx *srctx = arg;

    OCSP_RESPONSE *resp = NULL;

    unsigned char *rspder = NULL;

    int rspderlen;

    int ret = SSL_TLSEXT_ERR_ALERT_FATAL;

    if (srctx->verbose)

        BIO_puts(bio_err, "cert_status: callback called\n");

    if (srctx->respin != NULL) {

        BIO *derbio = bio_open_default(srctx->respin, 'r', FORMAT_ASN1);

        if (derbio == NULL) {

            BIO_puts(bio_err, "cert_status: Cannot open OCSP response file\n");

            goto err;

        }

        resp = d2i_OCSP_RESPONSE_bio(derbio, NULL);

        BIO_free(derbio);

        if (resp == NULL) {

            BIO_puts(bio_err, "cert_status: Error reading OCSP response\n");

            goto err;

        }

    } else {

        ret = get_ocsp_resp_from_responder(s, srctx, &resp);

        if (ret != SSL_TLSEXT_ERR_OK)

            goto err;

    }

    rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);

    if (rspderlen <= 0)

        goto err;

    SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);

    if (srctx->verbose) {

        BIO_puts(bio_err, "cert_status: ocsp response sent:\n");

        OCSP_RESPONSE_print(bio_err, resp, 2);

    }

    ret = SSL_TLSEXT_ERR_OK;

 err:

    if (ret != SSL_TLSEXT_ERR_OK)

        ERR_print_errors(bio_err);

    OCSP_RESPONSE_free(resp);

    return ret;

}

#endif

#ifndef OPENSSL_NO_NEXTPROTONEG

/* This is the context that we pass to next_proto_cb */

typedef struct tlsextnextprotoctx_st {

    unsigned char *data;

    size_t len;

} tlsextnextprotoctx;

static int next_proto_cb(SSL *s, const unsigned char **data,

                         unsigned int *len, void *arg)

{

    tlsextnextprotoctx *next_proto = arg;

    *data = next_proto->data;

    *len = next_proto->len;

    return SSL_TLSEXT_ERR_OK;

}

#endif                         /* ndef OPENSSL_NO_NEXTPROTONEG */

/* This the context that we pass to alpn_cb */

typedef struct tlsextalpnctx_st {

    unsigned char *data;

    size_t len;

} tlsextalpnctx;

static int alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,

                   const unsigned char *in, unsigned int inlen, void *arg)

{

    tlsextalpnctx *alpn_ctx = arg;

    if (!s_quiet) {

        /* We can assume that |in| is syntactically valid. */

        unsigned int i;

        BIO_printf(bio_s_out, "ALPN protocols advertised by the client: ");

        for (i = 0; i < inlen;) {

            if (i)

                BIO_write(bio_s_out, ", ", 2);

            BIO_write(bio_s_out, &in[i + 1], in[i]);

            i += in[i] + 1;

        }

        BIO_write(bio_s_out, "\n", 1);

    }

    if (SSL_select_next_proto

        ((unsigned char **)out, outlen, alpn_ctx->data, alpn_ctx->len, in,

         inlen) != OPENSSL_NPN_NEGOTIATED) {

        return SSL_TLSEXT_ERR_ALERT_FATAL;

    }

    if (!s_quiet) {

        BIO_printf(bio_s_out, "ALPN protocols selected: ");

        BIO_write(bio_s_out, *out, *outlen);

        BIO_write(bio_s_out, "\n", 1);

    }

    return SSL_TLSEXT_ERR_OK;

}

static int not_resumable_sess_cb(SSL *s, int is_forward_secure)

{

    /* disable resumption for sessions with forward secure ciphers */

    return is_forward_secure;

}

typedef enum OPTION_choice {

    OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ENGINE,

    OPT_4, OPT_6, OPT_ACCEPT, OPT_PORT, OPT_UNIX, OPT_UNLINK, OPT_NACCEPT,

    OPT_VERIFY, OPT_NAMEOPT, OPT_UPPER_V_VERIFY, OPT_CONTEXT, OPT_CERT, OPT_CRL,

    OPT_CRL_DOWNLOAD, OPT_SERVERINFO, OPT_CERTFORM, OPT_KEY, OPT_KEYFORM,

    OPT_PASS, OPT_CERT_CHAIN, OPT_DHPARAM, OPT_DCERTFORM, OPT_DCERT,

    OPT_DKEYFORM, OPT_DPASS, OPT_DKEY, OPT_DCERT_CHAIN, OPT_NOCERT,

    OPT_CAPATH, OPT_NOCAPATH, OPT_CHAINCAPATH, OPT_VERIFYCAPATH, OPT_NO_CACHE,

    OPT_EXT_CACHE, OPT_CRLFORM, OPT_VERIFY_RET_ERROR, OPT_VERIFY_QUIET,

    OPT_BUILD_CHAIN, OPT_CAFILE, OPT_NOCAFILE, OPT_CHAINCAFILE,

    OPT_VERIFYCAFILE, OPT_NBIO, OPT_NBIO_TEST, OPT_IGN_EOF, OPT_NO_IGN_EOF,

    OPT_DEBUG, OPT_TLSEXTDEBUG, OPT_STATUS, OPT_STATUS_VERBOSE,

    OPT_STATUS_TIMEOUT, OPT_STATUS_URL, OPT_STATUS_FILE, OPT_MSG, OPT_MSGFILE,

    OPT_TRACE, OPT_SECURITY_DEBUG, OPT_SECURITY_DEBUG_VERBOSE, OPT_STATE,

    OPT_CRLF, OPT_QUIET, OPT_BRIEF, OPT_NO_DHE,

    OPT_NO_RESUME_EPHEMERAL, OPT_PSK_IDENTITY, OPT_PSK_HINT, OPT_PSK,

    OPT_PSK_SESS, OPT_SRPVFILE, OPT_SRPUSERSEED, OPT_REV, OPT_WWW,

    OPT_UPPER_WWW, OPT_HTTP, OPT_ASYNC, OPT_SSL_CONFIG,

    OPT_MAX_SEND_FRAG, OPT_SPLIT_SEND_FRAG, OPT_MAX_PIPELINES, OPT_READ_BUF,

    OPT_SSL3, OPT_TLS1_3, OPT_TLS1_2, OPT_TLS1_1, OPT_TLS1, OPT_DTLS, OPT_DTLS1,

    OPT_DTLS1_2, OPT_SCTP, OPT_TIMEOUT, OPT_MTU, OPT_LISTEN, OPT_STATELESS,

    OPT_ID_PREFIX, OPT_SERVERNAME, OPT_SERVERNAME_FATAL,

    OPT_CERT2, OPT_KEY2, OPT_NEXTPROTONEG, OPT_ALPN,

    OPT_SRTP_PROFILES, OPT_KEYMATEXPORT, OPT_KEYMATEXPORTLEN,

    OPT_KEYLOG_FILE, OPT_MAX_EARLY, OPT_RECV_MAX_EARLY, OPT_EARLY_DATA,

    OPT_S_NUM_TICKETS, OPT_ANTI_REPLAY, OPT_NO_ANTI_REPLAY, OPT_SCTP_LABEL_BUG,

    OPT_R_ENUM,

    OPT_S_ENUM,

    OPT_V_ENUM,

    OPT_X_ENUM

} OPTION_CHOICE;

const OPTIONS s_server_options[] = {

    {"help", OPT_HELP, '-', "Display this summary"},

    {"port", OPT_PORT, 'p',

     "TCP/IP port to listen on for connections (default is " PORT ")"},

    {"accept", OPT_ACCEPT, 's',

     "TCP/IP optional host and port to listen on for connections (default is *:" PORT ")"},

#ifdef AF_UNIX

    {"unix", OPT_UNIX, 's', "Unix domain socket to accept on"},

#endif

    {"4", OPT_4, '-', "Use IPv4 only"},

    {"6", OPT_6, '-', "Use IPv6 only"},

#ifdef AF_UNIX

    {"unlink", OPT_UNLINK, '-', "For -unix, unlink existing socket first"},

#endif

    {"context", OPT_CONTEXT, 's', "Set session ID context"},

    {"verify", OPT_VERIFY, 'n', "Turn on peer certificate verification"},

    {"Verify", OPT_UPPER_V_VERIFY, 'n',

     "Turn on peer certificate verification, must have a cert"},

    {"cert", OPT_CERT, '<', "Certificate file to use; default is " TEST_CERT},

    {"nameopt", OPT_NAMEOPT, 's', "Various certificate name options"},

    {"naccept", OPT_NACCEPT, 'p', "Terminate after #num connections"},

    {"serverinfo", OPT_SERVERINFO, 's',

     "PEM serverinfo file for certificate"},

    {"certform", OPT_CERTFORM, 'F',

     "Certificate format (PEM or DER) PEM default"},

    {"key", OPT_KEY, 's',

     "Private Key if not in -cert; default is " TEST_CERT},

    {"keyform", OPT_KEYFORM, 'f',

     "Key format (PEM, DER or ENGINE) PEM default"},

    {"pass", OPT_PASS, 's', "Private key file pass phrase source"},

    {"dcert", OPT_DCERT, '<',

     "Second certificate file to use (usually for DSA)"},

    {"dhparam", OPT_DHPARAM, '<', "DH parameters file to use"},

    {"dcertform", OPT_DCERTFORM, 'F',

     "Second certificate format (PEM or DER) PEM default"},

    {"dkey", OPT_DKEY, '<',

     "Second private key file to use (usually for DSA)"},

    {"dkeyform", OPT_DKEYFORM, 'F',

     "Second key format (PEM, DER or ENGINE) PEM default"},

    {"dpass", OPT_DPASS, 's', "Second private key file pass phrase source"},

    {"nbio_test", OPT_NBIO_TEST, '-', "Test with the non-blocking test bio"},

    {"crlf", OPT_CRLF, '-', "Convert LF from terminal into CRLF"},

    {"debug", OPT_DEBUG, '-', "Print more output"},

    {"msg", OPT_MSG, '-', "Show protocol messages"},

    {"msgfile", OPT_MSGFILE, '>',

     "File to send output of -msg or -trace, instead of stdout"},

    {"state", OPT_STATE, '-', "Print the SSL states"},

    {"CAfile", OPT_CAFILE, '<', "PEM format file of CA's"},

    {"CApath", OPT_CAPATH, '/', "PEM format directory of CA's"},

    {"no-CAfile", OPT_NOCAFILE, '-',

     "Do not load the default certificates file"},

    {"no-CApath", OPT_NOCAPATH, '-',

     "Do not load certificates from the default certificates directory"},

    {"nocert", OPT_NOCERT, '-', "Don't use any certificates (Anon-DH)"},

    {"quiet", OPT_QUIET, '-', "No server output"},

    {"no_resume_ephemeral", OPT_NO_RESUME_EPHEMERAL, '-',

     "Disable caching and tickets if ephemeral (EC)DH is used"},

    {"www", OPT_WWW, '-', "Respond to a 'GET /' with a status page"},

    {"WWW", OPT_UPPER_WWW, '-', "Respond to a 'GET with the file ./path"},

    {"servername", OPT_SERVERNAME, 's',

     "Servername for HostName TLS extension"},

    {"servername_fatal", OPT_SERVERNAME_FATAL, '-',

     "mismatch send fatal alert (default warning alert)"},

    {"cert2", OPT_CERT2, '<',

     "Certificate file to use for servername; default is" TEST_CERT2},

    {"key2", OPT_KEY2, '<',

     "-Private Key file to use for servername if not in -cert2"},

    {"tlsextdebug", OPT_TLSEXTDEBUG, '-',

     "Hex dump of all TLS extensions received"},

    {"HTTP", OPT_HTTP, '-', "Like -WWW but ./path includes HTTP headers"},

    {"id_prefix", OPT_ID_PREFIX, 's',

     "Generate SSL/TLS session IDs prefixed by arg"},

    OPT_R_OPTIONS,

    {"keymatexport", OPT_KEYMATEXPORT, 's',

     "Export keying material using label"},

    {"keymatexportlen", OPT_KEYMATEXPORTLEN, 'p',

     "Export len bytes of keying material (default 20)"},

    {"CRL", OPT_CRL, '<', "CRL file to use"},

    {"crl_download", OPT_CRL_DOWNLOAD, '-',

     "Download CRL from distribution points"},

    {"cert_chain", OPT_CERT_CHAIN, '<',

     "certificate chain file in PEM format"},

    {"dcert_chain", OPT_DCERT_CHAIN, '<',

     "second certificate chain file in PEM format"},

    {"chainCApath", OPT_CHAINCAPATH, '/',

     "use dir as certificate store path to build CA certificate chain"},

    {"verifyCApath", OPT_VERIFYCAPATH, '/',

     "use dir as certificate store path to verify CA certificate"},

    {"no_cache", OPT_NO_CACHE, '-', "Disable session cache"},

    {"ext_cache", OPT_EXT_CACHE, '-',

     "Disable internal cache, setup and use external cache"},

    {"CRLform", OPT_CRLFORM, 'F', "CRL format (PEM or DER) PEM is default"},

    {"verify_return_error", OPT_VERIFY_RET_ERROR, '-',

     "Close connection on verification error"},

    {"verify_quiet", OPT_VERIFY_QUIET, '-',

     "No verify output except verify errors"},

    {"build_chain", OPT_BUILD_CHAIN, '-', "Build certificate chain"},

    {"chainCAfile", OPT_CHAINCAFILE, '<',

     "CA file for certificate chain (PEM format)"},

    {"verifyCAfile", OPT_VERIFYCAFILE, '<',

     "CA file for certificate verification (PEM format)"},

    {"ign_eof", OPT_IGN_EOF, '-', "ignore input eof (default when -quiet)"},

    {"no_ign_eof", OPT_NO_IGN_EOF, '-', "Do not ignore input eof"},

#ifndef OPENSSL_NO_OCSP

    {"status", OPT_STATUS, '-', "Request certificate status from server"},

    {"status_verbose", OPT_STATUS_VERBOSE, '-',

     "Print more output in certificate status callback"},

    {"status_timeout", OPT_STATUS_TIMEOUT, 'n',

     "Status request responder timeout"},

    {"status_url", OPT_STATUS_URL, 's', "Status request fallback URL"},

    {"status_file", OPT_STATUS_FILE, '<',

     "File containing DER encoded OCSP Response"},

#endif

#ifndef OPENSSL_NO_SSL_TRACE

    {"trace", OPT_TRACE, '-', "trace protocol messages"},

#endif

    {"security_debug", OPT_SECURITY_DEBUG, '-',

     "Print output from SSL/TLS security framework"},

    {"security_debug_verbose", OPT_SECURITY_DEBUG_VERBOSE, '-',

     "Print more output from SSL/TLS security framework"},

    {"brief", OPT_BRIEF, '-',

     "Restrict output to brief summary of connection parameters"},

    {"rev", OPT_REV, '-',