Upgrade chrome's OpenSSL to same version Android ships with.

openssl/apps/s_client.c

 /* apps/s_client.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 38 matching lines @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
  * The licence and distribution terms for any publically available version or
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
 /* ====================================================================
- * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer. 
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ skipping 31 matching lines @@
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  * ====================================================================
  *
  * This product includes cryptographic software written by Eric Young
  * (eay@cryptsoft.com).  This product includes software written by Tim
  * Hudson (tjh@cryptsoft.com).
  *
  */
+/* ====================================================================
+ * Copyright 2005 Nokia. All rights reserved.
+ *
+ * The portions of the attached software ("Contribution") is developed by
+ * Nokia Corporation and is licensed pursuant to the OpenSSL open source
+ * license.
+ *
+ * The Contribution, originally written by Mika Kousa and Pasi Eronen of
+ * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
+ * support (see RFC 4279) to OpenSSL.
+ *
+ * No patent licenses or other rights except those expressly stated in
+ * the OpenSSL open source license shall be deemed granted or received
+ * expressly, by implication, estoppel, or otherwise.
+ *
+ * No assurances are provided by Nokia that the Contribution does not
+ * infringe the patent or other intellectual property rights of any third
+ * party or that the license provides you with all the necessary rights
+ * to make use of the Contribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
+ * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
+ * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
+ * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
+ * OTHERWISE.
+ */
 
 #include <assert.h>
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <openssl/e_os2.h>
 #ifdef OPENSSL_NO_STDIO
 #define APPS_WIN16
 #endif
 
 /* With IPv6, it looks like Digital has mixed up the proper order of
    recursive header file inclusion, resulting in the compiler complaining
    that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which
    is needed to have fileno() declared correctly...  So let's define u_int */
 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
 #define __U_INT
 typedef unsigned int u_int;
 #endif
 
 #define USE_SOCKETS
 #include "apps.h"
 #include <openssl/x509.h>
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 #include <openssl/pem.h>
 #include <openssl/rand.h>
 #include <openssl/ocsp.h>
+#include <openssl/bn.h>
 #include "s_apps.h"
 #include "timeouts.h"
 
-#ifdef OPENSSL_SYS_WINCE
-/* Windows CE incorrectly defines fileno as returning void*, so to avoid problems below... */
-#ifdef fileno
-#undef fileno
-#endif
-#define fileno(a) (int)_fileno(a)
-#endif
-
-
 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
 #undef FIONBIO
 #endif
 
+#if defined(OPENSSL_SYS_BEOS_R5)
+#include <fcntl.h>
+#endif
+
 #undef PROG
 #define PROG    s_client_main
 
 /*#define SSL_HOST_NAME "www.netscape.com" */
 /*#define SSL_HOST_NAME "193.118.187.102" */
 #define SSL_HOST_NAME   "localhost"
 
 /*#define TEST_CERT "client.pem" */ /* no default cert. */
 
 #undef BUFSIZZ
 #define BUFSIZZ 1024*8
 
 extern int verify_depth;
 extern int verify_error;
+extern int verify_return_error;
 
 #ifdef FIONBIO
 static int c_nbio=0;
 #endif
 static int c_Pause=0;
 static int c_debug=0;
 #ifndef OPENSSL_NO_TLSEXT
 static int c_tlsextdebug=0;
 static int c_status_req=0;
 #endif
 static int c_msg=0;
 static int c_showcerts=0;
 
 static void sc_usage(void);
 static void print_stuff(BIO *berr,SSL *con,int full);
 #ifndef OPENSSL_NO_TLSEXT
 static int ocsp_resp_cb(SSL *s, void *arg);
 #endif
 static BIO *bio_c_out=NULL;
 static int c_quiet=0;
 static int c_ign_eof=0;
 
