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 /* With IPv6, it looks like Digital has mixed up the proper order of
 149    recursive header file inclusion, resulting in the compiler complaining
 150    that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which
 151    is needed to have fileno() declared correctly...  So let's define u_int */
 152 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
 153 #define __U_INT
 154 typedef unsigned int u_int;
 155 #endif
 156
 157 #define USE_SOCKETS
 158 #include "apps.h"
 159 #include <openssl/x509.h>
 160 #include <openssl/ssl.h>
 161 #include <openssl/err.h>
 162 #include <openssl/pem.h>
 163 #include <openssl/rand.h>
 164 #include <openssl/ocsp.h>
 165 #include <openssl/bn.h>
 166 #ifndef OPENSSL_NO_SRP
 167 #include <openssl/srp.h>
 168 #endif
 169 #include "s_apps.h"
 170 #include "timeouts.h"
 171
 172 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
 173 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
 174 #undef FIONBIO
 175 #endif
 176
 177 #if defined(OPENSSL_SYS_BEOS_R5)
 178 #include <fcntl.h>
 179 #endif
 180
 181 #undef PROG
 182 #define PROG    s_client_main
 183
 184 /*#define SSL_HOST_NAME "www.netscape.com" */
 185 /*#define SSL_HOST_NAME "193.118.187.102" */
 186 #define SSL_HOST_NAME   "localhost"
 187
 188 /*#define TEST_CERT "client.pem" */ /* no default cert. */
 189
 190 #undef BUFSIZZ
 191 #define BUFSIZZ 1024*8
 192
 193 extern int verify_depth;
 194 extern int verify_error;
 195 extern int verify_return_error;
 196 extern int verify_quiet;
 197
 198 #ifdef FIONBIO
 199 static int c_nbio=0;
 200 #endif
 201 static int c_Pause=0;
 202 static int c_debug=0;
 203 #ifndef OPENSSL_NO_TLSEXT
 204 static int c_tlsextdebug=0;
 205 static int c_status_req=0;
 206 #endif
 207 static int c_msg=0;
 208 static int c_showcerts=0;
 209
 210 static char *keymatexportlabel=NULL;
 211 static int keymatexportlen=20;
 212
 213 static void sc_usage(void);
 214 static void print_stuff(BIO *berr,SSL *con,int full);
 215 #ifndef OPENSSL_NO_TLSEXT
 216 static int ocsp_resp_cb(SSL *s, void *arg);
 217 static int c_auth = 0;
 218 static int c_auth_require_reneg = 0;
 219 #endif
 220 static BIO *bio_c_out=NULL;
 221 static BIO *bio_c_msg=NULL;
 222 static int c_quiet=0;
 223 static int c_ign_eof=0;
 224 static int c_brief=0;
 225
 226 #ifndef OPENSSL_NO_TLSEXT
 227
 228 static const unsigned char *most_recent_supplemental_data;
 229 static size_t most_recent_supplemental_data_length;
 230
 231 static int server_provided_server_authz = 0;
 232 static int server_provided_client_authz = 0;
 233
 234 static const unsigned char auth_ext_data[]={TLSEXT_AUTHZDATAFORMAT_dtcp};
 235
 236 static int suppdata_cb(SSL *s, unsigned short supp_data_type,
 237                        const unsigned char *in,
 238                        unsigned short inlen, int *al,
 239                        void *arg);
 240
 241 static int auth_suppdata_generate_cb(SSL *s, unsigned short supp_data_type,
 242                                      const unsigned char **out,
 243                                      unsigned short *outlen, void *arg);
 244
 245 static int authz_tlsext_generate_cb(SSL *s, unsigned short ext_type,
 246                                     const unsigned char **out, unsigned short *outlen,
 247                                     void *arg);
 248
 249 static int authz_tlsext_cb(SSL *s, unsigned short ext_type,
 250                            const unsigned char *in,
 251                            unsigned short inlen, int *al,
 252                            void *arg);
 253 #endif
 254
 255 #ifndef OPENSSL_NO_PSK
 256 /* Default PSK identity and key */
 257 static char *psk_identity="Client_identity";
 258 /*char *psk_key=NULL;  by default PSK is not used */
 259
 260 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity,
 261         unsigned int max_identity_len, unsigned char *psk,
 262         unsigned int max_psk_len)
 263         {
 264         unsigned int psk_len = 0;
 265         int ret;
 266         BIGNUM *bn=NULL;
 267
 268         if (c_debug)
 269                 BIO_printf(bio_c_out, "psk_client_cb\n");
 270         if (!hint)
 271                 {
 272                 /* no ServerKeyExchange message*/
 273                 if (c_debug)
 274                         BIO_printf(bio_c_out,"NULL received PSK identity hint, continuing anyway\n");
 275                 }
 276         else if (c_debug)
 277                 BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint);
 278
 279         /* lookup PSK identity and PSK key based on the given identity hint here */
 280         ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity);
 281         if (ret < 0 || (unsigned int)ret > max_identity_len)
 282                 goto out_err;
 283         if (c_debug)
 284                 BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity, ret);
 285         ret=BN_hex2bn(&bn, psk_key);
 286         if (!ret)
 287                 {
 288                 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", psk_key);
 289                 if (bn)
 290                         BN_free(bn);
 291                 return 0;
 292                 }
 293
 294         if ((unsigned int)BN_num_bytes(bn) > max_psk_len)
 295                 {
 296                 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
 297                         max_psk_len, BN_num_bytes(bn));
 298                 BN_free(bn);
 299                 return 0;
 300                 }
 301
 302         psk_len=BN_bn2bin(bn, psk);
 303         BN_free(bn);
 304         if (psk_len == 0)
 305                 goto out_err;
 306
 307         if (c_debug)
 308                 BIO_printf(bio_c_out, "created PSK len=%d\n", psk_len);
 309
 310         return psk_len;
 311  out_err:
 312         if (c_debug)
 313                 BIO_printf(bio_err, "Error in PSK client callback\n");
 314         return 0;
 315         }
 316 #endif
 317
 318 static void sc_usage(void)
 319         {
 320         BIO_printf(bio_err,"usage: s_client args\n");
 321         BIO_printf(bio_err,"\n");
 322         BIO_printf(bio_err," -host host     - use -connect instead\n");
 323         BIO_printf(bio_err," -port port     - use -connect instead\n");
 324         BIO_printf(bio_err," -connect host:port - who to connect to (default is %s:%s)\n",SSL_HOST_NAME,PORT_STR);
 325         BIO_printf(bio_err," -verify arg   - turn on peer certificate verification\n");
 326         BIO_printf(bio_err," -cert arg     - certificate file to use, PEM format assumed\n");
 327         BIO_printf(bio_err," -certform arg - certificate format (PEM or DER) PEM default\n");
 328         BIO_printf(bio_err," -key arg      - Private key file to use, in cert file if\n");
 329         BIO_printf(bio_err,"                 not specified but cert file is.\n");
 330         BIO_printf(bio_err," -keyform arg  - key format (PEM or DER) PEM default\n");
 331         BIO_printf(bio_err," -pass arg     - private key file pass phrase source\n");
 332         BIO_printf(bio_err," -CApath arg   - PEM format directory of CA's\n");
 333         BIO_printf(bio_err," -CAfile arg   - PEM format file of CA's\n");
 334         BIO_printf(bio_err," -reconnect    - Drop and re-make the connection with the same Session-ID\n");
 335         BIO_printf(bio_err," -pause        - sleep(1) after each read(2) and write(2) system call\n");
 336         BIO_printf(bio_err," -showcerts    - show all certificates in the chain\n");
 337         BIO_printf(bio_err," -debug        - extra output\n");
 338 #ifdef WATT32
 339         BIO_printf(bio_err," -wdebug       - WATT-32 tcp debugging\n");
 340 #endif
 341         BIO_printf(bio_err," -msg          - Show protocol messages\n");
 342         BIO_printf(bio_err," -nbio_test    - more ssl protocol testing\n");
 343         BIO_printf(bio_err," -state        - print the 'ssl' states\n");
 344 #ifdef FIONBIO
 345         BIO_printf(bio_err," -nbio         - Run with non-blocking IO\n");
 346 #endif
 347         BIO_printf(bio_err," -crlf         - convert LF from terminal into CRLF\n");
 348         BIO_printf(bio_err," -quiet        - no s_client output\n");
 349         BIO_printf(bio_err," -ign_eof      - ignore input eof (default when -quiet)\n");
 350         BIO_printf(bio_err," -no_ign_eof   - don't ignore input eof\n");
 351 #ifndef OPENSSL_NO_PSK
 352         BIO_printf(bio_err," -psk_identity arg - PSK identity\n");
 353         BIO_printf(bio_err," -psk arg      - PSK in hex (without 0x)\n");
 354 # ifndef OPENSSL_NO_JPAKE
 355         BIO_printf(bio_err," -jpake arg    - JPAKE secret to use\n");
 356 # endif
 357 #endif
 358 #ifndef OPENSSL_NO_SRP
 359         BIO_printf(bio_err," -srpuser user     - SRP authentification for 'user'\n");
 360         BIO_printf(bio_err," -srppass arg      - password for 'user'\n");
 361         BIO_printf(bio_err," -srp_lateuser     - SRP username into second ClientHello message\n");
 362         BIO_printf(bio_err," -srp_moregroups   - Tolerate other than the known g N values.\n");
 363         BIO_printf(bio_err," -srp_strength int - minimal mength in bits for N (default %d).\n",SRP_MINIMAL_N);
 364 #endif
 365         BIO_printf(bio_err," -ssl2         - just use SSLv2\n");
 366         BIO_printf(bio_err," -ssl3         - just use SSLv3\n");
 367         BIO_printf(bio_err," -tls1_2       - just use TLSv1.2\n");
 368         BIO_printf(bio_err," -tls1_1       - just use TLSv1.1\n");
 369         BIO_printf(bio_err," -tls1         - just use TLSv1\n");
 370         BIO_printf(bio_err," -dtls1        - just use DTLSv1\n");
 371         BIO_printf(bio_err," -mtu          - set the link layer MTU\n");
 372         BIO_printf(bio_err," -no_tls1_2/-no_tls1_1/-no_tls1/-no_ssl3/-no_ssl2 - turn off that protocol\n");
 373         BIO_printf(bio_err," -bugs         - Switch on all SSL implementation bug workarounds\n");
 374         BIO_printf(bio_err," -serverpref   - Use server's cipher preferences (only SSLv2)\n");
 375         BIO_printf(bio_err," -cipher       - preferred cipher to use, use the 'openssl ciphers'\n");
 376         BIO_printf(bio_err,"                 command to see what is available\n");
 377         BIO_printf(bio_err," -starttls prot - use the STARTTLS command before starting TLS\n");
 378         BIO_printf(bio_err,"                 for those protocols that support it, where\n");
 379         BIO_printf(bio_err,"                 'prot' defines which one to assume.  Currently,\n");
 380         BIO_printf(bio_err,"                 only \"smtp\", \"pop3\", \"imap\", \"ftp\" and \"xmpp\"\n");
 381         BIO_printf(bio_err,"                 are supported.\n");
 382         BIO_printf(bio_err," -xmpphost host - When used with \"-starttls xmpp\" specifies the virtual host.\n");
 383 #ifndef OPENSSL_NO_ENGINE
 384         BIO_printf(bio_err," -engine id    - Initialise and use the specified engine\n");
 385 #endif
 386         BIO_printf(bio_err," -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR);
 387         BIO_printf(bio_err," -sess_out arg - file to write SSL session to\n");
 388         BIO_printf(bio_err," -sess_in arg  - file to read SSL session from\n");
 389 #ifndef OPENSSL_NO_TLSEXT
 390         BIO_printf(bio_err," -servername host  - Set TLS extension servername in ClientHello\n");
 391         BIO_printf(bio_err," -tlsextdebug      - hex dump of all TLS extensions received\n");
 392         BIO_printf(bio_err," -status           - request certificate status from server\n");
 393         BIO_printf(bio_err," -no_ticket        - disable use of RFC4507bis session tickets\n");
 394         BIO_printf(bio_err," -serverinfo types - send empty ClientHello extensions (comma-separated numbers)\n");
 395         BIO_printf(bio_err," -auth               - send and receive RFC 5878 TLS auth extensions and supplemental data\n");
 396         BIO_printf(bio_err," -auth_require_reneg - Do not send TLS auth extensions until renegotiation\n");
 397 # ifndef OPENSSL_NO_NEXTPROTONEG
 398         BIO_printf(bio_err," -nextprotoneg arg - enable NPN extension, considering named protocols supported (comma-separated list)\n");
 399         BIO_printf(bio_err," -alpn arg         - enable ALPN extension, considering named protocols supported (comma-separated list)\n");
 400 # endif
 401 #endif
 402         BIO_printf(bio_err," -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 403         BIO_printf(bio_err," -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
 404         BIO_printf(bio_err," -keymatexport label   - Export keying material using label\n");
 405         BIO_printf(bio_err," -keymatexportlen len  - Export len bytes of keying material (default 20)\n");
 406         }
 407
 408 #ifndef OPENSSL_NO_TLSEXT
 409
 410 /* This is a context that we pass to callbacks */
 411 typedef struct tlsextctx_st {
 412    BIO * biodebug;
 413    int ack;
 414 } tlsextctx;
 415
 416
 417 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
 418         {
 419         tlsextctx * p = (tlsextctx *) arg;
 420         const char * hn= SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 421         if (SSL_get_servername_type(s) != -1)
 422                 p->ack = !SSL_session_reused(s) && hn != NULL;
 423         else
 424                 BIO_printf(bio_err,"Can't use SSL_get_servername\n");
 425
 426         return SSL_TLSEXT_ERR_OK;
 427         }
 428
 429 #ifndef OPENSSL_NO_SRP
 430
 431 /* This is a context that we pass to all callbacks */
 432 typedef struct srp_arg_st
 433         {
 434         char *srppassin;
 435         char *srplogin;
 436         int msg;   /* copy from c_msg */
 437         int debug; /* copy from c_debug */
 438         int amp;   /* allow more groups */
 439         int strength /* minimal size for N */ ;
 440         } SRP_ARG;
 441
 442 #define SRP_NUMBER_ITERATIONS_FOR_PRIME 64
 443
 444 static int srp_Verify_N_and_g(const BIGNUM *N, const BIGNUM *g)
 445         {
 446         BN_CTX *bn_ctx = BN_CTX_new();
 447         BIGNUM *p = BN_new();
 448         BIGNUM *r = BN_new();
 449         int ret =
 450                 g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) &&
 451                 BN_is_prime_ex(N, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) &&
 452                 p != NULL && BN_rshift1(p, N) &&
 453
 454                 /* p = (N-1)/2 */
 455                 BN_is_prime_ex(p, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) &&
 456                 r != NULL &&
 457
 458                 /* verify g^((N-1)/2) == -1 (mod N) */
 459                 BN_mod_exp(r, g, p, N, bn_ctx) &&
 460                 BN_add_word(r, 1) &&
 461                 BN_cmp(r, N) == 0;
 462
 463         if(r)
 464                 BN_free(r);
 465         if(p)
 466                 BN_free(p);
 467         if(bn_ctx)
 468                 BN_CTX_free(bn_ctx);
 469         return ret;
 470         }
 471
 472 /* This callback is used here for two purposes:
 473    - extended debugging
 474    - making some primality tests for unknown groups
 475    The callback is only called for a non default group.
 476
 477    An application does not need the call back at all if
 478    only the stanard groups are used.  In real life situations,
 479    client and server already share well known groups,
 480    thus there is no need to verify them.
 481    Furthermore, in case that a server actually proposes a group that
 482    is not one of those defined in RFC 5054, it is more appropriate
 483    to add the group to a static list and then compare since
 484    primality tests are rather cpu consuming.
 485 */
 486
 487 static int MS_CALLBACK ssl_srp_verify_param_cb(SSL *s, void *arg)
 488         {
 489         SRP_ARG *srp_arg = (SRP_ARG *)arg;
 490         BIGNUM *N = NULL, *g = NULL;
 491         if (!(N = SSL_get_srp_N(s)) || !(g = SSL_get_srp_g(s)))
 492                 return 0;
 493         if (srp_arg->debug || srp_arg->msg || srp_arg->amp == 1)
 494                 {
 495                 BIO_printf(bio_err, "SRP parameters:\n");
 496                 BIO_printf(bio_err,"\tN="); BN_print(bio_err,N);
 497                 BIO_printf(bio_err,"\n\tg="); BN_print(bio_err,g);
 498                 BIO_printf(bio_err,"\n");
 499                 }
 500
 501         if (SRP_check_known_gN_param(g,N))
 502                 return 1;
 503
 504         if (srp_arg->amp == 1)
 505                 {
 506                 if (srp_arg->debug)
 507                         BIO_printf(bio_err, "SRP param N and g are not known params, going to check deeper.\n");
 508
 509 /* The srp_moregroups is a real debugging feature.
 510    Implementors should rather add the value to the known ones.
 511    The minimal size has already been tested.
 512 */
 513                 if (BN_num_bits(g) <= BN_BITS && srp_Verify_N_and_g(N,g))
 514                         return 1;
 515                 }
 516         BIO_printf(bio_err, "SRP param N and g rejected.\n");
 517         return 0;
 518         }
 519
 520 #define PWD_STRLEN 1024
 521
 522 static char * MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
 523         {
 524         SRP_ARG *srp_arg = (SRP_ARG *)arg;
 525         char *pass = (char *)OPENSSL_malloc(PWD_STRLEN+1);
 526         PW_CB_DATA cb_tmp;
 527         int l;
 528
 529         cb_tmp.password = (char *)srp_arg->srppassin;
 530         cb_tmp.prompt_info = "SRP user";
 531         if ((l = password_callback(pass, PWD_STRLEN, 0, &cb_tmp))<0)
 532                 {
 533                 BIO_printf (bio_err, "Can't read Password\n");
 534                 OPENSSL_free(pass);
 535                 return NULL;
 536                 }
 537         *(pass+l)= '\0';
 538
 539         return pass;
 540         }
 541
 542 #endif
 543         char *srtp_profiles = NULL;
 544
 545 # ifndef OPENSSL_NO_NEXTPROTONEG
 546 /* This the context that we pass to next_proto_cb */
 547 typedef struct tlsextnextprotoctx_st {
 548         unsigned char *data;
 549         unsigned short len;
 550         int status;
 551 } tlsextnextprotoctx;
 552
 553 static tlsextnextprotoctx next_proto;
 554
 555 static int next_proto_cb(SSL *s, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
 556         {
 557         tlsextnextprotoctx *ctx = arg;
 558
 559         if (!c_quiet)
 560                 {
 561                 /* We can assume that |in| is syntactically valid. */
 562                 unsigned i;
 563                 BIO_printf(bio_c_out, "Protocols advertised by server: ");
 564                 for (i = 0; i < inlen; )
 565                         {
 566                         if (i)
 567                                 BIO_write(bio_c_out, ", ", 2);
 568                         BIO_write(bio_c_out, &in[i + 1], in[i]);
 569                         i += in[i] + 1;
 570                         }
 571                 BIO_write(bio_c_out, "\n", 1);
 572                 }
 573
 574         ctx->status = SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len);
 575         return SSL_TLSEXT_ERR_OK;
 576         }
 577 # endif  /* ndef OPENSSL_NO_NEXTPROTONEG */
 578
 579 static int serverinfo_cli_cb(SSL* s, unsigned short ext_type,
 580                              const unsigned char* in, unsigned short inlen,
 581                              int* al, void* arg)
 582         {
 583         char pem_name[100];
 584         unsigned char ext_buf[4 + 65536];
 585
 586         /* Reconstruct the type/len fields prior to extension data */
 587         ext_buf[0] = ext_type >> 8;
 588         ext_buf[1] = ext_type & 0xFF;
 589         ext_buf[2] = inlen >> 8;
 590         ext_buf[3] = inlen & 0xFF;
 591         memcpy(ext_buf+4, in, inlen);
 592
 593         BIO_snprintf(pem_name, sizeof(pem_name), "SERVER_INFO %d", ext_type);
 594         PEM_write_bio(bio_c_out, pem_name, "", ext_buf, 4 + inlen);
 595         return 1;
 596         }
 597
 598 #endif
 599
 600 enum
 601 {
 602         PROTO_OFF       = 0,
 603         PROTO_SMTP,
 604         PROTO_POP3,
 605         PROTO_IMAP,
 606         PROTO_FTP,
 607         PROTO_XMPP
 608 };
 609
 610 int MAIN(int, char **);
 611
 612 int MAIN(int argc, char **argv)
 613         {
 614         int build_chain = 0;
 615         SSL *con=NULL;
 616 #ifndef OPENSSL_NO_KRB5
 617         KSSL_CTX *kctx;
 618 #endif
 619         int s,k,width,state=0;
 620         char *cbuf=NULL,*sbuf=NULL,*mbuf=NULL;
 621         int cbuf_len,cbuf_off;
 622         int sbuf_len,sbuf_off;
 623         fd_set readfds,writefds;
 624         short port=PORT;
 625         int full_log=1;
 626         char *host=SSL_HOST_NAME;
 627         char *xmpphost = NULL;
 628         char *cert_file=NULL,*key_file=NULL,*chain_file=NULL;
 629         int cert_format = FORMAT_PEM, key_format = FORMAT_PEM;
 630         char *passarg = NULL, *pass = NULL;
 631         X509 *cert = NULL;
 632         EVP_PKEY *key = NULL;
 633         STACK_OF(X509) *chain = NULL;
 634         char *CApath=NULL,*CAfile=NULL;
 635         char *chCApath=NULL,*chCAfile=NULL;
 636         char *vfyCApath=NULL,*vfyCAfile=NULL;
 637         int reconnect=0,badop=0,verify=SSL_VERIFY_NONE;
 638         int crlf=0;
 639         int write_tty,read_tty,write_ssl,read_ssl,tty_on,ssl_pending;
 640         SSL_CTX *ctx=NULL;
 641         int ret=1,in_init=1,i,nbio_test=0;
 642         int starttls_proto = PROTO_OFF;
 643         int prexit = 0;
 644         X509_VERIFY_PARAM *vpm = NULL;
 645         int badarg = 0;
 646         const SSL_METHOD *meth=NULL;
 647         int socket_type=SOCK_STREAM;
 648         BIO *sbio;
 649         char *inrand=NULL;
 650         int mbuf_len=0;
 651         struct timeval timeout, *timeoutp;
 652 #ifndef OPENSSL_NO_ENGINE
 653         char *engine_id=NULL;
 654         char *ssl_client_engine_id=NULL;
 655         ENGINE *ssl_client_engine=NULL;
 656 #endif
 657         ENGINE *e=NULL;
 658 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
 659         struct timeval tv;
 660 #if defined(OPENSSL_SYS_BEOS_R5)
 661         int stdin_set = 0;
 662 #endif
 663 #endif
 664 #ifndef OPENSSL_NO_TLSEXT
 665         char *servername = NULL;
 666         tlsextctx tlsextcbp =
 667         {NULL,0};
 668 # ifndef OPENSSL_NO_NEXTPROTONEG
 669         const char *next_proto_neg_in = NULL;
 670         const char *alpn_in = NULL;
 671 # endif
 672 # define MAX_SI_TYPES 100
 673         unsigned short serverinfo_types[MAX_SI_TYPES];
 674         int serverinfo_types_count = 0;
 675 #endif
 676         char *sess_in = NULL;
 677         char *sess_out = NULL;
 678         struct sockaddr peer;
 679         int peerlen = sizeof(peer);
 680         int enable_timeouts = 0 ;
 681         long socket_mtu = 0;
 682 #ifndef OPENSSL_NO_JPAKE
 683 static char *jpake_secret = NULL;
 684 #define no_jpake !jpake_secret
 685 #else
 686 #define no_jpake 1
 687 #endif
 688 #ifndef OPENSSL_NO_SRP
 689         char * srppass = NULL;
 690         int srp_lateuser = 0;
 691         SRP_ARG srp_arg = {NULL,NULL,0,0,0,1024};
 692 #endif
 693         SSL_EXCERT *exc = NULL;
 694
 695         SSL_CONF_CTX *cctx = NULL;
 696         STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
 697
 698         char *crl_file = NULL;
 699         int crl_format = FORMAT_PEM;
 700         int crl_download = 0;
 701         STACK_OF(X509_CRL) *crls = NULL;
 702
 703         meth=SSLv23_client_method();
 704
 705         apps_startup();
 706         c_Pause=0;
 707         c_quiet=0;
 708         c_ign_eof=0;
 709         c_debug=0;
 710         c_msg=0;
 711         c_showcerts=0;
 712
 713         if (bio_err == NULL)
 714                 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
 715
 716         if (!load_config(bio_err, NULL))
 717                 goto end;
 718         cctx = SSL_CONF_CTX_new();
 719         if (!cctx)
 720                 goto end;
 721         SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT);
 722         SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
 723
 724         if (    ((cbuf=OPENSSL_malloc(BUFSIZZ)) == NULL) ||
 725                 ((sbuf=OPENSSL_malloc(BUFSIZZ)) == NULL) ||
 726                 ((mbuf=OPENSSL_malloc(BUFSIZZ)) == NULL))
 727                 {
 728                 BIO_printf(bio_err,"out of memory\n");
 729                 goto end;
 730                 }
 731
 732         verify_depth=0;
 733         verify_error=X509_V_OK;
 734 #ifdef FIONBIO
 735         c_nbio=0;
 736 #endif
 737
 738         argc--;
 739         argv++;
 740         while (argc >= 1)
 741                 {
 742                 if      (strcmp(*argv,"-host") == 0)
 743                         {
 744                         if (--argc < 1) goto bad;
 745                         host= *(++argv);
 746                         }
 747                 else if (strcmp(*argv,"-port") == 0)
 748                         {
 749                         if (--argc < 1) goto bad;
 750                         port=atoi(*(++argv));
 751                         if (port == 0) goto bad;
 752                         }
 753                 else if (strcmp(*argv,"-connect") == 0)
 754                         {
 755                         if (--argc < 1) goto bad;
 756                         if (!extract_host_port(*(++argv),&host,NULL,&port))
 757                                 goto bad;
 758                         }
 759                 else if (strcmp(*argv,"-xmpphost") == 0)
 760                         {
 761                         if (--argc < 1) goto bad;
 762                         xmpphost= *(++argv);
 763                         }
 764                 else if (strcmp(*argv,"-verify") == 0)
 765                         {
 766                         verify=SSL_VERIFY_PEER;
 767                         if (--argc < 1) goto bad;
 768                         verify_depth=atoi(*(++argv));
 769                         if (!c_quiet)
 770                                 BIO_printf(bio_err,"verify depth is %d\n",verify_depth);
 771                         }
 772                 else if (strcmp(*argv,"-cert") == 0)
 773                         {
 774                         if (--argc < 1) goto bad;
 775                         cert_file= *(++argv);
 776                         }
 777                 else if (strcmp(*argv,"-CRL") == 0)
 778                         {
 779                         if (--argc < 1) goto bad;
 780                         crl_file= *(++argv);
 781                         }
 782                 else if (strcmp(*argv,"-crl_download") == 0)
 783                         crl_download = 1;
 784                 else if (strcmp(*argv,"-sess_out") == 0)
 785                         {
 786                         if (--argc < 1) goto bad;
 787                         sess_out = *(++argv);
 788                         }
 789                 else if (strcmp(*argv,"-sess_in") == 0)
 790                         {
 791                         if (--argc < 1) goto bad;
 792                         sess_in = *(++argv);
 793                         }
 794                 else if (strcmp(*argv,"-certform") == 0)
 795                         {
 796                         if (--argc < 1) goto bad;
 797                         cert_format = str2fmt(*(++argv));
 798                         }
 799                 else if (strcmp(*argv,"-CRLform") == 0)
 800                         {
 801                         if (--argc < 1) goto bad;
 802                         crl_format = str2fmt(*(++argv));
 803                         }
 804                 else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm))
 805                         {
 806                         if (badarg)
 807                                 goto bad;
 808                         continue;
 809                         }
 810                 else if (strcmp(*argv,"-verify_return_error") == 0)
 811                         verify_return_error = 1;
 812                 else if (strcmp(*argv,"-verify_quiet") == 0)
 813                         verify_quiet = 1;
 814                 else if (strcmp(*argv,"-brief") == 0)
 815                         {
 816                         c_brief = 1;
 817                         verify_quiet = 1;
 818                         c_quiet = 1;
 819                         }
 820                 else if (args_excert(&argv, &argc, &badarg, bio_err, &exc))
 821                         {
 822                         if (badarg)
 823                                 goto bad;
 824                         continue;
 825                         }
 826                 else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args))
 827                         {
 828                         if (badarg)
 829                                 goto bad;
 830                         continue;
 831                         }
 832                 else if (strcmp(*argv,"-prexit") == 0)
 833                         prexit=1;
 834                 else if (strcmp(*argv,"-crlf") == 0)
 835                         crlf=1;
 836                 else if (strcmp(*argv,"-quiet") == 0)
 837                         {
 838                         c_quiet=1;
 839                         c_ign_eof=1;
 840                         }
 841                 else if (strcmp(*argv,"-ign_eof") == 0)
 842                         c_ign_eof=1;
 843                 else if (strcmp(*argv,"-no_ign_eof") == 0)
 844                         c_ign_eof=0;
 845                 else if (strcmp(*argv,"-pause") == 0)
 846                         c_Pause=1;
 847                 else if (strcmp(*argv,"-debug") == 0)
 848                         c_debug=1;
 849 #ifndef OPENSSL_NO_TLSEXT
 850                 else if (strcmp(*argv,"-tlsextdebug") == 0)
 851                         c_tlsextdebug=1;
 852                 else if (strcmp(*argv,"-status") == 0)
 853                         c_status_req=1;
 854                 else if (strcmp(*argv,"-auth") == 0)
 855                         c_auth = 1;
 856                 else if (strcmp(*argv,"-auth_require_reneg") == 0)
 857                         c_auth_require_reneg = 1;
 858 #endif
 859 #ifdef WATT32
 860                 else if (strcmp(*argv,"-wdebug") == 0)
 861                         dbug_init();
 862 #endif
 863                 else if (strcmp(*argv,"-msg") == 0)
 864                         c_msg=1;
 865                 else if (strcmp(*argv,"-msgfile") == 0)
 866                         {
 867                         if (--argc < 1) goto bad;
 868                         bio_c_msg = BIO_new_file(*(++argv), "w");
 869                         }
 870 #ifndef OPENSSL_NO_SSL_TRACE
 871                 else if (strcmp(*argv,"-trace") == 0)
 872                         c_msg=2;
 873 #endif
 874                 else if (strcmp(*argv,"-showcerts") == 0)
 875                         c_showcerts=1;
 876                 else if (strcmp(*argv,"-nbio_test") == 0)
 877                         nbio_test=1;
 878                 else if (strcmp(*argv,"-state") == 0)
 879                         state=1;
 880 #ifndef OPENSSL_NO_PSK
 881                 else if (strcmp(*argv,"-psk_identity") == 0)
 882                         {
 883                         if (--argc < 1) goto bad;
 884                         psk_identity=*(++argv);
 885                         }
 886                 else if (strcmp(*argv,"-psk") == 0)
 887                         {
 888                         size_t j;
 889
 890                         if (--argc < 1) goto bad;
 891                         psk_key=*(++argv);
 892                         for (j = 0; j < strlen(psk_key); j++)
 893                                 {
 894                                 if (isxdigit((unsigned char)psk_key[j]))
 895                                         continue;
 896                                 BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
 897                                 goto bad;
 898                                 }
 899                         }
 900 #endif
 901 #ifndef OPENSSL_NO_SRP
 902                 else if (strcmp(*argv,"-srpuser") == 0)
 903                         {
 904                         if (--argc < 1) goto bad;
 905                         srp_arg.srplogin= *(++argv);
 906                         meth=TLSv1_client_method();
 907                         }
 908                 else if (strcmp(*argv,"-srppass") == 0)
 909                         {
 910                         if (--argc < 1) goto bad;
 911                         srppass= *(++argv);
 912                         meth=TLSv1_client_method();
 913                         }
 914                 else if (strcmp(*argv,"-srp_strength") == 0)
 915                         {
 916                         if (--argc < 1) goto bad;
 917                         srp_arg.strength=atoi(*(++argv));
 918                         BIO_printf(bio_err,"SRP minimal length for N is %d\n",srp_arg.strength);
 919                         meth=TLSv1_client_method();
 920                         }
 921                 else if (strcmp(*argv,"-srp_lateuser") == 0)
 922                         {
 923                         srp_lateuser= 1;
 924                         meth=TLSv1_client_method();
 925                         }
 926                 else if (strcmp(*argv,"-srp_moregroups") == 0)
 927                         {
 928                         srp_arg.amp=1;
 929                         meth=TLSv1_client_method();
 930                         }
 931 #endif
 932 #ifndef OPENSSL_NO_SSL2
 933                 else if (strcmp(*argv,"-ssl2") == 0)
 934                         meth=SSLv2_client_method();
 935 #endif
 936 #ifndef OPENSSL_NO_SSL3
 937                 else if (strcmp(*argv,"-ssl3") == 0)
 938                         meth=SSLv3_client_method();
 939 #endif
 940 #ifndef OPENSSL_NO_TLS1
 941                 else if (strcmp(*argv,"-tls1_2") == 0)
 942                         meth=TLSv1_2_client_method();
 943                 else if (strcmp(*argv,"-tls1_1") == 0)
 944                         meth=TLSv1_1_client_method();
 945                 else if (strcmp(*argv,"-tls1") == 0)
 946                         meth=TLSv1_client_method();
 947 #endif
 948 #ifndef OPENSSL_NO_DTLS1
 949                 else if (strcmp(*argv,"-dtls") == 0)
 950                         {
 951                         meth=DTLS_client_method();
 952                         socket_type=SOCK_DGRAM;
 953                         }
 954                 else if (strcmp(*argv,"-dtls1") == 0)
 955                         {
 956                         meth=DTLSv1_client_method();
 957                         socket_type=SOCK_DGRAM;
 958                         }
 959                 else if (strcmp(*argv,"-dtls1_2") == 0)
 960                         {
 961                         meth=DTLSv1_2_client_method();
 962                         socket_type=SOCK_DGRAM;
 963                         }
 964                 else if (strcmp(*argv,"-timeout") == 0)
 965                         enable_timeouts=1;
 966                 else if (strcmp(*argv,"-mtu") == 0)
 967                         {
 968                         if (--argc < 1) goto bad;
 969                         socket_mtu = atol(*(++argv));
 970                         }
 971 #endif
 972                 else if (strcmp(*argv,"-keyform") == 0)
 973                         {
 974                         if (--argc < 1) goto bad;
 975                         key_format = str2fmt(*(++argv));
 976                         }
 977                 else if (strcmp(*argv,"-pass") == 0)
 978                         {
 979                         if (--argc < 1) goto bad;
 980                         passarg = *(++argv);
 981                         }
 982                 else if (strcmp(*argv,"-cert_chain") == 0)
 983                         {
 984                         if (--argc < 1) goto bad;
 985                         chain_file= *(++argv);
 986                         }
 987                 else if (strcmp(*argv,"-key") == 0)
 988                         {
 989                         if (--argc < 1) goto bad;
 990                         key_file= *(++argv);
 991                         }
 992                 else if (strcmp(*argv,"-reconnect") == 0)
 993                         {
 994                         reconnect=5;
 995                         }
 996                 else if (strcmp(*argv,"-CApath") == 0)
 997                         {
 998                         if (--argc < 1) goto bad;
 999                         CApath= *(++argv);
1000                         }
1001                 else if (strcmp(*argv,"-chainCApath") == 0)
1002                         {
1003                         if (--argc < 1) goto bad;
1004                         chCApath= *(++argv);
1005                         }
1006                 else if (strcmp(*argv,"-verifyCApath") == 0)
1007                         {
1008                         if (--argc < 1) goto bad;
1009                         vfyCApath= *(++argv);
1010                         }
1011                 else if (strcmp(*argv,"-build_chain") == 0)
1012                         build_chain = 1;
1013                 else if (strcmp(*argv,"-CAfile") == 0)
1014                         {
1015                         if (--argc < 1) goto bad;
1016                         CAfile= *(++argv);
1017                         }
1018                 else if (strcmp(*argv,"-chainCAfile") == 0)
1019                         {
1020                         if (--argc < 1) goto bad;
1021                         chCAfile= *(++argv);
1022                         }
1023                 else if (strcmp(*argv,"-verifyCAfile") == 0)
1024                         {
1025                         if (--argc < 1) goto bad;
1026                         vfyCAfile= *(++argv);
1027                         }
1028 #ifndef OPENSSL_NO_TLSEXT
1029 # ifndef OPENSSL_NO_NEXTPROTONEG
1030                 else if (strcmp(*argv,"-nextprotoneg") == 0)
1031                         {
1032                         if (--argc < 1) goto bad;
1033                         next_proto_neg_in = *(++argv);
1034                         }
1035                 else if (strcmp(*argv,"-alpn") == 0)
1036                         {
1037                         if (--argc < 1) goto bad;
1038                         alpn_in = *(++argv);
1039                         }
1040 # endif
1041                 else if (strcmp(*argv,"-serverinfo") == 0)
1042                         {
1043                         char *c;
1044                         int start = 0;
1045                         int len;
1046
1047                         if (--argc < 1) goto bad;
1048                         c = *(++argv);
1049                         serverinfo_types_count = 0;
1050                         len = strlen(c);
1051                         for (i = 0; i <= len; ++i)
1052                                 {
1053                                 if (i == len || c[i] == ',')
1054                                         {
1055                                         serverinfo_types[serverinfo_types_count]
1056                                             = atoi(c+start);
1057                                         serverinfo_types_count++;
1058                                         start = i+1;
1059                                         }
1060                                 if (serverinfo_types_count == MAX_SI_TYPES)
1061                                         break;
1062                                 }
1063                         }
1064 #endif
1065 #ifdef FIONBIO
1066                 else if (strcmp(*argv,"-nbio") == 0)
1067                         { c_nbio=1; }
1068 #endif
1069                 else if (strcmp(*argv,"-starttls") == 0)
1070                         {
1071                         if (--argc < 1) goto bad;
1072                         ++argv;
1073                         if (strcmp(*argv,"smtp") == 0)
1074                                 starttls_proto = PROTO_SMTP;
1075                         else if (strcmp(*argv,"pop3") == 0)
1076                                 starttls_proto = PROTO_POP3;
1077                         else if (strcmp(*argv,"imap") == 0)
1078                                 starttls_proto = PROTO_IMAP;
1079                         else if (strcmp(*argv,"ftp") == 0)
1080                                 starttls_proto = PROTO_FTP;
1081                         else if (strcmp(*argv, "xmpp") == 0)
1082                                 starttls_proto = PROTO_XMPP;
1083                         else
1084                                 goto bad;
1085                         }
1086 #ifndef OPENSSL_NO_ENGINE
1087                 else if (strcmp(*argv,"-engine") == 0)
1088                         {
1089                         if (--argc < 1) goto bad;
1090                         engine_id = *(++argv);
1091                         }
1092                 else if (strcmp(*argv,"-ssl_client_engine") == 0)
1093                         {
1094                         if (--argc < 1) goto bad;
1095                         ssl_client_engine_id = *(++argv);
1096                         }
1097 #endif
1098                 else if (strcmp(*argv,"-rand") == 0)
1099                         {
1100                         if (--argc < 1) goto bad;
1101                         inrand= *(++argv);
1102                         }
1103 #ifndef OPENSSL_NO_TLSEXT
1104                 else if (strcmp(*argv,"-servername") == 0)
1105                         {
1106                         if (--argc < 1) goto bad;
1107                         servername= *(++argv);
1108                         /* meth=TLSv1_client_method(); */
1109                         }
1110 #endif
1111 #ifndef OPENSSL_NO_JPAKE
1112                 else if (strcmp(*argv,"-jpake") == 0)
1113                         {
1114                         if (--argc < 1) goto bad;
1115                         jpake_secret = *++argv;
1116                         }
1117 #endif
1118                 else if (strcmp(*argv,"-use_srtp") == 0)
1119                         {
1120                         if (--argc < 1) goto bad;
1121                         srtp_profiles = *(++argv);
1122                         }
1123                 else if (strcmp(*argv,"-keymatexport") == 0)
1124                         {
1125                         if (--argc < 1) goto bad;
1126                         keymatexportlabel= *(++argv);
1127                         }
1128                 else if (strcmp(*argv,"-keymatexportlen") == 0)
1129                         {
1130                         if (--argc < 1) goto bad;
1131                         keymatexportlen=atoi(*(++argv));
1132                         if (keymatexportlen == 0) goto bad;
1133                         }
1134                 else
1135                         {
1136                         BIO_printf(bio_err,"unknown option %s\n",*argv);
1137                         badop=1;
1138                         break;
1139                         }
1140                 argc--;
1141                 argv++;
1142                 }
1143         if (badop)
1144                 {
1145 bad:
1146                 sc_usage();
1147                 goto end;
1148                 }
1149
1150 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1151         if (jpake_secret)
1152                 {
1153                 if (psk_key)
1154                         {
1155                         BIO_printf(bio_err,
1156                                    "Can't use JPAKE and PSK together\n");
1157                         goto end;
1158                         }
1159                 psk_identity = "JPAKE";
1160                 }
1161 #endif
1162
1163         OpenSSL_add_ssl_algorithms();
1164         SSL_load_error_strings();
1165
1166 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
1167         next_proto.status = -1;
1168         if (next_proto_neg_in)
1169                 {
1170                 next_proto.data = next_protos_parse(&next_proto.len, next_proto_neg_in);
1171                 if (next_proto.data == NULL)
1172                         {
1173                         BIO_printf(bio_err, "Error parsing -nextprotoneg argument\n");
1174                         goto end;
1175                         }
1176                 }
1177         else
1178                 next_proto.data = NULL;
1179 #endif
1180
1181 #ifndef OPENSSL_NO_ENGINE
1182         e = setup_engine(bio_err, engine_id, 1);
1183         if (ssl_client_engine_id)
1184                 {
1185                 ssl_client_engine = ENGINE_by_id(ssl_client_engine_id);
1186                 if (!ssl_client_engine)
1187                         {
1188                         BIO_printf(bio_err,
1189                                         "Error getting client auth engine\n");
1190                         goto end;
1191                         }
1192                 }
1193
1194 #endif
1195         if (!app_passwd(bio_err, passarg, NULL, &pass, NULL))
1196                 {
1197                 BIO_printf(bio_err, "Error getting password\n");
1198                 goto end;
1199                 }
1200
1201         if (key_file == NULL)
1202                 key_file = cert_file;
1203
1204
1205         if (key_file)
1206
1207                 {
1208
1209                 key = load_key(bio_err, key_file, key_format, 0, pass, e,
1210                                "client certificate private key file");
1211                 if (!key)
1212                         {
1213                         ERR_print_errors(bio_err);
1214                         goto end;
1215                         }
1216
1217                 }
1218
1219         if (cert_file)
1220
1221                 {
1222                 cert = load_cert(bio_err,cert_file,cert_format,
1223                                 NULL, e, "client certificate file");
1224
1225                 if (!cert)
1226                         {
1227                         ERR_print_errors(bio_err);
1228                         goto end;
1229                         }
1230                 }
1231
1232         if (chain_file)
1233                 {
1234                 chain = load_certs(bio_err, chain_file,FORMAT_PEM,
1235                                         NULL, e, "client certificate chain");
1236                 if (!chain)
1237                         goto end;
1238                 }
1239
1240         if (crl_file)
1241                 {
1242                 X509_CRL *crl;
1243                 crl = load_crl(crl_file, crl_format);
1244                 if (!crl)
1245                         {
1246                         BIO_puts(bio_err, "Error loading CRL\n");
1247                         ERR_print_errors(bio_err);
1248                         goto end;
1249                         }
1250                 crls = sk_X509_CRL_new_null();
1251                 if (!crls || !sk_X509_CRL_push(crls, crl))
1252                         {
1253                         BIO_puts(bio_err, "Error adding CRL\n");
1254                         ERR_print_errors(bio_err);
1255                         X509_CRL_free(crl);
1256                         goto end;
1257                         }
1258                 }
1259
1260         if (!load_excert(&exc, bio_err))
1261                 goto end;
1262
1263         if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1264                 && !RAND_status())
1265                 {
1266                 BIO_printf(bio_err,"warning, not much extra random data, consider using the -rand option\n");
1267                 }
1268         if (inrand != NULL)
1269                 BIO_printf(bio_err,"%ld semi-random bytes loaded\n",
1270                         app_RAND_load_files(inrand));
1271
1272         if (bio_c_out == NULL)
1273                 {
1274                 if (c_quiet && !c_debug)
1275                         {
1276                         bio_c_out=BIO_new(BIO_s_null());
1277                         if (c_msg && !bio_c_msg)
1278                                 bio_c_msg=BIO_new_fp(stdout,BIO_NOCLOSE);
1279                         }
1280                 else
1281                         {
1282                         if (bio_c_out == NULL)
1283                                 bio_c_out=BIO_new_fp(stdout,BIO_NOCLOSE);
1284                         }
1285                 }
1286
1287 #ifndef OPENSSL_NO_SRP
1288         if(!app_passwd(bio_err, srppass, NULL, &srp_arg.srppassin, NULL))
1289                 {
1290                 BIO_printf(bio_err, "Error getting password\n");
1291                 goto end;
1292                 }
1293 #endif
1294
1295         ctx=SSL_CTX_new(meth);
1296         if (ctx == NULL)
1297                 {
1298                 ERR_print_errors(bio_err);
1299                 goto end;
1300                 }
1301
1302         if (vpm)
1303                 SSL_CTX_set1_param(ctx, vpm);
1304
1305         if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, 1, no_jpake))
1306                 {
1307                 ERR_print_errors(bio_err);
1308                 goto end;
1309                 }
1310
1311         if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1312                                                 crls, crl_download))
1313                 {
1314                 BIO_printf(bio_err, "Error loading store locations\n");
1315                 ERR_print_errors(bio_err);
1316                 goto end;
1317                 }
1318
1319 #ifndef OPENSSL_NO_ENGINE
1320         if (ssl_client_engine)
1321                 {
1322                 if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine))
1323                         {
1324                         BIO_puts(bio_err, "Error setting client auth engine\n");
1325                         ERR_print_errors(bio_err);
1326                         ENGINE_free(ssl_client_engine);
1327                         goto end;
1328                         }
1329                 ENGINE_free(ssl_client_engine);
1330                 }
1331 #endif
1332
1333 #ifndef OPENSSL_NO_PSK
1334 #ifdef OPENSSL_NO_JPAKE
1335         if (psk_key != NULL)
1336 #else
1337         if (psk_key != NULL || jpake_secret)
1338 #endif
1339                 {
1340                 if (c_debug)
1341                         BIO_printf(bio_c_out, "PSK key given or JPAKE in use, setting client callback\n");
1342                 SSL_CTX_set_psk_client_callback(ctx, psk_client_cb);
1343                 }
1344         if (srtp_profiles != NULL)
1345                 SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1346 #endif
1347         if (exc) ssl_ctx_set_excert(ctx, exc);
1348         /* DTLS: partial reads end up discarding unread UDP bytes :-(
1349          * Setting read ahead solves this problem.
1350          */
1351         if (socket_type == SOCK_DGRAM) SSL_CTX_set_read_ahead(ctx, 1);
1352
1353 #if !defined(OPENSSL_NO_TLSEXT)
1354 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1355         if (next_proto.data)
1356                 SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto);
1357 # endif
1358         if (alpn_in)
1359                 {
1360                 unsigned short alpn_len;
1361                 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_in);
1362
1363                 if (alpn == NULL)
1364                         {
1365                         BIO_printf(bio_err, "Error parsing -alpn argument\n");
1366                         goto end;
1367                         }
1368                 SSL_CTX_set_alpn_protos(ctx, alpn, alpn_len);
1369                 OPENSSL_free(alpn);
1370                 }
1371 #endif
1372 #ifndef OPENSSL_NO_TLSEXT
1373                 if (serverinfo_types_count)
1374                         {
1375                         for (i = 0; i < serverinfo_types_count; i++)
1376                                 {
1377                                 SSL_CTX_set_custom_cli_ext(ctx,
1378                                                            serverinfo_types[i],
1379                                                            NULL,
1380                                                            serverinfo_cli_cb,
1381                                                            NULL);
1382                                 }
1383                         }
1384 #endif
1385
1386         if (state) SSL_CTX_set_info_callback(ctx,apps_ssl_info_callback);
1387 #if 0
1388         else
1389                 SSL_CTX_set_cipher_list(ctx,getenv("SSL_CIPHER"));
1390 #endif
1391
1392         SSL_CTX_set_verify(ctx,verify,verify_callback);
1393
1394         if ((!SSL_CTX_load_verify_locations(ctx,CAfile,CApath)) ||
1395                 (!SSL_CTX_set_default_verify_paths(ctx)))
1396                 {
1397                 /* BIO_printf(bio_err,"error setting default verify locations\n"); */
1398                 ERR_print_errors(bio_err);
1399                 /* goto end; */
1400                 }
1401
1402         ssl_ctx_add_crls(ctx, crls, crl_download);
1403
1404         if (!set_cert_key_stuff(ctx,cert,key,chain,build_chain))
1405                 goto end;
1406
1407 #ifndef OPENSSL_NO_TLSEXT
1408         if (servername != NULL)
1409                 {
1410                 tlsextcbp.biodebug = bio_err;
1411                 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1412                 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1413                 }
1414 #ifndef OPENSSL_NO_SRP
1415         if (srp_arg.srplogin)
1416                 {
1417                 if (!srp_lateuser && !SSL_CTX_set_srp_username(ctx, srp_arg.srplogin))
1418                         {
1419                         BIO_printf(bio_err,"Unable to set SRP username\n");
1420                         goto end;
1421                         }
1422                 srp_arg.msg = c_msg;
1423                 srp_arg.debug = c_debug ;
1424                 SSL_CTX_set_srp_cb_arg(ctx,&srp_arg);
1425                 SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1426                 SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
1427                 if (c_msg || c_debug || srp_arg.amp == 0)
1428                         SSL_CTX_set_srp_verify_param_callback(ctx, ssl_srp_verify_param_cb);
1429                 }
1430
1431 #endif
1432         if (c_auth)
1433                 {
1434                 SSL_CTX_set_custom_cli_ext(ctx, TLSEXT_TYPE_client_authz, authz_tlsext_generate_cb, authz_tlsext_cb, bio_err);
1435                 SSL_CTX_set_custom_cli_ext(ctx, TLSEXT_TYPE_server_authz, authz_tlsext_generate_cb, authz_tlsext_cb, bio_err);
1436                 SSL_CTX_set_cli_supp_data(ctx, TLSEXT_SUPPLEMENTALDATATYPE_authz_data, suppdata_cb, auth_suppdata_generate_cb, bio_err);
1437                 }
1438 #endif
1439
1440         con=SSL_new(ctx);
1441         if (sess_in)
1442                 {
1443                 SSL_SESSION *sess;
1444                 BIO *stmp = BIO_new_file(sess_in, "r");
1445                 if (!stmp)
1446                         {
1447                         BIO_printf(bio_err, "Can't open session file %s\n",
1448                                                 sess_in);
1449                         ERR_print_errors(bio_err);
1450                         goto end;
1451                         }
1452                 sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL);
1453                 BIO_free(stmp);
1454                 if (!sess)
1455                         {
1456                         BIO_printf(bio_err, "Can't open session file %s\n",
1457                                                 sess_in);
1458                         ERR_print_errors(bio_err);
1459                         goto end;
1460                         }
1461                 SSL_set_session(con, sess);
1462                 SSL_SESSION_free(sess);
1463                 }
1464 #ifndef OPENSSL_NO_TLSEXT
1465         if (servername != NULL)
1466                 {
1467                 if (!SSL_set_tlsext_host_name(con,servername))
1468                         {
1469                         BIO_printf(bio_err,"Unable to set TLS servername extension.\n");
1470                         ERR_print_errors(bio_err);
1471                         goto end;
1472                         }
1473                 }
1474 #endif
1475 #ifndef OPENSSL_NO_KRB5
1476         if (con  &&  (kctx = kssl_ctx_new()) != NULL)
1477                 {
1478                 SSL_set0_kssl_ctx(con, kctx);
1479                 kssl_ctx_setstring(kctx, KSSL_SERVER, host);
1480                 }
1481 #endif  /* OPENSSL_NO_KRB5  */
1482 /*      SSL_set_cipher_list(con,"RC4-MD5"); */
1483 #if 0
1484 #ifdef TLSEXT_TYPE_opaque_prf_input
1485         SSL_set_tlsext_opaque_prf_input(con, "Test client", 11);
1486 #endif
1487 #endif
1488
1489 re_start:
1490
1491         if (init_client(&s,host,port,socket_type) == 0)
1492                 {
1493                 BIO_printf(bio_err,"connect:errno=%d\n",get_last_socket_error());
1494                 SHUTDOWN(s);
1495                 goto end;
1496                 }
1497         BIO_printf(bio_c_out,"CONNECTED(%08X)\n",s);
1498
1499 #ifdef FIONBIO
1500         if (c_nbio)
1501                 {
1502                 unsigned long l=1;
1503                 BIO_printf(bio_c_out,"turning on non blocking io\n");
1504                 if (BIO_socket_ioctl(s,FIONBIO,&l) < 0)
1505                         {
1506                         ERR_print_errors(bio_err);
1507                         goto end;
1508                         }
1509                 }
1510 #endif
1511         if (c_Pause & 0x01) SSL_set_debug(con, 1);
1512
1513         if (socket_type == SOCK_DGRAM)
1514                 {
1515
1516                 sbio=BIO_new_dgram(s,BIO_NOCLOSE);
1517                 if (getsockname(s, &peer, (void *)&peerlen) < 0)
1518                         {
1519                         BIO_printf(bio_err, "getsockname:errno=%d\n",
1520                                 get_last_socket_error());
1521                         SHUTDOWN(s);
1522                         goto end;
1523                         }
1524
1525                 (void)BIO_ctrl_set_connected(sbio, 1, &peer);
1526
1527                 if (enable_timeouts)
1528                         {
1529                         timeout.tv_sec = 0;
1530                         timeout.tv_usec = DGRAM_RCV_TIMEOUT;
1531                         BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
1532
1533                         timeout.tv_sec = 0;
1534                         timeout.tv_usec = DGRAM_SND_TIMEOUT;
1535                         BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
1536                         }
1537
1538                 if (socket_mtu > 28)
1539                         {
1540                         SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
1541                         SSL_set_mtu(con, socket_mtu - 28);
1542                         }
1543                 else
1544                         /* want to do MTU discovery */
1545                         BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
1546                 }
1547         else
1548                 sbio=BIO_new_socket(s,BIO_NOCLOSE);
1549
1550         if (nbio_test)
1551                 {
1552                 BIO *test;
1553
1554                 test=BIO_new(BIO_f_nbio_test());
1555                 sbio=BIO_push(test,sbio);
1556                 }
1557
1558         if (c_debug)
1559                 {
1560                 SSL_set_debug(con, 1);
1561                 BIO_set_callback(sbio,bio_dump_callback);
1562                 BIO_set_callback_arg(sbio,(char *)bio_c_out);
1563                 }
1564         if (c_msg)
1565                 {
1566 #ifndef OPENSSL_NO_SSL_TRACE
1567                 if (c_msg == 2)
1568                         SSL_set_msg_callback(con, SSL_trace);
1569                 else
1570 #endif
1571                         SSL_set_msg_callback(con, msg_cb);
1572                 SSL_set_msg_callback_arg(con, bio_c_msg ? bio_c_msg : bio_c_out);
1573                 }
1574 #ifndef OPENSSL_NO_TLSEXT
1575         if (c_tlsextdebug)
1576                 {
1577                 SSL_set_tlsext_debug_callback(con, tlsext_cb);
1578                 SSL_set_tlsext_debug_arg(con, bio_c_out);
1579                 }
1580         if (c_status_req)
1581                 {
1582                 SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp);
1583                 SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb);
1584                 SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out);
1585 #if 0
1586 {
1587 STACK_OF(OCSP_RESPID) *ids = sk_OCSP_RESPID_new_null();
1588 OCSP_RESPID *id = OCSP_RESPID_new();
1589 id->value.byKey = ASN1_OCTET_STRING_new();
1590 id->type = V_OCSP_RESPID_KEY;
1591 ASN1_STRING_set(id->value.byKey, "Hello World", -1);
1592 sk_OCSP_RESPID_push(ids, id);
1593 SSL_set_tlsext_status_ids(con, ids);
1594 }
1595 #endif
1596                 }
1597 #endif
1598 #ifndef OPENSSL_NO_JPAKE
1599         if (jpake_secret)
1600                 jpake_client_auth(bio_c_out, sbio, jpake_secret);
1601 #endif
1602
1603         SSL_set_bio(con,sbio,sbio);
1604         SSL_set_connect_state(con);
1605
1606         /* ok, lets connect */
1607         width=SSL_get_fd(con)+1;
1608
1609         read_tty=1;
1610         write_tty=0;
1611         tty_on=0;
1612         read_ssl=1;
1613         write_ssl=1;
1614
1615         cbuf_len=0;
1616         cbuf_off=0;
1617         sbuf_len=0;
1618         sbuf_off=0;
1619
1620         /* This is an ugly hack that does a lot of assumptions */
1621         /* We do have to handle multi-line responses which may come
1622            in a single packet or not. We therefore have to use
1623            BIO_gets() which does need a buffering BIO. So during
1624            the initial chitchat we do push a buffering BIO into the
1625            chain that is removed again later on to not disturb the
1626            rest of the s_client operation. */
1627         if (starttls_proto == PROTO_SMTP)
1628                 {
1629                 int foundit=0;
1630                 BIO *fbio = BIO_new(BIO_f_buffer());
1631                 BIO_push(fbio, sbio);
1632                 /* wait for multi-line response to end from SMTP */
1633                 do
1634                         {
1635                         mbuf_len = BIO_gets(fbio,mbuf,BUFSIZZ);
1636                         }
1637                 while (mbuf_len>3 && mbuf[3]=='-');
1638                 /* STARTTLS command requires EHLO... */
1639                 BIO_printf(fbio,"EHLO openssl.client.net\r\n");
1640                 (void)BIO_flush(fbio);
1641                 /* wait for multi-line response to end EHLO SMTP response */
1642                 do
1643                         {
1644                         mbuf_len = BIO_gets(fbio,mbuf,BUFSIZZ);
1645                         if (strstr(mbuf,"STARTTLS"))
1646                                 foundit=1;
1647                         }
1648                 while (mbuf_len>3 && mbuf[3]=='-');
1649                 (void)BIO_flush(fbio);
1650                 BIO_pop(fbio);
1651                 BIO_free(fbio);
1652                 if (!foundit)
1653                         BIO_printf(bio_err,
1654                                    "didn't found starttls in server response,"
1655                                    " try anyway...\n");
1656                 BIO_printf(sbio,"STARTTLS\r\n");
1657                 BIO_read(sbio,sbuf,BUFSIZZ);
1658                 }
1659         else if (starttls_proto == PROTO_POP3)
1660                 {
1661                 BIO_read(sbio,mbuf,BUFSIZZ);
1662                 BIO_printf(sbio,"STLS\r\n");
1663                 BIO_read(sbio,sbuf,BUFSIZZ);
1664                 }
1665         else if (starttls_proto == PROTO_IMAP)
1666                 {
1667                 int foundit=0;
1668                 BIO *fbio = BIO_new(BIO_f_buffer());
1669                 BIO_push(fbio, sbio);
1670                 BIO_gets(fbio,mbuf,BUFSIZZ);
1671                 /* STARTTLS command requires CAPABILITY... */
1672                 BIO_printf(fbio,". CAPABILITY\r\n");
1673                 (void)BIO_flush(fbio);
1674                 /* wait for multi-line CAPABILITY response */
1675                 do
1676                         {
1677                         mbuf_len = BIO_gets(fbio,mbuf,BUFSIZZ);
1678                         if (strstr(mbuf,"STARTTLS"))
1679                                 foundit=1;
1680                         }
1681                 while (mbuf_len>3 && mbuf[0]!='.');
1682                 (void)BIO_flush(fbio);
1683                 BIO_pop(fbio);
1684                 BIO_free(fbio);
1685                 if (!foundit)
1686                         BIO_printf(bio_err,
1687                                    "didn't found STARTTLS in server response,"
1688                                    " try anyway...\n");
1689                 BIO_printf(sbio,". STARTTLS\r\n");
1690                 BIO_read(sbio,sbuf,BUFSIZZ);
1691                 }
1692         else if (starttls_proto == PROTO_FTP)
1693                 {
1694                 BIO *fbio = BIO_new(BIO_f_buffer());
1695                 BIO_push(fbio, sbio);
1696                 /* wait for multi-line response to end from FTP */
1697                 do
1698                         {
1699                         mbuf_len = BIO_gets(fbio,mbuf,BUFSIZZ);
1700                         }
1701                 while (mbuf_len>3 && mbuf[3]=='-');
1702                 (void)BIO_flush(fbio);
1703                 BIO_pop(fbio);
1704                 BIO_free(fbio);
1705                 BIO_printf(sbio,"AUTH TLS\r\n");
1706                 BIO_read(sbio,sbuf,BUFSIZZ);
1707                 }
1708         if (starttls_proto == PROTO_XMPP)
1709                 {
1710                 int seen = 0;
1711                 BIO_printf(sbio,"<stream:stream "
1712                     "xmlns:stream='http://etherx.jabber.org/streams' "
1713                     "xmlns='jabber:client' to='%s' version='1.0'>", xmpphost ?
1714                            xmpphost : host);
1715                 seen = BIO_read(sbio,mbuf,BUFSIZZ);
1716                 mbuf[seen] = 0;
1717                 while (!strstr(mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'") &&
1718                                 !strstr(mbuf, "<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\""))
1719                         {
1720                         seen = BIO_read(sbio,mbuf,BUFSIZZ);
1721
1722                         if (seen <= 0)
1723                                 goto shut;
1724
1725                         mbuf[seen] = 0;
1726                         }
1727                 BIO_printf(sbio, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
1728                 seen = BIO_read(sbio,sbuf,BUFSIZZ);
1729                 sbuf[seen] = 0;
1730                 if (!strstr(sbuf, "<proceed"))
1731                         goto shut;
1732                 mbuf[0] = 0;
1733                 }
1734
1735         for (;;)
1736                 {
1737                 FD_ZERO(&readfds);
1738                 FD_ZERO(&writefds);
1739
1740                 if ((SSL_version(con) == DTLS1_VERSION) &&
1741                         DTLSv1_get_timeout(con, &timeout))
1742                         timeoutp = &timeout;
1743                 else
1744                         timeoutp = NULL;
1745
1746                 if (SSL_in_init(con) && !SSL_total_renegotiations(con))
1747                         {
1748                         in_init=1;
1749                         tty_on=0;
1750                         }
1751                 else
1752                         {
1753                         tty_on=1;
1754                         if (in_init)
1755                                 {
1756                                 in_init=0;
1757 #if 0 /* This test doesn't really work as intended (needs to be fixed) */
1758 #ifndef OPENSSL_NO_TLSEXT
1759                                 if (servername != NULL && !SSL_session_reused(con))
1760                                         {
1761                                         BIO_printf(bio_c_out,"Server did %sacknowledge servername extension.\n",tlsextcbp.ack?"":"not ");
1762                                         }
1763 #endif
1764 #endif
1765                                 if (sess_out)
1766                                         {
1767                                         BIO *stmp = BIO_new_file(sess_out, "w");
1768                                         if (stmp)
1769                                                 {
1770                                                 PEM_write_bio_SSL_SESSION(stmp, SSL_get_session(con));
1771                                                 BIO_free(stmp);
1772                                                 }
1773                                         else
1774                                                 BIO_printf(bio_err, "Error writing session file %s\n", sess_out);
1775                                         }
1776                                 if (c_brief)
1777                                         {
1778                                         BIO_puts(bio_err,
1779                                                 "CONNECTION ESTABLISHED\n");
1780                                         print_ssl_summary(bio_err, con);
1781                                         }
1782                                 print_stuff(bio_c_out,con,full_log);
1783                                 if (full_log > 0) full_log--;
1784
1785                                 if (starttls_proto)
1786                                         {
1787                                         BIO_printf(bio_err,"%s",mbuf);
1788                                         /* We don't need to know any more */
1789                                         starttls_proto = PROTO_OFF;
1790                                         }
1791
1792                                 if (reconnect)
1793                                         {
1794                                         reconnect--;
1795                                         BIO_printf(bio_c_out,"drop connection and then reconnect\n");
1796                                         SSL_shutdown(con);
1797                                         SSL_set_connect_state(con);
1798                                         SHUTDOWN(SSL_get_fd(con));
1799                                         goto re_start;
1800                                         }
1801                                 }
1802                         }
1803
1804                 ssl_pending = read_ssl && SSL_pending(con);
1805
1806                 if (!ssl_pending)
1807                         {
1808 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined (OPENSSL_SYS_BEOS_R5)
1809                         if (tty_on)
1810                                 {
1811                                 if (read_tty)  openssl_fdset(fileno(stdin),&readfds);
1812                                 if (write_tty) openssl_fdset(fileno(stdout),&writefds);
1813                                 }
1814                         if (read_ssl)
1815                                 openssl_fdset(SSL_get_fd(con),&readfds);
1816                         if (write_ssl)
1817                                 openssl_fdset(SSL_get_fd(con),&writefds);
1818 #else
1819                         if(!tty_on || !write_tty) {
1820                                 if (read_ssl)
1821                                         openssl_fdset(SSL_get_fd(con),&readfds);
1822                                 if (write_ssl)
1823                                         openssl_fdset(SSL_get_fd(con),&writefds);
1824                         }
1825 #endif
1826 /*                      printf("mode tty(%d %d%d) ssl(%d%d)\n",
1827                                 tty_on,read_tty,write_tty,read_ssl,write_ssl);*/
1828
1829                         /* Note: under VMS with SOCKETSHR the second parameter
1830                          * is currently of type (int *) whereas under other
1831                          * systems it is (void *) if you don't have a cast it
1832                          * will choke the compiler: if you do have a cast then
1833                          * you can either go for (int *) or (void *).
1834                          */
1835 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
1836                         /* Under Windows/DOS we make the assumption that we can
1837                          * always write to the tty: therefore if we need to
1838                          * write to the tty we just fall through. Otherwise
1839                          * we timeout the select every second and see if there
1840                          * are any keypresses. Note: this is a hack, in a proper
1841                          * Windows application we wouldn't do this.
1842                          */
1843                         i=0;
1844                         if(!write_tty) {
1845                                 if(read_tty) {
1846                                         tv.tv_sec = 1;
1847                                         tv.tv_usec = 0;
1848                                         i=select(width,(void *)&readfds,(void *)&writefds,
1849                                                  NULL,&tv);
1850 #if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
1851                                         if(!i && (!_kbhit() || !read_tty) ) continue;
1852 #else
1853                                         if(!i && (!((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0))) || !read_tty) ) continue;
1854 #endif
1855                                 } else  i=select(width,(void *)&readfds,(void *)&writefds,
1856                                          NULL,timeoutp);
1857                         }
1858 #elif defined(OPENSSL_SYS_NETWARE)
1859                         if(!write_tty) {
1860                                 if(read_tty) {
1861                                         tv.tv_sec = 1;
1862                                         tv.tv_usec = 0;
1863                                         i=select(width,(void *)&readfds,(void *)&writefds,
1864                                                 NULL,&tv);
1865                                 } else  i=select(width,(void *)&readfds,(void *)&writefds,
1866                                         NULL,timeoutp);
1867                         }
1868 #elif defined(OPENSSL_SYS_BEOS_R5)
1869                         /* Under BeOS-R5 the situation is similar to DOS */
1870                         i=0;
1871                         stdin_set = 0;
1872                         (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
1873                         if(!write_tty) {
1874                                 if(read_tty) {
1875                                         tv.tv_sec = 1;
1876                                         tv.tv_usec = 0;
1877                                         i=select(width,(void *)&readfds,(void *)&writefds,
1878                                                  NULL,&tv);
1879                                         if (read(fileno(stdin), sbuf, 0) >= 0)
1880                                                 stdin_set = 1;
1881                                         if (!i && (stdin_set != 1 || !read_tty))
1882                                                 continue;
1883                                 } else  i=select(width,(void *)&readfds,(void *)&writefds,
1884                                          NULL,timeoutp);
1885                         }
1886                         (void)fcntl(fileno(stdin), F_SETFL, 0);
1887 #else
1888                         i=select(width,(void *)&readfds,(void *)&writefds,
1889                                  NULL,timeoutp);
1890 #endif
1891                         if ( i < 0)
1892                                 {
1893                                 BIO_printf(bio_err,"bad select %d\n",
1894                                 get_last_socket_error());
1895                                 goto shut;
1896                                 /* goto end; */
1897                                 }
1898                         }
1899
1900                 if ((SSL_version(con) == DTLS1_VERSION) && DTLSv1_handle_timeout(con) > 0)
1901                         {
1902                         BIO_printf(bio_err,"TIMEOUT occurred\n");
1903                         }
1904
1905                 if (!ssl_pending && FD_ISSET(SSL_get_fd(con),&writefds))
1906                         {
1907                         k=SSL_write(con,&(cbuf[cbuf_off]),
1908                                 (unsigned int)cbuf_len);
1909                         switch (SSL_get_error(con,k))
1910                                 {
1911                         case SSL_ERROR_NONE:
1912                                 cbuf_off+=k;
1913                                 cbuf_len-=k;
1914                                 if (k <= 0) goto end;
1915                                 /* we have done a  write(con,NULL,0); */
1916                                 if (cbuf_len <= 0)
1917                                         {
1918                                         read_tty=1;
1919                                         write_ssl=0;
1920                                         }
1921                                 else /* if (cbuf_len > 0) */
1922                                         {
1923                                         read_tty=0;
1924                                         write_ssl=1;
1925                                         }
1926                                 break;
1927                         case SSL_ERROR_WANT_WRITE:
1928                                 BIO_printf(bio_c_out,"write W BLOCK\n");
1929                                 write_ssl=1;
1930                                 read_tty=0;
1931                                 break;
1932                         case SSL_ERROR_WANT_READ:
1933                                 BIO_printf(bio_c_out,"write R BLOCK\n");
1934                                 write_tty=0;
1935                                 read_ssl=1;
1936                                 write_ssl=0;
1937                                 break;
1938                         case SSL_ERROR_WANT_X509_LOOKUP:
1939                                 BIO_printf(bio_c_out,"write X BLOCK\n");
1940                                 break;
1941                         case SSL_ERROR_ZERO_RETURN:
1942                                 if (cbuf_len != 0)
1943                                         {
1944                                         BIO_printf(bio_c_out,"shutdown\n");
1945                                         ret = 0;
1946                                         goto shut;
1947                                         }
1948                                 else
1949                                         {
1950                                         read_tty=1;
1951                                         write_ssl=0;
1952                                         break;
1953                                         }
1954
1955                         case SSL_ERROR_SYSCALL:
1956                                 if ((k != 0) || (cbuf_len != 0))
1957                                         {
1958                                         BIO_printf(bio_err,"write:errno=%d\n",
1959                                                 get_last_socket_error());
1960                                         goto shut;
1961                                         }
1962                                 else
1963                                         {
1964                                         read_tty=1;
1965                                         write_ssl=0;
1966                                         }
1967                                 break;
1968                         case SSL_ERROR_SSL:
1969                                 ERR_print_errors(bio_err);
1970                                 goto shut;
1971                                 }
1972                         }
1973 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
1974                 /* Assume Windows/DOS/BeOS can always write */
1975                 else if (!ssl_pending && write_tty)
1976 #else
1977                 else if (!ssl_pending && FD_ISSET(fileno(stdout),&writefds))
1978 #endif
1979                         {
1980 #ifdef CHARSET_EBCDIC
1981                         ascii2ebcdic(&(sbuf[sbuf_off]),&(sbuf[sbuf_off]),sbuf_len);
1982 #endif
1983                         i=raw_write_stdout(&(sbuf[sbuf_off]),sbuf_len);
1984
1985                         if (i <= 0)
1986                                 {
1987                                 BIO_printf(bio_c_out,"DONE\n");
1988                                 ret = 0;
1989                                 goto shut;
1990                                 /* goto end; */
1991                                 }
1992
1993                         sbuf_len-=i;;
1994                         sbuf_off+=i;
1995                         if (sbuf_len <= 0)
1996                                 {
1997                                 read_ssl=1;
1998                                 write_tty=0;
1999                                 }
2000                         }
2001                 else if (ssl_pending || FD_ISSET(SSL_get_fd(con),&readfds))
2002                         {
2003 #ifdef RENEG
2004 { static int iiii; if (++iiii == 52) { SSL_renegotiate(con); iiii=0; } }
2005 #endif
2006 #if 1
2007                         k=SSL_read(con,sbuf,1024 /* BUFSIZZ */ );
2008 #else
2009 /* Demo for pending and peek :-) */
2010                         k=SSL_read(con,sbuf,16);
2011 { char zbuf[10240];
2012 printf("read=%d pending=%d peek=%d\n",k,SSL_pending(con),SSL_peek(con,zbuf,10240));
2013 }
2014 #endif
2015
2016                         switch (SSL_get_error(con,k))
2017                                 {
2018                         case SSL_ERROR_NONE:
2019                                 if (k <= 0)
2020                                         goto end;
2021                                 sbuf_off=0;
2022                                 sbuf_len=k;
2023
2024                                 read_ssl=0;
2025                                 write_tty=1;
2026                                 break;
2027                         case SSL_ERROR_WANT_WRITE:
2028                                 BIO_printf(bio_c_out,"read W BLOCK\n");
2029                                 write_ssl=1;
2030                                 read_tty=0;
2031                                 break;
2032                         case SSL_ERROR_WANT_READ:
2033                                 BIO_printf(bio_c_out,"read R BLOCK\n");
2034                                 write_tty=0;
2035                                 read_ssl=1;
2036                                 if ((read_tty == 0) && (write_ssl == 0))
2037                                         write_ssl=1;
2038                                 break;
2039                         case SSL_ERROR_WANT_X509_LOOKUP:
2040                                 BIO_printf(bio_c_out,"read X BLOCK\n");
2041                                 break;
2042                         case SSL_ERROR_SYSCALL:
2043                                 ret=get_last_socket_error();
2044                                 if (c_brief)
2045                                         BIO_puts(bio_err, "CONNECTION CLOSED BY SERVER\n");
2046                                 else
2047                                         BIO_printf(bio_err,"read:errno=%d\n",ret);
2048                                 goto shut;
2049                         case SSL_ERROR_ZERO_RETURN:
2050                                 BIO_printf(bio_c_out,"closed\n");
2051                                 ret=0;
2052                                 goto shut;
2053                         case SSL_ERROR_SSL:
2054                                 ERR_print_errors(bio_err);
2055                                 goto shut;
2056                                 /* break; */
2057                                 }
2058                         }
2059
2060 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
2061 #if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
2062                 else if (_kbhit())
2063 #else
2064                 else if ((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
2065 #endif
2066 #elif defined (OPENSSL_SYS_NETWARE)
2067                 else if (_kbhit())
2068 #elif defined(OPENSSL_SYS_BEOS_R5)
2069                 else if (stdin_set)
2070 #else
2071                 else if (FD_ISSET(fileno(stdin),&readfds))
2072 #endif
2073                         {
2074                         if (crlf)
2075                                 {
2076                                 int j, lf_num;
2077
2078                                 i=raw_read_stdin(cbuf,BUFSIZZ/2);
2079                                 lf_num = 0;
2080                                 /* both loops are skipped when i <= 0 */
2081                                 for (j = 0; j < i; j++)
2082                                         if (cbuf[j] == '\n')
2083                                                 lf_num++;
2084                                 for (j = i-1; j >= 0; j--)
2085                                         {
2086                                         cbuf[j+lf_num] = cbuf[j];
2087                                         if (cbuf[j] == '\n')
2088                                                 {
2089                                                 lf_num--;
2090                                                 i++;
2091                                                 cbuf[j+lf_num] = '\r';
2092                                                 }
2093                                         }
2094                                 assert(lf_num == 0);
2095                                 }
2096                         else
2097                                 i=raw_read_stdin(cbuf,BUFSIZZ);
2098
2099                         if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q')))
2100                                 {
2101                                 BIO_printf(bio_err,"DONE\n");
2102                                 ret=0;
2103                                 goto shut;
2104                                 }
2105
2106                         if ((!c_ign_eof) && (cbuf[0] == 'R'))
2107                                 {
2108                                 BIO_printf(bio_err,"RENEGOTIATING\n");
2109                                 SSL_renegotiate(con);
2110                                 cbuf_len=0;
2111                                 }
2112 #ifndef OPENSSL_NO_HEARTBEATS
2113                         else if ((!c_ign_eof) && (cbuf[0] == 'B'))
2114                                 {
2115                                 BIO_printf(bio_err,"HEARTBEATING\n");
2116                                 SSL_heartbeat(con);
2117                                 cbuf_len=0;
2118                                 }
2119 #endif
2120                         else
2121                                 {
2122                                 cbuf_len=i;
2123                                 cbuf_off=0;
2124 #ifdef CHARSET_EBCDIC
2125                                 ebcdic2ascii(cbuf, cbuf, i);
2126 #endif
2127                                 }
2128
2129                         write_ssl=1;
2130                         read_tty=0;
2131                         }
2132                 }
2133
2134         ret=0;
2135 shut:
2136         if (in_init)
2137                 print_stuff(bio_c_out,con,full_log);
2138         SSL_shutdown(con);
2139         SHUTDOWN(SSL_get_fd(con));
2140 end:
2141         if (con != NULL)
2142                 {
2143                 if (prexit != 0)
2144                         print_stuff(bio_c_out,con,1);
2145                 SSL_free(con);
2146                 }
2147 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2148         if (next_proto.data)
2149                 OPENSSL_free(next_proto.data);
2150 #endif
2151         if (ctx != NULL) SSL_CTX_free(ctx);
2152         if (cert)
2153                 X509_free(cert);
2154         if (crls)
2155                 sk_X509_CRL_pop_free(crls, X509_CRL_free);
2156         if (key)
2157                 EVP_PKEY_free(key);
2158         if (chain)
2159                 sk_X509_pop_free(chain, X509_free);
2160         if (pass)
2161                 OPENSSL_free(pass);
2162         if (vpm)
2163                 X509_VERIFY_PARAM_free(vpm);
2164         ssl_excert_free(exc);
2165         if (ssl_args)
2166                 sk_OPENSSL_STRING_free(ssl_args);
2167         if (cctx)
2168                 SSL_CONF_CTX_free(cctx);
2169 #ifndef OPENSSL_NO_JPAKE
2170         if (jpake_secret && psk_key)
2171                 OPENSSL_free(psk_key);
2172 #endif
2173         if (cbuf != NULL) { OPENSSL_cleanse(cbuf,BUFSIZZ); OPENSSL_free(cbuf); }
2174         if (sbuf != NULL) { OPENSSL_cleanse(sbuf,BUFSIZZ); OPENSSL_free(sbuf); }
2175         if (mbuf != NULL) { OPENSSL_cleanse(mbuf,BUFSIZZ); OPENSSL_free(mbuf); }
2176         if (bio_c_out != NULL)
2177                 {
2178                 BIO_free(bio_c_out);
2179                 bio_c_out=NULL;
2180                 }
2181         if (bio_c_msg != NULL)
2182                 {
2183                 BIO_free(bio_c_msg);
2184                 bio_c_msg=NULL;
2185                 }
2186         apps_shutdown();
2187         OPENSSL_EXIT(ret);
2188         }
2189
2190
2191 static void print_stuff(BIO *bio, SSL *s, int full)
2192         {
2193         X509 *peer=NULL;
2194         char *p;
2195         static const char *space="                ";
2196         char buf[BUFSIZ];
2197         STACK_OF(X509) *sk;
2198         STACK_OF(X509_NAME) *sk2;
2199         const SSL_CIPHER *c;
2200         X509_NAME *xn;
2201         int j,i;
2202 #ifndef OPENSSL_NO_COMP
2203         const COMP_METHOD *comp, *expansion;
2204 #endif
2205         unsigned char *exportedkeymat;
2206
2207         if (full)
2208                 {
2209                 int got_a_chain = 0;
2210
2211                 sk=SSL_get_peer_cert_chain(s);
2212                 if (sk != NULL)
2213                         {
2214                         got_a_chain = 1; /* we don't have it for SSL2 (yet) */
2215
2216                         BIO_printf(bio,"---\nCertificate chain\n");
2217                         for (i=0; i<sk_X509_num(sk); i++)
2218                                 {
2219                                 X509_NAME_oneline(X509_get_subject_name(
2220                                         sk_X509_value(sk,i)),buf,sizeof buf);
2221                                 BIO_printf(bio,"%2d s:%s\n",i,buf);
2222                                 X509_NAME_oneline(X509_get_issuer_name(
2223                                         sk_X509_value(sk,i)),buf,sizeof buf);
2224                                 BIO_printf(bio,"   i:%s\n",buf);
2225                                 if (c_showcerts)
2226                                         PEM_write_bio_X509(bio,sk_X509_value(sk,i));
2227                                 }
2228                         }
2229
2230                 BIO_printf(bio,"---\n");
2231                 peer=SSL_get_peer_certificate(s);
2232                 if (peer != NULL)
2233                         {
2234                         BIO_printf(bio,"Server certificate\n");
2235                         if (!(c_showcerts && got_a_chain)) /* Redundant if we showed the whole chain */
2236                                 PEM_write_bio_X509(bio,peer);
2237                         X509_NAME_oneline(X509_get_subject_name(peer),
2238                                 buf,sizeof buf);
2239                         BIO_printf(bio,"subject=%s\n",buf);
2240                         X509_NAME_oneline(X509_get_issuer_name(peer),
2241                                 buf,sizeof buf);
2242                         BIO_printf(bio,"issuer=%s\n",buf);
2243                         }
2244                 else
2245                         BIO_printf(bio,"no peer certificate available\n");
2246
2247                 sk2=SSL_get_client_CA_list(s);
2248                 if ((sk2 != NULL) && (sk_X509_NAME_num(sk2) > 0))
2249                         {
2250                         BIO_printf(bio,"---\nAcceptable client certificate CA names\n");
2251                         for (i=0; i<sk_X509_NAME_num(sk2); i++)
2252                                 {
2253                                 xn=sk_X509_NAME_value(sk2,i);
2254                                 X509_NAME_oneline(xn,buf,sizeof(buf));
2255                                 BIO_write(bio,buf,strlen(buf));
2256                                 BIO_write(bio,"\n",1);
2257                                 }
2258                         }
2259                 else
2260                         {
2261                         BIO_printf(bio,"---\nNo client certificate CA names sent\n");
2262                         }
2263                 p=SSL_get_shared_ciphers(s,buf,sizeof buf);
2264                 if (p != NULL)
2265                         {
2266                         /* This works only for SSL 2.  In later protocol
2267                          * versions, the client does not know what other
2268                          * ciphers (in addition to the one to be used
2269                          * in the current connection) the server supports. */
2270
2271                         BIO_printf(bio,"---\nCiphers common between both SSL endpoints:\n");
2272                         j=i=0;
2273                         while (*p)
2274                                 {
2275                                 if (*p == ':')
2276                                         {
2277                                         BIO_write(bio,space,15-j%25);
2278                                         i++;
2279                                         j=0;
2280                                         BIO_write(bio,((i%3)?" ":"\n"),1);
2281                                         }
2282                                 else
2283                                         {
2284                                         BIO_write(bio,p,1);
2285                                         j++;
2286                                         }
2287                                 p++;
2288                                 }
2289                         BIO_write(bio,"\n",1);
2290                         }
2291
2292                 ssl_print_sigalgs(bio, s);
2293                 ssl_print_tmp_key(bio, s);
2294
2295                 BIO_printf(bio,"---\nSSL handshake has read %ld bytes and written %ld bytes\n",
2296                         BIO_number_read(SSL_get_rbio(s)),
2297                         BIO_number_written(SSL_get_wbio(s)));
2298                 }
2299         BIO_printf(bio,(SSL_cache_hit(s)?"---\nReused, ":"---\nNew, "));
2300         c=SSL_get_current_cipher(s);
2301         BIO_printf(bio,"%s, Cipher is %s\n",
2302                 SSL_CIPHER_get_version(c),
2303                 SSL_CIPHER_get_name(c));
2304         if (peer != NULL) {
2305                 EVP_PKEY *pktmp;
2306                 pktmp = X509_get_pubkey(peer);
2307                 BIO_printf(bio,"Server public key is %d bit\n",
2308                                                          EVP_PKEY_bits(pktmp));
2309                 EVP_PKEY_free(pktmp);
2310         }
2311         BIO_printf(bio, "Secure Renegotiation IS%s supported\n",
2312                         SSL_get_secure_renegotiation_support(s) ? "" : " NOT");
2313 #ifndef OPENSSL_NO_COMP
2314         comp=SSL_get_current_compression(s);
2315         expansion=SSL_get_current_expansion(s);
2316         BIO_printf(bio,"Compression: %s\n",
2317                 comp ? SSL_COMP_get_name(comp) : "NONE");
2318         BIO_printf(bio,"Expansion: %s\n",
2319                 expansion ? SSL_COMP_get_name(expansion) : "NONE");
2320 #endif
2321
2322 #ifdef SSL_DEBUG
2323         {
2324         /* Print out local port of connection: useful for debugging */
2325         int sock;
2326         struct sockaddr_in ladd;
2327         socklen_t ladd_size = sizeof(ladd);
2328         sock = SSL_get_fd(s);
2329         getsockname(sock, (struct sockaddr *)&ladd, &ladd_size);
2330         BIO_printf(bio_c_out, "LOCAL PORT is %u\n", ntohs(ladd.sin_port));
2331         }
2332 #endif
2333
2334 #if !defined(OPENSSL_NO_TLSEXT)
2335 # if !defined(OPENSSL_NO_NEXTPROTONEG)
2336         if (next_proto.status != -1) {
2337                 const unsigned char *proto;
2338                 unsigned int proto_len;
2339                 SSL_get0_next_proto_negotiated(s, &proto, &proto_len);
2340                 BIO_printf(bio, "Next protocol: (%d) ", next_proto.status);
2341                 BIO_write(bio, proto, proto_len);
2342                 BIO_write(bio, "\n", 1);
2343         }
2344         {
2345                 const unsigned char *proto;
2346                 unsigned int proto_len;
2347                 SSL_get0_alpn_selected(s, &proto, &proto_len);
2348                 if (proto_len > 0)
2349                         {
2350                         BIO_printf(bio, "ALPN protocol: ");
2351                         BIO_write(bio, proto, proto_len);
2352                         BIO_write(bio, "\n", 1);
2353                         }
2354                 else
2355                         BIO_printf(bio, "No ALPN negotiated\n");
2356         }
2357 # endif
2358 #endif
2359
2360         {
2361         SRTP_PROTECTION_PROFILE *srtp_profile=SSL_get_selected_srtp_profile(s);
2362
2363         if(srtp_profile)
2364                 BIO_printf(bio,"SRTP Extension negotiated, profile=%s\n",
2365                            srtp_profile->name);
2366         }
2367
2368         SSL_SESSION_print(bio,SSL_get_session(s));
2369         if (keymatexportlabel != NULL)
2370                 {
2371                 BIO_printf(bio, "Keying material exporter:\n");
2372                 BIO_printf(bio, "    Label: '%s'\n", keymatexportlabel);
2373                 BIO_printf(bio, "    Length: %i bytes\n", keymatexportlen);
2374                 exportedkeymat = OPENSSL_malloc(keymatexportlen);
2375                 if (exportedkeymat != NULL)
2376                         {
2377                         if (!SSL_export_keying_material(s, exportedkeymat,
2378                                                         keymatexportlen,
2379                                                         keymatexportlabel,
2380                                                         strlen(keymatexportlabel),
2381                                                         NULL, 0, 0))
2382                                 {
2383                                 BIO_printf(bio, "    Error\n");
2384                                 }
2385                         else
2386                                 {
2387                                 BIO_printf(bio, "    Keying material: ");
2388                                 for (i=0; i<keymatexportlen; i++)
2389                                         BIO_printf(bio, "%02X",
2390                                                    exportedkeymat[i]);
2391                                 BIO_printf(bio, "\n");
2392                                 }
2393                         OPENSSL_free(exportedkeymat);
2394                         }
2395                 }
2396         BIO_printf(bio,"---\n");
2397         if (peer != NULL)
2398                 X509_free(peer);
2399         /* flush, or debugging output gets mixed with http response */
2400         (void)BIO_flush(bio);
2401         }
2402
2403 #ifndef OPENSSL_NO_TLSEXT
2404
2405 static int ocsp_resp_cb(SSL *s, void *arg)
2406         {
2407         const unsigned char *p;
2408         int len;
2409         OCSP_RESPONSE *rsp;
2410         len = SSL_get_tlsext_status_ocsp_resp(s, &p);
2411         BIO_puts(arg, "OCSP response: ");
2412         if (!p)
2413                 {
2414                 BIO_puts(arg, "no response sent\n");
2415                 return 1;
2416                 }
2417         rsp = d2i_OCSP_RESPONSE(NULL, &p, len);
2418         if (!rsp)
2419                 {
2420                 BIO_puts(arg, "response parse error\n");
2421                 BIO_dump_indent(arg, (char *)p, len, 4);
2422                 return 0;
2423                 }
2424         BIO_puts(arg, "\n======================================\n");
2425         OCSP_RESPONSE_print(arg, rsp, 0);
2426         BIO_puts(arg, "======================================\n");
2427         OCSP_RESPONSE_free(rsp);
2428         return 1;
2429         }
2430
2431 static int authz_tlsext_cb(SSL *s, unsigned short ext_type,
2432                            const unsigned char *in,
2433                            unsigned short inlen, int *al,
2434                            void *arg)
2435         {
2436         if (TLSEXT_TYPE_server_authz == ext_type)
2437                 server_provided_server_authz
2438                   = (memchr(in, TLSEXT_AUTHZDATAFORMAT_dtcp, inlen) != NULL);
2439
2440         if (TLSEXT_TYPE_client_authz == ext_type)
2441                 server_provided_client_authz
2442                   = (memchr(in, TLSEXT_AUTHZDATAFORMAT_dtcp, inlen) != NULL);
2443
2444         return 1;
2445         }
2446
2447 static int authz_tlsext_generate_cb(SSL *s, unsigned short ext_type,
2448                                     const unsigned char **out, unsigned short *outlen,
2449                                     void *arg)
2450         {
2451         if (c_auth)
2452                 {
2453                 if (!c_auth_require_reneg || (c_auth_require_reneg && SSL_num_renegotiations(s)))
2454                         {
2455                         *out = auth_ext_data;
2456                         *outlen = 1;
2457                         return 1;
2458                         }
2459                 }
2460         /* no auth extension to send */
2461         return -1;
2462         }
2463
2464 static int suppdata_cb(SSL *s, unsigned short supp_data_type,
2465                        const unsigned char *in,
2466                        unsigned short inlen, int *al,
2467                        void *arg)
2468         {
2469         if (supp_data_type == TLSEXT_SUPPLEMENTALDATATYPE_authz_data)
2470                 {
2471                 most_recent_supplemental_data = in;
2472                 most_recent_supplemental_data_length = inlen;
2473                 }
2474         return 1;
2475         }
2476
2477 static int auth_suppdata_generate_cb(SSL *s, unsigned short supp_data_type,
2478                                      const unsigned char **out,
2479                                      unsigned short *outlen, void *arg)
2480         {
2481         unsigned char *result;
2482         if (c_auth && server_provided_client_authz && server_provided_server_authz)
2483                 {
2484                 if (!c_auth_require_reneg
2485                     || (c_auth_require_reneg && SSL_num_renegotiations(s)))
2486                         {
2487                         result = OPENSSL_malloc(10);
2488                         memcpy(result, "5432154321", 10);
2489                         *out = result;
2490                         *outlen = 10;
2491                         return 1;
2492                         }
2493                 }
2494         /* no supplemental data to send */
2495         return -1;
2496         }
2497
2498 #endif