apps/s_client.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* ====================================================================
  11  * Copyright 2005 Nokia. All rights reserved.
  12  *
  13  * The portions of the attached software ("Contribution") is developed by
  14  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
  15  * license.
  16  *
  17  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
  18  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
  19  * support (see RFC 4279) to OpenSSL.
  20  *
  21  * No patent licenses or other rights except those expressly stated in
  22  * the OpenSSL open source license shall be deemed granted or received
  23  * expressly, by implication, estoppel, or otherwise.
  24  *
  25  * No assurances are provided by Nokia that the Contribution does not
  26  * infringe the patent or other intellectual property rights of any third
  27  * party or that the license provides you with all the necessary rights
  28  * to make use of the Contribution.
  29  *
  30  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
  31  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
  32  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
  33  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
  34  * OTHERWISE.
  35  */
  36
  37 #include <ctype.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #include <openssl/e_os2.h>
  43
  44 #ifndef OPENSSL_NO_SOCK
  45
  46 /*
  47  * With IPv6, it looks like Digital has mixed up the proper order of
  48  * recursive header file inclusion, resulting in the compiler complaining
  49  * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is
  50  * needed to have fileno() declared correctly...  So let's define u_int
  51  */
  52 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
  53 # define __U_INT
  54 typedef unsigned int u_int;
  55 #endif
  56
  57 #define USE_SOCKETS
  58 #include "apps.h"
  59 #include <openssl/x509.h>
  60 #include <openssl/ssl.h>
  61 #include <openssl/err.h>
  62 #include <openssl/pem.h>
  63 #include <openssl/rand.h>
  64 #include <openssl/ocsp.h>
  65 #include <openssl/bn.h>
  66 #include <openssl/async.h>
  67 #ifndef OPENSSL_NO_SRP
  68 # include <openssl/srp.h>
  69 #endif
  70 #ifndef OPENSSL_NO_CT
  71 # include <openssl/ct.h>
  72 #endif
  73 #include "s_apps.h"
  74 #include "timeouts.h"
  75
  76 #if defined(__has_feature)
  77 # if __has_feature(memory_sanitizer)
  78 #  include <sanitizer/msan_interface.h>
  79 # endif
  80 #endif
  81
  82 #undef BUFSIZZ
  83 #define BUFSIZZ 1024*8
  84 #define S_CLIENT_IRC_READ_TIMEOUT 8
  85
  86 static char *prog;
  87 static int c_debug = 0;
  88 static int c_showcerts = 0;
  89 static char *keymatexportlabel = NULL;
  90 static int keymatexportlen = 20;
  91 static BIO *bio_c_out = NULL;
  92 static int c_quiet = 0;
  93 static char *sess_out = NULL;
  94
  95 static void print_stuff(BIO *berr, SSL *con, int full);
  96 #ifndef OPENSSL_NO_OCSP
  97 static int ocsp_resp_cb(SSL *s, void *arg);
  98 #endif
  99
 100 static int saved_errno;
 101
 102 static void save_errno(void)
 103 {
 104     saved_errno = errno;
 105     errno = 0;
 106 }
 107
 108 static int restore_errno(void)
 109 {
 110     int ret = errno;
 111     errno = saved_errno;
 112     return ret;
 113 }
 114
 115 static void do_ssl_shutdown(SSL *ssl)
 116 {
 117     int ret;
 118
 119     do {
 120         /* We only do unidirectional shutdown */
 121         ret = SSL_shutdown(ssl);
 122         if (ret < 0) {
 123             switch (SSL_get_error(ssl, ret)) {
 124             case SSL_ERROR_WANT_READ:
 125             case SSL_ERROR_WANT_WRITE:
 126             case SSL_ERROR_WANT_ASYNC:
 127             case SSL_ERROR_WANT_ASYNC_JOB:
 128                 /* We just do busy waiting. Nothing clever */
 129                 continue;
 130             }
 131             ret = 0;
 132         }
 133     } while (ret < 0);
 134 }
 135
 136 #ifndef OPENSSL_NO_PSK
 137 /* Default PSK identity and key */
 138 static char *psk_identity = "Client_identity";
 139 /*
 140  * char *psk_key=NULL; by default PSK is not used
 141  */
 142
 143 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity,
 144                                   unsigned int max_identity_len,
 145                                   unsigned char *psk,
 146                                   unsigned int max_psk_len)
 147 {
 148     int ret;
 149     long key_len;
 150     unsigned char *key;
 151
 152     if (c_debug)
 153         BIO_printf(bio_c_out, "psk_client_cb\n");
 154     if (!hint) {
 155         /* no ServerKeyExchange message */
 156         if (c_debug)
 157             BIO_printf(bio_c_out,
 158                        "NULL received PSK identity hint, continuing anyway\n");
 159     } else if (c_debug)
 160         BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint);
 161
 162     /*
 163      * lookup PSK identity and PSK key based on the given identity hint here
 164      */
 165     ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity);
 166     if (ret < 0 || (unsigned int)ret > max_identity_len)
 167         goto out_err;
 168     if (c_debug)
 169         BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity,
 170                    ret);
 171
 172     /* convert the PSK key to binary */
 173     key = OPENSSL_hexstr2buf(psk_key, &key_len);
 174     if (key == NULL) {
 175         BIO_printf(bio_err, "Could not convert PSK key '%s' to buffer\n",
 176                    psk_key);
 177         return 0;
 178     }
 179     if (key_len > max_psk_len) {
 180         BIO_printf(bio_err,
 181                    "psk buffer of callback is too small (%d) for key (%ld)\n",
 182                    max_psk_len, key_len);
 183         OPENSSL_free(key);
 184         return 0;
 185     }
 186
 187     memcpy(psk, key, key_len);
 188     OPENSSL_free(key);
 189
 190     if (c_debug)
 191         BIO_printf(bio_c_out, "created PSK len=%ld\n", key_len);
 192
 193     return key_len;
 194  out_err:
 195     if (c_debug)
 196         BIO_printf(bio_err, "Error in PSK client callback\n");
 197     return 0;
 198 }
 199 #endif
 200
 201 /* This is a context that we pass to callbacks */
 202 typedef struct tlsextctx_st {
 203     BIO *biodebug;
 204     int ack;
 205 } tlsextctx;
 206
 207 static int ssl_servername_cb(SSL *s, int *ad, void *arg)
 208 {
 209     tlsextctx *p = (tlsextctx *) arg;
 210     const char *hn = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 211     if (SSL_get_servername_type(s) != -1)
 212         p->ack = !SSL_session_reused(s) && hn != NULL;
 213     else
 214         BIO_printf(bio_err, "Can't use SSL_get_servername\n");
 215
 216     return SSL_TLSEXT_ERR_OK;
 217 }
 218
 219 #ifndef OPENSSL_NO_SRP
 220
 221 /* This is a context that we pass to all callbacks */
 222 typedef struct srp_arg_st {
 223     char *srppassin;
 224     char *srplogin;
 225     int msg;                    /* copy from c_msg */
 226     int debug;                  /* copy from c_debug */
 227     int amp;                    /* allow more groups */
 228     int strength;               /* minimal size for N */
 229 } SRP_ARG;
 230
 231 # define SRP_NUMBER_ITERATIONS_FOR_PRIME 64
 232
 233 static int srp_Verify_N_and_g(const BIGNUM *N, const BIGNUM *g)
 234 {
 235     BN_CTX *bn_ctx = BN_CTX_new();
 236     BIGNUM *p = BN_new();
 237     BIGNUM *r = BN_new();
 238     int ret =
 239         g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) &&
 240         BN_is_prime_ex(N, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) == 1 &&
 241         p != NULL && BN_rshift1(p, N) &&
 242         /* p = (N-1)/2 */
 243         BN_is_prime_ex(p, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) == 1 &&
 244         r != NULL &&
 245         /* verify g^((N-1)/2) == -1 (mod N) */
 246         BN_mod_exp(r, g, p, N, bn_ctx) &&
 247         BN_add_word(r, 1) && BN_cmp(r, N) == 0;
 248
 249     BN_free(r);
 250     BN_free(p);
 251     BN_CTX_free(bn_ctx);
 252     return ret;
 253 }
 254
 255 /*-
 256  * This callback is used here for two purposes:
 257  * - extended debugging
 258  * - making some primality tests for unknown groups
 259  * The callback is only called for a non default group.
 260  *
 261  * An application does not need the call back at all if
 262  * only the standard groups are used.  In real life situations,
 263  * client and server already share well known groups,
 264  * thus there is no need to verify them.
 265  * Furthermore, in case that a server actually proposes a group that
 266  * is not one of those defined in RFC 5054, it is more appropriate
 267  * to add the group to a static list and then compare since
 268  * primality tests are rather cpu consuming.
 269  */
 270
 271 static int ssl_srp_verify_param_cb(SSL *s, void *arg)
 272 {
 273     SRP_ARG *srp_arg = (SRP_ARG *)arg;
 274     BIGNUM *N = NULL, *g = NULL;
 275
 276     if (((N = SSL_get_srp_N(s)) == NULL) || ((g = SSL_get_srp_g(s)) == NULL))
 277         return 0;
 278     if (srp_arg->debug || srp_arg->msg || srp_arg->amp == 1) {
 279         BIO_printf(bio_err, "SRP parameters:\n");
 280         BIO_printf(bio_err, "\tN=");
 281         BN_print(bio_err, N);
 282         BIO_printf(bio_err, "\n\tg=");
 283         BN_print(bio_err, g);
 284         BIO_printf(bio_err, "\n");
 285     }
 286
 287     if (SRP_check_known_gN_param(g, N))
 288         return 1;
 289
 290     if (srp_arg->amp == 1) {
 291         if (srp_arg->debug)
 292             BIO_printf(bio_err,
 293                        "SRP param N and g are not known params, going to check deeper.\n");
 294
 295         /*
 296          * The srp_moregroups is a real debugging feature. Implementors
 297          * should rather add the value to the known ones. The minimal size
 298          * has already been tested.
 299          */
 300         if (BN_num_bits(g) <= BN_BITS && srp_Verify_N_and_g(N, g))
 301             return 1;
 302     }
 303     BIO_printf(bio_err, "SRP param N and g rejected.\n");
 304     return 0;
 305 }
 306
 307 # define PWD_STRLEN 1024
 308
 309 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
 310 {
 311     SRP_ARG *srp_arg = (SRP_ARG *)arg;
 312     char *pass = app_malloc(PWD_STRLEN + 1, "SRP password buffer");
 313     PW_CB_DATA cb_tmp;
 314     int l;
 315
 316     cb_tmp.password = (char *)srp_arg->srppassin;
 317     cb_tmp.prompt_info = "SRP user";
 318     if ((l = password_callback(pass, PWD_STRLEN, 0, &cb_tmp)) < 0) {
 319         BIO_printf(bio_err, "Can't read Password\n");
 320         OPENSSL_free(pass);
 321         return NULL;
 322     }
 323     *(pass + l) = '\0';
 324
 325     return pass;
 326 }
 327
 328 #endif
 329
 330 static char *srtp_profiles = NULL;
 331
 332 #ifndef OPENSSL_NO_NEXTPROTONEG
 333 /* This the context that we pass to next_proto_cb */
 334 typedef struct tlsextnextprotoctx_st {
 335     unsigned char *data;
 336     size_t len;
 337     int status;
 338 } tlsextnextprotoctx;
 339
 340 static tlsextnextprotoctx next_proto;
 341
 342 static int next_proto_cb(SSL *s, unsigned char **out, unsigned char *outlen,
 343                          const unsigned char *in, unsigned int inlen,
 344                          void *arg)
 345 {
 346     tlsextnextprotoctx *ctx = arg;
 347
 348     if (!c_quiet) {
 349         /* We can assume that |in| is syntactically valid. */
 350         unsigned i;
 351         BIO_printf(bio_c_out, "Protocols advertised by server: ");
 352         for (i = 0; i < inlen;) {
 353             if (i)
 354                 BIO_write(bio_c_out, ", ", 2);
 355             BIO_write(bio_c_out, &in[i + 1], in[i]);
 356             i += in[i] + 1;
 357         }
 358         BIO_write(bio_c_out, "\n", 1);
 359     }
 360
 361     ctx->status =
 362         SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len);
 363     return SSL_TLSEXT_ERR_OK;
 364 }
 365 #endif                         /* ndef OPENSSL_NO_NEXTPROTONEG */
 366
 367 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
 368                                    const unsigned char *in, size_t inlen,
 369                                    int *al, void *arg)
 370 {
 371     char pem_name[100];
 372     unsigned char ext_buf[4 + 65536];
 373
 374     /* Reconstruct the type/len fields prior to extension data */
 375     ext_buf[0] = ext_type >> 8;
 376     ext_buf[1] = ext_type & 0xFF;
 377     ext_buf[2] = inlen >> 8;
 378     ext_buf[3] = inlen & 0xFF;
 379     memcpy(ext_buf + 4, in, inlen);
 380
 381     BIO_snprintf(pem_name, sizeof(pem_name), "SERVERINFO FOR EXTENSION %d",
 382                  ext_type);
 383     PEM_write_bio(bio_c_out, pem_name, "", ext_buf, 4 + inlen);
 384     return 1;
 385 }
 386
 387 /*
 388  * Hex decoder that tolerates optional whitespace.  Returns number of bytes
 389  * produced, advances inptr to end of input string.
 390  */
 391 static ossl_ssize_t hexdecode(const char **inptr, void *result)
 392 {
 393     unsigned char **out = (unsigned char **)result;
 394     const char *in = *inptr;
 395     unsigned char *ret = app_malloc(strlen(in) / 2, "hexdecode");
 396     unsigned char *cp = ret;
 397     uint8_t byte;
 398     int nibble = 0;
 399
 400     if (ret == NULL)
 401         return -1;
 402
 403     for (byte = 0; *in; ++in) {
 404         int x;
 405
 406         if (isspace(_UC(*in)))
 407             continue;
 408         x = OPENSSL_hexchar2int(*in);
 409         if (x < 0) {
 410             OPENSSL_free(ret);
 411             return 0;
 412         }
 413         byte |= (char)x;
 414         if ((nibble ^= 1) == 0) {
 415             *cp++ = byte;
 416             byte = 0;
 417         } else {
 418             byte <<= 4;
 419         }
 420     }
 421     if (nibble != 0) {
 422         OPENSSL_free(ret);
 423         return 0;
 424     }
 425     *inptr = in;
 426
 427     return cp - (*out = ret);
 428 }
 429
 430 /*
 431  * Decode unsigned 0..255, returns 1 on success, <= 0 on failure. Advances
 432  * inptr to next field skipping leading whitespace.
 433  */
 434 static ossl_ssize_t checked_uint8(const char **inptr, void *out)
 435 {
 436     uint8_t *result = (uint8_t *)out;
 437     const char *in = *inptr;
 438     char *endp;
 439     long v;
 440     int e;
 441
 442     save_errno();
 443     v = strtol(in, &endp, 10);
 444     e = restore_errno();
 445
 446     if (((v == LONG_MIN || v == LONG_MAX) && e == ERANGE) ||
 447         endp == in || !isspace(_UC(*endp)) ||
 448         v != (*result = (uint8_t) v)) {
 449         return -1;
 450     }
 451     for (in = endp; isspace(_UC(*in)); ++in)
 452         continue;
 453
 454     *inptr = in;
 455     return 1;
 456 }
 457
 458 struct tlsa_field {
 459     void *var;
 460     const char *name;
 461     ossl_ssize_t (*parser)(const char **, void *);
 462 };
 463
 464 static int tlsa_import_rr(SSL *con, const char *rrdata)
 465 {
 466     /* Not necessary to re-init these values; the "parsers" do that. */
 467     static uint8_t usage;
 468     static uint8_t selector;
 469     static uint8_t mtype;
 470     static unsigned char *data;
 471     static struct tlsa_field tlsa_fields[] = {
 472         { &usage, "usage", checked_uint8 },
 473         { &selector, "selector", checked_uint8 },
 474         { &mtype, "mtype", checked_uint8 },
 475         { &data, "data", hexdecode },
 476         { NULL, }
 477     };
 478     struct tlsa_field *f;
 479     int ret;
 480     const char *cp = rrdata;
 481     ossl_ssize_t len = 0;
 482
 483     for (f = tlsa_fields; f->var; ++f) {
 484         /* Returns number of bytes produced, advances cp to next field */
 485         if ((len = f->parser(&cp, f->var)) <= 0) {
 486             BIO_printf(bio_err, "%s: warning: bad TLSA %s field in: %s\n",
 487                        prog, f->name, rrdata);
 488             return 0;
 489         }
 490     }
 491     /* The data field is last, so len is its length */
 492     ret = SSL_dane_tlsa_add(con, usage, selector, mtype, data, len);
 493     OPENSSL_free(data);
 494
 495     if (ret == 0) {
 496         ERR_print_errors(bio_err);
 497         BIO_printf(bio_err, "%s: warning: unusable TLSA rrdata: %s\n",
 498                    prog, rrdata);
 499         return 0;
 500     }
 501     if (ret < 0) {
 502         ERR_print_errors(bio_err);
 503         BIO_printf(bio_err, "%s: warning: error loading TLSA rrdata: %s\n",
 504                    prog, rrdata);
 505         return 0;
 506     }
 507     return ret;
 508 }
 509
 510 static int tlsa_import_rrset(SSL *con, STACK_OF(OPENSSL_STRING) *rrset)
 511 {
 512     int num = sk_OPENSSL_STRING_num(rrset);
 513     int count = 0;
 514     int i;
 515
 516     for (i = 0; i < num; ++i) {
 517         char *rrdata = sk_OPENSSL_STRING_value(rrset, i);
 518         if (tlsa_import_rr(con, rrdata) > 0)
 519             ++count;
 520     }
 521     return count > 0;
 522 }
 523
 524 typedef enum OPTION_choice {
 525     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
 526     OPT_4, OPT_6, OPT_HOST, OPT_PORT, OPT_CONNECT, OPT_UNIX,
 527     OPT_XMPPHOST, OPT_VERIFY,
 528     OPT_CERT, OPT_CRL, OPT_CRL_DOWNLOAD, OPT_SESS_OUT, OPT_SESS_IN,
 529     OPT_CERTFORM, OPT_CRLFORM, OPT_VERIFY_RET_ERROR, OPT_VERIFY_QUIET,
 530     OPT_BRIEF, OPT_PREXIT, OPT_CRLF, OPT_QUIET, OPT_NBIO,
 531     OPT_SSL_CLIENT_ENGINE, OPT_RAND, OPT_IGN_EOF, OPT_NO_IGN_EOF,
 532     OPT_DEBUG, OPT_TLSEXTDEBUG, OPT_STATUS, OPT_WDEBUG,
 533     OPT_MSG, OPT_MSGFILE, OPT_ENGINE, OPT_TRACE, OPT_SECURITY_DEBUG,
 534     OPT_SECURITY_DEBUG_VERBOSE, OPT_SHOWCERTS, OPT_NBIO_TEST, OPT_STATE,
 535 #ifndef OPENSSL_NO_PSK
 536     OPT_PSK_IDENTITY, OPT_PSK,
 537 #endif
 538 #ifndef OPENSSL_NO_SRP
 539     OPT_SRPUSER, OPT_SRPPASS, OPT_SRP_STRENGTH, OPT_SRP_LATEUSER,
 540     OPT_SRP_MOREGROUPS,
 541 #endif
 542     OPT_SSL3, OPT_SSL_CONFIG,
 543     OPT_TLS1_3, OPT_TLS1_2, OPT_TLS1_1, OPT_TLS1, OPT_DTLS, OPT_DTLS1,
 544     OPT_DTLS1_2, OPT_TIMEOUT, OPT_MTU, OPT_KEYFORM, OPT_PASS,
 545     OPT_CERT_CHAIN, OPT_CAPATH, OPT_NOCAPATH, OPT_CHAINCAPATH,
 546         OPT_VERIFYCAPATH,
 547     OPT_KEY, OPT_RECONNECT, OPT_BUILD_CHAIN, OPT_CAFILE, OPT_NOCAFILE,
 548     OPT_CHAINCAFILE, OPT_VERIFYCAFILE, OPT_NEXTPROTONEG, OPT_ALPN,
 549     OPT_SERVERINFO, OPT_STARTTLS, OPT_SERVERNAME,
 550     OPT_USE_SRTP, OPT_KEYMATEXPORT, OPT_KEYMATEXPORTLEN, OPT_SMTPHOST,
 551     OPT_ASYNC, OPT_SPLIT_SEND_FRAG, OPT_MAX_PIPELINES, OPT_READ_BUF,
 552     OPT_V_ENUM,
 553     OPT_X_ENUM,
 554     OPT_S_ENUM,
 555     OPT_FALLBACKSCSV, OPT_NOCMDS, OPT_PROXY, OPT_DANE_TLSA_DOMAIN,
 556 #ifndef OPENSSL_NO_CT
 557     OPT_CT, OPT_NOCT, OPT_CTLOG_FILE,
 558 #endif
 559     OPT_DANE_TLSA_RRDATA, OPT_DANE_EE_NO_NAME
 560 } OPTION_CHOICE;
 561
 562 const OPTIONS s_client_options[] = {
 563     {"help", OPT_HELP, '-', "Display this summary"},
 564     {"host", OPT_HOST, 's', "Use -connect instead"},
 565     {"port", OPT_PORT, 'p', "Use -connect instead"},
 566     {"connect", OPT_CONNECT, 's',
 567      "TCP/IP where to connect (default is :" PORT ")"},
 568     {"proxy", OPT_PROXY, 's',
 569      "Connect to via specified proxy to the real server"},
 570 #ifdef AF_UNIX
 571     {"unix", OPT_UNIX, 's', "Connect over the specified Unix-domain socket"},
 572 #endif
 573     {"4", OPT_4, '-', "Use IPv4 only"},
 574 #ifdef AF_INET6
 575     {"6", OPT_6, '-', "Use IPv6 only"},
 576 #endif
 577     {"verify", OPT_VERIFY, 'p', "Turn on peer certificate verification"},
 578     {"cert", OPT_CERT, '<', "Certificate file to use, PEM format assumed"},
 579     {"certform", OPT_CERTFORM, 'F',
 580      "Certificate format (PEM or DER) PEM default"},
 581     {"key", OPT_KEY, 's', "Private key file to use, if not in -cert file"},
 582     {"keyform", OPT_KEYFORM, 'E', "Key format (PEM, DER or engine) PEM default"},
 583     {"pass", OPT_PASS, 's', "Private key file pass phrase source"},
 584     {"CApath", OPT_CAPATH, '/', "PEM format directory of CA's"},
 585     {"CAfile", OPT_CAFILE, '<', "PEM format file of CA's"},
 586     {"no-CAfile", OPT_NOCAFILE, '-',
 587      "Do not load the default certificates file"},
 588     {"no-CApath", OPT_NOCAPATH, '-',
 589      "Do not load certificates from the default certificates directory"},
 590     {"dane_tlsa_domain", OPT_DANE_TLSA_DOMAIN, 's', "DANE TLSA base domain"},
 591     {"dane_tlsa_rrdata", OPT_DANE_TLSA_RRDATA, 's',
 592      "DANE TLSA rrdata presentation form"},
 593     {"dane_ee_no_namechecks", OPT_DANE_EE_NO_NAME, '-',
 594      "Disable name checks when matching DANE-EE(3) TLSA records"},
 595     {"reconnect", OPT_RECONNECT, '-',
 596      "Drop and re-make the connection with the same Session-ID"},
 597     {"showcerts", OPT_SHOWCERTS, '-', "Show all certificates in the chain"},
 598     {"debug", OPT_DEBUG, '-', "Extra output"},
 599     {"msg", OPT_MSG, '-', "Show protocol messages"},
 600     {"msgfile", OPT_MSGFILE, '>',
 601      "File to send output of -msg or -trace, instead of stdout"},
 602     {"nbio_test", OPT_NBIO_TEST, '-', "More ssl protocol testing"},
 603     {"state", OPT_STATE, '-', "Print the ssl states"},
 604     {"crlf", OPT_CRLF, '-', "Convert LF from terminal into CRLF"},
 605     {"quiet", OPT_QUIET, '-', "No s_client output"},
 606     {"ign_eof", OPT_IGN_EOF, '-', "Ignore input eof (default when -quiet)"},
 607     {"no_ign_eof", OPT_NO_IGN_EOF, '-', "Don't ignore input eof"},
 608     {"starttls", OPT_STARTTLS, 's',
 609      "Use the appropriate STARTTLS command before starting TLS"},
 610     {"xmpphost", OPT_XMPPHOST, 's',
 611      "Host to use with \"-starttls xmpp[-server]\""},
 612     {"rand", OPT_RAND, 's',
 613      "Load the file(s) into the random number generator"},
 614     {"sess_out", OPT_SESS_OUT, '>', "File to write SSL session to"},
 615     {"sess_in", OPT_SESS_IN, '<', "File to read SSL session from"},
 616     {"use_srtp", OPT_USE_SRTP, 's',
 617      "Offer SRTP key management with a colon-separated profile list"},
 618     {"keymatexport", OPT_KEYMATEXPORT, 's',
 619      "Export keying material using label"},
 620     {"keymatexportlen", OPT_KEYMATEXPORTLEN, 'p',
 621      "Export len bytes of keying material (default 20)"},
 622     {"fallback_scsv", OPT_FALLBACKSCSV, '-', "Send the fallback SCSV"},
 623     {"name", OPT_SMTPHOST, 's',
 624      "Hostname to use for \"-starttls lmtp\" or \"-starttls smtp\""},
 625     {"CRL", OPT_CRL, '<', "CRL file to use"},
 626     {"crl_download", OPT_CRL_DOWNLOAD, '-', "Download CRL from distribution points"},
 627     {"CRLform", OPT_CRLFORM, 'F', "CRL format (PEM or DER) PEM is default"},
 628     {"verify_return_error", OPT_VERIFY_RET_ERROR, '-',
 629      "Close connection on verification error"},
 630     {"verify_quiet", OPT_VERIFY_QUIET, '-', "Restrict verify output to errors"},
 631     {"brief", OPT_BRIEF, '-',
 632      "Restrict output to brief summary of connection parameters"},
 633     {"prexit", OPT_PREXIT, '-',
 634      "Print session information when the program exits"},
 635     {"security_debug", OPT_SECURITY_DEBUG, '-',
 636      "Enable security debug messages"},
 637     {"security_debug_verbose", OPT_SECURITY_DEBUG_VERBOSE, '-',
 638      "Output more security debug output"},
 639     {"cert_chain", OPT_CERT_CHAIN, '<',
 640      "Certificate chain file (in PEM format)"},
 641     {"chainCApath", OPT_CHAINCAPATH, '/',
 642      "Use dir as certificate store path to build CA certificate chain"},
 643     {"verifyCApath", OPT_VERIFYCAPATH, '/',
 644      "Use dir as certificate store path to verify CA certificate"},
 645     {"build_chain", OPT_BUILD_CHAIN, '-', "Build certificate chain"},
 646     {"chainCAfile", OPT_CHAINCAFILE, '<',
 647      "CA file for certificate chain (PEM format)"},
 648     {"verifyCAfile", OPT_VERIFYCAFILE, '<',
 649      "CA file for certificate verification (PEM format)"},
 650     {"nocommands", OPT_NOCMDS, '-', "Do not use interactive command letters"},
 651     {"servername", OPT_SERVERNAME, 's',
 652      "Set TLS extension servername in ClientHello"},
 653     {"tlsextdebug", OPT_TLSEXTDEBUG, '-',
 654      "Hex dump of all TLS extensions received"},
 655 #ifndef OPENSSL_NO_OCSP
 656     {"status", OPT_STATUS, '-', "Request certificate status from server"},
 657 #endif
 658     {"serverinfo", OPT_SERVERINFO, 's',
 659      "types  Send empty ClientHello extensions (comma-separated numbers)"},
 660     {"alpn", OPT_ALPN, 's',
 661      "Enable ALPN extension, considering named protocols supported (comma-separated list)"},
 662     {"async", OPT_ASYNC, '-', "Support asynchronous operation"},
 663     {"ssl_config", OPT_SSL_CONFIG, 's', "Use specified configuration file"},
 664     {"split_send_frag", OPT_SPLIT_SEND_FRAG, 'n',
 665      "Size used to split data for encrypt pipelines"},
 666     {"max_pipelines", OPT_MAX_PIPELINES, 'n',
 667      "Maximum number of encrypt/decrypt pipelines to be used"},
 668     {"read_buf", OPT_READ_BUF, 'n',
 669      "Default read buffer size to be used for connections"},
 670     OPT_S_OPTIONS,
 671     OPT_V_OPTIONS,
 672     OPT_X_OPTIONS,
 673 #ifndef OPENSSL_NO_SSL3
 674     {"ssl3", OPT_SSL3, '-', "Just use SSLv3"},
 675 #endif
 676 #ifndef OPENSSL_NO_TLS1
 677     {"tls1", OPT_TLS1, '-', "Just use TLSv1"},
 678 #endif
 679 #ifndef OPENSSL_NO_TLS1_1
 680     {"tls1_1", OPT_TLS1_1, '-', "Just use TLSv1.1"},
 681 #endif
 682 #ifndef OPENSSL_NO_TLS1_2
 683     {"tls1_2", OPT_TLS1_2, '-', "Just use TLSv1.2"},
 684 #endif
 685 #ifndef OPENSSL_NO_TLS1_3
 686     {"tls1_3", OPT_TLS1_3, '-', "Just use TLSv1.3"},
 687 #endif
 688 #ifndef OPENSSL_NO_DTLS
 689     {"dtls", OPT_DTLS, '-', "Use any version of DTLS"},
 690     {"timeout", OPT_TIMEOUT, '-',
 691      "Enable send/receive timeout on DTLS connections"},
 692     {"mtu", OPT_MTU, 'p', "Set the link layer MTU"},
 693 #endif
 694 #ifndef OPENSSL_NO_DTLS1
 695     {"dtls1", OPT_DTLS1, '-', "Just use DTLSv1"},
 696 #endif
 697 #ifndef OPENSSL_NO_DTLS1_2
 698     {"dtls1_2", OPT_DTLS1_2, '-', "Just use DTLSv1.2"},
 699 #endif
 700 #ifndef OPENSSL_NO_SSL_TRACE
 701     {"trace", OPT_TRACE, '-', "Show trace output of protocol messages"},
 702 #endif
 703 #ifdef WATT32
 704     {"wdebug", OPT_WDEBUG, '-', "WATT-32 tcp debugging"},
 705 #endif
 706     {"nbio", OPT_NBIO, '-', "Use non-blocking IO"},
 707 #ifndef OPENSSL_NO_PSK
 708     {"psk_identity", OPT_PSK_IDENTITY, 's', "PSK identity"},
 709     {"psk", OPT_PSK, 's', "PSK in hex (without 0x)"},
 710 #endif
 711 #ifndef OPENSSL_NO_SRP
 712     {"srpuser", OPT_SRPUSER, 's', "SRP authentication for 'user'"},
 713     {"srppass", OPT_SRPPASS, 's', "Password for 'user'"},
 714     {"srp_lateuser", OPT_SRP_LATEUSER, '-',
 715      "SRP username into second ClientHello message"},
 716     {"srp_moregroups", OPT_SRP_MOREGROUPS, '-',
 717      "Tolerate other than the known g N values."},
 718     {"srp_strength", OPT_SRP_STRENGTH, 'p', "Minimal length in bits for N"},
 719 #endif
 720 #ifndef OPENSSL_NO_NEXTPROTONEG
 721     {"nextprotoneg", OPT_NEXTPROTONEG, 's',
 722      "Enable NPN extension, considering named protocols supported (comma-separated list)"},
 723 #endif
 724 #ifndef OPENSSL_NO_ENGINE
 725     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
 726     {"ssl_client_engine", OPT_SSL_CLIENT_ENGINE, 's',
 727      "Specify engine to be used for client certificate operations"},
 728 #endif
 729 #ifndef OPENSSL_NO_CT
 730     {"ct", OPT_CT, '-', "Request and parse SCTs (also enables OCSP stapling)"},
 731     {"noct", OPT_NOCT, '-', "Do not request or parse SCTs (default)"},
 732     {"ctlogfile", OPT_CTLOG_FILE, '<', "CT log list CONF file"},
 733 #endif
 734     {NULL, OPT_EOF, 0x00, NULL}
 735 };
 736
 737 typedef enum PROTOCOL_choice {
 738     PROTO_OFF,
 739     PROTO_SMTP,
 740     PROTO_POP3,
 741     PROTO_IMAP,
 742     PROTO_FTP,
 743     PROTO_TELNET,
 744     PROTO_XMPP,
 745     PROTO_XMPP_SERVER,
 746     PROTO_CONNECT,
 747     PROTO_IRC,
 748     PROTO_POSTGRES,
 749     PROTO_LMTP
 750 } PROTOCOL_CHOICE;
 751
 752 static const OPT_PAIR services[] = {
 753     {"smtp", PROTO_SMTP},
 754     {"pop3", PROTO_POP3},
 755     {"imap", PROTO_IMAP},
 756     {"ftp", PROTO_FTP},
 757     {"xmpp", PROTO_XMPP},
 758     {"xmpp-server", PROTO_XMPP_SERVER},
 759     {"telnet", PROTO_TELNET},
 760     {"irc", PROTO_IRC},
 761     {"postgres", PROTO_POSTGRES},
 762     {"lmtp", PROTO_LMTP},
 763     {NULL, 0}
 764 };
 765
 766 #define IS_INET_FLAG(o) \
 767  (o == OPT_4 || o == OPT_6 || o == OPT_HOST || o == OPT_PORT || o == OPT_CONNECT)
 768 #define IS_UNIX_FLAG(o) (o == OPT_UNIX)
 769
 770 #define IS_PROT_FLAG(o) \
 771  (o == OPT_SSL3 || o == OPT_TLS1 || o == OPT_TLS1_1 || o == OPT_TLS1_2 \
 772   || o == OPT_TLS1_3 || o == OPT_DTLS || o == OPT_DTLS1 || o == OPT_DTLS1_2)
 773
 774 /* Free |*dest| and optionally set it to a copy of |source|. */
 775 static void freeandcopy(char **dest, const char *source)
 776 {
 777     OPENSSL_free(*dest);
 778     *dest = NULL;
 779     if (source != NULL)
 780         *dest = OPENSSL_strdup(source);
 781 }
 782
 783 static int new_session_cb(SSL *S, SSL_SESSION *sess)
 784 {
 785     BIO *stmp = BIO_new_file(sess_out, "w");
 786
 787     if (stmp != NULL) {
 788         PEM_write_bio_SSL_SESSION(stmp, sess);
 789         BIO_free(stmp);
 790     } else {
 791         BIO_printf(bio_err, "Error writing session file %s\n", sess_out);
 792     }
 793
 794     /*
 795      * We always return a "fail" response so that the session gets freed again
 796      * because we haven't used the reference.
 797      */
 798     return 0;
 799 }
 800
 801 int s_client_main(int argc, char **argv)
 802 {
 803     BIO *sbio;
 804     EVP_PKEY *key = NULL;
 805     SSL *con = NULL;
 806     SSL_CTX *ctx = NULL;
 807     STACK_OF(X509) *chain = NULL;
 808     X509 *cert = NULL;
 809     X509_VERIFY_PARAM *vpm = NULL;
 810     SSL_EXCERT *exc = NULL;
 811     SSL_CONF_CTX *cctx = NULL;
 812     STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
 813     char *dane_tlsa_domain = NULL;
 814     STACK_OF(OPENSSL_STRING) *dane_tlsa_rrset = NULL;
 815     int dane_ee_no_name = 0;
 816     STACK_OF(X509_CRL) *crls = NULL;
 817     const SSL_METHOD *meth = TLS_client_method();
 818     const char *CApath = NULL, *CAfile = NULL;
 819     char *cbuf = NULL, *sbuf = NULL;
 820     char *mbuf = NULL, *proxystr = NULL, *connectstr = NULL;
 821     char *cert_file = NULL, *key_file = NULL, *chain_file = NULL;
 822     char *chCApath = NULL, *chCAfile = NULL, *host = NULL;
 823     char *port = OPENSSL_strdup(PORT);
 824     char *inrand = NULL;
 825     char *passarg = NULL, *pass = NULL, *vfyCApath = NULL, *vfyCAfile = NULL;
 826     char *sess_in = NULL, *crl_file = NULL, *p;
 827     char *xmpphost = NULL;
 828     const char *ehlo = "mail.example.com";
 829     struct timeval timeout, *timeoutp;
 830     fd_set readfds, writefds;
 831     int noCApath = 0, noCAfile = 0;
 832     int build_chain = 0, cbuf_len, cbuf_off, cert_format = FORMAT_PEM;
 833     int key_format = FORMAT_PEM, crlf = 0, full_log = 1, mbuf_len = 0;
 834     int prexit = 0;
 835     int sdebug = 0;
 836     int reconnect = 0, verify = SSL_VERIFY_NONE, vpmtouched = 0;
 837     int ret = 1, in_init = 1, i, nbio_test = 0, s = -1, k, width, state = 0;
 838     int sbuf_len, sbuf_off, cmdletters = 1;
 839     int socket_family = AF_UNSPEC, socket_type = SOCK_STREAM;
 840     int starttls_proto = PROTO_OFF, crl_format = FORMAT_PEM, crl_download = 0;
 841     int write_tty, read_tty, write_ssl, read_ssl, tty_on, ssl_pending;
 842 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS)
 843     int at_eof = 0;
 844 #endif
 845     int read_buf_len = 0;
 846     int fallback_scsv = 0;
 847     long randamt = 0;
 848     OPTION_CHOICE o;
 849 #ifndef OPENSSL_NO_DTLS
 850     int enable_timeouts = 0;
 851     long socket_mtu = 0;
 852 #endif
 853 #ifndef OPENSSL_NO_ENGINE
 854     ENGINE *ssl_client_engine = NULL;
 855 #endif
 856     ENGINE *e = NULL;
 857 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
 858     struct timeval tv;
 859 #endif
 860     char *servername = NULL;
 861     const char *alpn_in = NULL;
 862     tlsextctx tlsextcbp = { NULL, 0 };
 863     const char *ssl_config = NULL;
 864 #define MAX_SI_TYPES 100
 865     unsigned short serverinfo_types[MAX_SI_TYPES];
 866     int serverinfo_count = 0, start = 0, len;
 867 #ifndef OPENSSL_NO_NEXTPROTONEG
 868     const char *next_proto_neg_in = NULL;
 869 #endif
 870 #ifndef OPENSSL_NO_SRP
 871     char *srppass = NULL;
 872     int srp_lateuser = 0;
 873     SRP_ARG srp_arg = { NULL, NULL, 0, 0, 0, 1024 };
 874 #endif
 875 #ifndef OPENSSL_NO_CT
 876     char *ctlog_file = NULL;
 877     int ct_validation = 0;
 878 #endif
 879     int min_version = 0, max_version = 0, prot_opt = 0, no_prot_opt = 0;
 880     int async = 0;
 881     unsigned int split_send_fragment = 0;
 882     unsigned int max_pipelines = 0;
 883     enum { use_inet, use_unix, use_unknown } connect_type = use_unknown;
 884     int count4or6 = 0;
 885     int c_nbio = 0, c_msg = 0, c_ign_eof = 0, c_brief = 0;
 886     int c_tlsextdebug = 0;
 887 #ifndef OPENSSL_NO_OCSP
 888     int c_status_req = 0;
 889 #endif
 890     BIO *bio_c_msg = NULL;
 891
 892     FD_ZERO(&readfds);
 893     FD_ZERO(&writefds);
 894 /* Known false-positive of MemorySanitizer. */
 895 #if defined(__has_feature)
 896 # if __has_feature(memory_sanitizer)
 897     __msan_unpoison(&readfds, sizeof(readfds));
 898     __msan_unpoison(&writefds, sizeof(writefds));
 899 # endif
 900 #endif
 901
 902     prog = opt_progname(argv[0]);
 903     c_quiet = 0;
 904     c_debug = 0;
 905     c_showcerts = 0;
 906     c_nbio = 0;
 907     vpm = X509_VERIFY_PARAM_new();
 908     cctx = SSL_CONF_CTX_new();
 909
 910     if (vpm == NULL || cctx == NULL) {
 911         BIO_printf(bio_err, "%s: out of memory\n", prog);
 912         goto end;
 913     }
 914
 915     cbuf = app_malloc(BUFSIZZ, "cbuf");
 916     sbuf = app_malloc(BUFSIZZ, "sbuf");
 917     mbuf = app_malloc(BUFSIZZ, "mbuf");
 918
 919     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT | SSL_CONF_FLAG_CMDLINE);
 920
 921     prog = opt_init(argc, argv, s_client_options);
 922     while ((o = opt_next()) != OPT_EOF) {
 923         /* Check for intermixing flags. */
 924         if (connect_type == use_unix && IS_INET_FLAG(o)) {
 925             BIO_printf(bio_err,
 926                        "%s: Intermixed protocol flags (unix and internet domains)\n",
 927                        prog);
 928             goto end;
 929         }
 930         if (connect_type == use_inet && IS_UNIX_FLAG(o)) {
 931             BIO_printf(bio_err,
 932                        "%s: Intermixed protocol flags (internet and unix domains)\n",
 933                        prog);
 934             goto end;
 935         }
 936
 937         if (IS_PROT_FLAG(o) && ++prot_opt > 1) {
 938             BIO_printf(bio_err, "Cannot supply multiple protocol flags\n");
 939             goto end;
 940         }
 941         if (IS_NO_PROT_FLAG(o))
 942             no_prot_opt++;
 943         if (prot_opt == 1 && no_prot_opt) {
 944             BIO_printf(bio_err,
 945                        "Cannot supply both a protocol flag and '-no_<prot>'\n");
 946             goto end;
 947         }
 948
 949         switch (o) {
 950         case OPT_EOF:
 951         case OPT_ERR:
 952  opthelp:
 953             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 954             goto end;
 955         case OPT_HELP:
 956             opt_help(s_client_options);
 957             ret = 0;
 958             goto end;
 959         case OPT_4:
 960             connect_type = use_inet;
 961             socket_family = AF_INET;
 962             count4or6++;
 963             break;
 964 #ifdef AF_INET6
 965         case OPT_6:
 966             connect_type = use_inet;
 967             socket_family = AF_INET6;
 968             count4or6++;
 969             break;
 970 #endif
 971         case OPT_HOST:
 972             connect_type = use_inet;
 973             freeandcopy(&host, opt_arg());
 974             break;
 975         case OPT_PORT:
 976             connect_type = use_inet;
 977             freeandcopy(&port, opt_arg());
 978             break;
 979         case OPT_CONNECT:
 980             connect_type = use_inet;
 981             freeandcopy(&connectstr, opt_arg());
 982             break;
 983         case OPT_PROXY:
 984             proxystr = opt_arg();
 985             starttls_proto = PROTO_CONNECT;
 986             break;
 987 #ifdef AF_UNIX
 988         case OPT_UNIX:
 989             connect_type = use_unix;
 990             socket_family = AF_UNIX;
 991             freeandcopy(&host, opt_arg());
 992             break;
 993 #endif
 994         case OPT_XMPPHOST:
 995             xmpphost = opt_arg();
 996             break;
 997         case OPT_SMTPHOST:
 998             ehlo = opt_arg();
 999             break;
1000         case OPT_VERIFY:
1001             verify = SSL_VERIFY_PEER;
1002             verify_args.depth = atoi(opt_arg());
1003             if (!c_quiet)
1004                 BIO_printf(bio_err, "verify depth is %d\n", verify_args.depth);
1005             break;
1006         case OPT_CERT:
1007             cert_file = opt_arg();
1008             break;
1009         case OPT_CRL:
1010             crl_file = opt_arg();
1011             break;
1012         case OPT_CRL_DOWNLOAD:
1013             crl_download = 1;
1014             break;
1015         case OPT_SESS_OUT:
1016             sess_out = opt_arg();
1017             break;
1018         case OPT_SESS_IN:
1019             sess_in = opt_arg();
1020             break;
1021         case OPT_CERTFORM:
1022             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &cert_format))
1023                 goto opthelp;
1024             break;
1025         case OPT_CRLFORM:
1026             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &crl_format))
1027                 goto opthelp;
1028             break;
1029         case OPT_VERIFY_RET_ERROR:
1030             verify_args.return_error = 1;
1031             break;
1032         case OPT_VERIFY_QUIET:
1033             verify_args.quiet = 1;
1034             break;
1035         case OPT_BRIEF:
1036             c_brief = verify_args.quiet = c_quiet = 1;
1037             break;
1038         case OPT_S_CASES:
1039             if (ssl_args == NULL)
1040                 ssl_args = sk_OPENSSL_STRING_new_null();
1041             if (ssl_args == NULL
1042                 || !sk_OPENSSL_STRING_push(ssl_args, opt_flag())
1043                 || !sk_OPENSSL_STRING_push(ssl_args, opt_arg())) {
1044                 BIO_printf(bio_err, "%s: Memory allocation failure\n", prog);
1045                 goto end;
1046             }
1047             break;
1048         case OPT_V_CASES:
1049             if (!opt_verify(o, vpm))
1050                 goto end;
1051             vpmtouched++;
1052             break;
1053         case OPT_X_CASES:
1054             if (!args_excert(o, &exc))
1055                 goto end;
1056             break;
1057         case OPT_PREXIT:
1058             prexit = 1;
1059             break;
1060         case OPT_CRLF:
1061             crlf = 1;
1062             break;
1063         case OPT_QUIET:
1064             c_quiet = c_ign_eof = 1;
1065             break;
1066         case OPT_NBIO:
1067             c_nbio = 1;
1068             break;
1069         case OPT_NOCMDS:
1070             cmdletters = 0;
1071             break;
1072         case OPT_ENGINE:
1073             e = setup_engine(opt_arg(), 1);
1074             break;
1075         case OPT_SSL_CLIENT_ENGINE:
1076 #ifndef OPENSSL_NO_ENGINE
1077             ssl_client_engine = ENGINE_by_id(opt_arg());
1078             if (ssl_client_engine == NULL) {
1079                 BIO_printf(bio_err, "Error getting client auth engine\n");
1080                 goto opthelp;
1081             }
1082 #endif
1083             break;
1084         case OPT_RAND:
1085             inrand = opt_arg();
1086             break;
1087         case OPT_IGN_EOF:
1088             c_ign_eof = 1;
1089             break;
1090         case OPT_NO_IGN_EOF:
1091             c_ign_eof = 0;
1092             break;
1093         case OPT_DEBUG:
1094             c_debug = 1;
1095             break;
1096         case OPT_TLSEXTDEBUG:
1097             c_tlsextdebug = 1;
1098             break;
1099         case OPT_STATUS:
1100 #ifndef OPENSSL_NO_OCSP
1101             c_status_req = 1;
1102 #endif
1103             break;
1104         case OPT_WDEBUG:
1105 #ifdef WATT32
1106             dbug_init();
1107 #endif
1108             break;
1109         case OPT_MSG:
1110             c_msg = 1;
1111             break;
1112         case OPT_MSGFILE:
1113             bio_c_msg = BIO_new_file(opt_arg(), "w");
1114             break;
1115         case OPT_TRACE:
1116 #ifndef OPENSSL_NO_SSL_TRACE
1117             c_msg = 2;
1118 #endif
1119             break;
1120         case OPT_SECURITY_DEBUG:
1121             sdebug = 1;
1122             break;
1123         case OPT_SECURITY_DEBUG_VERBOSE:
1124             sdebug = 2;
1125             break;
1126         case OPT_SHOWCERTS:
1127             c_showcerts = 1;
1128             break;
1129         case OPT_NBIO_TEST:
1130             nbio_test = 1;
1131             break;
1132         case OPT_STATE:
1133             state = 1;
1134             break;
1135 #ifndef OPENSSL_NO_PSK
1136         case OPT_PSK_IDENTITY:
1137             psk_identity = opt_arg();
1138             break;
1139         case OPT_PSK:
1140             for (p = psk_key = opt_arg(); *p; p++) {
1141                 if (isxdigit(_UC(*p)))
1142                     continue;
1143                 BIO_printf(bio_err, "Not a hex number '%s'\n", psk_key);
1144                 goto end;
1145             }
1146             break;
1147 #endif
1148 #ifndef OPENSSL_NO_SRP
1149         case OPT_SRPUSER:
1150             srp_arg.srplogin = opt_arg();
1151             if (min_version < TLS1_VERSION)
1152                 min_version = TLS1_VERSION;
1153             break;
1154         case OPT_SRPPASS:
1155             srppass = opt_arg();
1156             if (min_version < TLS1_VERSION)
1157                 min_version = TLS1_VERSION;
1158             break;
1159         case OPT_SRP_STRENGTH:
1160             srp_arg.strength = atoi(opt_arg());
1161             BIO_printf(bio_err, "SRP minimal length for N is %d\n",
1162                        srp_arg.strength);
1163             if (min_version < TLS1_VERSION)
1164                 min_version = TLS1_VERSION;
1165             break;
1166         case OPT_SRP_LATEUSER:
1167             srp_lateuser = 1;
1168             if (min_version < TLS1_VERSION)
1169                 min_version = TLS1_VERSION;
1170             break;
1171         case OPT_SRP_MOREGROUPS:
1172             srp_arg.amp = 1;
1173             if (min_version < TLS1_VERSION)
1174                 min_version = TLS1_VERSION;
1175             break;
1176 #endif
1177         case OPT_SSL_CONFIG:
1178             ssl_config = opt_arg();
1179             break;
1180         case OPT_SSL3:
1181             min_version = SSL3_VERSION;
1182             max_version = SSL3_VERSION;
1183             break;
1184         case OPT_TLS1_3:
1185             min_version = TLS1_3_VERSION;
1186             max_version = TLS1_3_VERSION;
1187             break;
1188         case OPT_TLS1_2:
1189             min_version = TLS1_2_VERSION;
1190             max_version = TLS1_2_VERSION;
1191             break;
1192         case OPT_TLS1_1:
1193             min_version = TLS1_1_VERSION;
1194             max_version = TLS1_1_VERSION;
1195             break;
1196         case OPT_TLS1:
1197             min_version = TLS1_VERSION;
1198             max_version = TLS1_VERSION;
1199             break;
1200         case OPT_DTLS:
1201 #ifndef OPENSSL_NO_DTLS
1202             meth = DTLS_client_method();
1203             socket_type = SOCK_DGRAM;
1204 #endif
1205             break;
1206         case OPT_DTLS1:
1207 #ifndef OPENSSL_NO_DTLS1
1208             meth = DTLS_client_method();
1209             min_version = DTLS1_VERSION;
1210             max_version = DTLS1_VERSION;
1211             socket_type = SOCK_DGRAM;
1212 #endif
1213             break;
1214         case OPT_DTLS1_2:
1215 #ifndef OPENSSL_NO_DTLS1_2
1216             meth = DTLS_client_method();
1217             min_version = DTLS1_2_VERSION;
1218             max_version = DTLS1_2_VERSION;
1219             socket_type = SOCK_DGRAM;
1220 #endif
1221             break;
1222         case OPT_TIMEOUT:
1223 #ifndef OPENSSL_NO_DTLS
1224             enable_timeouts = 1;
1225 #endif
1226             break;
1227         case OPT_MTU:
1228 #ifndef OPENSSL_NO_DTLS
1229             socket_mtu = atol(opt_arg());
1230 #endif
1231             break;
1232         case OPT_FALLBACKSCSV:
1233             fallback_scsv = 1;
1234             break;
1235         case OPT_KEYFORM:
1236             if (!opt_format(opt_arg(), OPT_FMT_PDE, &key_format))
1237                 goto opthelp;
1238             break;
1239         case OPT_PASS:
1240             passarg = opt_arg();
1241             break;
1242         case OPT_CERT_CHAIN:
1243             chain_file = opt_arg();
1244             break;
1245         case OPT_KEY:
1246             key_file = opt_arg();
1247             break;
1248         case OPT_RECONNECT:
1249             reconnect = 5;
1250             break;
1251         case OPT_CAPATH:
1252             CApath = opt_arg();
1253             break;
1254         case OPT_NOCAPATH:
1255             noCApath = 1;
1256             break;
1257         case OPT_CHAINCAPATH:
1258             chCApath = opt_arg();
1259             break;
1260         case OPT_VERIFYCAPATH:
1261             vfyCApath = opt_arg();
1262             break;
1263         case OPT_BUILD_CHAIN:
1264             build_chain = 1;
1265             break;
1266         case OPT_CAFILE:
1267             CAfile = opt_arg();
1268             break;
1269         case OPT_NOCAFILE:
1270             noCAfile = 1;
1271             break;
1272 #ifndef OPENSSL_NO_CT
1273         case OPT_NOCT:
1274             ct_validation = 0;
1275             break;
1276         case OPT_CT:
1277             ct_validation = 1;
1278             break;
1279         case OPT_CTLOG_FILE:
1280             ctlog_file = opt_arg();
1281             break;
1282 #endif
1283         case OPT_CHAINCAFILE:
1284             chCAfile = opt_arg();
1285             break;
1286         case OPT_VERIFYCAFILE:
1287             vfyCAfile = opt_arg();
1288             break;
1289         case OPT_DANE_TLSA_DOMAIN:
1290             dane_tlsa_domain = opt_arg();
1291             break;
1292         case OPT_DANE_TLSA_RRDATA:
1293             if (dane_tlsa_rrset == NULL)
1294                 dane_tlsa_rrset = sk_OPENSSL_STRING_new_null();
1295             if (dane_tlsa_rrset == NULL ||
1296                 !sk_OPENSSL_STRING_push(dane_tlsa_rrset, opt_arg())) {
1297                 BIO_printf(bio_err, "%s: Memory allocation failure\n", prog);
1298                 goto end;
1299             }
1300             break;
1301         case OPT_DANE_EE_NO_NAME:
1302             dane_ee_no_name = 1;
1303             break;
1304         case OPT_NEXTPROTONEG:
1305 #ifndef OPENSSL_NO_NEXTPROTONEG
1306             next_proto_neg_in = opt_arg();
1307 #endif
1308             break;
1309         case OPT_ALPN:
1310             alpn_in = opt_arg();
1311             break;
1312         case OPT_SERVERINFO:
1313             p = opt_arg();
1314             len = strlen(p);
1315             for (start = 0, i = 0; i <= len; ++i) {
1316                 if (i == len || p[i] == ',') {
1317                     serverinfo_types[serverinfo_count] = atoi(p + start);
1318                     if (++serverinfo_count == MAX_SI_TYPES)
1319                         break;
1320                     start = i + 1;
1321                 }
1322             }
1323             break;
1324         case OPT_STARTTLS:
1325             if (!opt_pair(opt_arg(), services, &starttls_proto))
1326                 goto end;
1327             break;
1328         case OPT_SERVERNAME:
1329             servername = opt_arg();
1330             break;
1331         case OPT_USE_SRTP:
1332             srtp_profiles = opt_arg();
1333             break;
1334         case OPT_KEYMATEXPORT:
1335             keymatexportlabel = opt_arg();
1336             break;
1337         case OPT_KEYMATEXPORTLEN:
1338             keymatexportlen = atoi(opt_arg());
1339             break;
1340         case OPT_ASYNC:
1341             async = 1;
1342             break;
1343         case OPT_SPLIT_SEND_FRAG:
1344             split_send_fragment = atoi(opt_arg());
1345             if (split_send_fragment == 0) {
1346                 /*
1347                  * Not allowed - set to a deliberately bad value so we get an
1348                  * error message below
1349                  */
1350                 split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH + 1;
1351             }
1352             break;
1353         case OPT_MAX_PIPELINES:
1354             max_pipelines = atoi(opt_arg());
1355             break;
1356         case OPT_READ_BUF:
1357             read_buf_len = atoi(opt_arg());
1358             break;
1359         }
1360     }
1361     if (count4or6 >= 2) {
1362         BIO_printf(bio_err, "%s: Can't use both -4 and -6\n", prog);
1363         goto opthelp;
1364     }
1365     argc = opt_num_rest();
1366     if (argc != 0)
1367         goto opthelp;
1368
1369     if (proxystr) {
1370         int res;
1371         char *tmp_host = host, *tmp_port = port;
1372         if (connectstr == NULL) {
1373             BIO_printf(bio_err, "%s: -proxy requires use of -connect\n", prog);
1374             goto opthelp;
1375         }
1376         res = BIO_parse_hostserv(proxystr, &host, &port, BIO_PARSE_PRIO_HOST);
1377         if (tmp_host != host)
1378             OPENSSL_free(tmp_host);
1379         if (tmp_port != port)
1380             OPENSSL_free(tmp_port);
1381         if (!res) {
1382             BIO_printf(bio_err,
1383                        "%s: -proxy argument malformed or ambiguous\n", prog);
1384             goto end;
1385         }
1386     } else {
1387         int res = 1;
1388         char *tmp_host = host, *tmp_port = port;
1389         if (connectstr != NULL)
1390             res = BIO_parse_hostserv(connectstr, &host, &port,
1391                                      BIO_PARSE_PRIO_HOST);
1392         if (tmp_host != host)
1393             OPENSSL_free(tmp_host);
1394         if (tmp_port != port)
1395             OPENSSL_free(tmp_port);
1396         if (!res) {
1397             BIO_printf(bio_err,
1398                        "%s: -connect argument malformed or ambiguous\n",
1399                        prog);
1400             goto end;
1401         }
1402     }
1403
1404     if (socket_family == AF_UNIX && socket_type != SOCK_STREAM) {
1405         BIO_printf(bio_err,
1406                    "Can't use unix sockets and datagrams together\n");
1407         goto end;
1408     }
1409
1410     if (split_send_fragment > SSL3_RT_MAX_PLAIN_LENGTH) {
1411         BIO_printf(bio_err, "Bad split send fragment size\n");
1412         goto end;
1413     }
1414
1415     if (max_pipelines > SSL_MAX_PIPELINES) {
1416         BIO_printf(bio_err, "Bad max pipelines value\n");
1417         goto end;
1418     }
1419
1420 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1421     next_proto.status = -1;
1422     if (next_proto_neg_in) {
1423         next_proto.data =
1424             next_protos_parse(&next_proto.len, next_proto_neg_in);
1425         if (next_proto.data == NULL) {
1426             BIO_printf(bio_err, "Error parsing -nextprotoneg argument\n");
1427             goto end;
1428         }
1429     } else
1430         next_proto.data = NULL;
1431 #endif
1432
1433     if (!app_passwd(passarg, NULL, &pass, NULL)) {
1434         BIO_printf(bio_err, "Error getting password\n");
1435         goto end;
1436     }
1437
1438     if (key_file == NULL)
1439         key_file = cert_file;
1440
1441     if (key_file) {
1442         key = load_key(key_file, key_format, 0, pass, e,
1443                        "client certificate private key file");
1444         if (key == NULL) {
1445             ERR_print_errors(bio_err);
1446             goto end;
1447         }
1448     }
1449
1450     if (cert_file) {
1451         cert = load_cert(cert_file, cert_format, "client certificate file");
1452         if (cert == NULL) {
1453             ERR_print_errors(bio_err);
1454             goto end;
1455         }
1456     }
1457
1458     if (chain_file) {
1459         if (!load_certs(chain_file, &chain, FORMAT_PEM, NULL,
1460                         "client certificate chain"))
1461             goto end;
1462     }
1463
1464     if (crl_file) {
1465         X509_CRL *crl;
1466         crl = load_crl(crl_file, crl_format);
1467         if (crl == NULL) {
1468             BIO_puts(bio_err, "Error loading CRL\n");
1469             ERR_print_errors(bio_err);
1470             goto end;
1471         }
1472         crls = sk_X509_CRL_new_null();
1473         if (crls == NULL || !sk_X509_CRL_push(crls, crl)) {
1474             BIO_puts(bio_err, "Error adding CRL\n");
1475             ERR_print_errors(bio_err);
1476             X509_CRL_free(crl);
1477             goto end;
1478         }
1479     }
1480
1481     if (!load_excert(&exc))
1482         goto end;
1483
1484     if (!app_RAND_load_file(NULL, 1) && inrand == NULL
1485         && !RAND_status()) {
1486         BIO_printf(bio_err,
1487                    "warning, not much extra random data, consider using the -rand option\n");
1488     }
1489     if (inrand != NULL) {
1490         randamt = app_RAND_load_files(inrand);
1491         BIO_printf(bio_err, "%ld semi-random bytes loaded\n", randamt);
1492     }
1493
1494     if (bio_c_out == NULL) {
1495         if (c_quiet && !c_debug) {
1496             bio_c_out = BIO_new(BIO_s_null());
1497             if (c_msg && !bio_c_msg)
1498                 bio_c_msg = dup_bio_out(FORMAT_TEXT);
1499         } else if (bio_c_out == NULL)
1500             bio_c_out = dup_bio_out(FORMAT_TEXT);
1501     }
1502 #ifndef OPENSSL_NO_SRP
1503     if (!app_passwd(srppass, NULL, &srp_arg.srppassin, NULL)) {
1504         BIO_printf(bio_err, "Error getting password\n");
1505         goto end;
1506     }
1507 #endif
1508
1509     ctx = SSL_CTX_new(meth);
1510     if (ctx == NULL) {
1511         ERR_print_errors(bio_err);
1512         goto end;
1513     }
1514
1515     if (sdebug)
1516         ssl_ctx_security_debug(ctx, sdebug);
1517
1518     if (ssl_config) {
1519         if (SSL_CTX_config(ctx, ssl_config) == 0) {
1520             BIO_printf(bio_err, "Error using configuration \"%s\"\n",
1521                        ssl_config);
1522             ERR_print_errors(bio_err);
1523             goto end;
1524         }
1525     }
1526
1527     if (SSL_CTX_set_min_proto_version(ctx, min_version) == 0)
1528         goto end;
1529     if (SSL_CTX_set_max_proto_version(ctx, max_version) == 0)
1530         goto end;
1531
1532     if (vpmtouched && !SSL_CTX_set1_param(ctx, vpm)) {
1533         BIO_printf(bio_err, "Error setting verify params\n");
1534         ERR_print_errors(bio_err);
1535         goto end;
1536     }
1537
1538     if (async) {
1539         SSL_CTX_set_mode(ctx, SSL_MODE_ASYNC);
1540     }
1541     if (split_send_fragment > 0) {
1542         SSL_CTX_set_split_send_fragment(ctx, split_send_fragment);
1543     }
1544     if (max_pipelines > 0) {
1545         SSL_CTX_set_max_pipelines(ctx, max_pipelines);
1546     }
1547
1548     if (read_buf_len > 0) {
1549         SSL_CTX_set_default_read_buffer_len(ctx, read_buf_len);
1550     }
1551
1552     if (!config_ctx(cctx, ssl_args, ctx))
1553         goto end;
1554
1555     if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1556                          crls, crl_download)) {
1557         BIO_printf(bio_err, "Error loading store locations\n");
1558         ERR_print_errors(bio_err);
1559         goto end;
1560     }
1561 #ifndef OPENSSL_NO_ENGINE
1562     if (ssl_client_engine) {
1563         if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine)) {
1564             BIO_puts(bio_err, "Error setting client auth engine\n");
1565             ERR_print_errors(bio_err);
1566             ENGINE_free(ssl_client_engine);
1567             goto end;
1568         }
1569         ENGINE_free(ssl_client_engine);
1570     }
1571 #endif
1572
1573 #ifndef OPENSSL_NO_PSK
1574     if (psk_key != NULL) {
1575         if (c_debug)
1576             BIO_printf(bio_c_out, "PSK key given, setting client callback\n");
1577         SSL_CTX_set_psk_client_callback(ctx, psk_client_cb);
1578     }
1579 #endif
1580 #ifndef OPENSSL_NO_SRTP
1581     if (srtp_profiles != NULL) {
1582         /* Returns 0 on success! */
1583         if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles) != 0) {
1584             BIO_printf(bio_err, "Error setting SRTP profile\n");
1585             ERR_print_errors(bio_err);
1586             goto end;
1587         }
1588     }
1589 #endif
1590
1591     if (exc)
1592         ssl_ctx_set_excert(ctx, exc);
1593
1594 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1595     if (next_proto.data)
1596         SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto);
1597 #endif
1598     if (alpn_in) {
1599         size_t alpn_len;
1600         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_in);
1601
1602         if (alpn == NULL) {
1603             BIO_printf(bio_err, "Error parsing -alpn argument\n");
1604             goto end;
1605         }
1606         /* Returns 0 on success! */
1607         if (SSL_CTX_set_alpn_protos(ctx, alpn, alpn_len) != 0) {
1608             BIO_printf(bio_err, "Error setting ALPN\n");
1609             goto end;
1610         }
1611         OPENSSL_free(alpn);
1612     }
1613
1614     for (i = 0; i < serverinfo_count; i++) {
1615         if (!SSL_CTX_add_client_custom_ext(ctx,
1616                                            serverinfo_types[i],
1617                                            NULL, NULL, NULL,
1618                                            serverinfo_cli_parse_cb, NULL)) {
1619             BIO_printf(bio_err,
1620                        "Warning: Unable to add custom extension %u, skipping\n",
1621                        serverinfo_types[i]);
1622         }
1623     }
1624
1625     if (state)
1626         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1627
1628 #ifndef OPENSSL_NO_CT
1629     /* Enable SCT processing, without early connection termination */
1630     if (ct_validation &&
1631         !SSL_CTX_enable_ct(ctx, SSL_CT_VALIDATION_PERMISSIVE)) {
1632         ERR_print_errors(bio_err);
1633         goto end;
1634     }
1635
1636     if (!ctx_set_ctlog_list_file(ctx, ctlog_file)) {
1637         if (ct_validation) {
1638             ERR_print_errors(bio_err);
1639             goto end;
1640         }
1641
1642         /*
1643          * If CT validation is not enabled, the log list isn't needed so don't
1644          * show errors or abort. We try to load it regardless because then we
1645          * can show the names of the logs any SCTs came from (SCTs may be seen
1646          * even with validation disabled).
1647          */
1648         ERR_clear_error();
1649     }
1650 #endif
1651
1652     SSL_CTX_set_verify(ctx, verify, verify_callback);
1653
1654     if (!ctx_set_verify_locations(ctx, CAfile, CApath, noCAfile, noCApath)) {
1655         ERR_print_errors(bio_err);
1656         goto end;
1657     }
1658
1659     ssl_ctx_add_crls(ctx, crls, crl_download);
1660
1661     if (!set_cert_key_stuff(ctx, cert, key, chain, build_chain))
1662         goto end;
1663
1664     if (servername != NULL) {
1665         tlsextcbp.biodebug = bio_err;
1666         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1667         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1668     }
1669 # ifndef OPENSSL_NO_SRP
1670     if (srp_arg.srplogin) {
1671         if (!srp_lateuser && !SSL_CTX_set_srp_username(ctx, srp_arg.srplogin)) {
1672             BIO_printf(bio_err, "Unable to set SRP username\n");
1673             goto end;
1674         }
1675         srp_arg.msg = c_msg;
1676         srp_arg.debug = c_debug;
1677         SSL_CTX_set_srp_cb_arg(ctx, &srp_arg);
1678         SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1679         SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
1680         if (c_msg || c_debug || srp_arg.amp == 0)
1681             SSL_CTX_set_srp_verify_param_callback(ctx,
1682                                                   ssl_srp_verify_param_cb);
1683     }
1684 # endif
1685
1686     if (dane_tlsa_domain != NULL) {
1687         if (SSL_CTX_dane_enable(ctx) <= 0) {
1688             BIO_printf(bio_err,
1689                        "%s: Error enabling DANE TLSA authentication.\n",
1690                        prog);
1691             ERR_print_errors(bio_err);
1692             goto end;
1693         }
1694     }
1695
1696     /*
1697      * In TLSv1.3 NewSessionTicket messages arrive after the handshake and can
1698      * come at any time. Therefore we use a callback to write out the session
1699      * when we know about it. This approach works for < TLSv1.3 as well.
1700      */
1701     if (sess_out) {
1702         SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_CLIENT
1703                                             | SSL_SESS_CACHE_NO_INTERNAL_STORE);
1704         SSL_CTX_sess_set_new_cb(ctx, new_session_cb);
1705     }
1706
1707     con = SSL_new(ctx);
1708     if (sess_in) {
1709         SSL_SESSION *sess;
1710         BIO *stmp = BIO_new_file(sess_in, "r");
1711         if (!stmp) {
1712             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
1713             ERR_print_errors(bio_err);
1714             goto end;
1715         }
1716         sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL);
1717         BIO_free(stmp);
1718         if (!sess) {
1719             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
1720             ERR_print_errors(bio_err);
1721             goto end;
1722         }
1723         if (!SSL_set_session(con, sess)) {
1724             BIO_printf(bio_err, "Can't set session\n");
1725             ERR_print_errors(bio_err);
1726             goto end;
1727         }
1728         SSL_SESSION_free(sess);
1729     }
1730
1731     if (fallback_scsv)
1732         SSL_set_mode(con, SSL_MODE_SEND_FALLBACK_SCSV);
1733
1734     if (servername != NULL) {
1735         if (!SSL_set_tlsext_host_name(con, servername)) {
1736             BIO_printf(bio_err, "Unable to set TLS servername extension.\n");
1737             ERR_print_errors(bio_err);
1738             goto end;
1739         }
1740     }
1741
1742     if (dane_tlsa_domain != NULL) {
1743         if (SSL_dane_enable(con, dane_tlsa_domain) <= 0) {
1744             BIO_printf(bio_err, "%s: Error enabling DANE TLSA "
1745                        "authentication.\n", prog);
1746             ERR_print_errors(bio_err);
1747             goto end;
1748         }
1749         if (dane_tlsa_rrset == NULL) {
1750             BIO_printf(bio_err, "%s: DANE TLSA authentication requires at "
1751                        "least one -dane_tlsa_rrdata option.\n", prog);
1752             goto end;
1753         }
1754         if (tlsa_import_rrset(con, dane_tlsa_rrset) <= 0) {
1755             BIO_printf(bio_err, "%s: Failed to import any TLSA "
1756                        "records.\n", prog);
1757             goto end;
1758         }
1759         if (dane_ee_no_name)
1760             SSL_dane_set_flags(con, DANE_FLAG_NO_DANE_EE_NAMECHECKS);
1761     } else if (dane_tlsa_rrset != NULL) {
1762         BIO_printf(bio_err, "%s: DANE TLSA authentication requires the "
1763                    "-dane_tlsa_domain option.\n", prog);
1764         goto end;
1765     }
1766
1767  re_start:
1768     if (init_client(&s, host, port, socket_family, socket_type) == 0) {
1769         BIO_printf(bio_err, "connect:errno=%d\n", get_last_socket_error());
1770         BIO_closesocket(s);
1771         goto end;
1772     }
1773     BIO_printf(bio_c_out, "CONNECTED(%08X)\n", s);
1774
1775     if (c_nbio) {
1776         if (!BIO_socket_nbio(s, 1)) {
1777             ERR_print_errors(bio_err);
1778             goto end;
1779         }
1780         BIO_printf(bio_c_out, "Turned on non blocking io\n");
1781     }
1782 #ifndef OPENSSL_NO_DTLS
1783     if (socket_type == SOCK_DGRAM) {
1784         union BIO_sock_info_u peer_info;
1785
1786         sbio = BIO_new_dgram(s, BIO_NOCLOSE);
1787         if ((peer_info.addr = BIO_ADDR_new()) == NULL) {
1788             BIO_printf(bio_err, "memory allocation failure\n");
1789             BIO_closesocket(s);
1790             goto end;
1791         }
1792         if (!BIO_sock_info(s, BIO_SOCK_INFO_ADDRESS, &peer_info)) {
1793             BIO_printf(bio_err, "getsockname:errno=%d\n",
1794                        get_last_socket_error());
1795             BIO_ADDR_free(peer_info.addr);
1796             BIO_closesocket(s);
1797             goto end;
1798         }
1799
1800         (void)BIO_ctrl_set_connected(sbio, peer_info.addr);
1801         BIO_ADDR_free(peer_info.addr);
1802         peer_info.addr = NULL;
1803
1804         if (enable_timeouts) {
1805             timeout.tv_sec = 0;
1806             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
1807             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
1808
1809             timeout.tv_sec = 0;
1810             timeout.tv_usec = DGRAM_SND_TIMEOUT;
1811             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
1812         }
1813
1814         if (socket_mtu) {
1815             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
1816                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
1817                            DTLS_get_link_min_mtu(con));
1818                 BIO_free(sbio);
1819                 goto shut;
1820             }
1821             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
1822             if (!DTLS_set_link_mtu(con, socket_mtu)) {
1823                 BIO_printf(bio_err, "Failed to set MTU\n");
1824                 BIO_free(sbio);
1825                 goto shut;
1826             }
1827         } else
1828             /* want to do MTU discovery */
1829             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
1830     } else
1831 #endif /* OPENSSL_NO_DTLS */
1832         sbio = BIO_new_socket(s, BIO_NOCLOSE);
1833
1834     if (nbio_test) {
1835         BIO *test;
1836
1837         test = BIO_new(BIO_f_nbio_test());
1838         sbio = BIO_push(test, sbio);
1839     }
1840
1841     if (c_debug) {
1842         BIO_set_callback(sbio, bio_dump_callback);
1843         BIO_set_callback_arg(sbio, (char *)bio_c_out);
1844     }
1845     if (c_msg) {
1846 #ifndef OPENSSL_NO_SSL_TRACE
1847         if (c_msg == 2)
1848             SSL_set_msg_callback(con, SSL_trace);
1849         else
1850 #endif
1851             SSL_set_msg_callback(con, msg_cb);
1852         SSL_set_msg_callback_arg(con, bio_c_msg ? bio_c_msg : bio_c_out);
1853     }
1854
1855     if (c_tlsextdebug) {
1856         SSL_set_tlsext_debug_callback(con, tlsext_cb);
1857         SSL_set_tlsext_debug_arg(con, bio_c_out);
1858     }
1859 #ifndef OPENSSL_NO_OCSP
1860     if (c_status_req) {
1861         SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp);
1862         SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb);
1863         SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out);
1864     }
1865 #endif
1866
1867     SSL_set_bio(con, sbio, sbio);
1868     SSL_set_connect_state(con);
1869
1870     /* ok, lets connect */
1871     if (fileno_stdin() > SSL_get_fd(con))
1872         width = fileno_stdin() + 1;
1873     else
1874         width = SSL_get_fd(con) + 1;
1875
1876     read_tty = 1;
1877     write_tty = 0;
1878     tty_on = 0;
1879     read_ssl = 1;
1880     write_ssl = 1;
1881
1882     cbuf_len = 0;
1883     cbuf_off = 0;
1884     sbuf_len = 0;
1885     sbuf_off = 0;
1886
1887     switch ((PROTOCOL_CHOICE) starttls_proto) {
1888     case PROTO_OFF:
1889         break;
1890     case PROTO_LMTP:
1891     case PROTO_SMTP:
1892         {
1893             /*
1894              * This is an ugly hack that does a lot of assumptions. We do
1895              * have to handle multi-line responses which may come in a single
1896              * packet or not. We therefore have to use BIO_gets() which does
1897              * need a buffering BIO. So during the initial chitchat we do
1898              * push a buffering BIO into the chain that is removed again
1899              * later on to not disturb the rest of the s_client operation.
1900              */
1901             int foundit = 0;
1902             BIO *fbio = BIO_new(BIO_f_buffer());
1903             BIO_push(fbio, sbio);
1904             /* Wait for multi-line response to end from LMTP or SMTP */
1905             do {
1906                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1907             }
1908             while (mbuf_len > 3 && mbuf[3] == '-');
1909             if (starttls_proto == (int)PROTO_LMTP)
1910                 BIO_printf(fbio, "LHLO %s\r\n", ehlo);
1911             else
1912                 BIO_printf(fbio, "EHLO %s\r\n", ehlo);
1913             (void)BIO_flush(fbio);
1914             /*
1915              * Wait for multi-line response to end LHLO LMTP or EHLO SMTP
1916              * response.
1917              */
1918             do {
1919                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1920                 if (strstr(mbuf, "STARTTLS"))
1921                     foundit = 1;
1922             }
1923             while (mbuf_len > 3 && mbuf[3] == '-');
1924             (void)BIO_flush(fbio);
1925             BIO_pop(fbio);
1926             BIO_free(fbio);
1927             if (!foundit)
1928                 BIO_printf(bio_err,
1929                            "didn't find starttls in server response,"
1930                            " trying anyway...\n");
1931             BIO_printf(sbio, "STARTTLS\r\n");
1932             BIO_read(sbio, sbuf, BUFSIZZ);
1933         }
1934         break;
1935     case PROTO_POP3:
1936         {
1937             BIO_read(sbio, mbuf, BUFSIZZ);
1938             BIO_printf(sbio, "STLS\r\n");
1939             mbuf_len = BIO_read(sbio, sbuf, BUFSIZZ);
1940             if (mbuf_len < 0) {
1941                 BIO_printf(bio_err, "BIO_read failed\n");
1942                 goto end;
1943             }
1944         }
1945         break;
1946     case PROTO_IMAP:
1947         {
1948             int foundit = 0;
1949             BIO *fbio = BIO_new(BIO_f_buffer());
1950             BIO_push(fbio, sbio);
1951             BIO_gets(fbio, mbuf, BUFSIZZ);
1952             /* STARTTLS command requires CAPABILITY... */
1953             BIO_printf(fbio, ". CAPABILITY\r\n");
1954             (void)BIO_flush(fbio);
1955             /* wait for multi-line CAPABILITY response */
1956             do {
1957                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1958                 if (strstr(mbuf, "STARTTLS"))
1959                     foundit = 1;
1960             }
1961             while (mbuf_len > 3 && mbuf[0] != '.');
1962             (void)BIO_flush(fbio);
1963             BIO_pop(fbio);
1964             BIO_free(fbio);
1965             if (!foundit)
1966                 BIO_printf(bio_err,
1967                            "didn't find STARTTLS in server response,"
1968                            " trying anyway...\n");
1969             BIO_printf(sbio, ". STARTTLS\r\n");
1970             BIO_read(sbio, sbuf, BUFSIZZ);
1971         }
1972         break;
1973     case PROTO_FTP:
1974         {
1975             BIO *fbio = BIO_new(BIO_f_buffer());
1976             BIO_push(fbio, sbio);
1977             /* wait for multi-line response to end from FTP */
1978             do {
1979                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1980             }
1981             while (mbuf_len > 3 && mbuf[3] == '-');
1982             (void)BIO_flush(fbio);
1983             BIO_pop(fbio);
1984             BIO_free(fbio);
1985             BIO_printf(sbio, "AUTH TLS\r\n");
1986             BIO_read(sbio, sbuf, BUFSIZZ);
1987         }
1988         break;
1989     case PROTO_XMPP:
1990     case PROTO_XMPP_SERVER:
1991         {
1992             int seen = 0;
1993             BIO_printf(sbio, "<stream:stream "
1994                        "xmlns:stream='http://etherx.jabber.org/streams' "
1995                        "xmlns='jabber:%s' to='%s' version='1.0'>",
1996                        starttls_proto == PROTO_XMPP ? "client" : "server",
1997                        xmpphost ? xmpphost : host);
1998             seen = BIO_read(sbio, mbuf, BUFSIZZ);
1999             mbuf[seen] = 0;
2000             while (!strstr
2001                    (mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'")
2002                    && !strstr(mbuf,
2003                               "<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\""))
2004             {
2005                 seen = BIO_read(sbio, mbuf, BUFSIZZ);
2006
2007                 if (seen <= 0)
2008                     goto shut;
2009
2010                 mbuf[seen] = 0;
2011             }
2012             BIO_printf(sbio,
2013                        "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
2014             seen = BIO_read(sbio, sbuf, BUFSIZZ);
2015             sbuf[seen] = 0;
2016             if (!strstr(sbuf, "<proceed"))
2017                 goto shut;
2018             mbuf[0] = 0;
2019         }
2020         break;
2021     case PROTO_TELNET:
2022         {
2023             static const unsigned char tls_do[] = {
2024                 /* IAC    DO   START_TLS */
2025                    255,   253, 46
2026             };
2027             static const unsigned char tls_will[] = {
2028                 /* IAC  WILL START_TLS */
2029                    255, 251, 46
2030             };
2031             static const unsigned char tls_follows[] = {
2032                 /* IAC  SB   START_TLS FOLLOWS IAC  SE */
2033                    255, 250, 46,       1,      255, 240
2034             };
2035             int bytes;
2036
2037             /* Telnet server should demand we issue START_TLS */
2038             bytes = BIO_read(sbio, mbuf, BUFSIZZ);
2039             if (bytes != 3 || memcmp(mbuf, tls_do, 3) != 0)
2040                 goto shut;
2041             /* Agree to issue START_TLS and send the FOLLOWS sub-command */
2042             BIO_write(sbio, tls_will, 3);
2043             BIO_write(sbio, tls_follows, 6);
2044             (void)BIO_flush(sbio);
2045             /* Telnet server also sent the FOLLOWS sub-command */
2046             bytes = BIO_read(sbio, mbuf, BUFSIZZ);
2047             if (bytes != 6 || memcmp(mbuf, tls_follows, 6) != 0)
2048                 goto shut;
2049         }
2050         break;
2051     case PROTO_CONNECT:
2052         {
2053             enum {
2054                 error_proto,     /* Wrong protocol, not even HTTP */
2055                 error_connect,   /* CONNECT failed */
2056                 success
2057             } foundit = error_connect;
2058             BIO *fbio = BIO_new(BIO_f_buffer());
2059
2060             BIO_push(fbio, sbio);
2061             BIO_printf(fbio, "CONNECT %s HTTP/1.0\r\n\r\n", connectstr);
2062             (void)BIO_flush(fbio);
2063             /*
2064              * The first line is the HTTP response.  According to RFC 7230,
2065              * it's formated exactly like this:
2066              *
2067              * HTTP/d.d ddd Reason text\r\n
2068              */
2069             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2070             if (mbuf[8] != ' ') {
2071                 BIO_printf(bio_err,
2072                            "%s: HTTP CONNECT failed, incorrect response "
2073                            "from proxy\n", prog);
2074                 foundit = error_proto;
2075             } else if (mbuf[9] != '2') {
2076                 BIO_printf(bio_err, "%s: HTTP CONNECT failed: %s ", prog,
2077                            &mbuf[9]);
2078             } else {
2079                 foundit = success;
2080             }
2081             if (foundit != error_proto) {
2082                 /* Read past all following headers */
2083                 do {
2084                     mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2085                 } while (mbuf_len > 2);
2086             }
2087             (void)BIO_flush(fbio);
2088             BIO_pop(fbio);
2089             BIO_free(fbio);
2090             if (foundit != success) {
2091                 goto shut;
2092             }
2093         }
2094         break;
2095     case PROTO_IRC:
2096         {
2097             int numeric;
2098             BIO *fbio = BIO_new(BIO_f_buffer());
2099
2100             BIO_push(fbio, sbio);
2101             BIO_printf(fbio, "STARTTLS\r\n");
2102             (void)BIO_flush(fbio);
2103             width = SSL_get_fd(con) + 1;
2104
2105             do {
2106                 numeric = 0;
2107
2108                 FD_ZERO(&readfds);
2109                 openssl_fdset(SSL_get_fd(con), &readfds);
2110                 timeout.tv_sec = S_CLIENT_IRC_READ_TIMEOUT;
2111                 timeout.tv_usec = 0;
2112                 /*
2113                  * If the IRCd doesn't respond within
2114                  * S_CLIENT_IRC_READ_TIMEOUT seconds, assume
2115                  * it doesn't support STARTTLS. Many IRCds
2116                  * will not give _any_ sort of response to a
2117                  * STARTTLS command when it's not supported.
2118                  */
2119                 if (!BIO_get_buffer_num_lines(fbio)
2120                     && !BIO_pending(fbio)
2121                     && !BIO_pending(sbio)
2122                     && select(width, (void *)&readfds, NULL, NULL,
2123                               &timeout) < 1) {
2124                     BIO_printf(bio_err,
2125                                "Timeout waiting for response (%d seconds).\n",
2126                                S_CLIENT_IRC_READ_TIMEOUT);
2127                     break;
2128                 }
2129
2130                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2131                 if (mbuf_len < 1 || sscanf(mbuf, "%*s %d", &numeric) != 1)
2132                     break;
2133                 /* :example.net 451 STARTTLS :You have not registered */
2134                 /* :example.net 421 STARTTLS :Unknown command */
2135                 if ((numeric == 451 || numeric == 421)
2136                     && strstr(mbuf, "STARTTLS") != NULL) {
2137                     BIO_printf(bio_err, "STARTTLS not supported: %s", mbuf);
2138                     break;
2139                 }
2140                 if (numeric == 691) {
2141                     BIO_printf(bio_err, "STARTTLS negotiation failed: ");
2142                     ERR_print_errors(bio_err);
2143                     break;
2144                 }
2145             } while (numeric != 670);
2146
2147             (void)BIO_flush(fbio);
2148             BIO_pop(fbio);
2149             BIO_free(fbio);
2150             if (numeric != 670) {
2151                 BIO_printf(bio_err, "Server does not support STARTTLS.\n");
2152                 ret = 1;
2153                 goto shut;
2154             }
2155         }
2156         break;
2157     case PROTO_POSTGRES:
2158         {
2159             static const unsigned char ssl_request[] = {
2160                 /* Length        SSLRequest */
2161                    0, 0, 0, 8,   4, 210, 22, 47
2162             };
2163             int bytes;
2164
2165             /* Send SSLRequest packet */
2166             BIO_write(sbio, ssl_request, 8);
2167             (void)BIO_flush(sbio);
2168
2169             /* Reply will be a single S if SSL is enabled */
2170             bytes = BIO_read(sbio, sbuf, BUFSIZZ);
2171             if (bytes != 1 || sbuf[0] != 'S')
2172                 goto shut;
2173         }
2174         break;
2175     }
2176
2177     for (;;) {
2178         FD_ZERO(&readfds);
2179         FD_ZERO(&writefds);
2180
2181         if ((SSL_version(con) == DTLS1_VERSION) &&
2182             DTLSv1_get_timeout(con, &timeout))
2183             timeoutp = &timeout;
2184         else
2185             timeoutp = NULL;
2186
2187         if (SSL_in_init(con) && !SSL_total_renegotiations(con)) {
2188             in_init = 1;
2189             tty_on = 0;
2190         } else {
2191             tty_on = 1;
2192             if (in_init) {
2193                 in_init = 0;
2194
2195                 if (servername != NULL && !SSL_session_reused(con)) {
2196                     BIO_printf(bio_c_out,
2197                                "Server did %sacknowledge servername extension.\n",
2198                                tlsextcbp.ack ? "" : "not ");
2199                 }
2200
2201                 if (c_brief) {
2202                     BIO_puts(bio_err, "CONNECTION ESTABLISHED\n");
2203                     print_ssl_summary(con);
2204                 }
2205
2206                 print_stuff(bio_c_out, con, full_log);
2207                 if (full_log > 0)
2208                     full_log--;
2209
2210                 if (starttls_proto) {
2211                     BIO_write(bio_err, mbuf, mbuf_len);
2212                     /* We don't need to know any more */
2213                     if (!reconnect)
2214                         starttls_proto = PROTO_OFF;
2215                 }
2216
2217                 if (reconnect) {
2218                     reconnect--;
2219                     BIO_printf(bio_c_out,
2220                                "drop connection and then reconnect\n");
2221                     do_ssl_shutdown(con);
2222                     SSL_set_connect_state(con);
2223                     BIO_closesocket(SSL_get_fd(con));
2224                     goto re_start;
2225                 }
2226             }
2227         }
2228
2229         ssl_pending = read_ssl && SSL_has_pending(con);
2230
2231         if (!ssl_pending) {
2232 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS)
2233             if (tty_on) {
2234                 /*
2235                  * Note that select() returns when read _would not block_,
2236                  * and EOF satisfies that.  To avoid a CPU-hogging loop,
2237                  * set the flag so we exit.
2238                  */
2239                 if (read_tty && !at_eof)
2240                     openssl_fdset(fileno_stdin(), &readfds);
2241 #if !defined(OPENSSL_SYS_VMS)
2242                 if (write_tty)
2243                     openssl_fdset(fileno_stdout(), &writefds);
2244 #endif
2245             }
2246             if (read_ssl)
2247                 openssl_fdset(SSL_get_fd(con), &readfds);
2248             if (write_ssl)
2249                 openssl_fdset(SSL_get_fd(con), &writefds);
2250 #else
2251             if (!tty_on || !write_tty) {
2252                 if (read_ssl)
2253                     openssl_fdset(SSL_get_fd(con), &readfds);
2254                 if (write_ssl)
2255                     openssl_fdset(SSL_get_fd(con), &writefds);
2256             }
2257 #endif
2258
2259             /*
2260              * Note: under VMS with SOCKETSHR the second parameter is
2261              * currently of type (int *) whereas under other systems it is
2262              * (void *) if you don't have a cast it will choke the compiler:
2263              * if you do have a cast then you can either go for (int *) or
2264              * (void *).
2265              */
2266 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
2267             /*
2268              * Under Windows/DOS we make the assumption that we can always
2269              * write to the tty: therefore if we need to write to the tty we
2270              * just fall through. Otherwise we timeout the select every
2271              * second and see if there are any keypresses. Note: this is a
2272              * hack, in a proper Windows application we wouldn't do this.
2273              */
2274             i = 0;
2275             if (!write_tty) {
2276                 if (read_tty) {
2277                     tv.tv_sec = 1;
2278                     tv.tv_usec = 0;
2279                     i = select(width, (void *)&readfds, (void *)&writefds,
2280                                NULL, &tv);
2281                     if (!i && (!has_stdin_waiting() || !read_tty))
2282                         continue;
2283                 } else
2284                     i = select(width, (void *)&readfds, (void *)&writefds,
2285                                NULL, timeoutp);
2286             }
2287 #else
2288             i = select(width, (void *)&readfds, (void *)&writefds,
2289                        NULL, timeoutp);
2290 #endif
2291             if (i < 0) {
2292                 BIO_printf(bio_err, "bad select %d\n",
2293                            get_last_socket_error());
2294                 goto shut;
2295                 /* goto end; */
2296             }
2297         }
2298
2299         if ((SSL_version(con) == DTLS1_VERSION)
2300             && DTLSv1_handle_timeout(con) > 0) {
2301             BIO_printf(bio_err, "TIMEOUT occurred\n");
2302         }
2303
2304         if (!ssl_pending && FD_ISSET(SSL_get_fd(con), &writefds)) {
2305             k = SSL_write(con, &(cbuf[cbuf_off]), (unsigned int)cbuf_len);
2306             switch (SSL_get_error(con, k)) {
2307             case SSL_ERROR_NONE:
2308                 cbuf_off += k;
2309                 cbuf_len -= k;
2310                 if (k <= 0)
2311                     goto end;
2312                 /* we have done a  write(con,NULL,0); */
2313                 if (cbuf_len <= 0) {
2314                     read_tty = 1;
2315                     write_ssl = 0;
2316                 } else {        /* if (cbuf_len > 0) */
2317
2318                     read_tty = 0;
2319                     write_ssl = 1;
2320                 }
2321                 break;
2322             case SSL_ERROR_WANT_WRITE:
2323                 BIO_printf(bio_c_out, "write W BLOCK\n");
2324                 write_ssl = 1;
2325                 read_tty = 0;
2326                 break;
2327             case SSL_ERROR_WANT_ASYNC:
2328                 BIO_printf(bio_c_out, "write A BLOCK\n");
2329                 wait_for_async(con);
2330                 write_ssl = 1;
2331                 read_tty = 0;
2332                 break;
2333             case SSL_ERROR_WANT_READ:
2334                 BIO_printf(bio_c_out, "write R BLOCK\n");
2335                 write_tty = 0;
2336                 read_ssl = 1;
2337                 write_ssl = 0;
2338                 break;
2339             case SSL_ERROR_WANT_X509_LOOKUP:
2340                 BIO_printf(bio_c_out, "write X BLOCK\n");
2341                 break;
2342             case SSL_ERROR_ZERO_RETURN:
2343                 if (cbuf_len != 0) {
2344                     BIO_printf(bio_c_out, "shutdown\n");
2345                     ret = 0;
2346                     goto shut;
2347                 } else {
2348                     read_tty = 1;
2349                     write_ssl = 0;
2350                     break;
2351                 }
2352
2353             case SSL_ERROR_SYSCALL:
2354                 if ((k != 0) || (cbuf_len != 0)) {
2355                     BIO_printf(bio_err, "write:errno=%d\n",
2356                                get_last_socket_error());
2357                     goto shut;
2358                 } else {
2359                     read_tty = 1;
2360                     write_ssl = 0;
2361                 }
2362                 break;
2363             case SSL_ERROR_WANT_ASYNC_JOB:
2364                 /* This shouldn't ever happen in s_client - treat as an error */
2365             case SSL_ERROR_SSL:
2366                 ERR_print_errors(bio_err);
2367                 goto shut;
2368             }
2369         }
2370 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_VMS)
2371         /* Assume Windows/DOS/BeOS can always write */
2372         else if (!ssl_pending && write_tty)
2373 #else
2374         else if (!ssl_pending && FD_ISSET(fileno_stdout(), &writefds))
2375 #endif
2376         {
2377 #ifdef CHARSET_EBCDIC
2378             ascii2ebcdic(&(sbuf[sbuf_off]), &(sbuf[sbuf_off]), sbuf_len);
2379 #endif
2380             i = raw_write_stdout(&(sbuf[sbuf_off]), sbuf_len);
2381
2382             if (i <= 0) {
2383                 BIO_printf(bio_c_out, "DONE\n");
2384                 ret = 0;
2385                 goto shut;
2386                 /* goto end; */
2387             }
2388
2389             sbuf_len -= i;
2390             sbuf_off += i;
2391             if (sbuf_len <= 0) {
2392                 read_ssl = 1;
2393                 write_tty = 0;
2394             }
2395         } else if (ssl_pending || FD_ISSET(SSL_get_fd(con), &readfds)) {
2396 #ifdef RENEG
2397             {
2398                 static int iiii;
2399                 if (++iiii == 52) {
2400                     SSL_renegotiate(con);
2401                     iiii = 0;
2402                 }
2403             }
2404 #endif
2405             k = SSL_read(con, sbuf, 1024 /* BUFSIZZ */ );
2406
2407             switch (SSL_get_error(con, k)) {
2408             case SSL_ERROR_NONE:
2409                 if (k <= 0)
2410                     goto end;
2411                 sbuf_off = 0;
2412                 sbuf_len = k;
2413
2414                 read_ssl = 0;
2415                 write_tty = 1;
2416                 break;
2417             case SSL_ERROR_WANT_ASYNC:
2418                 BIO_printf(bio_c_out, "read A BLOCK\n");
2419                 wait_for_async(con);
2420                 write_tty = 0;
2421                 read_ssl = 1;
2422                 if ((read_tty == 0) && (write_ssl == 0))
2423                     write_ssl = 1;
2424                 break;
2425             case SSL_ERROR_WANT_WRITE:
2426                 BIO_printf(bio_c_out, "read W BLOCK\n");
2427                 write_ssl = 1;
2428                 read_tty = 0;
2429                 break;
2430             case SSL_ERROR_WANT_READ:
2431                 BIO_printf(bio_c_out, "read R BLOCK\n");
2432                 write_tty = 0;
2433                 read_ssl = 1;
2434                 if ((read_tty == 0) && (write_ssl == 0))
2435                     write_ssl = 1;
2436                 break;
2437             case SSL_ERROR_WANT_X509_LOOKUP:
2438                 BIO_printf(bio_c_out, "read X BLOCK\n");
2439                 break;
2440             case SSL_ERROR_SYSCALL:
2441                 ret = get_last_socket_error();
2442                 if (c_brief)
2443                     BIO_puts(bio_err, "CONNECTION CLOSED BY SERVER\n");
2444                 else
2445                     BIO_printf(bio_err, "read:errno=%d\n", ret);
2446                 goto shut;
2447             case SSL_ERROR_ZERO_RETURN:
2448                 BIO_printf(bio_c_out, "closed\n");
2449                 ret = 0;
2450                 goto shut;
2451             case SSL_ERROR_WANT_ASYNC_JOB:
2452                 /* This shouldn't ever happen in s_client. Treat as an error */
2453             case SSL_ERROR_SSL:
2454                 ERR_print_errors(bio_err);
2455                 goto shut;
2456                 /* break; */
2457             }
2458         }
2459 /* OPENSSL_SYS_MSDOS includes OPENSSL_SYS_WINDOWS */
2460 #if defined(OPENSSL_SYS_MSDOS)
2461         else if (has_stdin_waiting())
2462 #else
2463         else if (FD_ISSET(fileno_stdin(), &readfds))
2464 #endif
2465         {
2466             if (crlf) {
2467                 int j, lf_num;
2468
2469                 i = raw_read_stdin(cbuf, BUFSIZZ / 2);
2470                 lf_num = 0;
2471                 /* both loops are skipped when i <= 0 */
2472                 for (j = 0; j < i; j++)
2473                     if (cbuf[j] == '\n')
2474                         lf_num++;
2475                 for (j = i - 1; j >= 0; j--) {
2476                     cbuf[j + lf_num] = cbuf[j];
2477                     if (cbuf[j] == '\n') {
2478                         lf_num--;
2479                         i++;
2480                         cbuf[j + lf_num] = '\r';
2481                     }
2482                 }
2483                 assert(lf_num == 0);
2484             } else
2485                 i = raw_read_stdin(cbuf, BUFSIZZ);
2486 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS)
2487             if (i == 0)
2488                 at_eof = 1;
2489 #endif
2490
2491             if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q' && cmdletters))) {
2492                 BIO_printf(bio_err, "DONE\n");
2493                 ret = 0;
2494                 goto shut;
2495             }
2496
2497             if ((!c_ign_eof) && (cbuf[0] == 'R' && cmdletters)) {
2498                 BIO_printf(bio_err, "RENEGOTIATING\n");
2499                 SSL_renegotiate(con);
2500                 cbuf_len = 0;
2501             }
2502 #ifndef OPENSSL_NO_HEARTBEATS
2503             else if ((!c_ign_eof) && (cbuf[0] == 'B' && cmdletters)) {
2504                 BIO_printf(bio_err, "HEARTBEATING\n");
2505                 SSL_heartbeat(con);
2506                 cbuf_len = 0;
2507             }
2508 #endif
2509             else {
2510                 cbuf_len = i;
2511                 cbuf_off = 0;
2512 #ifdef CHARSET_EBCDIC
2513                 ebcdic2ascii(cbuf, cbuf, i);
2514 #endif
2515             }
2516
2517             write_ssl = 1;
2518             read_tty = 0;
2519         }
2520     }
2521
2522     ret = 0;
2523  shut:
2524     if (in_init)
2525         print_stuff(bio_c_out, con, full_log);
2526     do_ssl_shutdown(con);
2527 #if defined(OPENSSL_SYS_WINDOWS)
2528     /*
2529      * Give the socket time to send its last data before we close it.
2530      * No amount of setting SO_LINGER etc on the socket seems to persuade
2531      * Windows to send the data before closing the socket...but sleeping
2532      * for a short time seems to do it (units in ms)
2533      * TODO: Find a better way to do this
2534      */
2535     Sleep(50);
2536 #endif
2537     BIO_closesocket(SSL_get_fd(con));
2538  end:
2539     if (con != NULL) {
2540         if (prexit != 0)
2541             print_stuff(bio_c_out, con, 1);
2542         SSL_free(con);
2543     }
2544 #if !defined(OPENSSL_NO_NEXTPROTONEG)
2545     OPENSSL_free(next_proto.data);
2546 #endif
2547     SSL_CTX_free(ctx);
2548     X509_free(cert);
2549     sk_X509_CRL_pop_free(crls, X509_CRL_free);
2550     EVP_PKEY_free(key);
2551     sk_X509_pop_free(chain, X509_free);
2552     OPENSSL_free(pass);
2553 #ifndef OPENSSL_NO_SRP
2554     OPENSSL_free(srp_arg.srppassin);
2555 #endif
2556     OPENSSL_free(connectstr);
2557     OPENSSL_free(host);
2558     OPENSSL_free(port);
2559     X509_VERIFY_PARAM_free(vpm);
2560     ssl_excert_free(exc);
2561     sk_OPENSSL_STRING_free(ssl_args);
2562     sk_OPENSSL_STRING_free(dane_tlsa_rrset);
2563     SSL_CONF_CTX_free(cctx);
2564     OPENSSL_clear_free(cbuf, BUFSIZZ);
2565     OPENSSL_clear_free(sbuf, BUFSIZZ);
2566     OPENSSL_clear_free(mbuf, BUFSIZZ);
2567     release_engine(e);
2568     BIO_free(bio_c_out);
2569     bio_c_out = NULL;
2570     BIO_free(bio_c_msg);
2571     bio_c_msg = NULL;
2572     return (ret);
2573 }
2574
2575 static void print_stuff(BIO *bio, SSL *s, int full)
2576 {
2577     X509 *peer = NULL;
2578     char buf[BUFSIZ];
2579     STACK_OF(X509) *sk;
2580     STACK_OF(X509_NAME) *sk2;
2581     const SSL_CIPHER *c;
2582     X509_NAME *xn;
2583     int i;
2584 #ifndef OPENSSL_NO_COMP
2585     const COMP_METHOD *comp, *expansion;
2586 #endif
2587     unsigned char *exportedkeymat;
2588 #ifndef OPENSSL_NO_CT
2589     const SSL_CTX *ctx = SSL_get_SSL_CTX(s);
2590 #endif
2591
2592     if (full) {
2593         int got_a_chain = 0;
2594
2595         sk = SSL_get_peer_cert_chain(s);
2596         if (sk != NULL) {
2597             got_a_chain = 1;
2598
2599             BIO_printf(bio, "---\nCertificate chain\n");
2600             for (i = 0; i < sk_X509_num(sk); i++) {
2601                 X509_NAME_oneline(X509_get_subject_name(sk_X509_value(sk, i)),
2602                                   buf, sizeof buf);
2603                 BIO_printf(bio, "%2d s:%s\n", i, buf);
2604                 X509_NAME_oneline(X509_get_issuer_name(sk_X509_value(sk, i)),
2605                                   buf, sizeof buf);
2606                 BIO_printf(bio, "   i:%s\n", buf);
2607                 if (c_showcerts)
2608                     PEM_write_bio_X509(bio, sk_X509_value(sk, i));
2609             }
2610         }
2611
2612         BIO_printf(bio, "---\n");
2613         peer = SSL_get_peer_certificate(s);
2614         if (peer != NULL) {
2615             BIO_printf(bio, "Server certificate\n");
2616
2617             /* Redundant if we showed the whole chain */
2618             if (!(c_showcerts && got_a_chain))
2619                 PEM_write_bio_X509(bio, peer);
2620             X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2621             BIO_printf(bio, "subject=%s\n", buf);
2622             X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2623             BIO_printf(bio, "issuer=%s\n", buf);
2624         } else
2625             BIO_printf(bio, "no peer certificate available\n");
2626
2627         sk2 = SSL_get_client_CA_list(s);
2628         if ((sk2 != NULL) && (sk_X509_NAME_num(sk2) > 0)) {
2629             BIO_printf(bio, "---\nAcceptable client certificate CA names\n");
2630             for (i = 0; i < sk_X509_NAME_num(sk2); i++) {
2631                 xn = sk_X509_NAME_value(sk2, i);
2632                 X509_NAME_oneline(xn, buf, sizeof(buf));
2633                 BIO_write(bio, buf, strlen(buf));
2634                 BIO_write(bio, "\n", 1);
2635             }
2636         } else {
2637             BIO_printf(bio, "---\nNo client certificate CA names sent\n");
2638         }
2639
2640         ssl_print_sigalgs(bio, s);
2641         ssl_print_tmp_key(bio, s);
2642
2643 #ifndef OPENSSL_NO_CT
2644         /*
2645          * When the SSL session is anonymous, or resumed via an abbreviated
2646          * handshake, no SCTs are provided as part of the handshake.  While in
2647          * a resumed session SCTs may be present in the session's certificate,
2648          * no callbacks are invoked to revalidate these, and in any case that
2649          * set of SCTs may be incomplete.  Thus it makes little sense to
2650          * attempt to display SCTs from a resumed session's certificate, and of
2651          * course none are associated with an anonymous peer.
2652          */
2653         if (peer != NULL && !SSL_session_reused(s) && SSL_ct_is_enabled(s)) {
2654             const STACK_OF(SCT) *scts = SSL_get0_peer_scts(s);
2655             int sct_count = scts != NULL ? sk_SCT_num(scts) : 0;
2656
2657             BIO_printf(bio, "---\nSCTs present (%i)\n", sct_count);
2658             if (sct_count > 0) {
2659                 const CTLOG_STORE *log_store = SSL_CTX_get0_ctlog_store(ctx);
2660
2661                 BIO_printf(bio, "---\n");
2662                 for (i = 0; i < sct_count; ++i) {
2663                     SCT *sct = sk_SCT_value(scts, i);
2664
2665                     BIO_printf(bio, "SCT validation status: %s\n",
2666                                SCT_validation_status_string(sct));
2667                     SCT_print(sct, bio, 0, log_store);
2668                     if (i < sct_count - 1)
2669                         BIO_printf(bio, "\n---\n");
2670                 }
2671                 BIO_printf(bio, "\n");
2672             }
2673         }
2674 #endif
2675
2676         BIO_printf(bio,
2677                    "---\nSSL handshake has read %" PRIu64
2678                    " bytes and written %" PRIu64 " bytes\n",
2679                    BIO_number_read(SSL_get_rbio(s)),
2680                    BIO_number_written(SSL_get_wbio(s)));
2681     }
2682     print_verify_detail(s, bio);
2683     BIO_printf(bio, (SSL_session_reused(s) ? "---\nReused, " : "---\nNew, "));
2684     c = SSL_get_current_cipher(s);
2685     BIO_printf(bio, "%s, Cipher is %s\n",
2686                SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2687     if (peer != NULL) {
2688         EVP_PKEY *pktmp;
2689
2690         pktmp = X509_get0_pubkey(peer);
2691         BIO_printf(bio, "Server public key is %d bit\n",
2692                    EVP_PKEY_bits(pktmp));
2693     }
2694     BIO_printf(bio, "Secure Renegotiation IS%s supported\n",
2695                SSL_get_secure_renegotiation_support(s) ? "" : " NOT");
2696 #ifndef OPENSSL_NO_COMP
2697     comp = SSL_get_current_compression(s);
2698     expansion = SSL_get_current_expansion(s);
2699     BIO_printf(bio, "Compression: %s\n",
2700                comp ? SSL_COMP_get_name(comp) : "NONE");
2701     BIO_printf(bio, "Expansion: %s\n",
2702                expansion ? SSL_COMP_get_name(expansion) : "NONE");
2703 #endif
2704
2705 #ifdef SSL_DEBUG
2706     {
2707         /* Print out local port of connection: useful for debugging */
2708         int sock;
2709         union BIO_sock_info_u info;
2710
2711         sock = SSL_get_fd(s);
2712         if ((info.addr = BIO_ADDR_new()) != NULL
2713             && BIO_sock_info(sock, BIO_SOCK_INFO_ADDRESS, &info)) {
2714             BIO_printf(bio_c_out, "LOCAL PORT is %u\n",
2715                        ntohs(BIO_ADDR_rawport(info.addr)));
2716         }
2717         BIO_ADDR_free(info.addr);
2718     }
2719 #endif
2720
2721 #if !defined(OPENSSL_NO_NEXTPROTONEG)
2722     if (next_proto.status != -1) {
2723         const unsigned char *proto;
2724         unsigned int proto_len;
2725         SSL_get0_next_proto_negotiated(s, &proto, &proto_len);
2726         BIO_printf(bio, "Next protocol: (%d) ", next_proto.status);
2727         BIO_write(bio, proto, proto_len);
2728         BIO_write(bio, "\n", 1);
2729     }
2730 #endif
2731     {
2732         const unsigned char *proto;
2733         unsigned int proto_len;
2734         SSL_get0_alpn_selected(s, &proto, &proto_len);
2735         if (proto_len > 0) {
2736             BIO_printf(bio, "ALPN protocol: ");
2737             BIO_write(bio, proto, proto_len);
2738             BIO_write(bio, "\n", 1);
2739         } else
2740             BIO_printf(bio, "No ALPN negotiated\n");
2741     }
2742
2743 #ifndef OPENSSL_NO_SRTP
2744     {
2745         SRTP_PROTECTION_PROFILE *srtp_profile =
2746             SSL_get_selected_srtp_profile(s);
2747
2748         if (srtp_profile)
2749             BIO_printf(bio, "SRTP Extension negotiated, profile=%s\n",
2750                        srtp_profile->name);
2751     }
2752 #endif
2753
2754     SSL_SESSION_print(bio, SSL_get_session(s));
2755     if (SSL_get_session(s) != NULL && keymatexportlabel != NULL) {
2756         BIO_printf(bio, "Keying material exporter:\n");
2757         BIO_printf(bio, "    Label: '%s'\n", keymatexportlabel);
2758         BIO_printf(bio, "    Length: %i bytes\n", keymatexportlen);
2759         exportedkeymat = app_malloc(keymatexportlen, "export key");
2760         if (!SSL_export_keying_material(s, exportedkeymat,
2761                                         keymatexportlen,
2762                                         keymatexportlabel,
2763                                         strlen(keymatexportlabel),
2764                                         NULL, 0, 0)) {
2765             BIO_printf(bio, "    Error\n");
2766         } else {
2767             BIO_printf(bio, "    Keying material: ");
2768             for (i = 0; i < keymatexportlen; i++)
2769                 BIO_printf(bio, "%02X", exportedkeymat[i]);
2770             BIO_printf(bio, "\n");
2771         }
2772         OPENSSL_free(exportedkeymat);
2773     }
2774     BIO_printf(bio, "---\n");
2775     X509_free(peer);
2776     /* flush, or debugging output gets mixed with http response */
2777     (void)BIO_flush(bio);
2778 }
2779
2780 # ifndef OPENSSL_NO_OCSP
2781 static int ocsp_resp_cb(SSL *s, void *arg)
2782 {
2783     const unsigned char *p;
2784     int len;
2785     OCSP_RESPONSE *rsp;
2786     len = SSL_get_tlsext_status_ocsp_resp(s, &p);
2787     BIO_puts(arg, "OCSP response: ");
2788     if (!p) {
2789         BIO_puts(arg, "no response sent\n");
2790         return 1;
2791     }
2792     rsp = d2i_OCSP_RESPONSE(NULL, &p, len);
2793     if (!rsp) {
2794         BIO_puts(arg, "response parse error\n");
2795         BIO_dump_indent(arg, (char *)p, len, 4);
2796         return 0;
2797     }
2798     BIO_puts(arg, "\n======================================\n");
2799     OCSP_RESPONSE_print(arg, rsp, 0);
2800     BIO_puts(arg, "======================================\n");
2801     OCSP_RESPONSE_free(rsp);
2802     return 1;
2803 }
2804 # endif
2805
2806 #endif                          /* OPENSSL_NO_SOCK */