+#ifndef OPENSSL_NO_PSK
+/* Default PSK identity and key */
+static char *psk_identity="Client_identity";
+/*char *psk_key=NULL;  by default PSK is not used */
+
+static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity,
+        unsigned int max_identity_len, unsigned char *psk,
+        unsigned int max_psk_len)
+        {
+        unsigned int psk_len = 0;
+        int ret;
+        BIGNUM *bn=NULL;
+
+        if (c_debug)
+                BIO_printf(bio_c_out, "psk_client_cb\n");
+        if (!hint)
+                {
+                /* no ServerKeyExchange message*/
+                if (c_debug)
+                        BIO_printf(bio_c_out,"NULL received PSK identity hint, continuing anyway\n");
+                }
+        else if (c_debug)
+                BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint);
+
+        /* lookup PSK identity and PSK key based on the given identity hint here */
+        ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity);
+        if (ret < 0 || (unsigned int)ret > max_identity_len)
+                goto out_err;
+        if (c_debug)
+                BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity, ret);
+        ret=BN_hex2bn(&bn, psk_key);
+        if (!ret)
+                {
+                BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", psk_key);
+                if (bn)
+                        BN_free(bn);
+                return 0;
+                }
+
+        if ((unsigned int)BN_num_bytes(bn) > max_psk_len)
+                {
+                BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
+                        max_psk_len, BN_num_bytes(bn));
+                BN_free(bn);
+                return 0;
+                }
+
+        psk_len=BN_bn2bin(bn, psk);
+        BN_free(bn);
+        if (psk_len == 0)
+                goto out_err;
+
+        if (c_debug)
+                BIO_printf(bio_c_out, "created PSK len=%d\n", psk_len);
+
+        return psk_len;
+ out_err:
+        if (c_debug)
+                BIO_printf(bio_err, "Error in PSK client callback\n");
+        return 0;
+        }
+#endif
+
 static void sc_usage(void)
         {
         BIO_printf(bio_err,"usage: s_client args\n");
         BIO_printf(bio_err,"\n");
         BIO_printf(bio_err," -host host     - use -connect instead\n");
         BIO_printf(bio_err," -port port     - use -connect instead\n");
         BIO_printf(bio_err," -connect host:port - who to connect to (default is %s:%s)\n",SSL_HOST_NAME,PORT_STR);
 
-        BIO_printf(bio_err," -verify depth - turn on peer certificate verification\n");
+        BIO_printf(bio_err," -verify arg   - turn on peer certificate verification\n");
         BIO_printf(bio_err," -cert arg     - certificate file to use, PEM format assumed\n");
         BIO_printf(bio_err," -certform arg - certificate format (PEM or DER) PEM default\n");
         BIO_printf(bio_err," -key arg      - Private key file to use, in cert file if\n");
         BIO_printf(bio_err,"                 not specified but cert file is.\n");
         BIO_printf(bio_err," -keyform arg  - key format (PEM or DER) PEM default\n");
         BIO_printf(bio_err," -pass arg     - private key file pass phrase source\n");
         BIO_printf(bio_err," -CApath arg   - PEM format directory of CA's\n");
         BIO_printf(bio_err," -CAfile arg   - PEM format file of CA's\n");
         BIO_printf(bio_err," -reconnect    - Drop and re-make the connection with the same Session-ID\n");
         BIO_printf(bio_err," -pause        - sleep(1) after each read(2) and write(2) system call\n");
         BIO_printf(bio_err," -showcerts    - show all certificates in the chain\n");
         BIO_printf(bio_err," -debug        - extra output\n");
 #ifdef WATT32
         BIO_printf(bio_err," -wdebug       - WATT-32 tcp debugging\n");
 #endif
         BIO_printf(bio_err," -msg          - Show protocol messages\n");
         BIO_printf(bio_err," -nbio_test    - more ssl protocol testing\n");
         BIO_printf(bio_err," -state        - print the 'ssl' states\n");
 #ifdef FIONBIO
         BIO_printf(bio_err," -nbio         - Run with non-blocking IO\n");
 #endif
         BIO_printf(bio_err," -crlf         - convert LF from terminal into CRLF\n");
         BIO_printf(bio_err," -quiet        - no s_client output\n");
         BIO_printf(bio_err," -ign_eof      - ignore input eof (default when -quiet)\n");
         BIO_printf(bio_err," -no_ign_eof   - don't ignore input eof\n");
+#ifndef OPENSSL_NO_PSK
+        BIO_printf(bio_err," -psk_identity arg - PSK identity\n");
+        BIO_printf(bio_err," -psk arg      - PSK in hex (without 0x)\n");
+# ifndef OPENSSL_NO_JPAKE
+        BIO_printf(bio_err," -jpake arg    - JPAKE secret to use\n");
+# endif
+#endif
         BIO_printf(bio_err," -ssl2         - just use SSLv2\n");
         BIO_printf(bio_err," -ssl3         - just use SSLv3\n");
         BIO_printf(bio_err," -tls1         - just use TLSv1\n");
         BIO_printf(bio_err," -dtls1        - just use DTLSv1\n");    
         BIO_printf(bio_err," -mtu          - set the link layer MTU\n");
         BIO_printf(bio_err," -no_tls1/-no_ssl3/-no_ssl2 - turn off that protocol\n");
         BIO_printf(bio_err," -bugs         - Switch on all SSL implementation bug workarounds\n");
         BIO_printf(bio_err," -serverpref   - Use server's cipher preferences (only SSLv2)\n");
         BIO_printf(bio_err," -cipher       - preferred cipher to use, use the 'openssl ciphers'\n");
         BIO_printf(bio_err,"                 command to see what is available\n");
         BIO_printf(bio_err," -starttls prot - use the STARTTLS command before starting TLS\n");
         BIO_printf(bio_err,"                 for those protocols that support it, where\n");
         BIO_printf(bio_err,"                 'prot' defines which one to assume.  Currently,\n");
         BIO_printf(bio_err,"                 only \"smtp\", \"pop3\", \"imap\", \"ftp\" and \"xmpp\"\n");
         BIO_printf(bio_err,"                 are supported.\n");
 #ifndef OPENSSL_NO_ENGINE
         BIO_printf(bio_err," -engine id    - Initialise and use the specified engine\n");
 #endif
         BIO_printf(bio_err," -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR);
         BIO_printf(bio_err," -sess_out arg - file to write SSL session to\n");
         BIO_printf(bio_err," -sess_in arg  - file to read SSL session from\n");
 #ifndef OPENSSL_NO_TLSEXT
         BIO_printf(bio_err," -servername host  - Set TLS extension servername in ClientHello\n");
         BIO_printf(bio_err," -tlsextdebug      - hex dump of all TLS extensions received\n");
         BIO_printf(bio_err," -status           - request certificate status from server\n");
         BIO_printf(bio_err," -no_ticket        - disable use of RFC4507bis session tickets\n");
+# ifndef OPENSSL_NO_NEXTPROTONEG
+        BIO_printf(bio_err," -nextprotoneg arg - enable NPN extension, considering named protocols supported (comma-separated list)\n");
+# endif
         BIO_printf(bio_err," -cutthrough       - enable 1-RTT full-handshake for strong ciphers\n");
-        BIO_printf(bio_err," -nextprotoneg arg - enable NPN extension, considering named protocols supported (comma-separated list)\n");
 #endif
         BIO_printf(bio_err," -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
         }
 
 #ifndef OPENSSL_NO_TLSEXT
 
 /* This is a context that we pass to callbacks */
 typedef struct tlsextctx_st {
    BIO * biodebug;
    int ack;
 } tlsextctx;
 
 
 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
         {
         tlsextctx * p = (tlsextctx *) arg;
         const char * hn= SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
         if (SSL_get_servername_type(s) != -1) 
                 p->ack = !SSL_session_reused(s) && hn != NULL;
         else 
                 BIO_printf(bio_err,"Can't use SSL_get_servername\n");
         
         return SSL_TLSEXT_ERR_OK;
         }
-#endif
-enum
-{
-        PROTO_OFF       = 0,
-        PROTO_SMTP,
-        PROTO_POP3,
-        PROTO_IMAP,
-        PROTO_FTP,
-        PROTO_XMPP
-};
 
+# ifndef OPENSSL_NO_NEXTPROTONEG
 /* This the context that we pass to next_proto_cb */
 typedef struct tlsextnextprotoctx_st {
         unsigned char *data;
         unsigned short len;
         int status;
 } tlsextnextprotoctx;
 
 static tlsextnextprotoctx next_proto;
 
 static int next_proto_cb(SSL *s, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
@@ skipping 11 matching lines @@
                                 BIO_write(bio_c_out, ", ", 2);
                         BIO_write(bio_c_out, &in[i + 1], in[i]);
                         i += in[i] + 1;
                         }
                 BIO_write(bio_c_out, "\n", 1);
                 }
 
         ctx->status = SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len);
         return SSL_TLSEXT_ERR_OK;
         }
