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