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                 if (k > 0) {
2041                     l += k;
2042                     i -= k;
2043                 }
2044                 if (i <= 0)
2045                     break;
2046             }
2047         }
2048         if (read_from_sslcon) {
2049             if (!SSL_is_init_finished(con)) {
2050                 i = init_ssl_connection(con);
2051
2052                 if (i < 0) {
2053                     ret = 0;
2054                     goto err;
2055                 } else if (i == 0) {
2056                     ret = 1;
2057                     goto err;
2058                 }
2059             } else {
2060  again:
2061                 i = SSL_read(con, (char *)buf, bufsize);
2062                 switch (SSL_get_error(con, i)) {
2063                 case SSL_ERROR_NONE:
2064 #ifdef CHARSET_EBCDIC
2065                     ascii2ebcdic(buf, buf, i);
2066 #endif
2067                     raw_write_stdout(buf, (unsigned int)i);
2068                     if (SSL_pending(con))
2069                         goto again;
2070                     break;
2071                 case SSL_ERROR_WANT_WRITE:
2072                 case SSL_ERROR_WANT_READ:
2073                 case SSL_ERROR_WANT_X509_LOOKUP:
2074                     BIO_printf(bio_s_out, "Read BLOCK\n");
2075                     break;
2076                 case SSL_ERROR_SYSCALL:
2077                 case SSL_ERROR_SSL:
2078                     BIO_printf(bio_s_out, "ERROR\n");
2079                     ERR_print_errors(bio_err);
2080                     ret = 1;
2081                     goto err;
2082                 case SSL_ERROR_ZERO_RETURN:
2083                     BIO_printf(bio_s_out, "DONE\n");
2084                     ret = 1;
2085                     goto err;
2086                 }
2087             }
2088         }
2089     }
2090  err:
2091     if (con != NULL) {
2092         BIO_printf(bio_s_out, "shutting down SSL\n");
2093 #if 1
2094         SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2095 #else
2096         SSL_shutdown(con);
2097 #endif
2098         SSL_free(con);
2099     }
2100     BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2101     if (buf != NULL) {
2102         OPENSSL_cleanse(buf, bufsize);
2103         OPENSSL_free(buf);
2104     }
2105     if (ret >= 0)
2106         BIO_printf(bio_s_out, "ACCEPT\n");
2107     return (ret);
2108 }
2109
2110 static void close_accept_socket(void)
2111 {
2112     BIO_printf(bio_err, "shutdown accept socket\n");
2113     if (accept_socket >= 0) {
2114         SHUTDOWN2(accept_socket);
2115     }
2116 }
2117
2118 static int init_ssl_connection(SSL *con)
2119 {
2120     int i;
2121     const char *str;
2122     X509 *peer;
2123     long verify_error;
2124     MS_STATIC char buf[BUFSIZ];
2125
2126     if ((i = SSL_accept(con)) <= 0) {
2127         if (BIO_sock_should_retry(i)) {
2128             BIO_printf(bio_s_out, "DELAY\n");
2129             return (1);
2130         }
2131
2132         BIO_printf(bio_err, "ERROR\n");
2133         verify_error = SSL_get_verify_result(con);
2134         if (verify_error != X509_V_OK) {
2135             BIO_printf(bio_err, "verify error:%s\n",
2136                        X509_verify_cert_error_string(verify_error));
2137         } else
2138             ERR_print_errors(bio_err);
2139         return (0);
2140     }
2141
2142     PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2143
2144     peer = SSL_get_peer_certificate(con);
2145     if (peer != NULL) {
2146         BIO_printf(bio_s_out, "Client certificate\n");
2147         PEM_write_bio_X509(bio_s_out, peer);
2148         X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2149         BIO_printf(bio_s_out, "subject=%s\n", buf);
2150         X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2151         BIO_printf(bio_s_out, "issuer=%s\n", buf);
2152         X509_free(peer);
2153     }
2154
2155     if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2156         BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2157     str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2158     BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2159     if (con->hit)
2160         BIO_printf(bio_s_out, "Reused session-id\n");
2161     if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2162         TLS1_FLAGS_TLS_PADDING_BUG)
2163         BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2164 #ifndef OPENSSL_NO_KRB5
2165     if (con->kssl_ctx->client_princ != NULL) {
2166         BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2167                    con->kssl_ctx->client_princ);
2168     }
2169 #endif                          /* OPENSSL_NO_KRB5 */
2170     BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2171                SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2172     return (1);
2173 }
2174
2175 #ifndef OPENSSL_NO_DH
2176 static DH *load_dh_param(const char *dhfile)
2177 {
2178     DH *ret = NULL;
2179     BIO *bio;
2180
2181     if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2182         goto err;
2183     ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2184  err:
2185     if (bio != NULL)
2186         BIO_free(bio);
2187     return (ret);
2188 }
2189 #endif
2190
2191 #if 0
2192 static int load_CA(SSL_CTX *ctx, char *file)
2193 {
2194     FILE *in;
2195     X509 *x = NULL;
2196
2197     if ((in = fopen(file, "r")) == NULL)
2198         return (0);
2199
2200     for (;;) {
2201         if (PEM_read_X509(in, &x, NULL) == NULL)
2202             break;
2203         SSL_CTX_add_client_CA(ctx, x);
2204     }
2205     if (x != NULL)
2206         X509_free(x);
2207     fclose(in);
2208     return (1);
2209 }
2210 #endif
2211
2212 static int www_body(char *hostname, int s, unsigned char *context)
2213 {
2214     char *buf = NULL;
2215     int ret = 1;
2216     int i, j, k, dot;
2217     SSL *con;
2218     const SSL_CIPHER *c;
2219     BIO *io, *ssl_bio, *sbio;
2220
2221     buf = OPENSSL_malloc(bufsize);
2222     if (buf == NULL)
2223         return (0);
2224     io = BIO_new(BIO_f_buffer());
2225     ssl_bio = BIO_new(BIO_f_ssl());
2226     if ((io == NULL) || (ssl_bio == NULL))
2227         goto err;
2228
2229 #ifdef FIONBIO
2230     if (s_nbio) {
2231         unsigned long sl = 1;
2232
2233         if (!s_quiet)
2234             BIO_printf(bio_err, "turning on non blocking io\n");
2235         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2236             ERR_print_errors(bio_err);
2237     }
2238 #endif
2239
2240     /* lets make the output buffer a reasonable size */
2241     if (!BIO_set_write_buffer_size(io, bufsize))
2242         goto err;
2243
2244     if ((con = SSL_new(ctx)) == NULL)
2245         goto err;
2246 #ifndef OPENSSL_NO_TLSEXT
2247     if (s_tlsextdebug) {
2248         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2249         SSL_set_tlsext_debug_arg(con, bio_s_out);
2250     }
2251 #endif
2252 #ifndef OPENSSL_NO_KRB5
2253     if ((con->kssl_ctx = kssl_ctx_new()) != NULL) {
2254         kssl_ctx_setstring(con->kssl_ctx, KSSL_SERVICE, KRB5SVC);
2255         kssl_ctx_setstring(con->kssl_ctx, KSSL_KEYTAB, KRB5KEYTAB);
2256     }
2257 #endif                          /* OPENSSL_NO_KRB5 */
2258     if (context)
2259         SSL_set_session_id_context(con, context, strlen((char *)context));
2260
2261     sbio = BIO_new_socket(s, BIO_NOCLOSE);
2262     if (s_nbio_test) {
2263         BIO *test;
2264
2265         test = BIO_new(BIO_f_nbio_test());
2266         sbio = BIO_push(test, sbio);
2267     }
2268     SSL_set_bio(con, sbio, sbio);
2269     SSL_set_accept_state(con);
2270
2271     /* SSL_set_fd(con,s); */
2272     BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2273     BIO_push(io, ssl_bio);
2274 #ifdef CHARSET_EBCDIC
2275     io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2276 #endif
2277
2278     if (s_debug) {
2279         con->debug = 1;
2280         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2281         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2282     }
2283     if (s_msg) {
2284         SSL_set_msg_callback(con, msg_cb);
2285         SSL_set_msg_callback_arg(con, bio_s_out);
2286     }
2287
2288     for (;;) {
2289         if (hack) {
2290             i = SSL_accept(con);
2291
2292             switch (SSL_get_error(con, i)) {
2293             case SSL_ERROR_NONE:
2294                 break;
2295             case SSL_ERROR_WANT_WRITE:
2296             case SSL_ERROR_WANT_READ:
2297             case SSL_ERROR_WANT_X509_LOOKUP:
2298                 continue;
2299             case SSL_ERROR_SYSCALL:
2300             case SSL_ERROR_SSL:
2301             case SSL_ERROR_ZERO_RETURN:
2302                 ret = 1;
2303                 goto err;
2304                 /* break; */
2305             }
2306
2307             SSL_renegotiate(con);
2308             SSL_write(con, NULL, 0);
2309         }
2310
2311         i = BIO_gets(io, buf, bufsize - 1);
2312         if (i < 0) {            /* error */
2313             if (!BIO_should_retry(io)) {
2314                 if (!s_quiet)
2315                     ERR_print_errors(bio_err);
2316                 goto err;
2317             } else {
2318                 BIO_printf(bio_s_out, "read R BLOCK\n");
2319 #if defined(OPENSSL_SYS_NETWARE)
2320                 delay(1000);
2321 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2322                 sleep(1);
2323 #endif
2324                 continue;
2325             }
2326         } else if (i == 0) {    /* end of input */
2327             ret = 1;
2328             goto end;
2329         }
2330
2331         /* else we have data */
2332         if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2333             ((www == 2) && (strncmp("GET /stats ", buf, 10) == 0))) {
2334             char *p;
2335             X509 *peer;
2336             STACK_OF(SSL_CIPHER) *sk;
2337             static const char *space = "                          ";
2338
2339             BIO_puts(io,
2340                      "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2341             BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2342             BIO_puts(io, "<pre>\n");
2343 /*                      BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2344             BIO_puts(io, "\n");
2345             for (i = 0; i < local_argc; i++) {
2346                 BIO_puts(io, local_argv[i]);
2347                 BIO_write(io, " ", 1);
2348             }
2349             BIO_puts(io, "\n");
2350
2351             /*
2352              * The following is evil and should not really be done
2353              */
2354             BIO_printf(io, "Ciphers supported in s_server binary\n");
2355             sk = SSL_get_ciphers(con);
2356             j = sk_SSL_CIPHER_num(sk);
2357             for (i = 0; i < j; i++) {
2358                 c = sk_SSL_CIPHER_value(sk, i);
2359                 BIO_printf(io, "%-11s:%-25s",
2360                            SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2361                 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2362                     BIO_puts(io, "\n");
2363             }
2364             BIO_puts(io, "\n");
2365             p = SSL_get_shared_ciphers(con, buf, bufsize);
2366             if (p != NULL) {
2367                 BIO_printf(io,
2368                            "---\nCiphers common between both SSL end points:\n");
2369                 j = i = 0;
2370                 while (*p) {
2371                     if (*p == ':') {
2372                         BIO_write(io, space, 26 - j);
2373                         i++;
2374                         j = 0;
2375                         BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2376                     } else {
2377                         BIO_write(io, p, 1);
2378                         j++;
2379                     }
2380                     p++;
2381                 }
2382                 BIO_puts(io, "\n");
2383             }
2384             BIO_printf(io, ((con->hit)
2385                             ? "---\nReused, " : "---\nNew, "));
2386             c = SSL_get_current_cipher(con);
2387             BIO_printf(io, "%s, Cipher is %s\n",
2388                        SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2389             SSL_SESSION_print(io, SSL_get_session(con));
2390             BIO_printf(io, "---\n");
2391             print_stats(io, SSL_get_SSL_CTX(con));
2392             BIO_printf(io, "---\n");
2393             peer = SSL_get_peer_certificate(con);
2394             if (peer != NULL) {
2395                 BIO_printf(io, "Client certificate\n");
2396                 X509_print(io, peer);
2397                 PEM_write_bio_X509(io, peer);
2398             } else
2399                 BIO_puts(io, "no client certificate available\n");
2400             BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2401             break;
2402         } else if ((www == 2 || www == 3)
2403                    && (strncmp("GET /", buf, 5) == 0)) {
2404             BIO *file;
2405             char *p, *e;
2406             static const char *text =
2407                 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2408
2409             /* skip the '/' */
2410             p = &(buf[5]);
2411
2412             dot = 1;
2413             for (e = p; *e != '\0'; e++) {
2414                 if (e[0] == ' ')
2415                     break;
2416
2417                 switch (dot) {
2418                 case 1:
2419                     dot = (e[0] == '.') ? 2 : 0;
2420                     break;
2421                 case 2:
2422                     dot = (e[0] == '.') ? 3 : 0;
2423                     break;
2424                 case 3:
2425                     dot = (e[0] == '/') ? -1 : 0;
2426                     break;
2427                 }
2428                 if (dot == 0)
2429                     dot = (e[0] == '/') ? 1 : 0;
2430             }
2431             dot = (dot == 3) || (dot == -1); /* filename contains ".."
2432                                               * component */
2433
2434             if (*e == '\0') {
2435                 BIO_puts(io, text);
2436                 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2437                 break;
2438             }
2439             *e = '\0';
2440
2441             if (dot) {
2442                 BIO_puts(io, text);
2443                 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
2444                 break;
2445             }
2446
2447             if (*p == '/') {
2448                 BIO_puts(io, text);
2449                 BIO_printf(io, "'%s' is an invalid path\r\n", p);
2450                 break;
2451             }
2452 #if 0
2453             /* append if a directory lookup */
2454             if (e[-1] == '/')
2455                 strcat(p, "index.html");
2456 #endif
2457
2458             /* if a directory, do the index thang */
2459             if (app_isdir(p) > 0) {
2460 #if 0                           /* must check buffer size */
2461                 strcat(p, "/index.html");
2462 #else
2463                 BIO_puts(io, text);
2464                 BIO_printf(io, "'%s' is a directory\r\n", p);
2465                 break;
2466 #endif
2467             }
2468
2469             if ((file = BIO_new_file(p, "r")) == NULL) {
2470                 BIO_puts(io, text);
2471                 BIO_printf(io, "Error opening '%s'\r\n", p);
2472                 ERR_print_errors(io);
2473                 break;
2474             }
2475
2476             if (!s_quiet)
2477                 BIO_printf(bio_err, "FILE:%s\n", p);
2478
2479             if (www == 2) {
2480                 i = strlen(p);
2481                 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
2482                     ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
2483                     ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
2484                     BIO_puts(io,
2485                              "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2486                 else
2487                     BIO_puts(io,
2488                              "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
2489             }
2490             /* send the file */
2491             for (;;) {
2492                 i = BIO_read(file, buf, bufsize);
2493                 if (i <= 0)
2494                     break;
2495
2496 #ifdef RENEG
2497                 total_bytes += i;
2498                 fprintf(stderr, "%d\n", i);
2499                 if (total_bytes > 3 * 1024) {
2500                     total_bytes = 0;
2501                     fprintf(stderr, "RENEGOTIATE\n");
2502                     SSL_renegotiate(con);
2503                 }
2504 #endif
2505
2506                 for (j = 0; j < i;) {
2507 #ifdef RENEG
2508                     {
2509                         static count = 0;
2510                         if (++count == 13) {
2511                             SSL_renegotiate(con);
2512                         }
2513                     }
2514 #endif
2515                     k = BIO_write(io, &(buf[j]), i - j);
2516                     if (k <= 0) {
2517                         if (!BIO_should_retry(io))
2518                             goto write_error;
2519                         else {
2520                             BIO_printf(bio_s_out, "rwrite W BLOCK\n");
2521                         }
2522                     } else {
2523                         j += k;
2524                     }
2525                 }
2526             }
2527  write_error:
2528             BIO_free(file);
2529             break;
2530         }
2531     }
2532
2533     for (;;) {
2534         i = (int)BIO_flush(io);
2535         if (i <= 0) {
2536             if (!BIO_should_retry(io))
2537                 break;
2538         } else
2539             break;
2540     }
2541  end:
2542 #if 1
2543     /* make sure we re-use sessions */
2544     SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2545 #else
2546     /* This kills performance */
2547     /*
2548      * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
2549      * procession
2550      */
2551 #endif
2552
2553  err:
2554
2555     if (ret >= 0)
2556         BIO_printf(bio_s_out, "ACCEPT\n");
2557
2558     if (buf != NULL)
2559         OPENSSL_free(buf);
2560     if (io != NULL)
2561         BIO_free_all(io);
2562 /*      if (ssl_bio != NULL) BIO_free(ssl_bio);*/
2563     return (ret);
2564 }
2565
2566 #ifndef OPENSSL_NO_RSA
2567 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2568 {
2569     BIGNUM *bn = NULL;
2570     static RSA *rsa_tmp = NULL;
2571
2572     if (!rsa_tmp && ((bn = BN_new()) == NULL))
2573         BIO_printf(bio_err, "Allocation error in generating RSA key\n");
2574     if (!rsa_tmp && bn) {
2575         if (!s_quiet) {
2576             BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
2577                        keylength);
2578             (void)BIO_flush(bio_err);
2579         }
2580         if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
2581             !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
2582             if (rsa_tmp)
2583                 RSA_free(rsa_tmp);
2584             rsa_tmp = NULL;
2585         }
2586         if (!s_quiet) {
2587             BIO_printf(bio_err, "\n");
2588             (void)BIO_flush(bio_err);
2589         }
2590         BN_free(bn);
2591     }
2592     return (rsa_tmp);
2593 }
2594 #endif
2595
2596 #define MAX_SESSION_ID_ATTEMPTS 10
2597 static int generate_session_id(const SSL *ssl, unsigned char *id,
2598                                unsigned int *id_len)
2599 {
2600     unsigned int count = 0;
2601     do {
2602         RAND_pseudo_bytes(id, *id_len);
2603         /*
2604          * Prefix the session_id with the required prefix. NB: If our prefix
2605          * is too long, clip it - but there will be worse effects anyway, eg.
2606          * the server could only possibly create 1 session ID (ie. the
2607          * prefix!) so all future session negotiations will fail due to
2608          * conflicts.
2609          */
2610         memcpy(id, session_id_prefix,
2611                (strlen(session_id_prefix) < *id_len) ?
2612                strlen(session_id_prefix) : *id_len);
2613     }
2614     while (SSL_has_matching_session_id(ssl, id, *id_len) &&
2615            (++count < MAX_SESSION_ID_ATTEMPTS));
2616     if (count >= MAX_SESSION_ID_ATTEMPTS)
2617         return 0;
2618     return 1;
2619 }