+# endif  /* ndef OPENSSL_NO_NEXTPROTONEG */
+#endif
+
+enum
+{
+        PROTO_OFF       = 0,
+        PROTO_SMTP,
+        PROTO_POP3,
+        PROTO_IMAP,
+        PROTO_FTP,
+        PROTO_XMPP
+};
 
 int MAIN(int, char **);
 
 int MAIN(int argc, char **argv)
         {
-        int off=0, clr = 0;
-        SSL *con=NULL,*con2=NULL;
-        X509_STORE *store = NULL;
+        unsigned int off=0, clr=0;
+        SSL *con=NULL;
         int s,k,width,state=0;
         char *cbuf=NULL,*sbuf=NULL,*mbuf=NULL;
         int cbuf_len,cbuf_off;
         int sbuf_len,sbuf_off;
         fd_set readfds,writefds;
         short port=PORT;
         int full_log=1;
         char *host=SSL_HOST_NAME;
         char *cert_file=NULL,*key_file=NULL;
         int cert_format = FORMAT_PEM, key_format = FORMAT_PEM;
         char *passarg = NULL, *pass = NULL;
         X509 *cert = NULL;
         EVP_PKEY *key = NULL;
         char *CApath=NULL,*CAfile=NULL,*cipher=NULL;
         int reconnect=0,badop=0,verify=SSL_VERIFY_NONE,bugs=0;
         int cutthrough=0;
         int crlf=0;
         int write_tty,read_tty,write_ssl,read_ssl,tty_on,ssl_pending;
         SSL_CTX *ctx=NULL;
         int ret=1,in_init=1,i,nbio_test=0;
         int starttls_proto = PROTO_OFF;
-        int prexit = 0, vflags = 0;
-        SSL_METHOD *meth=NULL;
-#ifdef sock_type
-#undef sock_type
-#endif
-        int sock_type=SOCK_STREAM;
+        int prexit = 0;
+        X509_VERIFY_PARAM *vpm = NULL;
+        int badarg = 0;
+        const SSL_METHOD *meth=NULL;
+        int socket_type=SOCK_STREAM;
         BIO *sbio;
         char *inrand=NULL;
         int mbuf_len=0;
         struct timeval timeout, *timeoutp;
 #ifndef OPENSSL_NO_ENGINE
         char *engine_id=NULL;
         char *ssl_client_engine_id=NULL;
         ENGINE *ssl_client_engine=NULL;
 #endif
         ENGINE *e=NULL;
-#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
+#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
         struct timeval tv;
+#if defined(OPENSSL_SYS_BEOS_R5)
+        int stdin_set = 0;
 #endif
-
+#endif
 #ifndef OPENSSL_NO_TLSEXT
         char *servername = NULL; 
         tlsextctx tlsextcbp = 
         {NULL,0};
+# ifndef OPENSSL_NO_NEXTPROTONEG
         const char *next_proto_neg_in = NULL;
+# endif
 #endif
         char *sess_in = NULL;
         char *sess_out = NULL;
         struct sockaddr peer;
         int peerlen = sizeof(peer);
         int enable_timeouts = 0 ;
         long socket_mtu = 0;
 #ifndef OPENSSL_NO_JPAKE
         char *jpake_secret = NULL;
 #endif
@@ skipping 75 matching lines @@
                 else if (strcmp(*argv,"-sess_in") == 0)
                         {
                         if (--argc < 1) goto bad;
                         sess_in = *(++argv);
                         }
                 else if (strcmp(*argv,"-certform") == 0)
                         {
                         if (--argc < 1) goto bad;
                         cert_format = str2fmt(*(++argv));
                         }
-                else if (strcmp(*argv,"-crl_check") == 0)
-                        vflags |= X509_V_FLAG_CRL_CHECK;
-                else if (strcmp(*argv,"-crl_check_all") == 0)
-                        vflags |= X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL;
+                else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm))
+                        {
+                        if (badarg)
+                                goto bad;
+                        continue;
+                        }
+                else if (strcmp(*argv,"-verify_return_error") == 0)
+                        verify_return_error = 1;
                 else if (strcmp(*argv,"-prexit") == 0)
                         prexit=1;
                 else if (strcmp(*argv,"-crlf") == 0)
                         crlf=1;
                 else if (strcmp(*argv,"-quiet") == 0)
                         {
                         c_quiet=1;
                         c_ign_eof=1;
                         }
                 else if (strcmp(*argv,"-ign_eof") == 0)
