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