apps/s_server.c

   1 /* apps/s_server.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 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 113  * ECC cipher suite support in OpenSSL originally developed by
 114  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 115  */
 116 /* ====================================================================
 117  * Copyright 2005 Nokia. All rights reserved.
 118  *
 119  * The portions of the attached software ("Contribution") is developed by
 120  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 121  * license.
 122  *
 123  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
 124  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
 125  * support (see RFC 4279) to OpenSSL.
 126  *
 127  * No patent licenses or other rights except those expressly stated in
 128  * the OpenSSL open source license shall be deemed granted or received
 129  * expressly, by implication, estoppel, or otherwise.
 130  *
 131  * No assurances are provided by Nokia that the Contribution does not
 132  * infringe the patent or other intellectual property rights of any third
 133  * party or that the license provides you with all the necessary rights
 134  * to make use of the Contribution.
 135  *
 136  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
 137  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
 138  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
 139  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
 140  * OTHERWISE.
 141  */
 142
 143 /*
 144  * Until the key-gen callbacks are modified to use newer prototypes, we allow
 145  * deprecated functions for openssl-internal code
 146  */
 147 #ifdef OPENSSL_NO_DEPRECATED
 148 # undef OPENSSL_NO_DEPRECATED
 149 #endif
 150
 151 #include <assert.h>
 152 #include <ctype.h>
 153 #include <stdio.h>
 154 #include <stdlib.h>
 155 #include <string.h>
 156
 157 #include <openssl/e_os2.h>
 158 #ifdef OPENSSL_NO_STDIO
 159 # define APPS_WIN16
 160 #endif
 161
 162 /* conflicts with winsock2 stuff on netware */
 163 #if !defined(OPENSSL_SYS_NETWARE)
 164 # include <sys/types.h>
 165 #endif
 166
 167 /*
 168  * With IPv6, it looks like Digital has mixed up the proper order of
 169  * recursive header file inclusion, resulting in the compiler complaining
 170  * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is
 171  * needed to have fileno() declared correctly...  So let's define u_int
 172  */
 173 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
 174 # define __U_INT
 175 typedef unsigned int u_int;
 176 #endif
 177
 178 #include <openssl/lhash.h>
 179 #include <openssl/bn.h>
 180 #define USE_SOCKETS
 181 #include "apps.h"
 182 #include <openssl/err.h>
 183 #include <openssl/pem.h>
 184 #include <openssl/x509.h>
 185 #include <openssl/ssl.h>
 186 #include <openssl/rand.h>
 187 #include <openssl/ocsp.h>
 188 #ifndef OPENSSL_NO_DH
 189 # include <openssl/dh.h>
 190 #endif
 191 #ifndef OPENSSL_NO_RSA
 192 # include <openssl/rsa.h>
 193 #endif
 194 #include "s_apps.h"
 195 #include "timeouts.h"
 196
 197 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
 198 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
 199 # undef FIONBIO
 200 #endif
 201
 202 #if defined(OPENSSL_SYS_BEOS_R5)
 203 # include <fcntl.h>
 204 #endif
 205
 206 #ifndef OPENSSL_NO_RSA
 207 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength);
 208 #endif
 209 static int sv_body(char *hostname, int s, unsigned char *context);
 210 static int www_body(char *hostname, int s, unsigned char *context);
 211 static void close_accept_socket(void);
 212 static void sv_usage(void);
 213 static int init_ssl_connection(SSL *s);
 214 static void print_stats(BIO *bp, SSL_CTX *ctx);
 215 static int generate_session_id(const SSL *ssl, unsigned char *id,
 216                                unsigned int *id_len);
 217 #ifndef OPENSSL_NO_DH
 218 static DH *load_dh_param(const char *dhfile);
 219 static DH *get_dh512(void);
 220 #endif
 221
 222 #ifdef MONOLITH
 223 static void s_server_init(void);
 224 #endif
 225
 226 #ifndef OPENSSL_NO_DH
 227 static unsigned char dh512_p[] = {
 228     0xDA, 0x58, 0x3C, 0x16, 0xD9, 0x85, 0x22, 0x89, 0xD0, 0xE4, 0xAF, 0x75,
 229     0x6F, 0x4C, 0xCA, 0x92, 0xDD, 0x4B, 0xE5, 0x33, 0xB8, 0x04, 0xFB, 0x0F,
 230     0xED, 0x94, 0xEF, 0x9C, 0x8A, 0x44, 0x03, 0xED, 0x57, 0x46, 0x50, 0xD3,
 231     0x69, 0x99, 0xDB, 0x29, 0xD7, 0x76, 0x27, 0x6B, 0xA2, 0xD3, 0xD4, 0x12,
 232     0xE2, 0x18, 0xF4, 0xDD, 0x1E, 0x08, 0x4C, 0xF6, 0xD8, 0x00, 0x3E, 0x7C,
 233     0x47, 0x74, 0xE8, 0x33,
 234 };
 235
 236 static unsigned char dh512_g[] = {
 237     0x02,
 238 };
 239
 240 static DH *get_dh512(void)
 241 {
 242     DH *dh = NULL;
 243
 244     if ((dh = DH_new()) == NULL)
 245         return (NULL);
 246     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
 247     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
 248     if ((dh->p == NULL) || (dh->g == NULL))
 249         return (NULL);
 250     return (dh);
 251 }
 252 #endif
 253
 254 /* static int load_CA(SSL_CTX *ctx, char *file);*/
 255
 256 #undef BUFSIZZ
 257 #define BUFSIZZ 16*1024
 258 static int bufsize = BUFSIZZ;
 259 static int accept_socket = -1;
 260
 261 #define TEST_CERT       "server.pem"
 262 #ifndef OPENSSL_NO_TLSEXT
 263 # define TEST_CERT2      "server2.pem"
 264 #endif
 265 #undef PROG
 266 #define PROG            s_server_main
 267
 268 extern int verify_depth, verify_return_error;
 269
 270 static char *cipher = NULL;
 271 static int s_server_verify = SSL_VERIFY_NONE;
 272 static int s_server_session_id_context = 1; /* anything will do */
 273 static const char *s_cert_file = TEST_CERT, *s_key_file = NULL;
 274 #ifndef OPENSSL_NO_TLSEXT
 275 static const char *s_cert_file2 = TEST_CERT2, *s_key_file2 = NULL;
 276 #endif
 277 static char *s_dcert_file = NULL, *s_dkey_file = NULL;
 278 #ifdef FIONBIO
 279 static int s_nbio = 0;
 280 #endif
 281 static int s_nbio_test = 0;
 282 int s_crlf = 0;
 283 static SSL_CTX *ctx = NULL;
 284 #ifndef OPENSSL_NO_TLSEXT
 285 static SSL_CTX *ctx2 = NULL;
 286 #endif
 287 static int www = 0;
 288
 289 static BIO *bio_s_out = NULL;
 290 static int s_debug = 0;
 291 #ifndef OPENSSL_NO_TLSEXT
 292 static int s_tlsextdebug = 0;
 293 static int s_tlsextstatus = 0;
 294 static int cert_status_cb(SSL *s, void *arg);
 295 #endif
 296 static int s_msg = 0;
 297 static int s_quiet = 0;
 298
 299 static int hack = 0;
 300 #ifndef OPENSSL_NO_ENGINE
 301 static char *engine_id = NULL;
 302 #endif
 303 static const char *session_id_prefix = NULL;
 304
 305 static int enable_timeouts = 0;
 306 static long socket_mtu;
 307 #ifndef OPENSSL_NO_DTLS1
 308 static int cert_chain = 0;
 309 #endif
 310
 311 #ifndef OPENSSL_NO_PSK
 312 static char *psk_identity = "Client_identity";
 313 char *psk_key = NULL;           /* by default PSK is not used */
 314
 315 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
 316                                   unsigned char *psk,
 317                                   unsigned int max_psk_len)
 318 {
 319     unsigned int psk_len = 0;
 320     int ret;
 321     BIGNUM *bn = NULL;
 322
 323     if (s_debug)
 324         BIO_printf(bio_s_out, "psk_server_cb\n");
 325     if (!identity) {
 326         BIO_printf(bio_err, "Error: client did not send PSK identity\n");
 327         goto out_err;
 328     }
 329     if (s_debug)
 330         BIO_printf(bio_s_out, "identity_len=%d identity=%s\n",
 331                    identity ? (int)strlen(identity) : 0, identity);
 332
 333     /* here we could lookup the given identity e.g. from a database */
 334     if (strcmp(identity, psk_identity) != 0) {
 335         BIO_printf(bio_s_out, "PSK error: client identity not found"
 336                    " (got '%s' expected '%s')\n", identity, psk_identity);
 337         goto out_err;
 338     }
 339     if (s_debug)
 340         BIO_printf(bio_s_out, "PSK client identity found\n");
 341
 342     /* convert the PSK key to binary */
 343     ret = BN_hex2bn(&bn, psk_key);
 344     if (!ret) {
 345         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
 346                    psk_key);
 347         if (bn)
 348             BN_free(bn);
 349         return 0;
 350     }
 351     if (BN_num_bytes(bn) > (int)max_psk_len) {
 352         BIO_printf(bio_err,
 353                    "psk buffer of callback is too small (%d) for key (%d)\n",
 354                    max_psk_len, BN_num_bytes(bn));
 355         BN_free(bn);
 356         return 0;
 357     }
 358
 359     ret = BN_bn2bin(bn, psk);
 360     BN_free(bn);
 361
 362     if (ret < 0)
 363         goto out_err;
 364     psk_len = (unsigned int)ret;
 365
 366     if (s_debug)
 367         BIO_printf(bio_s_out, "fetched PSK len=%d\n", psk_len);
 368     return psk_len;
 369  out_err:
 370     if (s_debug)
 371         BIO_printf(bio_err, "Error in PSK server callback\n");
 372     return 0;
 373 }
 374 #endif
 375
 376 #ifdef MONOLITH
 377 static void s_server_init(void)
 378 {
 379     accept_socket = -1;
 380     cipher = NULL;
 381     s_server_verify = SSL_VERIFY_NONE;
 382     s_dcert_file = NULL;
 383     s_dkey_file = NULL;
 384     s_cert_file = TEST_CERT;
 385     s_key_file = NULL;
 386 # ifndef OPENSSL_NO_TLSEXT
 387     s_cert_file2 = TEST_CERT2;
 388     s_key_file2 = NULL;
 389     ctx2 = NULL;
 390 # endif
 391 # ifdef FIONBIO
 392     s_nbio = 0;
 393 # endif
 394     s_nbio_test = 0;
 395     ctx = NULL;
 396     www = 0;
 397
 398     bio_s_out = NULL;
 399     s_debug = 0;
 400     s_msg = 0;
 401     s_quiet = 0;
 402     hack = 0;
 403 # ifndef OPENSSL_NO_ENGINE
 404     engine_id = NULL;
 405 # endif
 406 }
 407 #endif
 408
 409 static void sv_usage(void)
 410 {
 411     BIO_printf(bio_err, "usage: s_server [args ...]\n");
 412     BIO_printf(bio_err, "\n");
 413     BIO_printf(bio_err,
 414                " -accept arg   - port to accept on (default is %d)\n", PORT);
 415     BIO_printf(bio_err, " -context arg  - set session ID context\n");
 416     BIO_printf(bio_err,
 417                " -verify arg   - turn on peer certificate verification\n");
 418     BIO_printf(bio_err,
 419                " -Verify arg   - turn on peer certificate verification, must have a cert.\n");
 420     BIO_printf(bio_err,
 421                " -verify_return_error - return verification errors\n");
 422     BIO_printf(bio_err, " -cert arg     - certificate file to use\n");
 423     BIO_printf(bio_err, "                 (default is %s)\n", TEST_CERT);
 424     BIO_printf(bio_err,
 425                " -crl_check    - check the peer certificate has not been revoked by its CA.\n"
 426                "                 The CRL(s) are appended to the certificate file\n");
 427     BIO_printf(bio_err,
 428                " -crl_check_all - check the peer certificate has not been revoked by its CA\n"
 429                "                 or any other CRL in the CA chain. CRL(s) are appened to the\n"
 430                "                 the certificate file.\n");
 431     BIO_printf(bio_err,
 432                " -certform arg - certificate format (PEM or DER) PEM default\n");
 433     BIO_printf(bio_err,
 434                " -key arg      - Private Key file to use, in cert file if\n");
 435     BIO_printf(bio_err, "                 not specified (default is %s)\n",
 436                TEST_CERT);
 437     BIO_printf(bio_err,
 438                " -keyform arg  - key format (PEM, DER or ENGINE) PEM default\n");
 439     BIO_printf(bio_err,
 440                " -pass arg     - private key file pass phrase source\n");
 441     BIO_printf(bio_err,
 442                " -dcert arg    - second certificate file to use (usually for DSA)\n");
 443     BIO_printf(bio_err,
 444                " -dcertform x  - second certificate format (PEM or DER) PEM default\n");
 445     BIO_printf(bio_err,
 446                " -dkey arg     - second private key file to use (usually for DSA)\n");
 447     BIO_printf(bio_err,
 448                " -dkeyform arg - second key format (PEM, DER or ENGINE) PEM default\n");
 449     BIO_printf(bio_err,
 450                " -dpass arg    - second private key file pass phrase source\n");
 451     BIO_printf(bio_err,
 452                " -dhparam arg  - DH parameter file to use, in cert file if not specified\n");
 453     BIO_printf(bio_err,
 454                "                 or a default set of parameters is used\n");
 455 #ifndef OPENSSL_NO_ECDH
 456     BIO_printf(bio_err,
 457                " -named_curve arg  - Elliptic curve name to use for ephemeral ECDH keys.\n"
 458                "                 Use \"openssl ecparam -list_curves\" for all names\n"
 459                "                 (default is nistp256).\n");
 460 #endif
 461 #ifdef FIONBIO
 462     BIO_printf(bio_err, " -nbio         - Run with non-blocking IO\n");
 463 #endif
 464     BIO_printf(bio_err,
 465                " -nbio_test    - test with the non-blocking test bio\n");
 466     BIO_printf(bio_err,
 467                " -crlf         - convert LF from terminal into CRLF\n");
 468     BIO_printf(bio_err, " -debug        - Print more output\n");
 469     BIO_printf(bio_err, " -msg          - Show protocol messages\n");
 470     BIO_printf(bio_err, " -state        - Print the SSL states\n");
 471     BIO_printf(bio_err, " -CApath arg   - PEM format directory of CA's\n");
 472     BIO_printf(bio_err, " -CAfile arg   - PEM format file of CA's\n");
 473     BIO_printf(bio_err,
 474                " -nocert       - Don't use any certificates (Anon-DH)\n");
 475     BIO_printf(bio_err,
 476                " -cipher arg   - play with 'openssl ciphers' to see what goes here\n");
 477     BIO_printf(bio_err, " -serverpref   - Use server's cipher preferences\n");
 478     BIO_printf(bio_err, " -quiet        - No server output\n");
 479     BIO_printf(bio_err, " -no_tmp_rsa   - Do not generate a tmp RSA key\n");
 480 #ifndef OPENSSL_NO_PSK
 481     BIO_printf(bio_err, " -psk_hint arg - PSK identity hint to use\n");
 482     BIO_printf(bio_err, " -psk arg      - PSK in hex (without 0x)\n");
 483 # ifndef OPENSSL_NO_JPAKE
 484     BIO_printf(bio_err, " -jpake arg    - JPAKE secret to use\n");
 485 # endif
 486 #endif
 487     BIO_printf(bio_err, " -ssl2         - Just talk SSLv2\n");
 488     BIO_printf(bio_err, " -ssl3         - Just talk SSLv3\n");
 489     BIO_printf(bio_err, " -tls1         - Just talk TLSv1\n");
 490     BIO_printf(bio_err, " -dtls1        - Just talk DTLSv1\n");
 491     BIO_printf(bio_err, " -timeout      - Enable timeouts\n");
 492     BIO_printf(bio_err, " -mtu          - Set link layer MTU\n");
 493     BIO_printf(bio_err, " -chain        - Read a certificate chain\n");
 494     BIO_printf(bio_err, " -no_ssl2      - Just disable SSLv2\n");
 495     BIO_printf(bio_err, " -no_ssl3      - Just disable SSLv3\n");
 496     BIO_printf(bio_err, " -no_tls1      - Just disable TLSv1\n");
 497 #ifndef OPENSSL_NO_DH
 498     BIO_printf(bio_err, " -no_dhe       - Disable ephemeral DH\n");
 499 #endif
 500 #ifndef OPENSSL_NO_ECDH
 501     BIO_printf(bio_err, " -no_ecdhe     - Disable ephemeral ECDH\n");
 502 #endif
 503     BIO_printf(bio_err, " -bugs         - Turn on SSL bug compatibility\n");
 504     BIO_printf(bio_err,
 505                " -hack         - workaround for early Netscape code\n");
 506     BIO_printf(bio_err,
 507                " -www          - Respond to a 'GET /' with a status page\n");
 508     BIO_printf(bio_err,
 509                " -WWW          - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
 510     BIO_printf(bio_err,
 511                " -HTTP         - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
 512     BIO_printf(bio_err,
 513                "                 with the assumption it contains a complete HTTP response.\n");
 514 #ifndef OPENSSL_NO_ENGINE
 515     BIO_printf(bio_err,
 516                " -engine id    - Initialise and use the specified engine\n");
 517 #endif
 518     BIO_printf(bio_err,
 519                " -id_prefix arg - Generate SSL/TLS session IDs prefixed by 'arg'\n");
 520     BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
 521                LIST_SEPARATOR_CHAR);
 522 #ifndef OPENSSL_NO_TLSEXT
 523     BIO_printf(bio_err,
 524                " -servername host - servername for HostName TLS extension\n");
 525     BIO_printf(bio_err,
 526                " -servername_fatal - on mismatch send fatal alert (default warning alert)\n");
 527     BIO_printf(bio_err,
 528                " -cert2 arg    - certificate file to use for servername\n");
 529     BIO_printf(bio_err, "                 (default is %s)\n", TEST_CERT2);
 530     BIO_printf(bio_err,
 531                " -key2 arg     - Private Key file to use for servername, in cert file if\n");
 532     BIO_printf(bio_err, "                 not specified (default is %s)\n",
 533                TEST_CERT2);
 534     BIO_printf(bio_err,
 535                " -tlsextdebug  - hex dump of all TLS extensions received\n");
 536     BIO_printf(bio_err,
 537                " -no_ticket    - disable use of RFC4507bis session tickets\n");
 538     BIO_printf(bio_err,
 539                " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 540 #endif
 541     BIO_printf(bio_err,
 542                " -status           - respond to certificate status requests\n");
 543     BIO_printf(bio_err,
 544                " -status_verbose   - enable status request verbose printout\n");
 545     BIO_printf(bio_err,
 546                " -status_timeout n - status request responder timeout\n");
 547     BIO_printf(bio_err, " -status_url URL   - status request fallback URL\n");
 548 }
 549
 550 static int local_argc = 0;
 551 static char **local_argv;
 552
 553 #ifdef CHARSET_EBCDIC
 554 static int ebcdic_new(BIO *bi);
 555 static int ebcdic_free(BIO *a);
 556 static int ebcdic_read(BIO *b, char *out, int outl);
 557 static int ebcdic_write(BIO *b, const char *in, int inl);
 558 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr);
 559 static int ebcdic_gets(BIO *bp, char *buf, int size);
 560 static int ebcdic_puts(BIO *bp, const char *str);
 561
 562 # define BIO_TYPE_EBCDIC_FILTER  (18|0x0200)
 563 static BIO_METHOD methods_ebcdic = {
 564     BIO_TYPE_EBCDIC_FILTER,
 565     "EBCDIC/ASCII filter",
 566     ebcdic_write,
 567     ebcdic_read,
 568     ebcdic_puts,
 569     ebcdic_gets,
 570     ebcdic_ctrl,
 571     ebcdic_new,
 572     ebcdic_free,
 573 };
 574
 575 typedef struct {
 576     size_t alloced;
 577     char buff[1];
 578 } EBCDIC_OUTBUFF;
 579
 580 BIO_METHOD *BIO_f_ebcdic_filter()
 581 {
 582     return (&methods_ebcdic);
 583 }
 584
 585 static int ebcdic_new(BIO *bi)
 586 {
 587     EBCDIC_OUTBUFF *wbuf;
 588
 589     wbuf = (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
 590     wbuf->alloced = 1024;
 591     wbuf->buff[0] = '\0';
 592
 593     bi->ptr = (char *)wbuf;
 594     bi->init = 1;
 595     bi->flags = 0;
 596     return (1);
 597 }
 598
 599 static int ebcdic_free(BIO *a)
 600 {
 601     if (a == NULL)
 602         return (0);
 603     if (a->ptr != NULL)
 604         OPENSSL_free(a->ptr);
 605     a->ptr = NULL;
 606     a->init = 0;
 607     a->flags = 0;
 608     return (1);
 609 }
 610
 611 static int ebcdic_read(BIO *b, char *out, int outl)
 612 {
 613     int ret = 0;
 614
 615     if (out == NULL || outl == 0)
 616         return (0);
 617     if (b->next_bio == NULL)
 618         return (0);
 619
 620     ret = BIO_read(b->next_bio, out, outl);
 621     if (ret > 0)
 622         ascii2ebcdic(out, out, ret);
 623     return (ret);
 624 }
 625
 626 static int ebcdic_write(BIO *b, const char *in, int inl)
 627 {
 628     EBCDIC_OUTBUFF *wbuf;
 629     int ret = 0;
 630     int num;
 631     unsigned char n;
 632
 633     if ((in == NULL) || (inl <= 0))
 634         return (0);
 635     if (b->next_bio == NULL)
 636         return (0);
 637
 638     wbuf = (EBCDIC_OUTBUFF *) b->ptr;
 639
 640     if (inl > (num = wbuf->alloced)) {
 641         num = num + num;        /* double the size */
 642         if (num < inl)
 643             num = inl;
 644         OPENSSL_free(wbuf);
 645         wbuf =
 646             (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
 647
 648         wbuf->alloced = num;
 649         wbuf->buff[0] = '\0';
 650
 651         b->ptr = (char *)wbuf;
 652     }
 653
 654     ebcdic2ascii(wbuf->buff, in, inl);
 655
 656     ret = BIO_write(b->next_bio, wbuf->buff, inl);
 657
 658     return (ret);
 659 }
 660
 661 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)
 662 {
 663     long ret;
 664
 665     if (b->next_bio == NULL)
 666         return (0);
 667     switch (cmd) {
 668     case BIO_CTRL_DUP:
 669         ret = 0L;
 670         break;
 671     default:
 672         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
 673         break;
 674     }
 675     return (ret);
 676 }
 677
 678 static int ebcdic_gets(BIO *bp, char *buf, int size)
 679 {
 680     int i, ret = 0;
 681     if (bp->next_bio == NULL)
 682         return (0);
 683 /*      return(BIO_gets(bp->next_bio,buf,size));*/
 684     for (i = 0; i < size - 1; ++i) {
 685         ret = ebcdic_read(bp, &buf[i], 1);
 686         if (ret <= 0)
 687             break;
 688         else if (buf[i] == '\n') {
 689             ++i;
 690             break;
 691         }
 692     }
 693     if (i < size)
 694         buf[i] = '\0';
 695     return (ret < 0 && i == 0) ? ret : i;
 696 }
 697
 698 static int ebcdic_puts(BIO *bp, const char *str)
 699 {
 700     if (bp->next_bio == NULL)
 701         return (0);
 702     return ebcdic_write(bp, str, strlen(str));
 703 }
 704 #endif
 705
 706 #ifndef OPENSSL_NO_TLSEXT
 707
 708 /* This is a context that we pass to callbacks */
 709 typedef struct tlsextctx_st {
 710     char *servername;
 711     BIO *biodebug;
 712     int extension_error;
 713 } tlsextctx;
 714
 715 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
 716 {
 717     tlsextctx *p = (tlsextctx *) arg;
 718     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 719     if (servername && p->biodebug)
 720         BIO_printf(p->biodebug, "Hostname in TLS extension: \"%s\"\n",
 721                    servername);
 722
 723     if (!p->servername)
 724         return SSL_TLSEXT_ERR_NOACK;
 725
 726     if (servername) {
 727         if (strcasecmp(servername, p->servername))
 728             return p->extension_error;
 729         if (ctx2) {
 730             BIO_printf(p->biodebug, "Switching server context.\n");
 731             SSL_set_SSL_CTX(s, ctx2);
 732         }
 733     }
 734     return SSL_TLSEXT_ERR_OK;
 735 }
 736
 737 /* Structure passed to cert status callback */
 738
 739 typedef struct tlsextstatusctx_st {
 740     /* Default responder to use */
 741     char *host, *path, *port;
 742     int use_ssl;
 743     int timeout;
 744     BIO *err;
 745     int verbose;
 746 } tlsextstatusctx;
 747
 748 static tlsextstatusctx tlscstatp = { NULL, NULL, NULL, 0, -1, NULL, 0 };
 749
 750 /*
 751  * Certificate Status callback. This is called when a client includes a
 752  * certificate status request extension. This is a simplified version. It
 753  * examines certificates each time and makes one OCSP responder query for
 754  * each request. A full version would store details such as the OCSP
 755  * certificate IDs and minimise the number of OCSP responses by caching them
 756  * until they were considered "expired".
 757  */
 758
 759 static int cert_status_cb(SSL *s, void *arg)
 760 {
 761     tlsextstatusctx *srctx = arg;
 762     BIO *err = srctx->err;
 763     char *host, *port, *path;
 764     int use_ssl;
 765     unsigned char *rspder = NULL;
 766     int rspderlen;
 767     STACK_OF(OPENSSL_STRING) *aia = NULL;
 768     X509 *x = NULL;
 769     X509_STORE_CTX inctx;
 770     X509_OBJECT obj;
 771     OCSP_REQUEST *req = NULL;
 772     OCSP_RESPONSE *resp = NULL;
 773     OCSP_CERTID *id = NULL;
 774     STACK_OF(X509_EXTENSION) *exts;
 775     int ret = SSL_TLSEXT_ERR_NOACK;
 776     int i;
 777 # if 0
 778     STACK_OF(OCSP_RESPID) *ids;
 779     SSL_get_tlsext_status_ids(s, &ids);
 780     BIO_printf(err, "cert_status: received %d ids\n",
 781                sk_OCSP_RESPID_num(ids));
 782 # endif
 783     if (srctx->verbose)
 784         BIO_puts(err, "cert_status: callback called\n");
 785     /* Build up OCSP query from server certificate */
 786     x = SSL_get_certificate(s);
 787     aia = X509_get1_ocsp(x);
 788     if (aia) {
 789         if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
 790                             &host, &port, &path, &use_ssl)) {
 791             BIO_puts(err, "cert_status: can't parse AIA URL\n");
 792             goto err;
 793         }
 794         if (srctx->verbose)
 795             BIO_printf(err, "cert_status: AIA URL: %s\n",
 796                        sk_OPENSSL_STRING_value(aia, 0));
 797     } else {
 798         if (!srctx->host) {
 799             BIO_puts(srctx->err,
 800                      "cert_status: no AIA and no default responder URL\n");
 801             goto done;
 802         }
 803         host = srctx->host;
 804         path = srctx->path;
 805         port = srctx->port;
 806         use_ssl = srctx->use_ssl;
 807     }
 808
 809     if (!X509_STORE_CTX_init(&inctx,
 810                              SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),
 811                              NULL, NULL))
 812         goto err;
 813     if (X509_STORE_get_by_subject(&inctx, X509_LU_X509,
 814                                   X509_get_issuer_name(x), &obj) <= 0) {
 815         BIO_puts(err, "cert_status: Can't retrieve issuer certificate.\n");
 816         X509_STORE_CTX_cleanup(&inctx);
 817         goto done;
 818     }
 819     req = OCSP_REQUEST_new();
 820     if (!req)
 821         goto err;
 822     id = OCSP_cert_to_id(NULL, x, obj.data.x509);
 823     X509_free(obj.data.x509);
 824     X509_STORE_CTX_cleanup(&inctx);
 825     if (!id)
 826         goto err;
 827     if (!OCSP_request_add0_id(req, id))
 828         goto err;
 829     id = NULL;
 830     /* Add any extensions to the request */
 831     SSL_get_tlsext_status_exts(s, &exts);
 832     for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
 833         X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
 834         if (!OCSP_REQUEST_add_ext(req, ext, -1))
 835             goto err;
 836     }
 837     resp = process_responder(err, req, host, path, port, use_ssl, NULL,
 838                              srctx->timeout);
 839     if (!resp) {
 840         BIO_puts(err, "cert_status: error querying responder\n");
 841         goto done;
 842     }
 843     rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);
 844     if (rspderlen <= 0)
 845         goto err;
 846     SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);
 847     if (srctx->verbose) {
 848         BIO_puts(err, "cert_status: ocsp response sent:\n");
 849         OCSP_RESPONSE_print(err, resp, 2);
 850     }
 851     ret = SSL_TLSEXT_ERR_OK;
 852  done:
 853     if (ret != SSL_TLSEXT_ERR_OK)
 854         ERR_print_errors(err);
 855     if (aia) {
 856         OPENSSL_free(host);
 857         OPENSSL_free(path);
 858         OPENSSL_free(port);
 859         X509_email_free(aia);
 860     }
 861     if (id)
 862         OCSP_CERTID_free(id);
 863     if (req)
 864         OCSP_REQUEST_free(req);
 865     if (resp)
 866         OCSP_RESPONSE_free(resp);
 867     return ret;
 868  err:
 869     ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 870     goto done;
 871 }
 872 #endif
 873
 874 int MAIN(int, char **);
 875
 876 #ifndef OPENSSL_NO_JPAKE
 877 static char *jpake_secret = NULL;
 878 #endif
 879
 880 int MAIN(int argc, char *argv[])
 881 {
 882     X509_VERIFY_PARAM *vpm = NULL;
 883     int badarg = 0;
 884     short port = PORT;
 885     char *CApath = NULL, *CAfile = NULL;
 886     unsigned char *context = NULL;
 887     char *dhfile = NULL;
 888 #ifndef OPENSSL_NO_ECDH
 889     char *named_curve = NULL;
 890 #endif
 891     int badop = 0, bugs = 0;
 892     int ret = 1;
 893     int off = 0;
 894     int no_tmp_rsa = 0, no_dhe = 0, no_ecdhe = 0, nocert = 0;
 895     int state = 0;
 896     const SSL_METHOD *meth = NULL;
 897     int socket_type = SOCK_STREAM;
 898     ENGINE *e = NULL;
 899     char *inrand = NULL;
 900     int s_cert_format = FORMAT_PEM, s_key_format = FORMAT_PEM;
 901     char *passarg = NULL, *pass = NULL;
 902     char *dpassarg = NULL, *dpass = NULL;
 903     int s_dcert_format = FORMAT_PEM, s_dkey_format = FORMAT_PEM;
 904     X509 *s_cert = NULL, *s_dcert = NULL;
 905     EVP_PKEY *s_key = NULL, *s_dkey = NULL;
 906     int no_cache = 0;
 907 #ifndef OPENSSL_NO_TLSEXT
 908     EVP_PKEY *s_key2 = NULL;
 909     X509 *s_cert2 = NULL;
 910 #endif
 911 #ifndef OPENSSL_NO_TLSEXT
 912     tlsextctx tlsextcbp = { NULL, NULL, SSL_TLSEXT_ERR_ALERT_WARNING };
 913 #endif
 914 #ifndef OPENSSL_NO_PSK
 915     /* by default do not send a PSK identity hint */
 916     static char *psk_identity_hint = NULL;
 917 #endif
 918     meth = SSLv23_server_method();
 919
 920     local_argc = argc;
 921     local_argv = argv;
 922
 923     apps_startup();
 924 #ifdef MONOLITH
 925     s_server_init();
 926 #endif
 927
 928     if (bio_err == NULL)
 929         bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
 930
 931     if (!load_config(bio_err, NULL))
 932         goto end;
 933
 934     verify_depth = 0;
 935 #ifdef FIONBIO
 936     s_nbio = 0;
 937 #endif
 938     s_nbio_test = 0;
 939
 940     argc--;
 941     argv++;
 942
 943     while (argc >= 1) {
 944         if ((strcmp(*argv, "-port") == 0) || (strcmp(*argv, "-accept") == 0)) {
 945             if (--argc < 1)
 946                 goto bad;
 947             if (!extract_port(*(++argv), &port))
 948                 goto bad;
 949         } else if (strcmp(*argv, "-verify") == 0) {
 950             s_server_verify = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE;
 951             if (--argc < 1)
 952                 goto bad;
 953             verify_depth = atoi(*(++argv));
 954             BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
 955         } else if (strcmp(*argv, "-Verify") == 0) {
 956             s_server_verify =
 957                 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
 958                 SSL_VERIFY_CLIENT_ONCE;
 959             if (--argc < 1)
 960                 goto bad;
 961             verify_depth = atoi(*(++argv));
 962             BIO_printf(bio_err,
 963                        "verify depth is %d, must return a certificate\n",
 964                        verify_depth);
 965         } else if (strcmp(*argv, "-context") == 0) {
 966             if (--argc < 1)
 967                 goto bad;
 968             context = (unsigned char *)*(++argv);
 969         } else if (strcmp(*argv, "-cert") == 0) {
 970             if (--argc < 1)
 971                 goto bad;
 972             s_cert_file = *(++argv);
 973         } else if (strcmp(*argv, "-certform") == 0) {
 974             if (--argc < 1)
 975                 goto bad;
 976             s_cert_format = str2fmt(*(++argv));
 977         } else if (strcmp(*argv, "-key") == 0) {
 978             if (--argc < 1)
 979                 goto bad;
 980             s_key_file = *(++argv);
 981         } else if (strcmp(*argv, "-keyform") == 0) {
 982             if (--argc < 1)
 983                 goto bad;
 984             s_key_format = str2fmt(*(++argv));
 985         } else if (strcmp(*argv, "-pass") == 0) {
 986             if (--argc < 1)
 987                 goto bad;
 988             passarg = *(++argv);
 989         } else if (strcmp(*argv, "-dhparam") == 0) {
 990             if (--argc < 1)
 991                 goto bad;
 992             dhfile = *(++argv);
 993         }
 994 #ifndef OPENSSL_NO_ECDH
 995         else if (strcmp(*argv, "-named_curve") == 0) {
 996             if (--argc < 1)
 997                 goto bad;
 998             named_curve = *(++argv);
 999         }
1000 #endif
1001         else if (strcmp(*argv, "-dcertform") == 0) {
1002             if (--argc < 1)
1003                 goto bad;
1004             s_dcert_format = str2fmt(*(++argv));
1005         } else if (strcmp(*argv, "-dcert") == 0) {
1006             if (--argc < 1)
1007                 goto bad;
1008             s_dcert_file = *(++argv);
1009         } else if (strcmp(*argv, "-dkeyform") == 0) {
1010             if (--argc < 1)
1011                 goto bad;
1012             s_dkey_format = str2fmt(*(++argv));
1013         } else if (strcmp(*argv, "-dpass") == 0) {
1014             if (--argc < 1)
1015                 goto bad;
1016             dpassarg = *(++argv);
1017         } else if (strcmp(*argv, "-dkey") == 0) {
1018             if (--argc < 1)
1019                 goto bad;
1020             s_dkey_file = *(++argv);
1021         } else if (strcmp(*argv, "-nocert") == 0) {
1022             nocert = 1;
1023         } else if (strcmp(*argv, "-CApath") == 0) {
1024             if (--argc < 1)
1025                 goto bad;
1026             CApath = *(++argv);
1027         } else if (strcmp(*argv, "-no_cache") == 0)
1028             no_cache = 1;
1029         else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
1030             if (badarg)
1031                 goto bad;
1032             continue;
1033         } else if (strcmp(*argv, "-verify_return_error") == 0)
1034             verify_return_error = 1;
1035         else if (strcmp(*argv, "-serverpref") == 0) {
1036             off |= SSL_OP_CIPHER_SERVER_PREFERENCE;
1037         } else if (strcmp(*argv, "-legacy_renegotiation") == 0)
1038             off |= SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION;
1039         else if (strcmp(*argv, "-cipher") == 0) {
1040             if (--argc < 1)
1041                 goto bad;
1042             cipher = *(++argv);
1043         } else if (strcmp(*argv, "-CAfile") == 0) {
1044             if (--argc < 1)
1045                 goto bad;
1046             CAfile = *(++argv);
1047         }
1048 #ifdef FIONBIO
1049         else if (strcmp(*argv, "-nbio") == 0) {
1050             s_nbio = 1;
1051         }
1052 #endif
1053         else if (strcmp(*argv, "-nbio_test") == 0) {
1054 #ifdef FIONBIO
1055             s_nbio = 1;
1056 #endif
1057             s_nbio_test = 1;
1058         } else if (strcmp(*argv, "-debug") == 0) {
1059             s_debug = 1;
1060         }
1061 #ifndef OPENSSL_NO_TLSEXT
1062         else if (strcmp(*argv, "-tlsextdebug") == 0)
1063             s_tlsextdebug = 1;
1064         else if (strcmp(*argv, "-status") == 0)
1065             s_tlsextstatus = 1;
1066         else if (strcmp(*argv, "-status_verbose") == 0) {
1067             s_tlsextstatus = 1;
1068             tlscstatp.verbose = 1;
1069         } else if (!strcmp(*argv, "-status_timeout")) {
1070             s_tlsextstatus = 1;
1071             if (--argc < 1)
1072                 goto bad;
1073             tlscstatp.timeout = atoi(*(++argv));
1074         } else if (!strcmp(*argv, "-status_url")) {
1075             s_tlsextstatus = 1;
1076             if (--argc < 1)
1077                 goto bad;
1078             if (!OCSP_parse_url(*(++argv),
1079                                 &tlscstatp.host,
1080                                 &tlscstatp.port,
1081                                 &tlscstatp.path, &tlscstatp.use_ssl)) {
1082                 BIO_printf(bio_err, "Error parsing URL\n");
1083                 goto bad;
1084             }
1085         }
1086 #endif
1087         else if (strcmp(*argv, "-msg") == 0) {
1088             s_msg = 1;
1089         } else if (strcmp(*argv, "-hack") == 0) {
1090             hack = 1;
1091         } else if (strcmp(*argv, "-state") == 0) {
1092             state = 1;
1093         } else if (strcmp(*argv, "-crlf") == 0) {
1094             s_crlf = 1;
1095         } else if (strcmp(*argv, "-quiet") == 0) {
1096             s_quiet = 1;
1097         } else if (strcmp(*argv, "-bugs") == 0) {
1098             bugs = 1;
1099         } else if (strcmp(*argv, "-no_tmp_rsa") == 0) {
1100             no_tmp_rsa = 1;
1101         } else if (strcmp(*argv, "-no_dhe") == 0) {
1102             no_dhe = 1;
1103         } else if (strcmp(*argv, "-no_ecdhe") == 0) {
1104             no_ecdhe = 1;
1105         }
1106 #ifndef OPENSSL_NO_PSK
1107         else if (strcmp(*argv, "-psk_hint") == 0) {
1108             if (--argc < 1)
1109                 goto bad;
1110             psk_identity_hint = *(++argv);
1111         } else if (strcmp(*argv, "-psk") == 0) {
1112             size_t i;
1113
1114             if (--argc < 1)
1115                 goto bad;
1116             psk_key = *(++argv);
1117             for (i = 0; i < strlen(psk_key); i++) {
1118                 if (isxdigit((unsigned char)psk_key[i]))
1119                     continue;
1120                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1121                 goto bad;
1122             }
1123         }
1124 #endif
1125         else if (strcmp(*argv, "-www") == 0) {
1126             www = 1;
1127         } else if (strcmp(*argv, "-WWW") == 0) {
1128             www = 2;
1129         } else if (strcmp(*argv, "-HTTP") == 0) {
1130             www = 3;
1131         } else if (strcmp(*argv, "-no_ssl2") == 0) {
1132             off |= SSL_OP_NO_SSLv2;
1133         } else if (strcmp(*argv, "-no_ssl3") == 0) {
1134             off |= SSL_OP_NO_SSLv3;
1135         } else if (strcmp(*argv, "-no_tls1") == 0) {
1136             off |= SSL_OP_NO_TLSv1;
1137         } else if (strcmp(*argv, "-no_comp") == 0) {
1138             off |= SSL_OP_NO_COMPRESSION;
1139         }
1140 #ifndef OPENSSL_NO_TLSEXT
1141         else if (strcmp(*argv, "-no_ticket") == 0) {
1142             off |= SSL_OP_NO_TICKET;
1143         }
1144 #endif
1145 #ifndef OPENSSL_NO_SSL2
1146         else if (strcmp(*argv, "-ssl2") == 0) {
1147             meth = SSLv2_server_method();
1148         }
1149 #endif
1150 #ifndef OPENSSL_NO_SSL3
1151         else if (strcmp(*argv, "-ssl3") == 0) {
1152             meth = SSLv3_server_method();
1153         }
1154 #endif
1155 #ifndef OPENSSL_NO_TLS1
1156         else if (strcmp(*argv, "-tls1") == 0) {
1157             meth = TLSv1_server_method();
1158         }
1159 #endif
1160 #ifndef OPENSSL_NO_DTLS1
1161         else if (strcmp(*argv, "-dtls1") == 0) {
1162             meth = DTLSv1_server_method();
1163             socket_type = SOCK_DGRAM;
1164         } else if (strcmp(*argv, "-timeout") == 0)
1165             enable_timeouts = 1;
1166         else if (strcmp(*argv, "-mtu") == 0) {
1167             if (--argc < 1)
1168                 goto bad;
1169             socket_mtu = atol(*(++argv));
1170         } else if (strcmp(*argv, "-chain") == 0)
1171             cert_chain = 1;
1172 #endif
1173         else if (strcmp(*argv, "-id_prefix") == 0) {
1174             if (--argc < 1)
1175                 goto bad;
1176             session_id_prefix = *(++argv);
1177         }
1178 #ifndef OPENSSL_NO_ENGINE
1179         else if (strcmp(*argv, "-engine") == 0) {
1180             if (--argc < 1)
1181                 goto bad;
1182             engine_id = *(++argv);
1183         }
1184 #endif
1185         else if (strcmp(*argv, "-rand") == 0) {
1186             if (--argc < 1)
1187                 goto bad;
1188             inrand = *(++argv);
1189         }
1190 #ifndef OPENSSL_NO_TLSEXT
1191         else if (strcmp(*argv, "-servername") == 0) {
1192             if (--argc < 1)
1193                 goto bad;
1194             tlsextcbp.servername = *(++argv);
1195         } else if (strcmp(*argv, "-servername_fatal") == 0) {
1196             tlsextcbp.extension_error = SSL_TLSEXT_ERR_ALERT_FATAL;
1197         } else if (strcmp(*argv, "-cert2") == 0) {
1198             if (--argc < 1)
1199                 goto bad;
1200             s_cert_file2 = *(++argv);
1201         } else if (strcmp(*argv, "-key2") == 0) {
1202             if (--argc < 1)
1203                 goto bad;
1204             s_key_file2 = *(++argv);
1205         }
1206 #endif
1207 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1208         else if (strcmp(*argv, "-jpake") == 0) {
1209             if (--argc < 1)
1210                 goto bad;
1211             jpake_secret = *(++argv);
1212         }
1213 #endif
1214         else {
1215             BIO_printf(bio_err, "unknown option %s\n", *argv);
1216             badop = 1;
1217             break;
1218         }
1219         argc--;
1220         argv++;
1221     }
1222     if (badop) {
1223  bad:
1224         sv_usage();
1225         goto end;
1226     }
1227 #ifndef OPENSSL_NO_DTLS1
1228     if (www && socket_type == SOCK_DGRAM) {
1229         BIO_printf(bio_err, "Can't use -HTTP, -www or -WWW with DTLS\n");
1230         goto end;
1231     }
1232 #endif
1233
1234 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1235     if (jpake_secret) {
1236         if (psk_key) {
1237             BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1238             goto end;
1239         }
1240         psk_identity = "JPAKE";
1241         if (cipher) {
1242             BIO_printf(bio_err, "JPAKE sets cipher to PSK\n");
1243             goto end;
1244         }
1245         cipher = "PSK";
1246     }
1247 #endif
1248
1249     SSL_load_error_strings();
1250     OpenSSL_add_ssl_algorithms();
1251
1252 #ifndef OPENSSL_NO_ENGINE
1253     e = setup_engine(bio_err, engine_id, 1);
1254 #endif
1255
1256     if (!app_passwd(bio_err, passarg, dpassarg, &pass, &dpass)) {
1257         BIO_printf(bio_err, "Error getting password\n");
1258         goto end;
1259     }
1260
1261     if (s_key_file == NULL)
1262         s_key_file = s_cert_file;
1263 #ifndef OPENSSL_NO_TLSEXT
1264     if (s_key_file2 == NULL)
1265         s_key_file2 = s_cert_file2;
1266 #endif
1267
1268     if (nocert == 0) {
1269         s_key = load_key(bio_err, s_key_file, s_key_format, 0, pass, e,
1270                          "server certificate private key file");
1271         if (!s_key) {
1272             ERR_print_errors(bio_err);
1273             goto end;
1274         }
1275
1276         s_cert = load_cert(bio_err, s_cert_file, s_cert_format,
1277                            NULL, e, "server certificate file");
1278
1279         if (!s_cert) {
1280             ERR_print_errors(bio_err);
1281             goto end;
1282         }
1283 #ifndef OPENSSL_NO_TLSEXT
1284         if (tlsextcbp.servername) {
1285             s_key2 = load_key(bio_err, s_key_file2, s_key_format, 0, pass, e,
1286                               "second server certificate private key file");
1287             if (!s_key2) {
1288                 ERR_print_errors(bio_err);
1289                 goto end;
1290             }
1291
1292             s_cert2 = load_cert(bio_err, s_cert_file2, s_cert_format,
1293                                 NULL, e, "second server certificate file");
1294
1295             if (!s_cert2) {
1296                 ERR_print_errors(bio_err);
1297                 goto end;
1298             }
1299         }
1300 #endif
1301     }
1302
1303     if (s_dcert_file) {
1304
1305         if (s_dkey_file == NULL)
1306             s_dkey_file = s_dcert_file;
1307
1308         s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
1309                           0, dpass, e, "second certificate private key file");
1310         if (!s_dkey) {
1311             ERR_print_errors(bio_err);
1312             goto end;
1313         }
1314
1315         s_dcert = load_cert(bio_err, s_dcert_file, s_dcert_format,
1316                             NULL, e, "second server certificate file");
1317
1318         if (!s_dcert) {
1319             ERR_print_errors(bio_err);
1320             goto end;
1321         }
1322
1323     }
1324
1325     if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1326         && !RAND_status()) {
1327         BIO_printf(bio_err,
1328                    "warning, not much extra random data, consider using the -rand option\n");
1329     }
1330     if (inrand != NULL)
1331         BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1332                    app_RAND_load_files(inrand));
1333
1334     if (bio_s_out == NULL) {
1335         if (s_quiet && !s_debug && !s_msg) {
1336             bio_s_out = BIO_new(BIO_s_null());
1337         } else {
1338             if (bio_s_out == NULL)
1339                 bio_s_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1340         }
1341     }
1342 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
1343     if (nocert)
1344 #endif
1345     {
1346         s_cert_file = NULL;
1347         s_key_file = NULL;
1348         s_dcert_file = NULL;
1349         s_dkey_file = NULL;
1350 #ifndef OPENSSL_NO_TLSEXT
1351         s_cert_file2 = NULL;
1352         s_key_file2 = NULL;
1353 #endif
1354     }
1355
1356     ctx = SSL_CTX_new(meth);
1357     if (ctx == NULL) {
1358         ERR_print_errors(bio_err);
1359         goto end;
1360     }
1361     if (session_id_prefix) {
1362         if (strlen(session_id_prefix) >= 32)
1363             BIO_printf(bio_err,
1364                        "warning: id_prefix is too long, only one new session will be possible\n");
1365         else if (strlen(session_id_prefix) >= 16)
1366             BIO_printf(bio_err,
1367                        "warning: id_prefix is too long if you use SSLv2\n");
1368         if (!SSL_CTX_set_generate_session_id(ctx, generate_session_id)) {
1369             BIO_printf(bio_err, "error setting 'id_prefix'\n");
1370             ERR_print_errors(bio_err);
1371             goto end;
1372         }
1373         BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1374     }
1375     SSL_CTX_set_quiet_shutdown(ctx, 1);
1376     if (bugs)
1377         SSL_CTX_set_options(ctx, SSL_OP_ALL);
1378     if (hack)
1379         SSL_CTX_set_options(ctx, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1380     SSL_CTX_set_options(ctx, off);
1381     /*
1382      * DTLS: partial reads end up discarding unread UDP bytes :-( Setting
1383      * read ahead solves this problem.
1384      */
1385     if (socket_type == SOCK_DGRAM)
1386         SSL_CTX_set_read_ahead(ctx, 1);
1387
1388     if (state)
1389         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1390     if (no_cache)
1391         SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1392     else
1393         SSL_CTX_sess_set_cache_size(ctx, 128);
1394
1395 #if 0
1396     if (cipher == NULL)
1397         cipher = getenv("SSL_CIPHER");
1398 #endif
1399
1400 #if 0
1401     if (s_cert_file == NULL) {
1402         BIO_printf(bio_err,
1403                    "You must specify a certificate file for the server to use\n");
1404         goto end;
1405     }
1406 #endif
1407
1408     if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
1409         (!SSL_CTX_set_default_verify_paths(ctx))) {
1410         /* BIO_printf(bio_err,"X509_load_verify_locations\n"); */
1411         ERR_print_errors(bio_err);
1412         /* goto end; */
1413     }
1414     if (vpm)
1415         SSL_CTX_set1_param(ctx, vpm);
1416
1417 #ifndef OPENSSL_NO_TLSEXT
1418     if (s_cert2) {
1419         ctx2 = SSL_CTX_new(meth);
1420         if (ctx2 == NULL) {
1421             ERR_print_errors(bio_err);
1422             goto end;
1423         }
1424     }
1425
1426     if (ctx2) {
1427         BIO_printf(bio_s_out, "Setting secondary ctx parameters\n");
1428
1429         if (session_id_prefix) {
1430             if (strlen(session_id_prefix) >= 32)
1431                 BIO_printf(bio_err,
1432                            "warning: id_prefix is too long, only one new session will be possible\n");
1433             else if (strlen(session_id_prefix) >= 16)
1434                 BIO_printf(bio_err,
1435                            "warning: id_prefix is too long if you use SSLv2\n");
1436             if (!SSL_CTX_set_generate_session_id(ctx2, generate_session_id)) {
1437                 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1438                 ERR_print_errors(bio_err);
1439                 goto end;
1440             }
1441             BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1442         }
1443         SSL_CTX_set_quiet_shutdown(ctx2, 1);
1444         if (bugs)
1445             SSL_CTX_set_options(ctx2, SSL_OP_ALL);
1446         if (hack)
1447             SSL_CTX_set_options(ctx2, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1448         SSL_CTX_set_options(ctx2, off);
1449         /*
1450          * DTLS: partial reads end up discarding unread UDP bytes :-(
1451          * Setting read ahead solves this problem.
1452          */
1453         if (socket_type == SOCK_DGRAM)
1454             SSL_CTX_set_read_ahead(ctx2, 1);
1455
1456         if (state)
1457             SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1458
1459         if (no_cache)
1460             SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1461         else
1462             SSL_CTX_sess_set_cache_size(ctx2, 128);
1463
1464         if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1465             (!SSL_CTX_set_default_verify_paths(ctx2))) {
1466             ERR_print_errors(bio_err);
1467         }
1468         if (vpm)
1469             SSL_CTX_set1_param(ctx2, vpm);
1470     }
1471 #endif
1472
1473 #ifndef OPENSSL_NO_DH
1474     if (!no_dhe) {
1475         DH *dh = NULL;
1476
1477         if (dhfile)
1478             dh = load_dh_param(dhfile);
1479         else if (s_cert_file)
1480             dh = load_dh_param(s_cert_file);
1481
1482         if (dh != NULL) {
1483             BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1484         } else {
1485             BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1486             dh = get_dh512();
1487         }
1488         (void)BIO_flush(bio_s_out);
1489
1490         SSL_CTX_set_tmp_dh(ctx, dh);
1491 # ifndef OPENSSL_NO_TLSEXT
1492         if (ctx2) {
1493             if (!dhfile) {
1494                 DH *dh2 = load_dh_param(s_cert_file2);
1495                 if (dh2 != NULL) {
1496                     BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1497                     (void)BIO_flush(bio_s_out);
1498
1499                     DH_free(dh);
1500                     dh = dh2;
1501                 }
1502             }
1503             SSL_CTX_set_tmp_dh(ctx2, dh);
1504         }
1505 # endif
1506         DH_free(dh);
1507     }
1508 #endif
1509
1510 #ifndef OPENSSL_NO_ECDH
1511     if (!no_ecdhe) {
1512         EC_KEY *ecdh = NULL;
1513
1514         if (named_curve) {
1515             int nid = OBJ_sn2nid(named_curve);
1516
1517             if (nid == 0) {
1518                 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1519                 goto end;
1520             }
1521             ecdh = EC_KEY_new_by_curve_name(nid);
1522             if (ecdh == NULL) {
1523                 BIO_printf(bio_err, "unable to create curve (%s)\n",
1524                            named_curve);
1525                 goto end;
1526             }
1527         }
1528
1529         if (ecdh != NULL) {
1530             BIO_printf(bio_s_out, "Setting temp ECDH parameters\n");
1531         } else {
1532             BIO_printf(bio_s_out, "Using default temp ECDH parameters\n");
1533             ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
1534             if (ecdh == NULL) {
1535                 BIO_printf(bio_err, "unable to create curve (nistp256)\n");
1536                 goto end;
1537             }
1538         }
1539         (void)BIO_flush(bio_s_out);
1540
1541         SSL_CTX_set_tmp_ecdh(ctx, ecdh);
1542 # ifndef OPENSSL_NO_TLSEXT
1543         if (ctx2)
1544             SSL_CTX_set_tmp_ecdh(ctx2, ecdh);
1545 # endif
1546         EC_KEY_free(ecdh);
1547     }
1548 #endif
1549
1550     if (!set_cert_key_stuff(ctx, s_cert, s_key))
1551         goto end;
1552 #ifndef OPENSSL_NO_TLSEXT
1553     if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2))
1554         goto end;
1555 #endif
1556     if (s_dcert != NULL) {
1557         if (!set_cert_key_stuff(ctx, s_dcert, s_dkey))
1558             goto end;
1559     }
1560 #ifndef OPENSSL_NO_RSA
1561 # if 1
1562     if (!no_tmp_rsa) {
1563         SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1564 #  ifndef OPENSSL_NO_TLSEXT
1565         if (ctx2)
1566             SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1567 #  endif
1568     }
1569 # else
1570     if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1571         RSA *rsa;
1572
1573         BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1574         BIO_flush(bio_s_out);
1575
1576         rsa = RSA_generate_key(512, RSA_F4, NULL);
1577
1578         if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1579             ERR_print_errors(bio_err);
1580             goto end;
1581         }
1582 #  ifndef OPENSSL_NO_TLSEXT
1583         if (ctx2) {
1584             if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1585                 ERR_print_errors(bio_err);
1586                 goto end;
1587             }
1588         }
1589 #  endif
1590         RSA_free(rsa);
1591         BIO_printf(bio_s_out, "\n");
1592     }
1593 # endif
1594 #endif
1595
1596 #ifndef OPENSSL_NO_PSK
1597 # ifdef OPENSSL_NO_JPAKE
1598     if (psk_key != NULL)
1599 # else
1600     if (psk_key != NULL || jpake_secret)
1601 # endif
1602     {
1603         if (s_debug)
1604             BIO_printf(bio_s_out,
1605                        "PSK key given or JPAKE in use, setting server callback\n");
1606         SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1607     }
1608
1609     if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1610         BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1611         ERR_print_errors(bio_err);
1612         goto end;
1613     }
1614 #endif
1615
1616     if (cipher != NULL) {
1617         if (!SSL_CTX_set_cipher_list(ctx, cipher)) {
1618             BIO_printf(bio_err, "error setting cipher list\n");
1619             ERR_print_errors(bio_err);
1620             goto end;
1621         }
1622 #ifndef OPENSSL_NO_TLSEXT
1623         if (ctx2 && !SSL_CTX_set_cipher_list(ctx2, cipher)) {
1624             BIO_printf(bio_err, "error setting cipher list\n");
1625             ERR_print_errors(bio_err);
1626             goto end;
1627         }
1628 #endif
1629     }
1630     SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1631     SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1632                                    sizeof s_server_session_id_context);
1633
1634     /* Set DTLS cookie generation and verification callbacks */
1635     SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1636     SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1637
1638 #ifndef OPENSSL_NO_TLSEXT
1639     if (ctx2) {
1640         SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1641         SSL_CTX_set_session_id_context(ctx2,
1642                                        (void *)&s_server_session_id_context,
1643                                        sizeof s_server_session_id_context);
1644
1645         tlsextcbp.biodebug = bio_s_out;
1646         SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1647         SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1648         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1649         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1650     }
1651 #endif
1652
1653     if (CAfile != NULL) {
1654         SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
1655 #ifndef OPENSSL_NO_TLSEXT
1656         if (ctx2)
1657             SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
1658 #endif
1659     }
1660
1661     BIO_printf(bio_s_out, "ACCEPT\n");
1662     (void)BIO_flush(bio_s_out);
1663     if (www)
1664         do_server(port, socket_type, &accept_socket, www_body, context);
1665     else
1666         do_server(port, socket_type, &accept_socket, sv_body, context);
1667     print_stats(bio_s_out, ctx);
1668     ret = 0;
1669  end:
1670     if (ctx != NULL)
1671         SSL_CTX_free(ctx);
1672     if (s_cert)
1673         X509_free(s_cert);
1674     if (s_dcert)
1675         X509_free(s_dcert);
1676     if (s_key)
1677         EVP_PKEY_free(s_key);
1678     if (s_dkey)
1679         EVP_PKEY_free(s_dkey);
1680     if (pass)
1681         OPENSSL_free(pass);
1682     if (dpass)
1683         OPENSSL_free(dpass);
1684     if (vpm)
1685         X509_VERIFY_PARAM_free(vpm);
1686 #ifndef OPENSSL_NO_TLSEXT
1687     if (tlscstatp.host)
1688         OPENSSL_free(tlscstatp.host);
1689     if (tlscstatp.port)
1690         OPENSSL_free(tlscstatp.port);
1691     if (tlscstatp.path)
1692         OPENSSL_free(tlscstatp.path);
1693     if (ctx2 != NULL)
1694         SSL_CTX_free(ctx2);
1695     if (s_cert2)
1696         X509_free(s_cert2);
1697     if (s_key2)
1698         EVP_PKEY_free(s_key2);
1699 #endif
1700     if (bio_s_out != NULL) {
1701         BIO_free(bio_s_out);
1702         bio_s_out = NULL;
1703     }
1704     apps_shutdown();
1705     OPENSSL_EXIT(ret);
1706 }
1707
1708 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
1709 {
1710     BIO_printf(bio, "%4ld items in the session cache\n",
1711                SSL_CTX_sess_number(ssl_ctx));
1712     BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
1713                SSL_CTX_sess_connect(ssl_ctx));
1714     BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
1715                SSL_CTX_sess_connect_renegotiate(ssl_ctx));
1716     BIO_printf(bio, "%4ld client connects that finished\n",
1717                SSL_CTX_sess_connect_good(ssl_ctx));
1718     BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
1719                SSL_CTX_sess_accept(ssl_ctx));
1720     BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
1721                SSL_CTX_sess_accept_renegotiate(ssl_ctx));
1722     BIO_printf(bio, "%4ld server accepts that finished\n",
1723                SSL_CTX_sess_accept_good(ssl_ctx));
1724     BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
1725     BIO_printf(bio, "%4ld session cache misses\n",
1726                SSL_CTX_sess_misses(ssl_ctx));
1727     BIO_printf(bio, "%4ld session cache timeouts\n",
1728                SSL_CTX_sess_timeouts(ssl_ctx));
1729     BIO_printf(bio, "%4ld callback cache hits\n",
1730                SSL_CTX_sess_cb_hits(ssl_ctx));
1731     BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
1732                SSL_CTX_sess_cache_full(ssl_ctx),
1733                SSL_CTX_sess_get_cache_size(ssl_ctx));
1734 }
1735
1736 static int sv_body(char *hostname, int s, unsigned char *context)
1737 {
1738     char *buf = NULL;
1739     fd_set readfds;
1740     int ret = 1, width;
1741     int k, i;
1742     unsigned long l;
1743     SSL *con = NULL;
1744     BIO *sbio;
1745     struct timeval timeout;
1746 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
1747     struct timeval tv;
1748 #else
1749     struct timeval *timeoutp;
1750 #endif
1751
1752     if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
1753         BIO_printf(bio_err, "out of memory\n");
1754         goto err;
1755     }
1756 #ifdef FIONBIO
1757     if (s_nbio) {
1758         unsigned long sl = 1;
1759
1760         if (!s_quiet)
1761             BIO_printf(bio_err, "turning on non blocking io\n");
1762         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
1763             ERR_print_errors(bio_err);
1764     }
1765 #endif
1766
1767     if (con == NULL) {
1768         con = SSL_new(ctx);
1769 #ifndef OPENSSL_NO_TLSEXT
1770         if (s_tlsextdebug) {
1771             SSL_set_tlsext_debug_callback(con, tlsext_cb);
1772             SSL_set_tlsext_debug_arg(con, bio_s_out);
1773         }
1774         if (s_tlsextstatus) {
1775             SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
1776             tlscstatp.err = bio_err;
1777             SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
1778         }
1779 #endif
1780 #ifndef OPENSSL_NO_KRB5
1781         if ((con->kssl_ctx = kssl_ctx_new()) != NULL) {
1782             kssl_ctx_setstring(con->kssl_ctx, KSSL_SERVICE, KRB5SVC);
1783             kssl_ctx_setstring(con->kssl_ctx, KSSL_KEYTAB, KRB5KEYTAB);
1784         }
1785 #endif                          /* OPENSSL_NO_KRB5 */
1786         if (context)
1787             SSL_set_session_id_context(con, context, strlen((char *)context));
1788     }
1789     SSL_clear(con);
1790 #if 0
1791 # ifdef TLSEXT_TYPE_opaque_prf_input
1792     SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
1793 # endif
1794 #endif
1795
1796     if (SSL_version(con) == DTLS1_VERSION) {
1797
1798         sbio = BIO_new_dgram(s, BIO_NOCLOSE);
1799
1800         if (enable_timeouts) {
1801             timeout.tv_sec = 0;
1802             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
1803             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
1804
1805             timeout.tv_sec = 0;
1806             timeout.tv_usec = DGRAM_SND_TIMEOUT;
1807             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
1808         }
1809
1810         if (socket_mtu) {
1811             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
1812                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
1813                            DTLS_get_link_min_mtu(con));
1814                 ret = -1;
1815                 BIO_free(sbio);
1816                 goto err;
1817             }
1818             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
1819             if (!DTLS_set_link_mtu(con, socket_mtu)) {
1820                 BIO_printf(bio_err, "Failed to set MTU\n");
1821                 ret = -1;
1822                 BIO_free(sbio);
1823                 goto err;
1824             }
1825         } else
1826             /* want to do MTU discovery */
1827             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
1828
1829         /* turn on cookie exchange */
1830         SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
1831     } else
1832         sbio = BIO_new_socket(s, BIO_NOCLOSE);
1833
1834     if (s_nbio_test) {
1835         BIO *test;
1836
1837         test = BIO_new(BIO_f_nbio_test());
1838         sbio = BIO_push(test, sbio);
1839     }
1840 #ifndef OPENSSL_NO_JPAKE
1841     if (jpake_secret)
1842         jpake_server_auth(bio_s_out, sbio, jpake_secret);
1843 #endif
1844
1845     SSL_set_bio(con, sbio, sbio);
1846     SSL_set_accept_state(con);
1847     /* SSL_set_fd(con,s); */
1848
1849     if (s_debug) {
1850         con->debug = 1;
1851         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
1852         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
1853     }
1854     if (s_msg) {
1855         SSL_set_msg_callback(con, msg_cb);
1856         SSL_set_msg_callback_arg(con, bio_s_out);
1857     }
1858 #ifndef OPENSSL_NO_TLSEXT
1859     if (s_tlsextdebug) {
1860         SSL_set_tlsext_debug_callback(con, tlsext_cb);
1861         SSL_set_tlsext_debug_arg(con, bio_s_out);
1862     }
1863 #endif
1864
1865     width = s + 1;
1866     for (;;) {
1867         int read_from_terminal;
1868         int read_from_sslcon;
1869
1870         read_from_terminal = 0;
1871         read_from_sslcon = SSL_pending(con);
1872
1873         if (!read_from_sslcon) {
1874             FD_ZERO(&readfds);
1875 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
1876             openssl_fdset(fileno(stdin), &readfds);
1877 #endif
1878             openssl_fdset(s, &readfds);
1879             /*
1880              * Note: under VMS with SOCKETSHR the second parameter is
1881              * currently of type (int *) whereas under other systems it is
1882              * (void *) if you don't have a cast it will choke the compiler:
1883              * if you do have a cast then you can either go for (int *) or
1884              * (void *).
1885              */
1886 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
1887             /*
1888              * Under DOS (non-djgpp) and Windows we can't select on stdin:
1889              * only on sockets. As a workaround we timeout the select every
1890              * second and check for any keypress. In a proper Windows
1891              * application we wouldn't do this because it is inefficient.
1892              */
1893             tv.tv_sec = 1;
1894             tv.tv_usec = 0;
1895             i = select(width, (void *)&readfds, NULL, NULL, &tv);
1896             if ((i < 0) || (!i && !_kbhit()))
1897                 continue;
1898             if (_kbhit())
1899                 read_from_terminal = 1;
1900 #elif defined(OPENSSL_SYS_BEOS_R5)
1901             /* Under BeOS-R5 the situation is similar to DOS */
1902             tv.tv_sec = 1;
1903             tv.tv_usec = 0;
1904             (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
1905             i = select(width, (void *)&readfds, NULL, NULL, &tv);
1906             if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
1907                 continue;
1908             if (read(fileno(stdin), buf, 0) >= 0)
1909                 read_from_terminal = 1;
1910             (void)fcntl(fileno(stdin), F_SETFL, 0);
1911 #else
1912             if ((SSL_version(con) == DTLS1_VERSION) &&
1913                 DTLSv1_get_timeout(con, &timeout))
1914                 timeoutp = &timeout;
1915             else
1916                 timeoutp = NULL;
1917
1918             i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
1919
1920             if ((SSL_version(con) == DTLS1_VERSION)
1921                 && DTLSv1_handle_timeout(con) > 0) {
1922                 BIO_printf(bio_err, "TIMEOUT occured\n");
1923             }
1924
1925             if (i <= 0)
1926                 continue;
1927             if (FD_ISSET(fileno(stdin), &readfds))
1928                 read_from_terminal = 1;
1929 #endif
1930             if (FD_ISSET(s, &readfds))
1931                 read_from_sslcon = 1;
1932         }
1933         if (read_from_terminal) {
1934             if (s_crlf) {
1935                 int j, lf_num;
1936
1937                 i = raw_read_stdin(buf, bufsize / 2);
1938                 lf_num = 0;
1939                 /* both loops are skipped when i <= 0 */
1940                 for (j = 0; j < i; j++)
1941                     if (buf[j] == '\n')
1942                         lf_num++;
1943                 for (j = i - 1; j >= 0; j--) {
1944                     buf[j + lf_num] = buf[j];
1945                     if (buf[j] == '\n') {
1946                         lf_num--;
1947                         i++;
1948                         buf[j + lf_num] = '\r';
1949                     }
1950                 }
1951                 assert(lf_num == 0);
1952             } else
1953                 i = raw_read_stdin(buf, bufsize);
1954             if (!s_quiet) {
1955                 if ((i <= 0) || (buf[0] == 'Q')) {
1956                     BIO_printf(bio_s_out, "DONE\n");
1957                     SHUTDOWN(s);
1958                     close_accept_socket();
1959                     ret = -11;
1960                     goto err;
1961                 }
1962                 if ((i <= 0) || (buf[0] == 'q')) {
1963                     BIO_printf(bio_s_out, "DONE\n");
1964                     if (SSL_version(con) != DTLS1_VERSION)
1965                         SHUTDOWN(s);
1966                     /*
1967                      * close_accept_socket(); ret= -11;
1968                      */
1969                     goto err;
1970                 }
1971
1972                 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
1973                     SSL_renegotiate(con);
1974                     i = SSL_do_handshake(con);
1975                     printf("SSL_do_handshake -> %d\n", i);
1976                     i = 0;      /* 13; */
1977                     continue;
1978                     /*
1979                      * strcpy(buf,"server side RE-NEGOTIATE\n");
1980                      */
1981                 }
1982                 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
1983                     SSL_set_verify(con,
1984                                    SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
1985                                    NULL);
1986                     SSL_renegotiate(con);
1987                     i = SSL_do_handshake(con);
1988                     printf("SSL_do_handshake -> %d\n", i);
1989                     i = 0;      /* 13; */
1990                     continue;
1991                     /*
1992                      * strcpy(buf,"server side RE-NEGOTIATE asking for client
1993                      * cert\n");
1994                      */
1995                 }
1996                 if (buf[0] == 'P') {
1997                     static const char *str = "Lets print some clear text\n";
1998                     BIO_write(SSL_get_wbio(con), str, strlen(str));
1999                 }
2000                 if (buf[0] == 'S') {
2001                     print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2002                 }
2003             }
2004 #ifdef CHARSET_EBCDIC
2005             ebcdic2ascii(buf, buf, i);
2006 #endif
2007             l = k = 0;
2008             for (;;) {
2009                 /* should do a select for the write */
2010 #ifdef RENEG
2011                 {
2012                     static count = 0;
2013                     if (++count == 100) {
2014                         count = 0;
2015                         SSL_renegotiate(con);
2016                     }
2017                 }
2018 #endif
2019                 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2020                 switch (SSL_get_error(con, k)) {
2021                 case SSL_ERROR_NONE:
2022                     break;
2023                 case SSL_ERROR_WANT_WRITE:
2024                 case SSL_ERROR_WANT_READ:
2025                 case SSL_ERROR_WANT_X509_LOOKUP:
2026                     BIO_printf(bio_s_out, "Write BLOCK\n");
2027                     break;
2028                 case SSL_ERROR_SYSCALL:
2029                 case SSL_ERROR_SSL:
2030                     BIO_printf(bio_s_out, "ERROR\n");
2031                     ERR_print_errors(bio_err);
2032                     ret = 1;
2033                     goto err;
2034                     /* break; */
2035                 case SSL_ERROR_ZERO_RETURN:
2036                     BIO_printf(bio_s_out, "DONE\n");
2037                     ret = 1;
2038                     goto err;
2039                 }
2040                 l += k;
2041                 i -= k;
2042                 if (i <= 0)
2043                     break;
2044             }
2045         }
2046         if (read_from_sslcon) {
2047             if (!SSL_is_init_finished(con)) {
2048                 i = init_ssl_connection(con);
2049
2050                 if (i < 0) {
2051                     ret = 0;
2052                     goto err;
2053                 } else if (i == 0) {
2054                     ret = 1;
2055                     goto err;
2056                 }
2057             } else {
2058  again:
2059                 i = SSL_read(con, (char *)buf, bufsize);
2060                 switch (SSL_get_error(con, i)) {
2061                 case SSL_ERROR_NONE:
2062 #ifdef CHARSET_EBCDIC
2063                     ascii2ebcdic(buf, buf, i);
2064 #endif
2065                     raw_write_stdout(buf, (unsigned int)i);
2066                     if (SSL_pending(con))
2067                         goto again;
2068                     break;
2069                 case SSL_ERROR_WANT_WRITE:
2070                 case SSL_ERROR_WANT_READ:
2071                 case SSL_ERROR_WANT_X509_LOOKUP:
2072                     BIO_printf(bio_s_out, "Read BLOCK\n");
2073                     break;
2074                 case SSL_ERROR_SYSCALL:
2075                 case SSL_ERROR_SSL:
2076                     BIO_printf(bio_s_out, "ERROR\n");
2077                     ERR_print_errors(bio_err);
2078                     ret = 1;
2079                     goto err;
2080                 case SSL_ERROR_ZERO_RETURN:
2081                     BIO_printf(bio_s_out, "DONE\n");
2082                     ret = 1;
2083                     goto err;
2084                 }
2085             }
2086         }
2087     }
2088  err:
2089     if (con != NULL) {
2090         BIO_printf(bio_s_out, "shutting down SSL\n");
2091 #if 1
2092         SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2093 #else
2094         SSL_shutdown(con);
2095 #endif
2096         SSL_free(con);
2097     }
2098     BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2099     if (buf != NULL) {
2100         OPENSSL_cleanse(buf, bufsize);
2101         OPENSSL_free(buf);
2102     }
2103     if (ret >= 0)
2104         BIO_printf(bio_s_out, "ACCEPT\n");
2105     return (ret);
2106 }
2107
2108 static void close_accept_socket(void)
2109 {
2110     BIO_printf(bio_err, "shutdown accept socket\n");
2111     if (accept_socket >= 0) {
2112         SHUTDOWN2(accept_socket);
2113     }
2114 }
2115
2116 static int init_ssl_connection(SSL *con)
2117 {
2118     int i;
2119     const char *str;
2120     X509 *peer;
2121     long verify_error;
2122     MS_STATIC char buf[BUFSIZ];
2123
2124     if ((i = SSL_accept(con)) <= 0) {
2125         if (BIO_sock_should_retry(i)) {
2126             BIO_printf(bio_s_out, "DELAY\n");
2127             return (1);
2128         }
2129
2130         BIO_printf(bio_err, "ERROR\n");
2131         verify_error = SSL_get_verify_result(con);
2132         if (verify_error != X509_V_OK) {
2133             BIO_printf(bio_err, "verify error:%s\n",
2134                        X509_verify_cert_error_string(verify_error));
2135         } else
2136             ERR_print_errors(bio_err);
2137         return (0);
2138     }
2139
2140     PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2141
2142     peer = SSL_get_peer_certificate(con);
2143     if (peer != NULL) {
2144         BIO_printf(bio_s_out, "Client certificate\n");
2145         PEM_write_bio_X509(bio_s_out, peer);
2146         X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2147         BIO_printf(bio_s_out, "subject=%s\n", buf);
2148         X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2149         BIO_printf(bio_s_out, "issuer=%s\n", buf);
2150         X509_free(peer);
2151     }
2152
2153     if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2154         BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2155     str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2156     BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2157     if (con->hit)
2158         BIO_printf(bio_s_out, "Reused session-id\n");
2159     if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2160         TLS1_FLAGS_TLS_PADDING_BUG)
2161         BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2162 #ifndef OPENSSL_NO_KRB5
2163     if (con->kssl_ctx->client_princ != NULL) {
2164         BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2165                    con->kssl_ctx->client_princ);
2166     }
2167 #endif                          /* OPENSSL_NO_KRB5 */
2168     BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2169                SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2170     return (1);
2171 }
2172
2173 #ifndef OPENSSL_NO_DH
2174 static DH *load_dh_param(const char *dhfile)
2175 {
2176     DH *ret = NULL;
2177     BIO *bio;
2178
2179     if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2180         goto err;
2181     ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2182  err:
2183     if (bio != NULL)
2184         BIO_free(bio);
2185     return (ret);
2186 }
2187 #endif
2188
2189 #if 0
2190 static int load_CA(SSL_CTX *ctx, char *file)
2191 {
2192     FILE *in;
2193     X509 *x = NULL;
2194
2195     if ((in = fopen(file, "r")) == NULL)
2196         return (0);
2197
2198     for (;;) {
2199         if (PEM_read_X509(in, &x, NULL) == NULL)
2200             break;
2201         SSL_CTX_add_client_CA(ctx, x);
2202     }
2203     if (x != NULL)
2204         X509_free(x);
2205     fclose(in);
2206     return (1);
2207 }
2208 #endif
2209
2210 static int www_body(char *hostname, int s, unsigned char *context)
2211 {
2212     char *buf = NULL;
2213     int ret = 1;
2214     int i, j, k, dot;
2215     SSL *con;
2216     const SSL_CIPHER *c;
2217     BIO *io, *ssl_bio, *sbio;
2218
2219     buf = OPENSSL_malloc(bufsize);
2220     if (buf == NULL)
2221         return (0);
2222     io = BIO_new(BIO_f_buffer());
2223     ssl_bio = BIO_new(BIO_f_ssl());
2224     if ((io == NULL) || (ssl_bio == NULL))
2225         goto err;
2226
2227 #ifdef FIONBIO
2228     if (s_nbio) {
2229         unsigned long sl = 1;
2230
2231         if (!s_quiet)
2232             BIO_printf(bio_err, "turning on non blocking io\n");
2233         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2234             ERR_print_errors(bio_err);
2235     }
2236 #endif
2237
2238     /* lets make the output buffer a reasonable size */
2239     if (!BIO_set_write_buffer_size(io, bufsize))
2240         goto err;
2241
2242     if ((con = SSL_new(ctx)) == NULL)
2243         goto err;
2244 #ifndef OPENSSL_NO_TLSEXT
2245     if (s_tlsextdebug) {
2246         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2247         SSL_set_tlsext_debug_arg(con, bio_s_out);
2248     }
2249 #endif
2250 #ifndef OPENSSL_NO_KRB5
2251     if ((con->kssl_ctx = kssl_ctx_new()) != NULL) {
2252         kssl_ctx_setstring(con->kssl_ctx, KSSL_SERVICE, KRB5SVC);
2253         kssl_ctx_setstring(con->kssl_ctx, KSSL_KEYTAB, KRB5KEYTAB);
2254     }
2255 #endif                          /* OPENSSL_NO_KRB5 */
2256     if (context)
2257         SSL_set_session_id_context(con, context, strlen((char *)context));
2258
2259     sbio = BIO_new_socket(s, BIO_NOCLOSE);
2260     if (s_nbio_test) {
2261         BIO *test;
2262
2263         test = BIO_new(BIO_f_nbio_test());
2264         sbio = BIO_push(test, sbio);
2265     }
2266     SSL_set_bio(con, sbio, sbio);
2267     SSL_set_accept_state(con);
2268
2269     /* SSL_set_fd(con,s); */
2270     BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2271     BIO_push(io, ssl_bio);
2272 #ifdef CHARSET_EBCDIC
2273     io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2274 #endif
2275
2276     if (s_debug) {
2277         con->debug = 1;
2278         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2279         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2280     }
2281     if (s_msg) {
2282         SSL_set_msg_callback(con, msg_cb);
2283         SSL_set_msg_callback_arg(con, bio_s_out);
2284     }
2285
2286     for (;;) {
2287         if (hack) {
2288             i = SSL_accept(con);
2289
2290             switch (SSL_get_error(con, i)) {
2291             case SSL_ERROR_NONE:
2292                 break;
2293             case SSL_ERROR_WANT_WRITE:
2294             case SSL_ERROR_WANT_READ:
2295             case SSL_ERROR_WANT_X509_LOOKUP:
2296                 continue;
2297             case SSL_ERROR_SYSCALL:
2298             case SSL_ERROR_SSL:
2299             case SSL_ERROR_ZERO_RETURN:
2300                 ret = 1;
2301                 goto err;
2302                 /* break; */
2303             }
2304
2305             SSL_renegotiate(con);
2306             SSL_write(con, NULL, 0);
2307         }
2308
2309         i = BIO_gets(io, buf, bufsize - 1);
2310         if (i < 0) {            /* error */
2311             if (!BIO_should_retry(io)) {
2312                 if (!s_quiet)
2313                     ERR_print_errors(bio_err);
2314                 goto err;
2315             } else {
2316                 BIO_printf(bio_s_out, "read R BLOCK\n");
2317 #if defined(OPENSSL_SYS_NETWARE)
2318                 delay(1000);
2319 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2320                 sleep(1);
2321 #endif
2322                 continue;
2323             }
2324         } else if (i == 0) {    /* end of input */
2325             ret = 1;
2326             goto end;
2327         }
2328
2329         /* else we have data */
2330         if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2331             ((www == 2) && (strncmp("GET /stats ", buf, 10) == 0))) {
2332             char *p;
2333             X509 *peer;
2334             STACK_OF(SSL_CIPHER) *sk;
2335             static const char *space = "                          ";
2336
2337             BIO_puts(io,
2338                      "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2339             BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2340             BIO_puts(io, "<pre>\n");
2341 /*                      BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2342             BIO_puts(io, "\n");
2343             for (i = 0; i < local_argc; i++) {
2344                 BIO_puts(io, local_argv[i]);
2345                 BIO_write(io, " ", 1);
2346             }
2347             BIO_puts(io, "\n");
2348
2349             /*
2350              * The following is evil and should not really be done
2351              */
2352             BIO_printf(io, "Ciphers supported in s_server binary\n");
2353             sk = SSL_get_ciphers(con);
2354             j = sk_SSL_CIPHER_num(sk);
2355             for (i = 0; i < j; i++) {
2356                 c = sk_SSL_CIPHER_value(sk, i);
2357                 BIO_printf(io, "%-11s:%-25s",
2358                            SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2359                 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2360                     BIO_puts(io, "\n");
2361             }
2362             BIO_puts(io, "\n");
2363             p = SSL_get_shared_ciphers(con, buf, bufsize);
2364             if (p != NULL) {
2365                 BIO_printf(io,
2366                            "---\nCiphers common between both SSL end points:\n");
2367                 j = i = 0;
2368                 while (*p) {
2369                     if (*p == ':') {
2370                         BIO_write(io, space, 26 - j);
2371                         i++;
2372                         j = 0;
2373                         BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2374                     } else {
2375                         BIO_write(io, p, 1);
2376                         j++;
2377                     }
2378                     p++;
2379                 }
2380                 BIO_puts(io, "\n");
2381             }
2382             BIO_printf(io, ((con->hit)
2383                             ? "---\nReused, " : "---\nNew, "));
2384             c = SSL_get_current_cipher(con);
2385             BIO_printf(io, "%s, Cipher is %s\n",
2386                        SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2387             SSL_SESSION_print(io, SSL_get_session(con));
2388             BIO_printf(io, "---\n");
2389             print_stats(io, SSL_get_SSL_CTX(con));
2390             BIO_printf(io, "---\n");
2391             peer = SSL_get_peer_certificate(con);
2392             if (peer != NULL) {
2393                 BIO_printf(io, "Client certificate\n");
2394                 X509_print(io, peer);
2395                 PEM_write_bio_X509(io, peer);
2396             } else
2397                 BIO_puts(io, "no client certificate available\n");
2398             BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2399             break;
2400         } else if ((www == 2 || www == 3)
2401                    && (strncmp("GET /", buf, 5) == 0)) {
2402             BIO *file;
2403             char *p, *e;
2404             static const char *text =
2405                 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2406
2407             /* skip the '/' */
2408             p = &(buf[5]);
2409
2410             dot = 1;
2411             for (e = p; *e != '\0'; e++) {
2412                 if (e[0] == ' ')
2413                     break;
2414
2415                 switch (dot) {
2416                 case 1:
2417                     dot = (e[0] == '.') ? 2 : 0;
2418                     break;
2419                 case 2:
2420                     dot = (e[0] == '.') ? 3 : 0;
2421                     break;
2422                 case 3:
2423                     dot = (e[0] == '/') ? -1 : 0;
2424                     break;
2425                 }
2426                 if (dot == 0)
2427                     dot = (e[0] == '/') ? 1 : 0;
2428             }
2429             dot = (dot == 3) || (dot == -1); /* filename contains ".."
2430                                               * component */
2431
2432             if (*e == '\0') {
2433                 BIO_puts(io, text);
2434                 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2435                 break;
2436             }
2437             *e = '\0';
2438
2439             if (dot) {
2440                 BIO_puts(io, text);
2441                 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
2442                 break;
2443             }
2444
2445             if (*p == '/') {
2446                 BIO_puts(io, text);
2447                 BIO_printf(io, "'%s' is an invalid path\r\n", p);
2448                 break;
2449             }
2450 #if 0
2451             /* append if a directory lookup */
2452             if (e[-1] == '/')
2453                 strcat(p, "index.html");
2454 #endif
2455
2456             /* if a directory, do the index thang */
2457             if (app_isdir(p) > 0) {
2458 #if 0                           /* must check buffer size */
2459                 strcat(p, "/index.html");
2460 #else
2461                 BIO_puts(io, text);
2462                 BIO_printf(io, "'%s' is a directory\r\n", p);
2463                 break;
2464 #endif
2465             }
2466
2467             if ((file = BIO_new_file(p, "r")) == NULL) {
2468                 BIO_puts(io, text);
2469                 BIO_printf(io, "Error opening '%s'\r\n", p);
2470                 ERR_print_errors(io);
2471                 break;
2472             }
2473
2474             if (!s_quiet)
2475                 BIO_printf(bio_err, "FILE:%s\n", p);
2476
2477             if (www == 2) {
2478                 i = strlen(p);
2479                 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
2480                     ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
2481                     ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
2482                     BIO_puts(io,
2483                              "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2484                 else
2485                     BIO_puts(io,
2486                              "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
2487             }
2488             /* send the file */
2489             for (;;) {
2490                 i = BIO_read(file, buf, bufsize);
2491                 if (i <= 0)
2492                     break;
2493
2494 #ifdef RENEG
2495                 total_bytes += i;
2496                 fprintf(stderr, "%d\n", i);
2497                 if (total_bytes > 3 * 1024) {
2498                     total_bytes = 0;
2499                     fprintf(stderr, "RENEGOTIATE\n");
2500                     SSL_renegotiate(con);
2501                 }
2502 #endif
2503
2504                 for (j = 0; j < i;) {
2505 #ifdef RENEG
2506                     {
2507                         static count = 0;
2508                         if (++count == 13) {
2509                             SSL_renegotiate(con);
2510                         }
2511                     }
2512 #endif
2513                     k = BIO_write(io, &(buf[j]), i - j);
2514                     if (k <= 0) {
2515                         if (!BIO_should_retry(io))
2516                             goto write_error;
2517                         else {
2518                             BIO_printf(bio_s_out, "rwrite W BLOCK\n");
2519                         }
2520                     } else {
2521                         j += k;
2522                     }
2523                 }
2524             }
2525  write_error:
2526             BIO_free(file);
2527             break;
2528         }
2529     }
2530
2531     for (;;) {
2532         i = (int)BIO_flush(io);
2533         if (i <= 0) {
2534             if (!BIO_should_retry(io))
2535                 break;
2536         } else
2537             break;
2538     }
2539  end:
2540 #if 1
2541     /* make sure we re-use sessions */
2542     SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2543 #else
2544     /* This kills performance */
2545     /*
2546      * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
2547      * procession
2548      */
2549 #endif
2550
2551  err:
2552
2553     if (ret >= 0)
2554         BIO_printf(bio_s_out, "ACCEPT\n");
2555
2556     if (buf != NULL)
2557         OPENSSL_free(buf);
2558     if (io != NULL)
2559         BIO_free_all(io);
2560 /*      if (ssl_bio != NULL) BIO_free(ssl_bio);*/
2561     return (ret);
2562 }
2563
2564 #ifndef OPENSSL_NO_RSA
2565 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2566 {
2567     BIGNUM *bn = NULL;
2568     static RSA *rsa_tmp = NULL;
2569
2570     if (!rsa_tmp && ((bn = BN_new()) == NULL))
2571         BIO_printf(bio_err, "Allocation error in generating RSA key\n");
2572     if (!rsa_tmp && bn) {
2573         if (!s_quiet) {
2574             BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
2575                        keylength);
2576             (void)BIO_flush(bio_err);
2577         }
2578         if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
2579             !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
2580             if (rsa_tmp)
2581                 RSA_free(rsa_tmp);
2582             rsa_tmp = NULL;
2583         }
2584         if (!s_quiet) {
2585             BIO_printf(bio_err, "\n");
2586             (void)BIO_flush(bio_err);
2587         }
2588         BN_free(bn);
2589     }
2590     return (rsa_tmp);
2591 }
2592 #endif
2593
2594 #define MAX_SESSION_ID_ATTEMPTS 10
2595 static int generate_session_id(const SSL *ssl, unsigned char *id,
2596                                unsigned int *id_len)
2597 {
2598     unsigned int count = 0;
2599     do {
2600         RAND_pseudo_bytes(id, *id_len);
2601         /*
2602          * Prefix the session_id with the required prefix. NB: If our prefix
2603          * is too long, clip it - but there will be worse effects anyway, eg.
2604          * the server could only possibly create 1 session ID (ie. the
2605          * prefix!) so all future session negotiations will fail due to
2606          * conflicts.
2607          */
2608         memcpy(id, session_id_prefix,
2609                (strlen(session_id_prefix) < *id_len) ?
2610                strlen(session_id_prefix) : *id_len);
2611     }
2612     while (SSL_has_matching_session_id(ssl, id, *id_len) &&
2613            (++count < MAX_SESSION_ID_ATTEMPTS));
2614     if (count >= MAX_SESSION_ID_ATTEMPTS)
2615         return 0;
2616     return 1;
2617 }