@@ skipping 15 matching lines @@
                         dbug_init();
 #endif
                 else if (strcmp(*argv,"-msg") == 0)
                         c_msg=1;
                 else if (strcmp(*argv,"-showcerts") == 0)
                         c_showcerts=1;
                 else if (strcmp(*argv,"-nbio_test") == 0)
                         nbio_test=1;
                 else if (strcmp(*argv,"-state") == 0)
                         state=1;
+#ifndef OPENSSL_NO_PSK
+                else if (strcmp(*argv,"-psk_identity") == 0)
+                        {
+                        if (--argc < 1) goto bad;
+                        psk_identity=*(++argv);
+                        }
+                else if (strcmp(*argv,"-psk") == 0)
+                        {
+                        size_t j;
+
+                        if (--argc < 1) goto bad;
+                        psk_key=*(++argv);
+                        for (j = 0; j < strlen(psk_key); j++)
+                                {
+                                if (isxdigit((int)psk_key[j]))
+                                        continue;
+                                BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
+                                goto bad;
+                                }
+                        }
+#endif
 #ifndef OPENSSL_NO_SSL2
                 else if (strcmp(*argv,"-ssl2") == 0)
                         meth=SSLv2_client_method();
 #endif
 #ifndef OPENSSL_NO_SSL3
                 else if (strcmp(*argv,"-ssl3") == 0)
                         meth=SSLv3_client_method();
 #endif
 #ifndef OPENSSL_NO_TLS1
                 else if (strcmp(*argv,"-tls1") == 0)
                         meth=TLSv1_client_method();
 #endif
 #ifndef OPENSSL_NO_DTLS1
                 else if (strcmp(*argv,"-dtls1") == 0)
                         {
                         meth=DTLSv1_client_method();
-                        sock_type=SOCK_DGRAM;
+                        socket_type=SOCK_DGRAM;
                         }
                 else if (strcmp(*argv,"-timeout") == 0)
                         enable_timeouts=1;
                 else if (strcmp(*argv,"-mtu") == 0)
                         {
                         if (--argc < 1) goto bad;
                         socket_mtu = atol(*(++argv));
                         }
 #endif
                 else if (strcmp(*argv,"-bugs") == 0)
@@ skipping 26 matching lines @@
                         {
                         if (--argc < 1) goto bad;
                         CAfile= *(++argv);
                         }
                 else if (strcmp(*argv,"-no_tls1") == 0)
                         off|=SSL_OP_NO_TLSv1;
                 else if (strcmp(*argv,"-no_ssl3") == 0)
                         off|=SSL_OP_NO_SSLv3;
                 else if (strcmp(*argv,"-no_ssl2") == 0)
                         off|=SSL_OP_NO_SSLv2;
+                else if (strcmp(*argv,"-no_comp") == 0)
+                        { off|=SSL_OP_NO_COMPRESSION; }
 #ifndef OPENSSL_NO_TLSEXT
                 else if (strcmp(*argv,"-no_ticket") == 0)
                         { off|=SSL_OP_NO_TICKET; }
+# ifndef OPENSSL_NO_NEXTPROTONEG
                 else if (strcmp(*argv,"-nextprotoneg") == 0)
                         {
                         if (--argc < 1) goto bad;
                         next_proto_neg_in = *(++argv);
                         }
+# endif
 #endif
                 else if (strcmp(*argv,"-cutthrough") == 0)
                         cutthrough=1;
                 else if (strcmp(*argv,"-serverpref") == 0)
                         off|=SSL_OP_CIPHER_SERVER_PREFERENCE;
                 else if (strcmp(*argv,"-legacy_renegotiation") == 0)
                         off|=SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION;
                 else if (strcmp(*argv,"-legacy_server_connect") == 0)
                         { off|=SSL_OP_LEGACY_SERVER_CONNECT; }
                 else if (strcmp(*argv,"-no_legacy_server_connect") == 0)
@@ skipping 65 matching lines @@
                 argc--;
                 argv++;
                 }
         if (badop)
                 {
 bad:
                 sc_usage();
                 goto end;
                 }
 
