apps/s_client.c

   1 /* apps/s_client.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111 /* ====================================================================
 112  * Copyright 2005 Nokia. All rights reserved.
 113  *
 114  * The portions of the attached software ("Contribution") is developed by
 115  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 116  * license.
 117  *
 118  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
 119  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
 120  * support (see RFC 4279) to OpenSSL.
 121  *
 122  * No patent licenses or other rights except those expressly stated in
 123  * the OpenSSL open source license shall be deemed granted or received
 124  * expressly, by implication, estoppel, or otherwise.
 125  *
 126  * No assurances are provided by Nokia that the Contribution does not
 127  * infringe the patent or other intellectual property rights of any third
 128  * party or that the license provides you with all the necessary rights
 129  * to make use of the Contribution.
 130  *
 131  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
 132  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
 133  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
 134  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
 135  * OTHERWISE.
 136  */
 137
 138 #include <assert.h>
 139 #include <ctype.h>
 140 #include <stdio.h>
 141 #include <stdlib.h>
 142 #include <string.h>
 143 #include <openssl/e_os2.h>
 144 #ifdef OPENSSL_NO_STDIO
 145 # define APPS_WIN16
 146 #endif
 147
 148 /*
 149  * With IPv6, it looks like Digital has mixed up the proper order of
 150  * recursive header file inclusion, resulting in the compiler complaining
 151  * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is
 152  * needed to have fileno() declared correctly...  So let's define u_int
 153  */
 154 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
 155 # define __U_INT
 156 typedef unsigned int u_int;
 157 #endif
 158
 159 #define USE_SOCKETS
 160 #include "apps.h"
 161 #include <openssl/x509.h>
 162 #include <openssl/ssl.h>
 163 #include <openssl/err.h>
 164 #include <openssl/pem.h>
 165 #include <openssl/rand.h>
 166 #include <openssl/ocsp.h>
 167 #include <openssl/bn.h>
 168 #include "s_apps.h"
 169 #include "timeouts.h"
 170
 171 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
 172 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
 173 # undef FIONBIO
 174 #endif
 175
 176 #if defined(OPENSSL_SYS_BEOS_R5)
 177 # include <fcntl.h>
 178 #endif
 179
 180 #undef PROG
 181 #define PROG    s_client_main
 182
 183 /*
 184  * #define SSL_HOST_NAME "www.netscape.com"
 185  */
 186 /*
 187  * #define SSL_HOST_NAME "193.118.187.102"
 188  */
 189 #define SSL_HOST_NAME   "localhost"
 190
 191 /* no default cert. */
 192 /*
 193  * #define TEST_CERT "client.pem"
 194  */
 195
 196 #undef BUFSIZZ
 197 #define BUFSIZZ 1024*8
 198
 199 extern int verify_depth;
 200 extern int verify_error;
 201 extern int verify_return_error;
 202
 203 #ifdef FIONBIO
 204 static int c_nbio = 0;
 205 #endif
 206 static int c_Pause = 0;
 207 static int c_debug = 0;
 208 #ifndef OPENSSL_NO_TLSEXT
 209 static int c_tlsextdebug = 0;
 210 static int c_status_req = 0;
 211 #endif
 212 static int c_msg = 0;
 213 static int c_showcerts = 0;
 214
 215 static void sc_usage(void);
 216 static void print_stuff(BIO *berr, SSL *con, int full);
 217 #ifndef OPENSSL_NO_TLSEXT
 218 static int ocsp_resp_cb(SSL *s, void *arg);
 219 #endif
 220 static BIO *bio_c_out = NULL;
 221 static int c_quiet = 0;
 222 static int c_ign_eof = 0;
 223
 224 #ifndef OPENSSL_NO_PSK
 225 /* Default PSK identity and key */
 226 static char *psk_identity = "Client_identity";
 227 /*
 228  * char *psk_key=NULL; by default PSK is not used
 229  */
 230
 231 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity,
 232                                   unsigned int max_identity_len,
 233                                   unsigned char *psk,
 234                                   unsigned int max_psk_len)
 235 {
 236     unsigned int psk_len = 0;
 237     int ret;
 238     BIGNUM *bn = NULL;
 239
 240     if (c_debug)
 241         BIO_printf(bio_c_out, "psk_client_cb\n");
 242     if (!hint) {
 243         /* no ServerKeyExchange message */
 244         if (c_debug)
 245             BIO_printf(bio_c_out,
 246                        "NULL received PSK identity hint, continuing anyway\n");
 247     } else if (c_debug)
 248         BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint);
 249
 250     /*
 251      * lookup PSK identity and PSK key based on the given identity hint here
 252      */
 253     ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity);
 254     if (ret < 0 || (unsigned int)ret > max_identity_len)
 255         goto out_err;
 256     if (c_debug)
 257         BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity,
 258                    ret);
 259     ret = BN_hex2bn(&bn, psk_key);
 260     if (!ret) {
 261         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
 262                    psk_key);
 263         if (bn)
 264             BN_free(bn);
 265         return 0;
 266     }
 267
 268     if ((unsigned int)BN_num_bytes(bn) > max_psk_len) {
 269         BIO_printf(bio_err,
 270                    "psk buffer of callback is too small (%d) for key (%d)\n",
 271                    max_psk_len, BN_num_bytes(bn));
 272         BN_free(bn);
 273         return 0;
 274     }
 275
 276     psk_len = BN_bn2bin(bn, psk);
 277     BN_free(bn);
 278     if (psk_len == 0)
 279         goto out_err;
 280
 281     if (c_debug)
 282         BIO_printf(bio_c_out, "created PSK len=%d\n", psk_len);
 283
 284     return psk_len;
 285  out_err:
 286     if (c_debug)
 287         BIO_printf(bio_err, "Error in PSK client callback\n");
 288     return 0;
 289 }
 290 #endif
 291
 292 static void sc_usage(void)
 293 {
 294     BIO_printf(bio_err, "usage: s_client args\n");
 295     BIO_printf(bio_err, "\n");
 296     BIO_printf(bio_err, " -host host     - use -connect instead\n");
 297     BIO_printf(bio_err, " -port port     - use -connect instead\n");
 298     BIO_printf(bio_err,
 299                " -connect host:port - who to connect to (default is %s:%s)\n",
 300                SSL_HOST_NAME, PORT_STR);
 301
 302     BIO_printf(bio_err,
 303                " -verify arg   - turn on peer certificate verification\n");
 304     BIO_printf(bio_err,
 305                " -verify_return_error - return verification errors\n");
 306     BIO_printf(bio_err,
 307                " -cert arg     - certificate file to use, PEM format assumed\n");
 308     BIO_printf(bio_err,
 309                " -certform arg - certificate format (PEM or DER) PEM default\n");
 310     BIO_printf(bio_err,
 311                " -key arg      - Private key file to use, in cert file if\n");
 312     BIO_printf(bio_err, "                 not specified but cert file is.\n");
 313     BIO_printf(bio_err,
 314                " -keyform arg  - key format (PEM or DER) PEM default\n");
 315     BIO_printf(bio_err,
 316                " -pass arg     - private key file pass phrase source\n");
 317     BIO_printf(bio_err, " -CApath arg   - PEM format directory of CA's\n");
 318     BIO_printf(bio_err, " -CAfile arg   - PEM format file of CA's\n");
 319     BIO_printf(bio_err,
 320                " -reconnect    - Drop and re-make the connection with the same Session-ID\n");
 321     BIO_printf(bio_err,
 322                " -pause        - sleep(1) after each read(2) and write(2) system call\n");
 323     BIO_printf(bio_err,
 324                " -prexit       - print session information even on connection failure\n");
 325     BIO_printf(bio_err,
 326                " -showcerts    - show all certificates in the chain\n");
 327     BIO_printf(bio_err, " -debug        - extra output\n");
 328 #ifdef WATT32
 329     BIO_printf(bio_err, " -wdebug       - WATT-32 tcp debugging\n");
 330 #endif
 331     BIO_printf(bio_err, " -msg          - Show protocol messages\n");
 332     BIO_printf(bio_err, " -nbio_test    - more ssl protocol testing\n");
 333     BIO_printf(bio_err, " -state        - print the 'ssl' states\n");
 334 #ifdef FIONBIO
 335     BIO_printf(bio_err, " -nbio         - Run with non-blocking IO\n");
 336 #endif
 337     BIO_printf(bio_err,
 338                " -crlf         - convert LF from terminal into CRLF\n");
 339     BIO_printf(bio_err, " -quiet        - no s_client output\n");
 340     BIO_printf(bio_err,
 341                " -ign_eof      - ignore input eof (default when -quiet)\n");
 342     BIO_printf(bio_err, " -no_ign_eof   - don't ignore input eof\n");
 343 #ifndef OPENSSL_NO_PSK
 344     BIO_printf(bio_err, " -psk_identity arg - PSK identity\n");
 345     BIO_printf(bio_err, " -psk arg      - PSK in hex (without 0x)\n");
 346 # ifndef OPENSSL_NO_JPAKE
 347     BIO_printf(bio_err, " -jpake arg    - JPAKE secret to use\n");
 348 # endif
 349 #endif
 350     BIO_printf(bio_err, " -ssl2         - just use SSLv2\n");
 351     BIO_printf(bio_err, " -ssl3         - just use SSLv3\n");
 352     BIO_printf(bio_err, " -tls1         - just use TLSv1\n");
 353     BIO_printf(bio_err, " -dtls1        - just use DTLSv1\n");
 354     BIO_printf(bio_err, " -fallback_scsv - send TLS_FALLBACK_SCSV\n");
 355     BIO_printf(bio_err, " -mtu          - set the link layer MTU\n");
 356     BIO_printf(bio_err,
 357                " -no_tls1/-no_ssl3/-no_ssl2 - turn off that protocol\n");
 358     BIO_printf(bio_err,
 359                " -bugs         - Switch on all SSL implementation bug workarounds\n");
 360     BIO_printf(bio_err,
 361                " -serverpref   - Use server's cipher preferences (only SSLv2)\n");
 362     BIO_printf(bio_err,
 363                " -cipher       - preferred cipher to use, use the 'openssl ciphers'\n");
 364     BIO_printf(bio_err,
 365                "                 command to see what is available\n");
 366     BIO_printf(bio_err,
 367                " -starttls prot - use the STARTTLS command before starting TLS\n");
 368     BIO_printf(bio_err,
 369                "                 for those protocols that support it, where\n");
 370     BIO_printf(bio_err,
 371                "                 'prot' defines which one to assume.  Currently,\n");
 372     BIO_printf(bio_err,
 373                "                 only \"smtp\", \"pop3\", \"imap\", \"ftp\" and \"xmpp\"\n");
 374     BIO_printf(bio_err, "                 are supported.\n");
 375 #ifndef OPENSSL_NO_ENGINE
 376     BIO_printf(bio_err,
 377                " -engine id    - Initialise and use the specified engine\n");
 378 #endif
 379     BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
 380                LIST_SEPARATOR_CHAR);
 381     BIO_printf(bio_err, " -sess_out arg - file to write SSL session to\n");
 382     BIO_printf(bio_err, " -sess_in arg  - file to read SSL session from\n");
 383 #ifndef OPENSSL_NO_TLSEXT
 384     BIO_printf(bio_err,
 385                " -servername host  - Set TLS extension servername in ClientHello\n");
 386     BIO_printf(bio_err,
 387                " -tlsextdebug      - hex dump of all TLS extensions received\n");
 388     BIO_printf(bio_err,
 389                " -status           - request certificate status from server\n");
 390     BIO_printf(bio_err,
 391                " -no_ticket        - disable use of RFC4507bis session tickets\n");
 392 #endif
 393     BIO_printf(bio_err,
 394                " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 395 }
 396
 397 #ifndef OPENSSL_NO_TLSEXT
 398
 399 /* This is a context that we pass to callbacks */
 400 typedef struct tlsextctx_st {
 401     BIO *biodebug;
 402     int ack;
 403 } tlsextctx;
 404
 405 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
 406 {
 407     tlsextctx *p = (tlsextctx *) arg;
 408     const char *hn = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 409     if (SSL_get_servername_type(s) != -1)
 410         p->ack = !SSL_session_reused(s) && hn != NULL;
 411     else
 412         BIO_printf(bio_err, "Can't use SSL_get_servername\n");
 413
 414     return SSL_TLSEXT_ERR_OK;
 415 }
 416 #endif
 417
 418 enum {
 419     PROTO_OFF = 0,
 420     PROTO_SMTP,
 421     PROTO_POP3,
 422     PROTO_IMAP,
 423     PROTO_FTP,
 424     PROTO_XMPP
 425 };
 426
 427 int MAIN(int, char **);
 428
 429 int MAIN(int argc, char **argv)
 430 {
 431     unsigned int off = 0, clr = 0;
 432     SSL *con = NULL;
 433     int s, k, width, state = 0;
 434     char *cbuf = NULL, *sbuf = NULL, *mbuf = NULL;
 435     int cbuf_len, cbuf_off;
 436     int sbuf_len, sbuf_off;
 437     fd_set readfds, writefds;
 438     short port = PORT;
 439     int full_log = 1;
 440     char *host = SSL_HOST_NAME;
 441     char *cert_file = NULL, *key_file = NULL;
 442     int cert_format = FORMAT_PEM, key_format = FORMAT_PEM;
 443     char *passarg = NULL, *pass = NULL;
 444     X509 *cert = NULL;
 445     EVP_PKEY *key = NULL;
 446     char *CApath = NULL, *CAfile = NULL, *cipher = NULL;
 447     int reconnect = 0, badop = 0, verify = SSL_VERIFY_NONE, bugs = 0;
 448     int crlf = 0;
 449     int write_tty, read_tty, write_ssl, read_ssl, tty_on, ssl_pending;
 450     SSL_CTX *ctx = NULL;
 451     int ret = 1, in_init = 1, i, nbio_test = 0;
 452     int starttls_proto = PROTO_OFF;
 453     int prexit = 0;
 454     X509_VERIFY_PARAM *vpm = NULL;
 455     int badarg = 0;
 456     const SSL_METHOD *meth = NULL;
 457     int socket_type = SOCK_STREAM;
 458     BIO *sbio;
 459     char *inrand = NULL;
 460     int mbuf_len = 0;
 461     struct timeval timeout, *timeoutp;
 462 #ifndef OPENSSL_NO_ENGINE
 463     char *engine_id = NULL;
 464     char *ssl_client_engine_id = NULL;
 465     ENGINE *ssl_client_engine = NULL;
 466 #endif
 467     ENGINE *e = NULL;
 468 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
 469     struct timeval tv;
 470 # if defined(OPENSSL_SYS_BEOS_R5)
 471     int stdin_set = 0;
 472 # endif
 473 #endif
 474 #ifndef OPENSSL_NO_TLSEXT
 475     char *servername = NULL;
 476     tlsextctx tlsextcbp = { NULL, 0 };
 477 #endif
 478     char *sess_in = NULL;
 479     char *sess_out = NULL;
 480     struct sockaddr peer;
 481     int peerlen = sizeof(peer);
 482     int fallback_scsv = 0;
 483     int enable_timeouts = 0;
 484     long socket_mtu = 0;
 485 #ifndef OPENSSL_NO_JPAKE
 486     char *jpake_secret = NULL;
 487 #endif
 488
 489     meth = SSLv23_client_method();
 490
 491     apps_startup();
 492     c_Pause = 0;
 493     c_quiet = 0;
 494     c_ign_eof = 0;
 495     c_debug = 0;
 496     c_msg = 0;
 497     c_showcerts = 0;
 498
 499     if (bio_err == NULL)
 500         bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
 501
 502     if (!load_config(bio_err, NULL))
 503         goto end;
 504
 505     if (((cbuf = OPENSSL_malloc(BUFSIZZ)) == NULL) ||
 506         ((sbuf = OPENSSL_malloc(BUFSIZZ)) == NULL) ||
 507         ((mbuf = OPENSSL_malloc(BUFSIZZ)) == NULL)) {
 508         BIO_printf(bio_err, "out of memory\n");
 509         goto end;
 510     }
 511
 512     verify_depth = 0;
 513     verify_error = X509_V_OK;
 514 #ifdef FIONBIO
 515     c_nbio = 0;
 516 #endif
 517
 518     argc--;
 519     argv++;
 520     while (argc >= 1) {
 521         if (strcmp(*argv, "-host") == 0) {
 522             if (--argc < 1)
 523                 goto bad;
 524             host = *(++argv);
 525         } else if (strcmp(*argv, "-port") == 0) {
 526             if (--argc < 1)
 527                 goto bad;
 528             port = atoi(*(++argv));
 529             if (port == 0)
 530                 goto bad;
 531         } else if (strcmp(*argv, "-connect") == 0) {
 532             if (--argc < 1)
 533                 goto bad;
 534             if (!extract_host_port(*(++argv), &host, NULL, &port))
 535                 goto bad;
 536         } else if (strcmp(*argv, "-verify") == 0) {
 537             verify = SSL_VERIFY_PEER;
 538             if (--argc < 1)
 539                 goto bad;
 540             verify_depth = atoi(*(++argv));
 541             BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
 542         } else if (strcmp(*argv, "-cert") == 0) {
 543             if (--argc < 1)
 544                 goto bad;
 545             cert_file = *(++argv);
 546         } else if (strcmp(*argv, "-sess_out") == 0) {
 547             if (--argc < 1)
 548                 goto bad;
 549             sess_out = *(++argv);
 550         } else if (strcmp(*argv, "-sess_in") == 0) {
 551             if (--argc < 1)
 552                 goto bad;
 553             sess_in = *(++argv);
 554         } else if (strcmp(*argv, "-certform") == 0) {
 555             if (--argc < 1)
 556                 goto bad;
 557             cert_format = str2fmt(*(++argv));
 558         } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
 559             if (badarg)
 560                 goto bad;
 561             continue;
 562         } else if (strcmp(*argv, "-verify_return_error") == 0)
 563             verify_return_error = 1;
 564         else if (strcmp(*argv, "-prexit") == 0)
 565             prexit = 1;
 566         else if (strcmp(*argv, "-crlf") == 0)
 567             crlf = 1;
 568         else if (strcmp(*argv, "-quiet") == 0) {
 569             c_quiet = 1;
 570             c_ign_eof = 1;
 571         } else if (strcmp(*argv, "-ign_eof") == 0)
 572             c_ign_eof = 1;
 573         else if (strcmp(*argv, "-no_ign_eof") == 0)
 574             c_ign_eof = 0;
 575         else if (strcmp(*argv, "-pause") == 0)
 576             c_Pause = 1;
 577         else if (strcmp(*argv, "-debug") == 0)
 578             c_debug = 1;
 579 #ifndef OPENSSL_NO_TLSEXT
 580         else if (strcmp(*argv, "-tlsextdebug") == 0)
 581             c_tlsextdebug = 1;
 582         else if (strcmp(*argv, "-status") == 0)
 583             c_status_req = 1;
 584 #endif
 585 #ifdef WATT32
 586         else if (strcmp(*argv, "-wdebug") == 0)
 587             dbug_init();
 588 #endif
 589         else if (strcmp(*argv, "-msg") == 0)
 590             c_msg = 1;
 591         else if (strcmp(*argv, "-showcerts") == 0)
 592             c_showcerts = 1;
 593         else if (strcmp(*argv, "-nbio_test") == 0)
 594             nbio_test = 1;
 595         else if (strcmp(*argv, "-state") == 0)
 596             state = 1;
 597 #ifndef OPENSSL_NO_PSK
 598         else if (strcmp(*argv, "-psk_identity") == 0) {
 599             if (--argc < 1)
 600                 goto bad;
 601             psk_identity = *(++argv);
 602         } else if (strcmp(*argv, "-psk") == 0) {
 603             size_t j;
 604
 605             if (--argc < 1)
 606                 goto bad;
 607             psk_key = *(++argv);
 608             for (j = 0; j < strlen(psk_key); j++) {
 609                 if (isxdigit((unsigned char)psk_key[j]))
 610                     continue;
 611                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
 612                 goto bad;
 613             }
 614         }
 615 #endif
 616 #ifndef OPENSSL_NO_SSL2
 617         else if (strcmp(*argv, "-ssl2") == 0)
 618             meth = SSLv2_client_method();
 619 #endif
 620 #ifndef OPENSSL_NO_SSL3
 621         else if (strcmp(*argv, "-ssl3") == 0)
 622             meth = SSLv3_client_method();
 623 #endif
 624 #ifndef OPENSSL_NO_TLS1
 625         else if (strcmp(*argv, "-tls1") == 0)
 626             meth = TLSv1_client_method();
 627 #endif
 628 #ifndef OPENSSL_NO_DTLS1
 629         else if (strcmp(*argv, "-dtls1") == 0) {
 630             meth = DTLSv1_client_method();
 631             socket_type = SOCK_DGRAM;
 632         } else if (strcmp(*argv, "-timeout") == 0)
 633             enable_timeouts = 1;
 634         else if (strcmp(*argv, "-mtu") == 0) {
 635             if (--argc < 1)
 636                 goto bad;
 637             socket_mtu = atol(*(++argv));
 638         }
 639 #endif
 640         else if (strcmp(*argv, "-fallback_scsv") == 0) {
 641             fallback_scsv = 1;
 642         } else if (strcmp(*argv, "-bugs") == 0)
 643             bugs = 1;
 644         else if (strcmp(*argv, "-keyform") == 0) {
 645             if (--argc < 1)
 646                 goto bad;
 647             key_format = str2fmt(*(++argv));
 648         } else if (strcmp(*argv, "-pass") == 0) {
 649             if (--argc < 1)
 650                 goto bad;
 651             passarg = *(++argv);
 652         } else if (strcmp(*argv, "-key") == 0) {
 653             if (--argc < 1)
 654                 goto bad;
 655             key_file = *(++argv);
 656         } else if (strcmp(*argv, "-reconnect") == 0) {
 657             reconnect = 5;
 658         } else if (strcmp(*argv, "-CApath") == 0) {
 659             if (--argc < 1)
 660                 goto bad;
 661             CApath = *(++argv);
 662         } else if (strcmp(*argv, "-CAfile") == 0) {
 663             if (--argc < 1)
 664                 goto bad;
 665             CAfile = *(++argv);
 666         } else if (strcmp(*argv, "-no_tls1") == 0)
 667             off |= SSL_OP_NO_TLSv1;
 668         else if (strcmp(*argv, "-no_ssl3") == 0)
 669             off |= SSL_OP_NO_SSLv3;
 670         else if (strcmp(*argv, "-no_ssl2") == 0)
 671             off |= SSL_OP_NO_SSLv2;
 672         else if (strcmp(*argv, "-no_comp") == 0) {
 673             off |= SSL_OP_NO_COMPRESSION;
 674         }
 675 #ifndef OPENSSL_NO_TLSEXT
 676         else if (strcmp(*argv, "-no_ticket") == 0) {
 677             off |= SSL_OP_NO_TICKET;
 678         }
 679 #endif
 680         else if (strcmp(*argv, "-serverpref") == 0)
 681             off |= SSL_OP_CIPHER_SERVER_PREFERENCE;
 682         else if (strcmp(*argv, "-legacy_renegotiation") == 0)
 683             off |= SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION;
 684         else if (strcmp(*argv, "-legacy_server_connect") == 0) {
 685             off |= SSL_OP_LEGACY_SERVER_CONNECT;
 686         } else if (strcmp(*argv, "-no_legacy_server_connect") == 0) {
 687             clr |= SSL_OP_LEGACY_SERVER_CONNECT;
 688         } else if (strcmp(*argv, "-cipher") == 0) {
 689             if (--argc < 1)
 690                 goto bad;
 691             cipher = *(++argv);
 692         }
 693 #ifdef FIONBIO
 694         else if (strcmp(*argv, "-nbio") == 0) {
 695             c_nbio = 1;
 696         }
 697 #endif
 698         else if (strcmp(*argv, "-starttls") == 0) {
 699             if (--argc < 1)
 700                 goto bad;
 701             ++argv;
 702             if (strcmp(*argv, "smtp") == 0)
 703                 starttls_proto = PROTO_SMTP;
 704             else if (strcmp(*argv, "pop3") == 0)
 705                 starttls_proto = PROTO_POP3;
 706             else if (strcmp(*argv, "imap") == 0)
 707                 starttls_proto = PROTO_IMAP;
 708             else if (strcmp(*argv, "ftp") == 0)
 709                 starttls_proto = PROTO_FTP;
 710             else if (strcmp(*argv, "xmpp") == 0)
 711                 starttls_proto = PROTO_XMPP;
 712             else
 713                 goto bad;
 714         }
 715 #ifndef OPENSSL_NO_ENGINE
 716         else if (strcmp(*argv, "-engine") == 0) {
 717             if (--argc < 1)
 718                 goto bad;
 719             engine_id = *(++argv);
 720         } else if (strcmp(*argv, "-ssl_client_engine") == 0) {
 721             if (--argc < 1)
 722                 goto bad;
 723             ssl_client_engine_id = *(++argv);
 724         }
 725 #endif
 726         else if (strcmp(*argv, "-rand") == 0) {
 727             if (--argc < 1)
 728                 goto bad;
 729             inrand = *(++argv);
 730         }
 731 #ifndef OPENSSL_NO_TLSEXT
 732         else if (strcmp(*argv, "-servername") == 0) {
 733             if (--argc < 1)
 734                 goto bad;
 735             servername = *(++argv);
 736             /* meth=TLSv1_client_method(); */
 737         }
 738 #endif
 739 #ifndef OPENSSL_NO_JPAKE
 740         else if (strcmp(*argv, "-jpake") == 0) {
 741             if (--argc < 1)
 742                 goto bad;
 743             jpake_secret = *++argv;
 744         }
 745 #endif
 746         else {
 747             BIO_printf(bio_err, "unknown option %s\n", *argv);
 748             badop = 1;
 749             break;
 750         }
 751         argc--;
 752         argv++;
 753     }
 754     if (badop) {
 755  bad:
 756         sc_usage();
 757         goto end;
 758     }
 759 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
 760     if (jpake_secret) {
 761         if (psk_key) {
 762             BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
 763             goto end;
 764         }
 765         psk_identity = "JPAKE";
 766         if (cipher) {
 767             BIO_printf(bio_err, "JPAKE sets cipher to PSK\n");
 768             goto end;
 769         }
 770         cipher = "PSK";
 771     }
 772 #endif
 773
 774     OpenSSL_add_ssl_algorithms();
 775     SSL_load_error_strings();
 776
 777 #ifndef OPENSSL_NO_ENGINE
 778     e = setup_engine(bio_err, engine_id, 1);
 779     if (ssl_client_engine_id) {
 780         ssl_client_engine = ENGINE_by_id(ssl_client_engine_id);
 781         if (!ssl_client_engine) {
 782             BIO_printf(bio_err, "Error getting client auth engine\n");
 783             goto end;
 784         }
 785     }
 786 #endif
 787     if (!app_passwd(bio_err, passarg, NULL, &pass, NULL)) {
 788         BIO_printf(bio_err, "Error getting password\n");
 789         goto end;
 790     }
 791
 792     if (key_file == NULL)
 793         key_file = cert_file;
 794
 795     if (key_file) {
 796
 797         key = load_key(bio_err, key_file, key_format, 0, pass, e,
 798                        "client certificate private key file");
 799         if (!key) {
 800             ERR_print_errors(bio_err);
 801             goto end;
 802         }
 803
 804     }
 805
 806     if (cert_file) {
 807         cert = load_cert(bio_err, cert_file, cert_format,
 808                          NULL, e, "client certificate file");
 809
 810         if (!cert) {
 811             ERR_print_errors(bio_err);
 812             goto end;
 813         }
 814     }
 815
 816     if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
 817         && !RAND_status()) {
 818         BIO_printf(bio_err,
 819                    "warning, not much extra random data, consider using the -rand option\n");
 820     }
 821     if (inrand != NULL)
 822         BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
 823                    app_RAND_load_files(inrand));
 824
 825     if (bio_c_out == NULL) {
 826         if (c_quiet && !c_debug && !c_msg) {
 827             bio_c_out = BIO_new(BIO_s_null());
 828         } else {
 829             if (bio_c_out == NULL)
 830                 bio_c_out = BIO_new_fp(stdout, BIO_NOCLOSE);
 831         }
 832     }
 833
 834     ctx = SSL_CTX_new(meth);
 835     if (ctx == NULL) {
 836         ERR_print_errors(bio_err);
 837         goto end;
 838     }
 839
 840     if (vpm)
 841         SSL_CTX_set1_param(ctx, vpm);
 842
 843 #ifndef OPENSSL_NO_ENGINE
 844     if (ssl_client_engine) {
 845         if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine)) {
 846             BIO_puts(bio_err, "Error setting client auth engine\n");
 847             ERR_print_errors(bio_err);
 848             ENGINE_free(ssl_client_engine);
 849             goto end;
 850         }
 851         ENGINE_free(ssl_client_engine);
 852     }
 853 #endif
 854
 855 #ifndef OPENSSL_NO_PSK
 856 # ifdef OPENSSL_NO_JPAKE
 857     if (psk_key != NULL)
 858 # else
 859     if (psk_key != NULL || jpake_secret)
 860 # endif
 861     {
 862         if (c_debug)
 863             BIO_printf(bio_c_out,
 864                        "PSK key given or JPAKE in use, setting client callback\n");
 865         SSL_CTX_set_psk_client_callback(ctx, psk_client_cb);
 866     }
 867 #endif
 868     if (bugs)
 869         SSL_CTX_set_options(ctx, SSL_OP_ALL | off);
 870     else
 871         SSL_CTX_set_options(ctx, off);
 872
 873     if (clr)
 874         SSL_CTX_clear_options(ctx, clr);
 875     /*
 876      * DTLS: partial reads end up discarding unread UDP bytes :-( Setting
 877      * read ahead solves this problem.
 878      */
 879     if (socket_type == SOCK_DGRAM)
 880         SSL_CTX_set_read_ahead(ctx, 1);
 881
 882     if (state)
 883         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
 884     if (cipher != NULL)
 885         if (!SSL_CTX_set_cipher_list(ctx, cipher)) {
 886             BIO_printf(bio_err, "error setting cipher list\n");
 887             ERR_print_errors(bio_err);
 888             goto end;
 889         }
 890 #if 0
 891         else
 892             SSL_CTX_set_cipher_list(ctx, getenv("SSL_CIPHER"));
 893 #endif
 894
 895     SSL_CTX_set_verify(ctx, verify, verify_callback);
 896     if (!set_cert_key_stuff(ctx, cert, key))
 897         goto end;
 898
 899     if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
 900         (!SSL_CTX_set_default_verify_paths(ctx))) {
 901         /*
 902          * BIO_printf(bio_err,"error setting default verify locations\n");
 903          */
 904         ERR_print_errors(bio_err);
 905         /* goto end; */
 906     }
 907 #ifndef OPENSSL_NO_TLSEXT
 908     if (servername != NULL) {
 909         tlsextcbp.biodebug = bio_err;
 910         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
 911         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
 912     }
 913 #endif
 914
 915     con = SSL_new(ctx);
 916     if (sess_in) {
 917         SSL_SESSION *sess;
 918         BIO *stmp = BIO_new_file(sess_in, "r");
 919         if (!stmp) {
 920             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
 921             ERR_print_errors(bio_err);
 922             goto end;
 923         }
 924         sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL);
 925         BIO_free(stmp);
 926         if (!sess) {
 927             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
 928             ERR_print_errors(bio_err);
 929             goto end;
 930         }
 931         SSL_set_session(con, sess);
 932         SSL_SESSION_free(sess);
 933     }
 934
 935     if (fallback_scsv)
 936         SSL_set_mode(con, SSL_MODE_SEND_FALLBACK_SCSV);
 937
 938 #ifndef OPENSSL_NO_TLSEXT
 939     if (servername != NULL) {
 940         if (!SSL_set_tlsext_host_name(con, servername)) {
 941             BIO_printf(bio_err, "Unable to set TLS servername extension.\n");
 942             ERR_print_errors(bio_err);
 943             goto end;
 944         }
 945     }
 946 #endif
 947 #ifndef OPENSSL_NO_KRB5
 948     if (con && (con->kssl_ctx = kssl_ctx_new()) != NULL) {
 949         kssl_ctx_setstring(con->kssl_ctx, KSSL_SERVER, host);
 950     }
 951 #endif                          /* OPENSSL_NO_KRB5 */
 952 /*      SSL_set_cipher_list(con,"RC4-MD5"); */
 953 #if 0
 954 # ifdef TLSEXT_TYPE_opaque_prf_input
 955     SSL_set_tlsext_opaque_prf_input(con, "Test client", 11);
 956 # endif
 957 #endif
 958
 959  re_start:
 960
 961     if (init_client(&s, host, port, socket_type) == 0) {
 962         BIO_printf(bio_err, "connect:errno=%d\n", get_last_socket_error());
 963         SHUTDOWN(s);
 964         goto end;
 965     }
 966     BIO_printf(bio_c_out, "CONNECTED(%08X)\n", s);
 967
 968 #ifdef FIONBIO
 969     if (c_nbio) {
 970         unsigned long l = 1;
 971         BIO_printf(bio_c_out, "turning on non blocking io\n");
 972         if (BIO_socket_ioctl(s, FIONBIO, &l) < 0) {
 973             ERR_print_errors(bio_err);
 974             goto end;
 975         }
 976     }
 977 #endif
 978     if (c_Pause & 0x01)
 979         con->debug = 1;
 980
 981     if (SSL_version(con) == DTLS1_VERSION) {
 982
 983         sbio = BIO_new_dgram(s, BIO_NOCLOSE);
 984         if (getsockname(s, &peer, (void *)&peerlen) < 0) {
 985             BIO_printf(bio_err, "getsockname:errno=%d\n",
 986                        get_last_socket_error());
 987             SHUTDOWN(s);
 988             goto end;
 989         }
 990
 991         (void)BIO_ctrl_set_connected(sbio, 1, &peer);
 992
 993         if (enable_timeouts) {
 994             timeout.tv_sec = 0;
 995             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
 996             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
 997
 998             timeout.tv_sec = 0;
 999             timeout.tv_usec = DGRAM_SND_TIMEOUT;
1000             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
1001         }
1002
1003         if (socket_mtu) {
1004             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
1005                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
1006                            DTLS_get_link_min_mtu(con));
1007                 BIO_free(sbio);
1008                 goto shut;
1009             }
1010             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
1011             if (!DTLS_set_link_mtu(con, socket_mtu)) {
1012                 BIO_printf(bio_err, "Failed to set MTU\n");
1013                 BIO_free(sbio);
1014                 goto shut;
1015             }
1016         } else
1017             /* want to do MTU discovery */
1018             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
1019     } else
1020         sbio = BIO_new_socket(s, BIO_NOCLOSE);
1021
1022     if (nbio_test) {
1023         BIO *test;
1024
1025         test = BIO_new(BIO_f_nbio_test());
1026         sbio = BIO_push(test, sbio);
1027     }
1028
1029     if (c_debug) {
1030         con->debug = 1;
1031         BIO_set_callback(sbio, bio_dump_callback);
1032         BIO_set_callback_arg(sbio, (char *)bio_c_out);
1033     }
1034     if (c_msg) {
1035         SSL_set_msg_callback(con, msg_cb);
1036         SSL_set_msg_callback_arg(con, bio_c_out);
1037     }
1038 #ifndef OPENSSL_NO_TLSEXT
1039     if (c_tlsextdebug) {
1040         SSL_set_tlsext_debug_callback(con, tlsext_cb);
1041         SSL_set_tlsext_debug_arg(con, bio_c_out);
1042     }
1043     if (c_status_req) {
1044         SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp);
1045         SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb);
1046         SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out);
1047 # if 0
1048         {
1049             STACK_OF(OCSP_RESPID) *ids = sk_OCSP_RESPID_new_null();
1050             OCSP_RESPID *id = OCSP_RESPID_new();
1051             id->value.byKey = ASN1_OCTET_STRING_new();
1052             id->type = V_OCSP_RESPID_KEY;
1053             ASN1_STRING_set(id->value.byKey, "Hello World", -1);
1054             sk_OCSP_RESPID_push(ids, id);
1055             SSL_set_tlsext_status_ids(con, ids);
1056         }
1057 # endif
1058     }
1059 #endif
1060 #ifndef OPENSSL_NO_JPAKE
1061     if (jpake_secret)
1062         jpake_client_auth(bio_c_out, sbio, jpake_secret);
1063 #endif
1064
1065     SSL_set_bio(con, sbio, sbio);
1066     SSL_set_connect_state(con);
1067
1068     /* ok, lets connect */
1069     width = SSL_get_fd(con) + 1;
1070
1071     read_tty = 1;
1072     write_tty = 0;
1073     tty_on = 0;
1074     read_ssl = 1;
1075     write_ssl = 1;
1076
1077     cbuf_len = 0;
1078     cbuf_off = 0;
1079     sbuf_len = 0;
1080     sbuf_off = 0;
1081
1082     /* This is an ugly hack that does a lot of assumptions */
1083     /*
1084      * We do have to handle multi-line responses which may come in a single
1085      * packet or not. We therefore have to use BIO_gets() which does need a
1086      * buffering BIO. So during the initial chitchat we do push a buffering
1087      * BIO into the chain that is removed again later on to not disturb the
1088      * rest of the s_client operation.
1089      */
1090     if (starttls_proto == PROTO_SMTP) {
1091         int foundit = 0;
1092         BIO *fbio = BIO_new(BIO_f_buffer());
1093         BIO_push(fbio, sbio);
1094         /* wait for multi-line response to end from SMTP */
1095         do {
1096             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1097         }
1098         while (mbuf_len > 3 && mbuf[3] == '-');
1099         /* STARTTLS command requires EHLO... */
1100         BIO_printf(fbio, "EHLO openssl.client.net\r\n");
1101         (void)BIO_flush(fbio);
1102         /* wait for multi-line response to end EHLO SMTP response */
1103         do {
1104             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1105             if (strstr(mbuf, "STARTTLS"))
1106                 foundit = 1;
1107         }
1108         while (mbuf_len > 3 && mbuf[3] == '-');
1109         (void)BIO_flush(fbio);
1110         BIO_pop(fbio);
1111         BIO_free(fbio);
1112         if (!foundit)
1113             BIO_printf(bio_err,
1114                        "didn't found starttls in server response,"
1115                        " try anyway...\n");
1116         BIO_printf(sbio, "STARTTLS\r\n");
1117         BIO_read(sbio, sbuf, BUFSIZZ);
1118     } else if (starttls_proto == PROTO_POP3) {
1119         BIO_read(sbio, mbuf, BUFSIZZ);
1120         BIO_printf(sbio, "STLS\r\n");
1121         BIO_read(sbio, sbuf, BUFSIZZ);
1122     } else if (starttls_proto == PROTO_IMAP) {
1123         int foundit = 0;
1124         BIO *fbio = BIO_new(BIO_f_buffer());
1125         BIO_push(fbio, sbio);
1126         BIO_gets(fbio, mbuf, BUFSIZZ);
1127         /* STARTTLS command requires CAPABILITY... */
1128         BIO_printf(fbio, ". CAPABILITY\r\n");
1129         (void)BIO_flush(fbio);
1130         /* wait for multi-line CAPABILITY response */
1131         do {
1132             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1133             if (strstr(mbuf, "STARTTLS"))
1134                 foundit = 1;
1135         }
1136         while (mbuf_len > 3 && mbuf[0] != '.');
1137         (void)BIO_flush(fbio);
1138         BIO_pop(fbio);
1139         BIO_free(fbio);
1140         if (!foundit)
1141             BIO_printf(bio_err,
1142                        "didn't found STARTTLS in server response,"
1143                        " try anyway...\n");
1144         BIO_printf(sbio, ". STARTTLS\r\n");
1145         BIO_read(sbio, sbuf, BUFSIZZ);
1146     } else if (starttls_proto == PROTO_FTP) {
1147         BIO *fbio = BIO_new(BIO_f_buffer());
1148         BIO_push(fbio, sbio);
1149         /* wait for multi-line response to end from FTP */
1150         do {
1151             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1152         }
1153         while (mbuf_len > 3 && mbuf[3] == '-');
1154         (void)BIO_flush(fbio);
1155         BIO_pop(fbio);
1156         BIO_free(fbio);
1157         BIO_printf(sbio, "AUTH TLS\r\n");
1158         BIO_read(sbio, sbuf, BUFSIZZ);
1159     }
1160     if (starttls_proto == PROTO_XMPP) {
1161         int seen = 0;
1162         BIO_printf(sbio, "<stream:stream "
1163                    "xmlns:stream='http://etherx.jabber.org/streams' "
1164                    "xmlns='jabber:client' to='%s' version='1.0'>", host);
1165         seen = BIO_read(sbio, mbuf, BUFSIZZ);
1166         mbuf[seen] = 0;
1167         while (!strstr
1168                (mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'")) {
1169             if (strstr(mbuf, "/stream:features>"))
1170                 goto shut;
1171             seen = BIO_read(sbio, mbuf, BUFSIZZ);
1172             mbuf[seen] = 0;
1173         }
1174         BIO_printf(sbio,
1175                    "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
1176         seen = BIO_read(sbio, sbuf, BUFSIZZ);
1177         sbuf[seen] = 0;
1178         if (!strstr(sbuf, "<proceed"))
1179             goto shut;
1180         mbuf[0] = 0;
1181     }
1182
1183     for (;;) {
1184         FD_ZERO(&readfds);
1185         FD_ZERO(&writefds);
1186
1187         if ((SSL_version(con) == DTLS1_VERSION) &&
1188             DTLSv1_get_timeout(con, &timeout))
1189             timeoutp = &timeout;
1190         else
1191             timeoutp = NULL;
1192
1193         if (SSL_in_init(con) && !SSL_total_renegotiations(con)) {
1194             in_init = 1;
1195             tty_on = 0;
1196         } else {
1197             tty_on = 1;
1198             if (in_init) {
1199                 in_init = 0;
1200 #if 0                           /* This test doesn't really work as intended
1201                                  * (needs to be fixed) */
1202 # ifndef OPENSSL_NO_TLSEXT
1203                 if (servername != NULL && !SSL_session_reused(con)) {
1204                     BIO_printf(bio_c_out,
1205                                "Server did %sacknowledge servername extension.\n",
1206                                tlsextcbp.ack ? "" : "not ");
1207                 }
1208 # endif
1209 #endif
1210                 if (sess_out) {
1211                     BIO *stmp = BIO_new_file(sess_out, "w");
1212                     if (stmp) {
1213                         PEM_write_bio_SSL_SESSION(stmp, SSL_get_session(con));
1214                         BIO_free(stmp);
1215                     } else
1216                         BIO_printf(bio_err, "Error writing session file %s\n",
1217                                    sess_out);
1218                 }
1219                 print_stuff(bio_c_out, con, full_log);
1220                 if (full_log > 0)
1221                     full_log--;
1222
1223                 if (starttls_proto) {
1224                     BIO_printf(bio_err, "%s", mbuf);
1225                     /* We don't need to know any more */
1226                     starttls_proto = PROTO_OFF;
1227                 }
1228
1229                 if (reconnect) {
1230                     reconnect--;
1231                     BIO_printf(bio_c_out,
1232                                "drop connection and then reconnect\n");
1233                     SSL_shutdown(con);
1234                     SSL_set_connect_state(con);
1235                     SHUTDOWN(SSL_get_fd(con));
1236                     goto re_start;
1237                 }
1238             }
1239         }
1240
1241         ssl_pending = read_ssl && SSL_pending(con);
1242
1243         if (!ssl_pending) {
1244 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined (OPENSSL_SYS_BEOS_R5)
1245             if (tty_on) {
1246                 if (read_tty)
1247                     openssl_fdset(fileno(stdin), &readfds);
1248                 if (write_tty)
1249                     openssl_fdset(fileno(stdout), &writefds);
1250             }
1251             if (read_ssl)
1252                 openssl_fdset(SSL_get_fd(con), &readfds);
1253             if (write_ssl)
1254                 openssl_fdset(SSL_get_fd(con), &writefds);
1255 #else
1256             if (!tty_on || !write_tty) {
1257                 if (read_ssl)
1258                     openssl_fdset(SSL_get_fd(con), &readfds);
1259                 if (write_ssl)
1260                     openssl_fdset(SSL_get_fd(con), &writefds);
1261             }
1262 #endif
1263 /*-         printf("mode tty(%d %d%d) ssl(%d%d)\n",
1264                     tty_on,read_tty,write_tty,read_ssl,write_ssl);*/
1265
1266             /*
1267              * Note: under VMS with SOCKETSHR the second parameter is
1268              * currently of type (int *) whereas under other systems it is
1269              * (void *) if you don't have a cast it will choke the compiler:
1270              * if you do have a cast then you can either go for (int *) or
1271              * (void *).
1272              */
1273 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
1274             /*
1275              * Under Windows/DOS we make the assumption that we can always
1276              * write to the tty: therefore if we need to write to the tty we
1277              * just fall through. Otherwise we timeout the select every
1278              * second and see if there are any keypresses. Note: this is a
1279              * hack, in a proper Windows application we wouldn't do this.
1280              */
1281             i = 0;
1282             if (!write_tty) {
1283                 if (read_tty) {
1284                     tv.tv_sec = 1;
1285                     tv.tv_usec = 0;
1286                     i = select(width, (void *)&readfds, (void *)&writefds,
1287                                NULL, &tv);
1288 # if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
1289                     if (!i && (!_kbhit() || !read_tty))
1290                         continue;
1291 # else
1292                     if (!i && (!((_kbhit())
1293                                  || (WAIT_OBJECT_0 ==
1294                                      WaitForSingleObject(GetStdHandle
1295                                                          (STD_INPUT_HANDLE),
1296                                                          0)))
1297                                || !read_tty))
1298                         continue;
1299 # endif
1300                 } else
1301                     i = select(width, (void *)&readfds, (void *)&writefds,
1302                                NULL, timeoutp);
1303             }
1304 #elif defined(OPENSSL_SYS_NETWARE)
1305             if (!write_tty) {
1306                 if (read_tty) {
1307                     tv.tv_sec = 1;
1308                     tv.tv_usec = 0;
1309                     i = select(width, (void *)&readfds, (void *)&writefds,
1310                                NULL, &tv);
1311                 } else
1312                     i = select(width, (void *)&readfds, (void *)&writefds,
1313                                NULL, timeoutp);
1314             }
1315 #elif defined(OPENSSL_SYS_BEOS_R5)
1316             /* Under BeOS-R5 the situation is similar to DOS */
1317             i = 0;
1318             stdin_set = 0;
1319             (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
1320             if (!write_tty) {
1321                 if (read_tty) {
1322                     tv.tv_sec = 1;
1323                     tv.tv_usec = 0;
1324                     i = select(width, (void *)&readfds, (void *)&writefds,
1325                                NULL, &tv);
1326                     if (read(fileno(stdin), sbuf, 0) >= 0)
1327                         stdin_set = 1;
1328                     if (!i && (stdin_set != 1 || !read_tty))
1329                         continue;
1330                 } else
1331                     i = select(width, (void *)&readfds, (void *)&writefds,
1332                                NULL, timeoutp);
1333             }
1334             (void)fcntl(fileno(stdin), F_SETFL, 0);
1335 #else
1336             i = select(width, (void *)&readfds, (void *)&writefds,
1337                        NULL, timeoutp);
1338 #endif
1339             if (i < 0) {
1340                 BIO_printf(bio_err, "bad select %d\n",
1341                            get_last_socket_error());
1342                 goto shut;
1343                 /* goto end; */
1344             }
1345         }
1346
1347         if ((SSL_version(con) == DTLS1_VERSION)
1348             && DTLSv1_handle_timeout(con) > 0) {
1349             BIO_printf(bio_err, "TIMEOUT occured\n");
1350         }
1351
1352         if (!ssl_pending && FD_ISSET(SSL_get_fd(con), &writefds)) {
1353             k = SSL_write(con, &(cbuf[cbuf_off]), (unsigned int)cbuf_len);
1354             switch (SSL_get_error(con, k)) {
1355             case SSL_ERROR_NONE:
1356                 cbuf_off += k;
1357                 cbuf_len -= k;
1358                 if (k <= 0)
1359                     goto end;
1360                 /* we have done a  write(con,NULL,0); */
1361                 if (cbuf_len <= 0) {
1362                     read_tty = 1;
1363                     write_ssl = 0;
1364                 } else {        /* if (cbuf_len > 0) */
1365
1366                     read_tty = 0;
1367                     write_ssl = 1;
1368                 }
1369                 break;
1370             case SSL_ERROR_WANT_WRITE:
1371                 BIO_printf(bio_c_out, "write W BLOCK\n");
1372                 write_ssl = 1;
1373                 read_tty = 0;
1374                 break;
1375             case SSL_ERROR_WANT_READ:
1376                 BIO_printf(bio_c_out, "write R BLOCK\n");
1377                 write_tty = 0;
1378                 read_ssl = 1;
1379                 write_ssl = 0;
1380                 break;
1381             case SSL_ERROR_WANT_X509_LOOKUP:
1382                 BIO_printf(bio_c_out, "write X BLOCK\n");
1383                 break;
1384             case SSL_ERROR_ZERO_RETURN:
1385                 if (cbuf_len != 0) {
1386                     BIO_printf(bio_c_out, "shutdown\n");
1387                     ret = 0;
1388                     goto shut;
1389                 } else {
1390                     read_tty = 1;
1391                     write_ssl = 0;
1392                     break;
1393                 }
1394
1395             case SSL_ERROR_SYSCALL:
1396                 if ((k != 0) || (cbuf_len != 0)) {
1397                     BIO_printf(bio_err, "write:errno=%d\n",
1398                                get_last_socket_error());
1399                     goto shut;
1400                 } else {
1401                     read_tty = 1;
1402                     write_ssl = 0;
1403                 }
1404                 break;
1405             case SSL_ERROR_SSL:
1406                 ERR_print_errors(bio_err);
1407                 goto shut;
1408             }
1409         }
1410 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
1411         /* Assume Windows/DOS/BeOS can always write */
1412         else if (!ssl_pending && write_tty)
1413 #else
1414         else if (!ssl_pending && FD_ISSET(fileno(stdout), &writefds))
1415 #endif
1416         {
1417 #ifdef CHARSET_EBCDIC
1418             ascii2ebcdic(&(sbuf[sbuf_off]), &(sbuf[sbuf_off]), sbuf_len);
1419 #endif
1420             i = raw_write_stdout(&(sbuf[sbuf_off]), sbuf_len);
1421
1422             if (i <= 0) {
1423                 BIO_printf(bio_c_out, "DONE\n");
1424                 ret = 0;
1425                 goto shut;
1426                 /* goto end; */
1427             }
1428
1429             sbuf_len -= i;;
1430             sbuf_off += i;
1431             if (sbuf_len <= 0) {
1432                 read_ssl = 1;
1433                 write_tty = 0;
1434             }
1435         } else if (ssl_pending || FD_ISSET(SSL_get_fd(con), &readfds)) {
1436 #ifdef RENEG
1437             {
1438                 static int iiii;
1439                 if (++iiii == 52) {
1440                     SSL_renegotiate(con);
1441                     iiii = 0;
1442                 }
1443             }
1444 #endif
1445 #if 1
1446             k = SSL_read(con, sbuf, 1024 /* BUFSIZZ */ );
1447 #else
1448 /* Demo for pending and peek :-) */
1449             k = SSL_read(con, sbuf, 16);
1450             {
1451                 char zbuf[10240];
1452                 printf("read=%d pending=%d peek=%d\n", k, SSL_pending(con),
1453                        SSL_peek(con, zbuf, 10240));
1454             }
1455 #endif
1456
1457             switch (SSL_get_error(con, k)) {
1458             case SSL_ERROR_NONE:
1459                 if (k <= 0)
1460                     goto end;
1461                 sbuf_off = 0;
1462                 sbuf_len = k;
1463
1464                 read_ssl = 0;
1465                 write_tty = 1;
1466                 break;
1467             case SSL_ERROR_WANT_WRITE:
1468                 BIO_printf(bio_c_out, "read W BLOCK\n");
1469                 write_ssl = 1;
1470                 read_tty = 0;
1471                 break;
1472             case SSL_ERROR_WANT_READ:
1473                 BIO_printf(bio_c_out, "read R BLOCK\n");
1474                 write_tty = 0;
1475                 read_ssl = 1;
1476                 if ((read_tty == 0) && (write_ssl == 0))
1477                     write_ssl = 1;
1478                 break;
1479             case SSL_ERROR_WANT_X509_LOOKUP:
1480                 BIO_printf(bio_c_out, "read X BLOCK\n");
1481                 break;
1482             case SSL_ERROR_SYSCALL:
1483                 ret = get_last_socket_error();
1484                 BIO_printf(bio_err, "read:errno=%d\n", ret);
1485                 goto shut;
1486             case SSL_ERROR_ZERO_RETURN:
1487                 BIO_printf(bio_c_out, "closed\n");
1488                 ret = 0;
1489                 goto shut;
1490             case SSL_ERROR_SSL:
1491                 ERR_print_errors(bio_err);
1492                 goto shut;
1493                 /* break; */
1494             }
1495         }
1496 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
1497 # if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
1498         else if (_kbhit())
1499 # else
1500         else if ((_kbhit())
1501                  || (WAIT_OBJECT_0 ==
1502                      WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
1503 # endif
1504 #elif defined (OPENSSL_SYS_NETWARE)
1505         else if (_kbhit())
1506 #elif defined(OPENSSL_SYS_BEOS_R5)
1507         else if (stdin_set)
1508 #else
1509         else if (FD_ISSET(fileno(stdin), &readfds))
1510 #endif
1511         {
1512             if (crlf) {
1513                 int j, lf_num;
1514
1515                 i = raw_read_stdin(cbuf, BUFSIZZ / 2);
1516                 lf_num = 0;
1517                 /* both loops are skipped when i <= 0 */
1518                 for (j = 0; j < i; j++)
1519                     if (cbuf[j] == '\n')
1520                         lf_num++;
1521                 for (j = i - 1; j >= 0; j--) {
1522                     cbuf[j + lf_num] = cbuf[j];
1523                     if (cbuf[j] == '\n') {
1524                         lf_num--;
1525                         i++;
1526                         cbuf[j + lf_num] = '\r';
1527                     }
1528                 }
1529                 assert(lf_num == 0);
1530             } else
1531                 i = raw_read_stdin(cbuf, BUFSIZZ);
1532
1533             if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q'))) {
1534                 BIO_printf(bio_err, "DONE\n");
1535                 ret = 0;
1536                 goto shut;
1537             }
1538
1539             if ((!c_ign_eof) && (cbuf[0] == 'R')) {
1540                 BIO_printf(bio_err, "RENEGOTIATING\n");
1541                 SSL_renegotiate(con);
1542                 cbuf_len = 0;
1543             } else {
1544                 cbuf_len = i;
1545                 cbuf_off = 0;
1546 #ifdef CHARSET_EBCDIC
1547                 ebcdic2ascii(cbuf, cbuf, i);
1548 #endif
1549             }
1550
1551             write_ssl = 1;
1552             read_tty = 0;
1553         }
1554     }
1555
1556     ret = 0;
1557  shut:
1558     if (in_init)
1559         print_stuff(bio_c_out, con, full_log);
1560     SSL_shutdown(con);
1561     SHUTDOWN(SSL_get_fd(con));
1562  end:
1563     if (con != NULL) {
1564         if (prexit != 0)
1565             print_stuff(bio_c_out, con, 1);
1566         SSL_free(con);
1567     }
1568     if (ctx != NULL)
1569         SSL_CTX_free(ctx);
1570     if (cert)
1571         X509_free(cert);
1572     if (key)
1573         EVP_PKEY_free(key);
1574     if (pass)
1575         OPENSSL_free(pass);
1576     if (vpm)
1577         X509_VERIFY_PARAM_free(vpm);
1578     if (cbuf != NULL) {
1579         OPENSSL_cleanse(cbuf, BUFSIZZ);
1580         OPENSSL_free(cbuf);
1581     }
1582     if (sbuf != NULL) {
1583         OPENSSL_cleanse(sbuf, BUFSIZZ);
1584         OPENSSL_free(sbuf);
1585     }
1586     if (mbuf != NULL) {
1587         OPENSSL_cleanse(mbuf, BUFSIZZ);
1588         OPENSSL_free(mbuf);
1589     }
1590     if (bio_c_out != NULL) {
1591         BIO_free(bio_c_out);
1592         bio_c_out = NULL;
1593     }
1594     apps_shutdown();
1595     OPENSSL_EXIT(ret);
1596 }
1597
1598 static void print_stuff(BIO *bio, SSL *s, int full)
1599 {
1600     X509 *peer = NULL;
1601     char *p;
1602     static const char *space = "                ";
1603     char buf[BUFSIZ];
1604     STACK_OF(X509) *sk;
1605     STACK_OF(X509_NAME) *sk2;
1606     const SSL_CIPHER *c;
1607     X509_NAME *xn;
1608     int j, i;
1609 #ifndef OPENSSL_NO_COMP
1610     const COMP_METHOD *comp, *expansion;
1611 #endif
1612
1613     if (full) {
1614         int got_a_chain = 0;
1615
1616         sk = SSL_get_peer_cert_chain(s);
1617         if (sk != NULL) {
1618             got_a_chain = 1;    /* we don't have it for SSL2 (yet) */
1619
1620             BIO_printf(bio, "---\nCertificate chain\n");
1621             for (i = 0; i < sk_X509_num(sk); i++) {
1622                 X509_NAME_oneline(X509_get_subject_name(sk_X509_value(sk, i)),
1623                                   buf, sizeof buf);
1624                 BIO_printf(bio, "%2d s:%s\n", i, buf);
1625                 X509_NAME_oneline(X509_get_issuer_name(sk_X509_value(sk, i)),
1626                                   buf, sizeof buf);
1627                 BIO_printf(bio, "   i:%s\n", buf);
1628                 if (c_showcerts)
1629                     PEM_write_bio_X509(bio, sk_X509_value(sk, i));
1630             }
1631         }
1632
1633         BIO_printf(bio, "---\n");
1634         peer = SSL_get_peer_certificate(s);
1635         if (peer != NULL) {
1636             BIO_printf(bio, "Server certificate\n");
1637
1638             /* Redundant if we showed the whole chain */
1639             if (!(c_showcerts && got_a_chain))
1640                 PEM_write_bio_X509(bio, peer);
1641             X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
1642             BIO_printf(bio, "subject=%s\n", buf);
1643             X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
1644             BIO_printf(bio, "issuer=%s\n", buf);
1645         } else
1646             BIO_printf(bio, "no peer certificate available\n");
1647
1648         sk2 = SSL_get_client_CA_list(s);
1649         if ((sk2 != NULL) && (sk_X509_NAME_num(sk2) > 0)) {
1650             BIO_printf(bio, "---\nAcceptable client certificate CA names\n");
1651             for (i = 0; i < sk_X509_NAME_num(sk2); i++) {
1652                 xn = sk_X509_NAME_value(sk2, i);
1653                 X509_NAME_oneline(xn, buf, sizeof(buf));
1654                 BIO_write(bio, buf, strlen(buf));
1655                 BIO_write(bio, "\n", 1);
1656             }
1657         } else {
1658             BIO_printf(bio, "---\nNo client certificate CA names sent\n");
1659         }
1660         p = SSL_get_shared_ciphers(s, buf, sizeof buf);
1661         if (p != NULL) {
1662             /*
1663              * This works only for SSL 2.  In later protocol versions, the
1664              * client does not know what other ciphers (in addition to the
1665              * one to be used in the current connection) the server supports.
1666              */
1667
1668             BIO_printf(bio,
1669                        "---\nCiphers common between both SSL endpoints:\n");
1670             j = i = 0;
1671             while (*p) {
1672                 if (*p == ':') {
1673                     BIO_write(bio, space, 15 - j % 25);
1674                     i++;
1675                     j = 0;
1676                     BIO_write(bio, ((i % 3) ? " " : "\n"), 1);
1677                 } else {
1678                     BIO_write(bio, p, 1);
1679                     j++;
1680                 }
1681                 p++;
1682             }
1683             BIO_write(bio, "\n", 1);
1684         }
1685
1686         BIO_printf(bio,
1687                    "---\nSSL handshake has read %ld bytes and written %ld bytes\n",
1688                    BIO_number_read(SSL_get_rbio(s)),
1689                    BIO_number_written(SSL_get_wbio(s)));
1690     }
1691     BIO_printf(bio, ((s->hit) ? "---\nReused, " : "---\nNew, "));
1692     c = SSL_get_current_cipher(s);
1693     BIO_printf(bio, "%s, Cipher is %s\n",
1694                SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
1695     if (peer != NULL) {
1696         EVP_PKEY *pktmp;
1697         pktmp = X509_get_pubkey(peer);
1698         BIO_printf(bio, "Server public key is %d bit\n",
1699                    EVP_PKEY_bits(pktmp));
1700         EVP_PKEY_free(pktmp);
1701     }
1702     BIO_printf(bio, "Secure Renegotiation IS%s supported\n",
1703                SSL_get_secure_renegotiation_support(s) ? "" : " NOT");
1704 #ifndef OPENSSL_NO_COMP
1705     comp = SSL_get_current_compression(s);
1706     expansion = SSL_get_current_expansion(s);
1707     BIO_printf(bio, "Compression: %s\n",
1708                comp ? SSL_COMP_get_name(comp) : "NONE");
1709     BIO_printf(bio, "Expansion: %s\n",
1710                expansion ? SSL_COMP_get_name(expansion) : "NONE");
1711 #endif
1712     SSL_SESSION_print(bio, SSL_get_session(s));
1713     BIO_printf(bio, "---\n");
1714     if (peer != NULL)
1715         X509_free(peer);
1716     /* flush, or debugging output gets mixed with http response */
1717     (void)BIO_flush(bio);
1718 }
1719
1720 #ifndef OPENSSL_NO_TLSEXT
1721
1722 static int ocsp_resp_cb(SSL *s, void *arg)
1723 {
1724     const unsigned char *p;
1725     int len;
1726     OCSP_RESPONSE *rsp;
1727     len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1728     BIO_puts(arg, "OCSP response: ");
1729     if (!p) {
1730         BIO_puts(arg, "no response sent\n");
1731         return 1;
1732     }
1733     rsp = d2i_OCSP_RESPONSE(NULL, &p, len);
1734     if (!rsp) {
1735         BIO_puts(arg, "response parse error\n");
1736         BIO_dump_indent(arg, (char *)p, len, 4);
1737         return 0;
1738     }
1739     BIO_puts(arg, "\n======================================\n");
1740     OCSP_RESPONSE_print(arg, rsp, 0);
1741     BIO_puts(arg, "======================================\n");
1742     OCSP_RESPONSE_free(rsp);
1743     return 1;
1744 }
1745
1746 #endif