+#if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
+        if (jpake_secret)
+                {
+                if (psk_key)
+                        {
+                        BIO_printf(bio_err,
+                                   "Can't use JPAKE and PSK together\n");
+                        goto end;
+                        }
+                psk_identity = "JPAKE";
+                }
+
+        if (cipher)
+                {
+                BIO_printf(bio_err, "JPAKE sets cipher to PSK\n");
+                goto end;
+                }
+        cipher = "PSK";
+#endif
+
         OpenSSL_add_ssl_algorithms();
         SSL_load_error_strings();
 
-#ifndef OPENSSL_NO_TLSEXT
+#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
         next_proto.status = -1;
         if (next_proto_neg_in)
                 {
                 next_proto.data = next_protos_parse(&next_proto.len, next_proto_neg_in);
                 if (next_proto.data == NULL)
                         {
                         BIO_printf(bio_err, "Error parsing -nextprotoneg argument\n");
                         goto end;
                         }
                 }
         else
                 next_proto.data = NULL;
 #endif
 
 #ifndef OPENSSL_NO_ENGINE
         e = setup_engine(bio_err, engine_id, 1);
         if (ssl_client_engine_id)
                 {
                 ssl_client_engine = ENGINE_by_id(ssl_client_engine_id);
                 if (!ssl_client_engine)
                         {
                         BIO_printf(bio_err,
                                         "Error getting client auth engine\n");
                         goto end;
                         }
                 }
+
 #endif
         if (!app_passwd(bio_err, passarg, NULL, &pass, NULL))
                 {
                 BIO_printf(bio_err, "Error getting password\n");
                 goto end;
                 }
 
         if (key_file == NULL)
                 key_file = cert_file;
 
@@ skipping 47 matching lines @@
                         }
                 }
 
         ctx=SSL_CTX_new(meth);
         if (ctx == NULL)
                 {
                 ERR_print_errors(bio_err);
                 goto end;
                 }
 
+        if (vpm)
+                SSL_CTX_set1_param(ctx, vpm);
+
 #ifndef OPENSSL_NO_ENGINE
         if (ssl_client_engine)
                 {
                 if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine))
                         {
                         BIO_puts(bio_err, "Error setting client auth engine\n");
                         ERR_print_errors(bio_err);
                         ENGINE_free(ssl_client_engine);
                         goto end;
                         }
                 ENGINE_free(ssl_client_engine);
                 }
 #endif
 
+#ifndef OPENSSL_NO_PSK
+#ifdef OPENSSL_NO_JPAKE
+        if (psk_key != NULL)
+#else
+        if (psk_key != NULL || jpake_secret)
+#endif
+                {
+                if (c_debug)
+                        BIO_printf(bio_c_out, "PSK key given or JPAKE in use, setting client callback\n");
+                SSL_CTX_set_psk_client_callback(ctx, psk_client_cb);
+                }
+#endif
         if (bugs)
                 SSL_CTX_set_options(ctx,SSL_OP_ALL|off);
         else
                 SSL_CTX_set_options(ctx,off);
 
         if (clr)
                 SSL_CTX_clear_options(ctx, clr);
         /* DTLS: partial reads end up discarding unread UDP bytes :-( 
          * Setting read ahead solves this problem.
          */
-        if (sock_type == SOCK_DGRAM) SSL_CTX_set_read_ahead(ctx, 1);
+        if (socket_type == SOCK_DGRAM) SSL_CTX_set_read_ahead(ctx, 1);
 
         /* Enable handshake cutthrough for client connections using
          * strong ciphers. */
         if (cutthrough)
                 {
                 int ssl_mode = SSL_CTX_get_mode(ctx);
                 ssl_mode |= SSL_MODE_HANDSHAKE_CUTTHROUGH;
                 SSL_CTX_set_mode(ctx, ssl_mode);
                 }
 
+#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
         if (next_proto.data)
                 SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto);
+#endif
 
         if (state) SSL_CTX_set_info_callback(ctx,apps_ssl_info_callback);
         if (cipher != NULL)
                 if(!SSL_CTX_set_cipher_list(ctx,cipher)) {
                 BIO_printf(bio_err,"error setting cipher list\n");
                 ERR_print_errors(bio_err);
                 goto end;
         }
 #if 0
         else
                 SSL_CTX_set_cipher_list(ctx,getenv("SSL_CIPHER"));
 #endif
 
         SSL_CTX_set_verify(ctx,verify,verify_callback);
         if (!set_cert_key_stuff(ctx,cert,key))
                 goto end;
 
         if ((!SSL_CTX_load_verify_locations(ctx,CAfile,CApath)) ||
                 (!SSL_CTX_set_default_verify_paths(ctx)))
                 {
                 /* BIO_printf(bio_err,"error setting default verify locations\n"); */
                 ERR_print_errors(bio_err);
                 /* goto end; */
                 }
 
-        store = SSL_CTX_get_cert_store(ctx);
-        X509_STORE_set_flags(store, vflags);
 #ifndef OPENSSL_NO_TLSEXT
         if (servername != NULL)
                 {
                 tlsextcbp.biodebug = bio_err;
                 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
                 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
                 }
 #endif
 
         con=SSL_new(ctx);
@@ skipping 24 matching lines @@
         if (servername != NULL)
                 {
                 if (!SSL_set_tlsext_host_name(con,servername))
                         {
                         BIO_printf(bio_err,"Unable to set TLS servername extension.\n");
                         ERR_print_errors(bio_err);
                         goto end;
                         }
                 }
 #endif
-
 #ifndef OPENSSL_NO_KRB5
         if (con  &&  (con->kssl_ctx = kssl_ctx_new()) != NULL)
                 {
                 kssl_ctx_setstring(con->kssl_ctx, KSSL_SERVER, host);
                 }
 #endif  /* OPENSSL_NO_KRB5  */
 /*      SSL_set_cipher_list(con,"RC4-MD5"); */
+#if 0
+#ifdef TLSEXT_TYPE_opaque_prf_input
+        SSL_set_tlsext_opaque_prf_input(con, "Test client", 11);
+#endif
+#endif
 
 re_start:
 
-        if (init_client(&s,host,port,sock_type) == 0)
+        if (init_client(&s,host,port,socket_type) == 0)
                 {
                 BIO_printf(bio_err,"connect:errno=%d\n",get_last_socket_error());
                 SHUTDOWN(s);
                 goto end;
                 }
         BIO_printf(bio_c_out,"CONNECTED(%08X)\n",s);
 
 #ifdef FIONBIO
         if (c_nbio)
                 {
@@ skipping 15 matching lines @@
                 if (getsockname(s, &peer, (void *)&peerlen) < 0)
                         {
                         BIO_printf(bio_err, "getsockname:errno=%d\n",
                                 get_last_socket_error());
                         SHUTDOWN(s);
                         goto end;
                         }
 
                 (void)BIO_ctrl_set_connected(sbio, 1, &peer);
 
-                if ( enable_timeouts)
+                if (enable_timeouts)
                         {
                         timeout.tv_sec = 0;
                         timeout.tv_usec = DGRAM_RCV_TIMEOUT;
                         BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
                         
                         timeout.tv_sec = 0;
                         timeout.tv_usec = DGRAM_SND_TIMEOUT;
                         BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
                         }
 
@@ skipping 200 matching lines @@
                         {
                         in_init=1;
                         tty_on=0;
                         }
                 else
                         {
                         tty_on=1;
                         if (in_init)
                                 {
                                 in_init=0;
+#if 0 /* This test doesn't really work as intended (needs to be fixed) */
+#ifndef OPENSSL_NO_TLSEXT
+                                if (servername != NULL && !SSL_session_reused(con))
+                                        {
+                                        BIO_printf(bio_c_out,"Server did %sacknowledge servername extension.\n",tlsextcbp.ack?"":"not ");
+                                        }
+#endif
+#endif
                                 if (sess_out)
                                         {
                                         BIO *stmp = BIO_new_file(sess_out, "w");
                                         if (stmp)
                                                 {
                                                 PEM_write_bio_SSL_SESSION(stmp, SSL_get_session(con));
                                                 BIO_free(stmp);
                                                 }
                                         else 
                                                 BIO_printf(bio_err, "Error writing session file %s\n", sess_out);
@@ skipping 17 matching lines @@
                                         SHUTDOWN(SSL_get_fd(con));
                                         goto re_start;
                                         }
                                 }
                         }
 
                 ssl_pending = read_ssl && SSL_pending(con);
 
                 if (!ssl_pending)
                         {
-#if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE)
+#if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined (OPENSSL_SYS_BEOS_R5)
                         if (tty_on)
                                 {
-                                if (read_tty)  FD_SET(fileno(stdin),&readfds);
-                                if (write_tty) FD_SET(fileno(stdout),&writefds);
+                                if (read_tty)  openssl_fdset(fileno(stdin),&readfds);
+                                if (write_tty) openssl_fdset(fileno(stdout),&writefds);
                                 }
                         if (read_ssl)
-                                FD_SET(SSL_get_fd(con),&readfds);
+                                openssl_fdset(SSL_get_fd(con),&readfds);
                         if (write_ssl)
-                                FD_SET(SSL_get_fd(con),&writefds);
+                                openssl_fdset(SSL_get_fd(con),&writefds);
 #else
                         if(!tty_on || !write_tty) {
                                 if (read_ssl)
-                                        FD_SET(SSL_get_fd(con),&readfds);
+                                        openssl_fdset(SSL_get_fd(con),&readfds);
                                 if (write_ssl)
-                                        FD_SET(SSL_get_fd(con),&writefds);
+                                        openssl_fdset(SSL_get_fd(con),&writefds);
                         }
 #endif
 /*                      printf("mode tty(%d %d%d) ssl(%d%d)\n",
                                 tty_on,read_tty,write_tty,read_ssl,write_ssl);*/
 
                         /* Note: under VMS with SOCKETSHR the second parameter
                          * is currently of type (int *) whereas under other
                          * systems it is (void *) if you don't have a cast it
                          * will choke the compiler: if you do have a cast then
                          * you can either go for (int *) or (void *).
@@ skipping 24 matching lines @@
 #elif defined(OPENSSL_SYS_NETWARE)
                         if(!write_tty) {
                                 if(read_tty) {
                                         tv.tv_sec = 1;
                                         tv.tv_usec = 0;
                                         i=select(width,(void *)&readfds,(void *)&writefds,
                                                 NULL,&tv);
                                 } else  i=select(width,(void *)&readfds,(void *)&writefds,
                                         NULL,timeoutp);
                         }
+#elif defined(OPENSSL_SYS_BEOS_R5)
+                        /* Under BeOS-R5 the situation is similar to DOS */
+                        i=0;
+                        stdin_set = 0;
+                        (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
+                        if(!write_tty) {
+                                if(read_tty) {
+                                        tv.tv_sec = 1;
+                                        tv.tv_usec = 0;
+                                        i=select(width,(void *)&readfds,(void *)&writefds,
+                                                 NULL,&tv);
+                                        if (read(fileno(stdin), sbuf, 0) >= 0)
+                                                stdin_set = 1;
+                                        if (!i && (stdin_set != 1 || !read_tty))
+                                                continue;
+                                } else  i=select(width,(void *)&readfds,(void *)&writefds,
+                                         NULL,timeoutp);
+                        }
+                        (void)fcntl(fileno(stdin), F_SETFL, 0);
 #else
                         i=select(width,(void *)&readfds,(void *)&writefds,
                                  NULL,timeoutp);
 #endif
                         if ( i < 0)
                                 {
                                 BIO_printf(bio_err,"bad select %d\n",
                                 get_last_socket_error());
                                 goto shut;
                                 /* goto end; */
@@ skipping 38 matching lines @@
                                 read_ssl=1;
                                 write_ssl=0;
                                 break;
                         case SSL_ERROR_WANT_X509_LOOKUP:
                                 BIO_printf(bio_c_out,"write X BLOCK\n");
                                 break;
                         case SSL_ERROR_ZERO_RETURN:
                                 if (cbuf_len != 0)
                                         {
                                         BIO_printf(bio_c_out,"shutdown\n");
+                                        ret = 0;
                                         goto shut;
                                         }
                                 else
                                         {
                                         read_tty=1;
                                         write_ssl=0;
                                         break;
                                         }
                                 
                         case SSL_ERROR_SYSCALL:
                                 if ((k != 0) || (cbuf_len != 0))
                                         {
                                         BIO_printf(bio_err,"write:errno=%d\n",
                                                 get_last_socket_error());
                                         goto shut;
                                         }
                                 else
                                         {
                                         read_tty=1;
                                         write_ssl=0;
                                         }
                                 break;
                         case SSL_ERROR_SSL:
                                 ERR_print_errors(bio_err);
                                 goto shut;
                                 }
                         }
-#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
-                /* Assume Windows/DOS can always write */
+#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
+                /* Assume Windows/DOS/BeOS can always write */
                 else if (!ssl_pending && write_tty)
 #else
                 else if (!ssl_pending && FD_ISSET(fileno(stdout),&writefds))
 #endif
                         {
 #ifdef CHARSET_EBCDIC
                         ascii2ebcdic(&(sbuf[sbuf_off]),&(sbuf[sbuf_off]),sbuf_len);
 #endif
-                        i=write(fileno(stdout),&(sbuf[sbuf_off]),sbuf_len);
+                        i=raw_write_stdout(&(sbuf[sbuf_off]),sbuf_len);
 
                         if (i <= 0)
                                 {
                                 BIO_printf(bio_c_out,"DONE\n");
+                                ret = 0;
                                 goto shut;
                                 /* goto end; */
                                 }
 
                         sbuf_len-=i;;
                         sbuf_off+=i;
                         if (sbuf_len <= 0)
                                 {
                                 read_ssl=1;
                                 write_tty=0;
@@ skipping 34 matching lines @@
                                 BIO_printf(bio_c_out,"read R BLOCK\n");
                                 write_tty=0;
                                 read_ssl=1;
                                 if ((read_tty == 0) && (write_ssl == 0))
                                         write_ssl=1;
                                 break;
                         case SSL_ERROR_WANT_X509_LOOKUP:
                                 BIO_printf(bio_c_out,"read X BLOCK\n");
                                 break;
                         case SSL_ERROR_SYSCALL:
-                                BIO_printf(bio_err,"read:errno=%d\n",get_last_socket_error());
+                                ret=get_last_socket_error();
+                                BIO_printf(bio_err,"read:errno=%d\n",ret);
                                 goto shut;
                         case SSL_ERROR_ZERO_RETURN:
                                 BIO_printf(bio_c_out,"closed\n");
+                                ret=0;
                                 goto shut;
                         case SSL_ERROR_SSL:
                                 ERR_print_errors(bio_err);
                                 goto shut;
                                 /* break; */
                                 }
                         }
 
 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
 #if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
                 else if (_kbhit())
 #else
                 else if ((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
 #endif
 #elif defined (OPENSSL_SYS_NETWARE)
-        else if (_kbhit())
+                else if (_kbhit())
+#elif defined(OPENSSL_SYS_BEOS_R5)
+                else if (stdin_set)
 #else
                 else if (FD_ISSET(fileno(stdin),&readfds))
 #endif
                         {
                         if (crlf)
                                 {
                                 int j, lf_num;
 
-                                i=read(fileno(stdin),cbuf,BUFSIZZ/2);
+                                i=raw_read_stdin(cbuf,BUFSIZZ/2);
                                 lf_num = 0;
                                 /* both loops are skipped when i <= 0 */
                                 for (j = 0; j < i; j++)
                                         if (cbuf[j] == '\n')
                                                 lf_num++;
                                 for (j = i-1; j >= 0; j--)
                                         {
                                         cbuf[j+lf_num] = cbuf[j];
                                         if (cbuf[j] == '\n')
                                                 {
                                                 lf_num--;
                                                 i++;
                                                 cbuf[j+lf_num] = '\r';
                                                 }
                                         }
                                 assert(lf_num == 0);
                                 }
                         else
-                                i=read(fileno(stdin),cbuf,BUFSIZZ);
+                                i=raw_read_stdin(cbuf,BUFSIZZ);
 
                         if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q')))
                                 {
                                 BIO_printf(bio_err,"DONE\n");
+                                ret=0;
                                 goto shut;
                                 }
 
                         if ((!c_ign_eof) && (cbuf[0] == 'R'))
                                 {
                                 BIO_printf(bio_err,"RENEGOTIATING\n");
                                 SSL_renegotiate(con);
                                 cbuf_len=0;
                                 }
                         else
                                 {
                                 cbuf_len=i;
                                 cbuf_off=0;
 #ifdef CHARSET_EBCDIC
                                 ebcdic2ascii(cbuf, cbuf, i);
 #endif
                                 }
 
                         write_ssl=1;
                         read_tty=0;
                         }
                 }
+
+        ret=0;
 shut:
+        if (in_init)
+                print_stuff(bio_c_out,con,full_log);
         SSL_shutdown(con);
         SHUTDOWN(SSL_get_fd(con));
-        ret=0;
 end:
-        if(prexit) print_stuff(bio_c_out,con,1);
-        if (con != NULL) SSL_free(con);
-        if (con2 != NULL) SSL_free(con2);
+        if (con != NULL)
+                {
+                if (prexit != 0)
+                        print_stuff(bio_c_out,con,1);
+                SSL_free(con);
+                }
         if (ctx != NULL) SSL_CTX_free(ctx);
         if (cert)
                 X509_free(cert);
         if (key)
                 EVP_PKEY_free(key);
         if (pass)
                 OPENSSL_free(pass);
         if (cbuf != NULL) { OPENSSL_cleanse(cbuf,BUFSIZZ); OPENSSL_free(cbuf); }
         if (sbuf != NULL) { OPENSSL_cleanse(sbuf,BUFSIZZ); OPENSSL_free(sbuf); }
         if (mbuf != NULL) { OPENSSL_cleanse(mbuf,BUFSIZZ); OPENSSL_free(mbuf); }
         if (bio_c_out != NULL)
                 {
                 BIO_free(bio_c_out);
                 bio_c_out=NULL;
                 }
         apps_shutdown();
         OPENSSL_EXIT(ret);
         }
 
 
 static void print_stuff(BIO *bio, SSL *s, int full)
         {
         X509 *peer=NULL;
         char *p;
         static const char *space="                ";
         char buf[BUFSIZ];
         STACK_OF(X509) *sk;
         STACK_OF(X509_NAME) *sk2;
-        SSL_CIPHER *c;
+        const SSL_CIPHER *c;
         X509_NAME *xn;
         int j,i;
 #ifndef OPENSSL_NO_COMP
         const COMP_METHOD *comp, *expansion;
 #endif
 
         if (full)
                 {
                 int got_a_chain = 0;
 
@@ skipping 98 matching lines @@
                         SSL_get_secure_renegotiation_support(s) ? "" : " NOT");
 #ifndef OPENSSL_NO_COMP
         comp=SSL_get_current_compression(s);
         expansion=SSL_get_current_expansion(s);
         BIO_printf(bio,"Compression: %s\n",
                 comp ? SSL_COMP_get_name(comp) : "NONE");
         BIO_printf(bio,"Expansion: %s\n",
                 expansion ? SSL_COMP_get_name(expansion) : "NONE");
 #endif
 
-#ifndef OPENSSL_NO_TLSEXT
-        {
-                if (next_proto.status != -1) {
-                        const unsigned char *proto;
-                        unsigned int proto_len;
-                        SSL_get0_next_proto_negotiated(s, &proto, &proto_len);
-                        BIO_printf(bio, "Next protocol: (%d) ", next_proto.status);
-                        BIO_write(bio, proto, proto_len);
-                        BIO_write(bio, "\n", 1);
-                }
+#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
+        if (next_proto.status != -1) {
+                const unsigned char *proto;
+                unsigned int proto_len;
+                SSL_get0_next_proto_negotiated(s, &proto, &proto_len);
+                BIO_printf(bio, "Next protocol: (%d) ", next_proto.status);
+                BIO_write(bio, proto, proto_len);
+                BIO_write(bio, "\n", 1);
         }
 #endif
 
         SSL_SESSION_print(bio,SSL_get_session(s));
         BIO_printf(bio,"---\n");
         if (peer != NULL)
                 X509_free(peer);
         /* flush, or debugging output gets mixed with http response */
         (void)BIO_flush(bio);
         }
@@ skipping 18 matching lines @@
                 BIO_puts(arg, "response parse error\n");
                 BIO_dump_indent(arg, (char *)p, len, 4);
                 return 0;
                 }
         BIO_puts(arg, "\n======================================\n");
         OCSP_RESPONSE_print(arg, rsp, 0);
         BIO_puts(arg, "======================================\n");
         OCSP_RESPONSE_free(rsp);
         return 1;
         }
-#endif  /* ndef OPENSSL_NO_TLSEXT */
+
+#endif