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 #ifndef OPENSSL_NO_SRP
 195 # include <openssl/srp.h>
 196 #endif
 197 #include "s_apps.h"
 198 #include "timeouts.h"
 199
 200 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
 201 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
 202 # undef FIONBIO
 203 #endif
 204
 205 #if defined(OPENSSL_SYS_BEOS_R5)
 206 # include <fcntl.h>
 207 #endif
 208
 209 #ifndef OPENSSL_NO_RSA
 210 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength);
 211 #endif
 212 static int sv_body(char *hostname, int s, int stype, unsigned char *context);
 213 static int www_body(char *hostname, int s, int stype, unsigned char *context);
 214 static int rev_body(char *hostname, int s, int stype, unsigned char *context);
 215 static void close_accept_socket(void);
 216 static void sv_usage(void);
 217 static int init_ssl_connection(SSL *s);
 218 static void print_stats(BIO *bp, SSL_CTX *ctx);
 219 static int generate_session_id(const SSL *ssl, unsigned char *id,
 220                                unsigned int *id_len);
 221 static void init_session_cache_ctx(SSL_CTX *sctx);
 222 static void free_sessions(void);
 223 #ifndef OPENSSL_NO_DH
 224 static DH *load_dh_param(const char *dhfile);
 225 static DH *get_dh512(void);
 226 #endif
 227
 228 #ifdef MONOLITH
 229 static void s_server_init(void);
 230 #endif
 231
 232 #ifndef OPENSSL_NO_DH
 233 static unsigned char dh512_p[] = {
 234     0xDA, 0x58, 0x3C, 0x16, 0xD9, 0x85, 0x22, 0x89, 0xD0, 0xE4, 0xAF, 0x75,
 235     0x6F, 0x4C, 0xCA, 0x92, 0xDD, 0x4B, 0xE5, 0x33, 0xB8, 0x04, 0xFB, 0x0F,
 236     0xED, 0x94, 0xEF, 0x9C, 0x8A, 0x44, 0x03, 0xED, 0x57, 0x46, 0x50, 0xD3,
 237     0x69, 0x99, 0xDB, 0x29, 0xD7, 0x76, 0x27, 0x6B, 0xA2, 0xD3, 0xD4, 0x12,
 238     0xE2, 0x18, 0xF4, 0xDD, 0x1E, 0x08, 0x4C, 0xF6, 0xD8, 0x00, 0x3E, 0x7C,
 239     0x47, 0x74, 0xE8, 0x33,
 240 };
 241
 242 static unsigned char dh512_g[] = {
 243     0x02,
 244 };
 245
 246 static DH *get_dh512(void)
 247 {
 248     DH *dh = NULL;
 249
 250     if ((dh = DH_new()) == NULL)
 251         return (NULL);
 252     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
 253     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
 254     if ((dh->p == NULL) || (dh->g == NULL))
 255         return (NULL);
 256     return (dh);
 257 }
 258 #endif
 259
 260 /* static int load_CA(SSL_CTX *ctx, char *file);*/
 261
 262 #undef BUFSIZZ
 263 #define BUFSIZZ 16*1024
 264 static int bufsize = BUFSIZZ;
 265 static int accept_socket = -1;
 266
 267 #define TEST_CERT       "server.pem"
 268 #ifndef OPENSSL_NO_TLSEXT
 269 # define TEST_CERT2      "server2.pem"
 270 #endif
 271 #undef PROG
 272 #define PROG            s_server_main
 273
 274 extern int verify_depth, verify_return_error, verify_quiet;
 275
 276 static int s_server_verify = SSL_VERIFY_NONE;
 277 static int s_server_session_id_context = 1; /* anything will do */
 278 static const char *s_cert_file = TEST_CERT, *s_key_file =
 279     NULL, *s_chain_file = NULL;
 280 #ifndef OPENSSL_NO_TLSEXT
 281 static const char *s_cert_file2 = TEST_CERT2, *s_key_file2 = NULL;
 282 #endif
 283 static char *s_dcert_file = NULL, *s_dkey_file = NULL, *s_dchain_file = NULL;
 284 #ifdef FIONBIO
 285 static int s_nbio = 0;
 286 #endif
 287 static int s_nbio_test = 0;
 288 int s_crlf = 0;
 289 static SSL_CTX *ctx = NULL;
 290 #ifndef OPENSSL_NO_TLSEXT
 291 static SSL_CTX *ctx2 = NULL;
 292 #endif
 293 static int www = 0;
 294
 295 static BIO *bio_s_out = NULL;
 296 static BIO *bio_s_msg = NULL;
 297 static int s_debug = 0;
 298 #ifndef OPENSSL_NO_TLSEXT
 299 static int s_tlsextdebug = 0;
 300 static int s_tlsextstatus = 0;
 301 static int cert_status_cb(SSL *s, void *arg);
 302 #endif
 303 static int no_resume_ephemeral = 0;
 304 static int s_msg = 0;
 305 static int s_quiet = 0;
 306 static int s_ign_eof = 0;
 307 static int s_brief = 0;
 308
 309 static char *keymatexportlabel = NULL;
 310 static int keymatexportlen = 20;
 311
 312 static int hack = 0;
 313 #ifndef OPENSSL_NO_ENGINE
 314 static char *engine_id = NULL;
 315 #endif
 316 static const char *session_id_prefix = NULL;
 317
 318 static int enable_timeouts = 0;
 319 static long socket_mtu;
 320 #ifndef OPENSSL_NO_DTLS1
 321 static int cert_chain = 0;
 322 #endif
 323
 324 #ifndef OPENSSL_NO_TLSEXT
 325 static BIO *serverinfo_in = NULL;
 326 static const char *s_serverinfo_file = NULL;
 327
 328 #endif
 329
 330 #ifndef OPENSSL_NO_PSK
 331 static char *psk_identity = "Client_identity";
 332 char *psk_key = NULL;           /* by default PSK is not used */
 333
 334 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
 335                                   unsigned char *psk,
 336                                   unsigned int max_psk_len)
 337 {
 338     unsigned int psk_len = 0;
 339     int ret;
 340     BIGNUM *bn = NULL;
 341
 342     if (s_debug)
 343         BIO_printf(bio_s_out, "psk_server_cb\n");
 344     if (!identity) {
 345         BIO_printf(bio_err, "Error: client did not send PSK identity\n");
 346         goto out_err;
 347     }
 348     if (s_debug)
 349         BIO_printf(bio_s_out, "identity_len=%d identity=%s\n",
 350                    (int)strlen(identity), identity);
 351
 352     /* here we could lookup the given identity e.g. from a database */
 353     if (strcmp(identity, psk_identity) != 0) {
 354         BIO_printf(bio_s_out, "PSK error: client identity not found"
 355                    " (got '%s' expected '%s')\n", identity, psk_identity);
 356         goto out_err;
 357     }
 358     if (s_debug)
 359         BIO_printf(bio_s_out, "PSK client identity found\n");
 360
 361     /* convert the PSK key to binary */
 362     ret = BN_hex2bn(&bn, psk_key);
 363     if (!ret) {
 364         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
 365                    psk_key);
 366         if (bn)
 367             BN_free(bn);
 368         return 0;
 369     }
 370     if (BN_num_bytes(bn) > (int)max_psk_len) {
 371         BIO_printf(bio_err,
 372                    "psk buffer of callback is too small (%d) for key (%d)\n",
 373                    max_psk_len, BN_num_bytes(bn));
 374         BN_free(bn);
 375         return 0;
 376     }
 377
 378     ret = BN_bn2bin(bn, psk);
 379     BN_free(bn);
 380
 381     if (ret < 0)
 382         goto out_err;
 383     psk_len = (unsigned int)ret;
 384
 385     if (s_debug)
 386         BIO_printf(bio_s_out, "fetched PSK len=%d\n", psk_len);
 387     return psk_len;
 388  out_err:
 389     if (s_debug)
 390         BIO_printf(bio_err, "Error in PSK server callback\n");
 391     return 0;
 392 }
 393 #endif
 394
 395 #ifndef OPENSSL_NO_SRP
 396 /* This is a context that we pass to callbacks */
 397 typedef struct srpsrvparm_st {
 398     char *login;
 399     SRP_VBASE *vb;
 400     SRP_user_pwd *user;
 401 } srpsrvparm;
 402
 403 /*
 404  * This callback pretends to require some asynchronous logic in order to
 405  * obtain a verifier. When the callback is called for a new connection we
 406  * return with a negative value. This will provoke the accept etc to return
 407  * with an LOOKUP_X509. The main logic of the reinvokes the suspended call
 408  * (which would normally occur after a worker has finished) and we set the
 409  * user parameters.
 410  */
 411 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
 412 {
 413     srpsrvparm *p = (srpsrvparm *) arg;
 414     if (p->login == NULL && p->user == NULL) {
 415         p->login = SSL_get_srp_username(s);
 416         BIO_printf(bio_err, "SRP username = \"%s\"\n", p->login);
 417         return (-1);
 418     }
 419
 420     if (p->user == NULL) {
 421         BIO_printf(bio_err, "User %s doesn't exist\n", p->login);
 422         return SSL3_AL_FATAL;
 423     }
 424     if (SSL_set_srp_server_param
 425         (s, p->user->N, p->user->g, p->user->s, p->user->v,
 426          p->user->info) < 0) {
 427         *ad = SSL_AD_INTERNAL_ERROR;
 428         return SSL3_AL_FATAL;
 429     }
 430     BIO_printf(bio_err,
 431                "SRP parameters set: username = \"%s\" info=\"%s\" \n",
 432                p->login, p->user->info);
 433     /* need to check whether there are memory leaks */
 434     p->user = NULL;
 435     p->login = NULL;
 436     return SSL_ERROR_NONE;
 437 }
 438
 439 #endif
 440
 441 #ifdef MONOLITH
 442 static void s_server_init(void)
 443 {
 444     accept_socket = -1;
 445     s_server_verify = SSL_VERIFY_NONE;
 446     s_dcert_file = NULL;
 447     s_dkey_file = NULL;
 448     s_dchain_file = NULL;
 449     s_cert_file = TEST_CERT;
 450     s_key_file = NULL;
 451     s_chain_file = NULL;
 452 # ifndef OPENSSL_NO_TLSEXT
 453     s_cert_file2 = TEST_CERT2;
 454     s_key_file2 = NULL;
 455     ctx2 = NULL;
 456 # endif
 457 # ifdef FIONBIO
 458     s_nbio = 0;
 459 # endif
 460     s_nbio_test = 0;
 461     ctx = NULL;
 462     www = 0;
 463
 464     bio_s_out = NULL;
 465     s_debug = 0;
 466     s_msg = 0;
 467     s_quiet = 0;
 468     s_brief = 0;
 469     hack = 0;
 470 # ifndef OPENSSL_NO_ENGINE
 471     engine_id = NULL;
 472 # endif
 473 }
 474 #endif
 475
 476 static void sv_usage(void)
 477 {
 478     BIO_printf(bio_err, "usage: s_server [args ...]\n");
 479     BIO_printf(bio_err, "\n");
 480     BIO_printf(bio_err,
 481                " -accept arg   - port to accept on (default is %d)\n", PORT);
 482     BIO_printf(bio_err,
 483                " -verify_host host - check peer certificate matches \"host\"\n");
 484     BIO_printf(bio_err,
 485                " -verify_email email - check peer certificate matches \"email\"\n");
 486     BIO_printf(bio_err,
 487                " -verify_ip ipaddr - check peer certificate matches \"ipaddr\"\n");
 488     BIO_printf(bio_err, " -context arg  - set session ID context\n");
 489     BIO_printf(bio_err,
 490                " -verify arg   - turn on peer certificate verification\n");
 491     BIO_printf(bio_err,
 492                " -Verify arg   - turn on peer certificate verification, must have a cert.\n");
 493     BIO_printf(bio_err,
 494                " -verify_return_error - return verification errors\n");
 495     BIO_printf(bio_err, " -cert arg     - certificate file to use\n");
 496     BIO_printf(bio_err, "                 (default is %s)\n", TEST_CERT);
 497 #ifndef OPENSSL_NO_TLSEXT
 498     BIO_printf(bio_err,
 499                " -serverinfo arg - PEM serverinfo file for certificate\n");
 500     BIO_printf(bio_err,
 501                " -auth               - send and receive RFC 5878 TLS auth extensions and supplemental data\n");
 502     BIO_printf(bio_err,
 503                " -auth_require_reneg - Do not send TLS auth extensions until renegotiation\n");
 504 #endif
 505     BIO_printf(bio_err,
 506                " -no_resumption_on_reneg - set SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION flag\n");
 507     BIO_printf(bio_err,
 508                " -crl_check    - check the peer certificate has not been revoked by its CA.\n"
 509                "                 The CRL(s) are appended to the certificate file\n");
 510     BIO_printf(bio_err,
 511                " -crl_check_all - check the peer certificate has not been revoked by its CA\n"
 512                "                 or any other CRL in the CA chain. CRL(s) are appened to the\n"
 513                "                 the certificate file.\n");
 514     BIO_printf(bio_err,
 515                " -certform arg - certificate format (PEM or DER) PEM default\n");
 516     BIO_printf(bio_err,
 517                " -key arg      - Private Key file to use, in cert file if\n");
 518     BIO_printf(bio_err, "                 not specified (default is %s)\n",
 519                TEST_CERT);
 520     BIO_printf(bio_err,
 521                " -keyform arg  - key format (PEM, DER or ENGINE) PEM default\n");
 522     BIO_printf(bio_err,
 523                " -pass arg     - private key file pass phrase source\n");
 524     BIO_printf(bio_err,
 525                " -dcert arg    - second certificate file to use (usually for DSA)\n");
 526     BIO_printf(bio_err,
 527                " -dcertform x  - second certificate format (PEM or DER) PEM default\n");
 528     BIO_printf(bio_err,
 529                " -dkey arg     - second private key file to use (usually for DSA)\n");
 530     BIO_printf(bio_err,
 531                " -dkeyform arg - second key format (PEM, DER or ENGINE) PEM default\n");
 532     BIO_printf(bio_err,
 533                " -dpass arg    - second private key file pass phrase source\n");
 534     BIO_printf(bio_err,
 535                " -dhparam arg  - DH parameter file to use, in cert file if not specified\n");
 536     BIO_printf(bio_err,
 537                "                 or a default set of parameters is used\n");
 538 #ifndef OPENSSL_NO_ECDH
 539     BIO_printf(bio_err,
 540                " -named_curve arg  - Elliptic curve name to use for ephemeral ECDH keys.\n"
 541                "                 Use \"openssl ecparam -list_curves\" for all names\n"
 542                "                 (default is nistp256).\n");
 543 #endif
 544 #ifdef FIONBIO
 545     BIO_printf(bio_err, " -nbio         - Run with non-blocking IO\n");
 546 #endif
 547     BIO_printf(bio_err,
 548                " -nbio_test    - test with the non-blocking test bio\n");
 549     BIO_printf(bio_err,
 550                " -crlf         - convert LF from terminal into CRLF\n");
 551     BIO_printf(bio_err, " -debug        - Print more output\n");
 552     BIO_printf(bio_err, " -msg          - Show protocol messages\n");
 553     BIO_printf(bio_err, " -state        - Print the SSL states\n");
 554     BIO_printf(bio_err, " -CApath arg   - PEM format directory of CA's\n");
 555     BIO_printf(bio_err, " -CAfile arg   - PEM format file of CA's\n");
 556     BIO_printf(bio_err,
 557                " -no_alt_chains - only ever use the first certificate chain found\n");
 558     BIO_printf(bio_err,
 559                " -nocert       - Don't use any certificates (Anon-DH)\n");
 560     BIO_printf(bio_err,
 561                " -cipher arg   - play with 'openssl ciphers' to see what goes here\n");
 562     BIO_printf(bio_err, " -serverpref   - Use server's cipher preferences\n");
 563     BIO_printf(bio_err, " -quiet        - No server output\n");
 564     BIO_printf(bio_err, " -no_tmp_rsa   - Do not generate a tmp RSA key\n");
 565 #ifndef OPENSSL_NO_PSK
 566     BIO_printf(bio_err, " -psk_hint arg - PSK identity hint to use\n");
 567     BIO_printf(bio_err, " -psk arg      - PSK in hex (without 0x)\n");
 568 # ifndef OPENSSL_NO_JPAKE
 569     BIO_printf(bio_err, " -jpake arg    - JPAKE secret to use\n");
 570 # endif
 571 #endif
 572 #ifndef OPENSSL_NO_SRP
 573     BIO_printf(bio_err, " -srpvfile file      - The verifier file for SRP\n");
 574     BIO_printf(bio_err,
 575                " -srpuserseed string - A seed string for a default user salt.\n");
 576 #endif
 577     BIO_printf(bio_err, " -ssl2         - Just talk SSLv2\n");
 578 #ifndef OPENSSL_NO_SSL3_METHOD
 579     BIO_printf(bio_err, " -ssl3         - Just talk SSLv3\n");
 580 #endif
 581     BIO_printf(bio_err, " -tls1_2       - Just talk TLSv1.2\n");
 582     BIO_printf(bio_err, " -tls1_1       - Just talk TLSv1.1\n");
 583     BIO_printf(bio_err, " -tls1         - Just talk TLSv1\n");
 584     BIO_printf(bio_err, " -dtls1        - Just talk DTLSv1\n");
 585     BIO_printf(bio_err, " -dtls1_2      - Just talk DTLSv1.2\n");
 586     BIO_printf(bio_err, " -timeout      - Enable timeouts\n");
 587     BIO_printf(bio_err, " -mtu          - Set link layer MTU\n");
 588     BIO_printf(bio_err, " -chain        - Read a certificate chain\n");
 589     BIO_printf(bio_err, " -no_ssl2      - Just disable SSLv2\n");
 590     BIO_printf(bio_err, " -no_ssl3      - Just disable SSLv3\n");
 591     BIO_printf(bio_err, " -no_tls1      - Just disable TLSv1\n");
 592     BIO_printf(bio_err, " -no_tls1_1    - Just disable TLSv1.1\n");
 593     BIO_printf(bio_err, " -no_tls1_2    - Just disable TLSv1.2\n");
 594 #ifndef OPENSSL_NO_DH
 595     BIO_printf(bio_err, " -no_dhe       - Disable ephemeral DH\n");
 596 #endif
 597 #ifndef OPENSSL_NO_ECDH
 598     BIO_printf(bio_err, " -no_ecdhe     - Disable ephemeral ECDH\n");
 599 #endif
 600     BIO_printf(bio_err, " -bugs         - Turn on SSL bug compatibility\n");
 601     BIO_printf(bio_err,
 602                " -hack         - workaround for early Netscape code\n");
 603     BIO_printf(bio_err,
 604                " -www          - Respond to a 'GET /' with a status page\n");
 605     BIO_printf(bio_err,
 606                " -WWW          - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
 607     BIO_printf(bio_err,
 608                " -HTTP         - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
 609     BIO_printf(bio_err,
 610                "                 with the assumption it contains a complete HTTP response.\n");
 611 #ifndef OPENSSL_NO_ENGINE
 612     BIO_printf(bio_err,
 613                " -engine id    - Initialise and use the specified engine\n");
 614 #endif
 615     BIO_printf(bio_err,
 616                " -id_prefix arg - Generate SSL/TLS session IDs prefixed by 'arg'\n");
 617     BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
 618                LIST_SEPARATOR_CHAR);
 619 #ifndef OPENSSL_NO_TLSEXT
 620     BIO_printf(bio_err,
 621                " -servername host - servername for HostName TLS extension\n");
 622     BIO_printf(bio_err,
 623                " -servername_fatal - on mismatch send fatal alert (default warning alert)\n");
 624     BIO_printf(bio_err,
 625                " -cert2 arg    - certificate file to use for servername\n");
 626     BIO_printf(bio_err, "                 (default is %s)\n", TEST_CERT2);
 627     BIO_printf(bio_err,
 628                " -key2 arg     - Private Key file to use for servername, in cert file if\n");
 629     BIO_printf(bio_err, "                 not specified (default is %s)\n",
 630                TEST_CERT2);
 631     BIO_printf(bio_err,
 632                " -tlsextdebug  - hex dump of all TLS extensions received\n");
 633     BIO_printf(bio_err,
 634                " -no_ticket    - disable use of RFC4507bis session tickets\n");
 635     BIO_printf(bio_err,
 636                " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 637 # ifndef OPENSSL_NO_NEXTPROTONEG
 638     BIO_printf(bio_err,
 639                " -nextprotoneg arg - set the advertised protocols for the NPN extension (comma-separated list)\n");
 640 # endif
 641 # ifndef OPENSSL_NO_SRTP
 642     BIO_printf(bio_err,
 643                " -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
 644 # endif
 645     BIO_printf(bio_err,
 646                " -alpn arg  - set the advertised protocols for the ALPN extension (comma-separated list)\n");
 647 #endif
 648     BIO_printf(bio_err,
 649                " -keymatexport label   - Export keying material using label\n");
 650     BIO_printf(bio_err,
 651                " -keymatexportlen len  - Export len bytes of keying material (default 20)\n");
 652     BIO_printf(bio_err,
 653                " -status           - respond to certificate status requests\n");
 654     BIO_printf(bio_err,
 655                " -status_verbose   - enable status request verbose printout\n");
 656     BIO_printf(bio_err,
 657                " -status_timeout n - status request responder timeout\n");
 658     BIO_printf(bio_err, " -status_url URL   - status request fallback URL\n");
 659 }
 660
 661 static int local_argc = 0;
 662 static char **local_argv;
 663
 664 #ifdef CHARSET_EBCDIC
 665 static int ebcdic_new(BIO *bi);
 666 static int ebcdic_free(BIO *a);
 667 static int ebcdic_read(BIO *b, char *out, int outl);
 668 static int ebcdic_write(BIO *b, const char *in, int inl);
 669 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr);
 670 static int ebcdic_gets(BIO *bp, char *buf, int size);
 671 static int ebcdic_puts(BIO *bp, const char *str);
 672
 673 # define BIO_TYPE_EBCDIC_FILTER  (18|0x0200)
 674 static BIO_METHOD methods_ebcdic = {
 675     BIO_TYPE_EBCDIC_FILTER,
 676     "EBCDIC/ASCII filter",
 677     ebcdic_write,
 678     ebcdic_read,
 679     ebcdic_puts,
 680     ebcdic_gets,
 681     ebcdic_ctrl,
 682     ebcdic_new,
 683     ebcdic_free,
 684 };
 685
 686 typedef struct {
 687     size_t alloced;
 688     char buff[1];
 689 } EBCDIC_OUTBUFF;
 690
 691 BIO_METHOD *BIO_f_ebcdic_filter()
 692 {
 693     return (&methods_ebcdic);
 694 }
 695
 696 static int ebcdic_new(BIO *bi)
 697 {
 698     EBCDIC_OUTBUFF *wbuf;
 699
 700     wbuf = (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
 701     if (!wbuf)
 702         return 0;
 703     wbuf->alloced = 1024;
 704     wbuf->buff[0] = '\0';
 705
 706     bi->ptr = (char *)wbuf;
 707     bi->init = 1;
 708     bi->flags = 0;
 709     return (1);
 710 }
 711
 712 static int ebcdic_free(BIO *a)
 713 {
 714     if (a == NULL)
 715         return (0);
 716     if (a->ptr != NULL)
 717         OPENSSL_free(a->ptr);
 718     a->ptr = NULL;
 719     a->init = 0;
 720     a->flags = 0;
 721     return (1);
 722 }
 723
 724 static int ebcdic_read(BIO *b, char *out, int outl)
 725 {
 726     int ret = 0;
 727
 728     if (out == NULL || outl == 0)
 729         return (0);
 730     if (b->next_bio == NULL)
 731         return (0);
 732
 733     ret = BIO_read(b->next_bio, out, outl);
 734     if (ret > 0)
 735         ascii2ebcdic(out, out, ret);
 736     return (ret);
 737 }
 738
 739 static int ebcdic_write(BIO *b, const char *in, int inl)
 740 {
 741     EBCDIC_OUTBUFF *wbuf;
 742     int ret = 0;
 743     int num;
 744     unsigned char n;
 745
 746     if ((in == NULL) || (inl <= 0))
 747         return (0);
 748     if (b->next_bio == NULL)
 749         return (0);
 750
 751     wbuf = (EBCDIC_OUTBUFF *) b->ptr;
 752
 753     if (inl > (num = wbuf->alloced)) {
 754         num = num + num;        /* double the size */
 755         if (num < inl)
 756             num = inl;
 757         wbuf =
 758             (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
 759         if (!wbuf)
 760             return 0;
 761         OPENSSL_free(b->ptr);
 762
 763         wbuf->alloced = num;
 764         wbuf->buff[0] = '\0';
 765
 766         b->ptr = (char *)wbuf;
 767     }
 768
 769     ebcdic2ascii(wbuf->buff, in, inl);
 770
 771     ret = BIO_write(b->next_bio, wbuf->buff, inl);
 772
 773     return (ret);
 774 }
 775
 776 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)
 777 {
 778     long ret;
 779
 780     if (b->next_bio == NULL)
 781         return (0);
 782     switch (cmd) {
 783     case BIO_CTRL_DUP:
 784         ret = 0L;
 785         break;
 786     default:
 787         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
 788         break;
 789     }
 790     return (ret);
 791 }
 792
 793 static int ebcdic_gets(BIO *bp, char *buf, int size)
 794 {
 795     int i, ret = 0;
 796     if (bp->next_bio == NULL)
 797         return (0);
 798 /*      return(BIO_gets(bp->next_bio,buf,size));*/
 799     for (i = 0; i < size - 1; ++i) {
 800         ret = ebcdic_read(bp, &buf[i], 1);
 801         if (ret <= 0)
 802             break;
 803         else if (buf[i] == '\n') {
 804             ++i;
 805             break;
 806         }
 807     }
 808     if (i < size)
 809         buf[i] = '\0';
 810     return (ret < 0 && i == 0) ? ret : i;
 811 }
 812
 813 static int ebcdic_puts(BIO *bp, const char *str)
 814 {
 815     if (bp->next_bio == NULL)
 816         return (0);
 817     return ebcdic_write(bp, str, strlen(str));
 818 }
 819 #endif
 820
 821 #ifndef OPENSSL_NO_TLSEXT
 822
 823 /* This is a context that we pass to callbacks */
 824 typedef struct tlsextctx_st {
 825     char *servername;
 826     BIO *biodebug;
 827     int extension_error;
 828 } tlsextctx;
 829
 830 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
 831 {
 832     tlsextctx *p = (tlsextctx *) arg;
 833     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 834     if (servername && p->biodebug)
 835         BIO_printf(p->biodebug, "Hostname in TLS extension: \"%s\"\n",
 836                    servername);
 837
 838     if (!p->servername)
 839         return SSL_TLSEXT_ERR_NOACK;
 840
 841     if (servername) {
 842         if (strcasecmp(servername, p->servername))
 843             return p->extension_error;
 844         if (ctx2) {
 845             BIO_printf(p->biodebug, "Switching server context.\n");
 846             SSL_set_SSL_CTX(s, ctx2);
 847         }
 848     }
 849     return SSL_TLSEXT_ERR_OK;
 850 }
 851
 852 /* Structure passed to cert status callback */
 853
 854 typedef struct tlsextstatusctx_st {
 855     /* Default responder to use */
 856     char *host, *path, *port;
 857     int use_ssl;
 858     int timeout;
 859     BIO *err;
 860     int verbose;
 861 } tlsextstatusctx;
 862
 863 static tlsextstatusctx tlscstatp = { NULL, NULL, NULL, 0, -1, NULL, 0 };
 864
 865 /*
 866  * Certificate Status callback. This is called when a client includes a
 867  * certificate status request extension. This is a simplified version. It
 868  * examines certificates each time and makes one OCSP responder query for
 869  * each request. A full version would store details such as the OCSP
 870  * certificate IDs and minimise the number of OCSP responses by caching them
 871  * until they were considered "expired".
 872  */
 873
 874 static int cert_status_cb(SSL *s, void *arg)
 875 {
 876     tlsextstatusctx *srctx = arg;
 877     BIO *err = srctx->err;
 878     char *host, *port, *path;
 879     int use_ssl;
 880     unsigned char *rspder = NULL;
 881     int rspderlen;
 882     STACK_OF(OPENSSL_STRING) *aia = NULL;
 883     X509 *x = NULL;
 884     X509_STORE_CTX inctx;
 885     X509_OBJECT obj;
 886     OCSP_REQUEST *req = NULL;
 887     OCSP_RESPONSE *resp = NULL;
 888     OCSP_CERTID *id = NULL;
 889     STACK_OF(X509_EXTENSION) *exts;
 890     int ret = SSL_TLSEXT_ERR_NOACK;
 891     int i;
 892 # if 0
 893     STACK_OF(OCSP_RESPID) *ids;
 894     SSL_get_tlsext_status_ids(s, &ids);
 895     BIO_printf(err, "cert_status: received %d ids\n",
 896                sk_OCSP_RESPID_num(ids));
 897 # endif
 898     if (srctx->verbose)
 899         BIO_puts(err, "cert_status: callback called\n");
 900     /* Build up OCSP query from server certificate */
 901     x = SSL_get_certificate(s);
 902     aia = X509_get1_ocsp(x);
 903     if (aia) {
 904         if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
 905                             &host, &port, &path, &use_ssl)) {
 906             BIO_puts(err, "cert_status: can't parse AIA URL\n");
 907             goto err;
 908         }
 909         if (srctx->verbose)
 910             BIO_printf(err, "cert_status: AIA URL: %s\n",
 911                        sk_OPENSSL_STRING_value(aia, 0));
 912     } else {
 913         if (!srctx->host) {
 914             BIO_puts(srctx->err,
 915                      "cert_status: no AIA and no default responder URL\n");
 916             goto done;
 917         }
 918         host = srctx->host;
 919         path = srctx->path;
 920         port = srctx->port;
 921         use_ssl = srctx->use_ssl;
 922     }
 923
 924     if (!X509_STORE_CTX_init(&inctx,
 925                              SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),
 926                              NULL, NULL))
 927         goto err;
 928     if (X509_STORE_get_by_subject(&inctx, X509_LU_X509,
 929                                   X509_get_issuer_name(x), &obj) <= 0) {
 930         BIO_puts(err, "cert_status: Can't retrieve issuer certificate.\n");
 931         X509_STORE_CTX_cleanup(&inctx);
 932         goto done;
 933     }
 934     req = OCSP_REQUEST_new();
 935     if (!req)
 936         goto err;
 937     id = OCSP_cert_to_id(NULL, x, obj.data.x509);
 938     X509_free(obj.data.x509);
 939     X509_STORE_CTX_cleanup(&inctx);
 940     if (!id)
 941         goto err;
 942     if (!OCSP_request_add0_id(req, id))
 943         goto err;
 944     id = NULL;
 945     /* Add any extensions to the request */
 946     SSL_get_tlsext_status_exts(s, &exts);
 947     for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
 948         X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
 949         if (!OCSP_REQUEST_add_ext(req, ext, -1))
 950             goto err;
 951     }
 952     resp = process_responder(err, req, host, path, port, use_ssl, NULL,
 953                              srctx->timeout);
 954     if (!resp) {
 955         BIO_puts(err, "cert_status: error querying responder\n");
 956         goto done;
 957     }
 958     rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);
 959     if (rspderlen <= 0)
 960         goto err;
 961     SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);
 962     if (srctx->verbose) {
 963         BIO_puts(err, "cert_status: ocsp response sent:\n");
 964         OCSP_RESPONSE_print(err, resp, 2);
 965     }
 966     ret = SSL_TLSEXT_ERR_OK;
 967  done:
 968     if (ret != SSL_TLSEXT_ERR_OK)
 969         ERR_print_errors(err);
 970     if (aia) {
 971         OPENSSL_free(host);
 972         OPENSSL_free(path);
 973         OPENSSL_free(port);
 974         X509_email_free(aia);
 975     }
 976     if (id)
 977         OCSP_CERTID_free(id);
 978     if (req)
 979         OCSP_REQUEST_free(req);
 980     if (resp)
 981         OCSP_RESPONSE_free(resp);
 982     return ret;
 983  err:
 984     ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 985     goto done;
 986 }
 987
 988 # ifndef OPENSSL_NO_NEXTPROTONEG
 989 /* This is the context that we pass to next_proto_cb */
 990 typedef struct tlsextnextprotoctx_st {
 991     unsigned char *data;
 992     unsigned int len;
 993 } tlsextnextprotoctx;
 994
 995 static int next_proto_cb(SSL *s, const unsigned char **data,
 996                          unsigned int *len, void *arg)
 997 {
 998     tlsextnextprotoctx *next_proto = arg;
 999
1000     *data = next_proto->data;
1001     *len = next_proto->len;
1002
1003     return SSL_TLSEXT_ERR_OK;
1004 }
1005 # endif                         /* ndef OPENSSL_NO_NEXTPROTONEG */
1006
1007 /* This the context that we pass to alpn_cb */
1008 typedef struct tlsextalpnctx_st {
1009     unsigned char *data;
1010     unsigned short len;
1011 } tlsextalpnctx;
1012
1013 static int alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,
1014                    const unsigned char *in, unsigned int inlen, void *arg)
1015 {
1016     tlsextalpnctx *alpn_ctx = arg;
1017
1018     if (!s_quiet) {
1019         /* We can assume that |in| is syntactically valid. */
1020         unsigned i;
1021         BIO_printf(bio_s_out, "ALPN protocols advertised by the client: ");
1022         for (i = 0; i < inlen;) {
1023             if (i)
1024                 BIO_write(bio_s_out, ", ", 2);
1025             BIO_write(bio_s_out, &in[i + 1], in[i]);
1026             i += in[i] + 1;
1027         }
1028         BIO_write(bio_s_out, "\n", 1);
1029     }
1030
1031     if (SSL_select_next_proto
1032         ((unsigned char **)out, outlen, alpn_ctx->data, alpn_ctx->len, in,
1033          inlen) != OPENSSL_NPN_NEGOTIATED) {
1034         return SSL_TLSEXT_ERR_NOACK;
1035     }
1036
1037     if (!s_quiet) {
1038         BIO_printf(bio_s_out, "ALPN protocols selected: ");
1039         BIO_write(bio_s_out, *out, *outlen);
1040         BIO_write(bio_s_out, "\n", 1);
1041     }
1042
1043     return SSL_TLSEXT_ERR_OK;
1044 }
1045 #endif                          /* ndef OPENSSL_NO_TLSEXT */
1046
1047 int MAIN(int, char **);
1048
1049 #ifndef OPENSSL_NO_JPAKE
1050 static char *jpake_secret = NULL;
1051 # define no_jpake !jpake_secret
1052 #else
1053 # define no_jpake 1
1054 #endif
1055 #ifndef OPENSSL_NO_SRP
1056 static srpsrvparm srp_callback_parm;
1057 #endif
1058 #ifndef OPENSSL_NO_SRTP
1059 static char *srtp_profiles = NULL;
1060 #endif
1061
1062 int MAIN(int argc, char *argv[])
1063 {
1064     X509_VERIFY_PARAM *vpm = NULL;
1065     int badarg = 0;
1066     short port = PORT;
1067     char *CApath = NULL, *CAfile = NULL;
1068     char *chCApath = NULL, *chCAfile = NULL;
1069     char *vfyCApath = NULL, *vfyCAfile = NULL;
1070     unsigned char *context = NULL;
1071     char *dhfile = NULL;
1072     int badop = 0;
1073     int ret = 1;
1074     int build_chain = 0;
1075     int no_tmp_rsa = 0, no_dhe = 0, no_ecdhe = 0, nocert = 0;
1076     int state = 0;
1077     const SSL_METHOD *meth = NULL;
1078     int socket_type = SOCK_STREAM;
1079     ENGINE *e = NULL;
1080     char *inrand = NULL;
1081     int s_cert_format = FORMAT_PEM, s_key_format = FORMAT_PEM;
1082     char *passarg = NULL, *pass = NULL;
1083     char *dpassarg = NULL, *dpass = NULL;
1084     int s_dcert_format = FORMAT_PEM, s_dkey_format = FORMAT_PEM;
1085     X509 *s_cert = NULL, *s_dcert = NULL;
1086     STACK_OF(X509) *s_chain = NULL, *s_dchain = NULL;
1087     EVP_PKEY *s_key = NULL, *s_dkey = NULL;
1088     int no_cache = 0, ext_cache = 0;
1089     int rev = 0, naccept = -1;
1090 #ifndef OPENSSL_NO_TLSEXT
1091     EVP_PKEY *s_key2 = NULL;
1092     X509 *s_cert2 = NULL;
1093     tlsextctx tlsextcbp = { NULL, NULL, SSL_TLSEXT_ERR_ALERT_WARNING };
1094 # ifndef OPENSSL_NO_NEXTPROTONEG
1095     const char *next_proto_neg_in = NULL;
1096     tlsextnextprotoctx next_proto = { NULL, 0 };
1097 # endif
1098     const char *alpn_in = NULL;
1099     tlsextalpnctx alpn_ctx = { NULL, 0 };
1100 #endif
1101 #ifndef OPENSSL_NO_PSK
1102     /* by default do not send a PSK identity hint */
1103     static char *psk_identity_hint = NULL;
1104 #endif
1105 #ifndef OPENSSL_NO_SRP
1106     char *srpuserseed = NULL;
1107     char *srp_verifier_file = NULL;
1108 #endif
1109     SSL_EXCERT *exc = NULL;
1110     SSL_CONF_CTX *cctx = NULL;
1111     STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
1112
1113     char *crl_file = NULL;
1114     int crl_format = FORMAT_PEM;
1115     int crl_download = 0;
1116     STACK_OF(X509_CRL) *crls = NULL;
1117
1118     meth = SSLv23_server_method();
1119
1120     local_argc = argc;
1121     local_argv = argv;
1122
1123     apps_startup();
1124 #ifdef MONOLITH
1125     s_server_init();
1126 #endif
1127
1128     if (bio_err == NULL)
1129         bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
1130
1131     if (!load_config(bio_err, NULL))
1132         goto end;
1133
1134     cctx = SSL_CONF_CTX_new();
1135     if (!cctx)
1136         goto end;
1137     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
1138     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
1139
1140     verify_depth = 0;
1141 #ifdef FIONBIO
1142     s_nbio = 0;
1143 #endif
1144     s_nbio_test = 0;
1145
1146     argc--;
1147     argv++;
1148
1149     while (argc >= 1) {
1150         if ((strcmp(*argv, "-port") == 0) || (strcmp(*argv, "-accept") == 0)) {
1151             if (--argc < 1)
1152                 goto bad;
1153             if (!extract_port(*(++argv), &port))
1154                 goto bad;
1155         } else if (strcmp(*argv, "-naccept") == 0) {
1156             if (--argc < 1)
1157                 goto bad;
1158             naccept = atol(*(++argv));
1159             if (naccept <= 0) {
1160                 BIO_printf(bio_err, "bad accept value %s\n", *argv);
1161                 goto bad;
1162             }
1163         } else if (strcmp(*argv, "-verify") == 0) {
1164             s_server_verify = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE;
1165             if (--argc < 1)
1166                 goto bad;
1167             verify_depth = atoi(*(++argv));
1168             if (!s_quiet)
1169                 BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
1170         } else if (strcmp(*argv, "-Verify") == 0) {
1171             s_server_verify =
1172                 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1173                 SSL_VERIFY_CLIENT_ONCE;
1174             if (--argc < 1)
1175                 goto bad;
1176             verify_depth = atoi(*(++argv));
1177             if (!s_quiet)
1178                 BIO_printf(bio_err,
1179                            "verify depth is %d, must return a certificate\n",
1180                            verify_depth);
1181         } else if (strcmp(*argv, "-context") == 0) {
1182             if (--argc < 1)
1183                 goto bad;
1184             context = (unsigned char *)*(++argv);
1185         } else if (strcmp(*argv, "-cert") == 0) {
1186             if (--argc < 1)
1187                 goto bad;
1188             s_cert_file = *(++argv);
1189         } else if (strcmp(*argv, "-CRL") == 0) {
1190             if (--argc < 1)
1191                 goto bad;
1192             crl_file = *(++argv);
1193         } else if (strcmp(*argv, "-crl_download") == 0)
1194             crl_download = 1;
1195 #ifndef OPENSSL_NO_TLSEXT
1196         else if (strcmp(*argv, "-serverinfo") == 0) {
1197             if (--argc < 1)
1198                 goto bad;
1199             s_serverinfo_file = *(++argv);
1200         }
1201 #endif
1202         else if (strcmp(*argv, "-certform") == 0) {
1203             if (--argc < 1)
1204                 goto bad;
1205             s_cert_format = str2fmt(*(++argv));
1206         } else if (strcmp(*argv, "-key") == 0) {
1207             if (--argc < 1)
1208                 goto bad;
1209             s_key_file = *(++argv);
1210         } else if (strcmp(*argv, "-keyform") == 0) {
1211             if (--argc < 1)
1212                 goto bad;
1213             s_key_format = str2fmt(*(++argv));
1214         } else if (strcmp(*argv, "-pass") == 0) {
1215             if (--argc < 1)
1216                 goto bad;
1217             passarg = *(++argv);
1218         } else if (strcmp(*argv, "-cert_chain") == 0) {
1219             if (--argc < 1)
1220                 goto bad;
1221             s_chain_file = *(++argv);
1222         } else if (strcmp(*argv, "-dhparam") == 0) {
1223             if (--argc < 1)
1224                 goto bad;
1225             dhfile = *(++argv);
1226         } else if (strcmp(*argv, "-dcertform") == 0) {
1227             if (--argc < 1)
1228                 goto bad;
1229             s_dcert_format = str2fmt(*(++argv));
1230         } else if (strcmp(*argv, "-dcert") == 0) {
1231             if (--argc < 1)
1232                 goto bad;
1233             s_dcert_file = *(++argv);
1234         } else if (strcmp(*argv, "-dkeyform") == 0) {
1235             if (--argc < 1)
1236                 goto bad;
1237             s_dkey_format = str2fmt(*(++argv));
1238         } else if (strcmp(*argv, "-dpass") == 0) {
1239             if (--argc < 1)
1240                 goto bad;
1241             dpassarg = *(++argv);
1242         } else if (strcmp(*argv, "-dkey") == 0) {
1243             if (--argc < 1)
1244                 goto bad;
1245             s_dkey_file = *(++argv);
1246         } else if (strcmp(*argv, "-dcert_chain") == 0) {
1247             if (--argc < 1)
1248                 goto bad;
1249             s_dchain_file = *(++argv);
1250         } else if (strcmp(*argv, "-nocert") == 0) {
1251             nocert = 1;
1252         } else if (strcmp(*argv, "-CApath") == 0) {
1253             if (--argc < 1)
1254                 goto bad;
1255             CApath = *(++argv);
1256         } else if (strcmp(*argv, "-chainCApath") == 0) {
1257             if (--argc < 1)
1258                 goto bad;
1259             chCApath = *(++argv);
1260         } else if (strcmp(*argv, "-verifyCApath") == 0) {
1261             if (--argc < 1)
1262                 goto bad;
1263             vfyCApath = *(++argv);
1264         } else if (strcmp(*argv, "-no_cache") == 0)
1265             no_cache = 1;
1266         else if (strcmp(*argv, "-ext_cache") == 0)
1267             ext_cache = 1;
1268         else if (strcmp(*argv, "-CRLform") == 0) {
1269             if (--argc < 1)
1270                 goto bad;
1271             crl_format = str2fmt(*(++argv));
1272         } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
1273             if (badarg)
1274                 goto bad;
1275             continue;
1276         } else if (args_excert(&argv, &argc, &badarg, bio_err, &exc)) {
1277             if (badarg)
1278                 goto bad;
1279             continue;
1280         } else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args)) {
1281             if (badarg)
1282                 goto bad;
1283             continue;
1284         } else if (strcmp(*argv, "-verify_return_error") == 0)
1285             verify_return_error = 1;
1286         else if (strcmp(*argv, "-verify_quiet") == 0)
1287             verify_quiet = 1;
1288         else if (strcmp(*argv, "-build_chain") == 0)
1289             build_chain = 1;
1290         else if (strcmp(*argv, "-CAfile") == 0) {
1291             if (--argc < 1)
1292                 goto bad;
1293             CAfile = *(++argv);
1294         } else if (strcmp(*argv, "-chainCAfile") == 0) {
1295             if (--argc < 1)
1296                 goto bad;
1297             chCAfile = *(++argv);
1298         } else if (strcmp(*argv, "-verifyCAfile") == 0) {
1299             if (--argc < 1)
1300                 goto bad;
1301             vfyCAfile = *(++argv);
1302         }
1303 #ifdef FIONBIO
1304         else if (strcmp(*argv, "-nbio") == 0) {
1305             s_nbio = 1;
1306         }
1307 #endif
1308         else if (strcmp(*argv, "-nbio_test") == 0) {
1309 #ifdef FIONBIO
1310             s_nbio = 1;
1311 #endif
1312             s_nbio_test = 1;
1313         } else if (strcmp(*argv, "-ign_eof") == 0)
1314             s_ign_eof = 1;
1315         else if (strcmp(*argv, "-no_ign_eof") == 0)
1316             s_ign_eof = 0;
1317         else if (strcmp(*argv, "-debug") == 0) {
1318             s_debug = 1;
1319         }
1320 #ifndef OPENSSL_NO_TLSEXT
1321         else if (strcmp(*argv, "-tlsextdebug") == 0)
1322             s_tlsextdebug = 1;
1323         else if (strcmp(*argv, "-status") == 0)
1324             s_tlsextstatus = 1;
1325         else if (strcmp(*argv, "-status_verbose") == 0) {
1326             s_tlsextstatus = 1;
1327             tlscstatp.verbose = 1;
1328         } else if (!strcmp(*argv, "-status_timeout")) {
1329             s_tlsextstatus = 1;
1330             if (--argc < 1)
1331                 goto bad;
1332             tlscstatp.timeout = atoi(*(++argv));
1333         } else if (!strcmp(*argv, "-status_url")) {
1334             s_tlsextstatus = 1;
1335             if (--argc < 1)
1336                 goto bad;
1337             if (!OCSP_parse_url(*(++argv),
1338                                 &tlscstatp.host,
1339                                 &tlscstatp.port,
1340                                 &tlscstatp.path, &tlscstatp.use_ssl)) {
1341                 BIO_printf(bio_err, "Error parsing URL\n");
1342                 goto bad;
1343             }
1344         }
1345 #endif
1346         else if (strcmp(*argv, "-msg") == 0) {
1347             s_msg = 1;
1348         } else if (strcmp(*argv, "-msgfile") == 0) {
1349             if (--argc < 1)
1350                 goto bad;
1351             bio_s_msg = BIO_new_file(*(++argv), "w");
1352         }
1353 #ifndef OPENSSL_NO_SSL_TRACE
1354         else if (strcmp(*argv, "-trace") == 0) {
1355             s_msg = 2;
1356         }
1357 #endif
1358         else if (strcmp(*argv, "-hack") == 0) {
1359             hack = 1;
1360         } else if (strcmp(*argv, "-state") == 0) {
1361             state = 1;
1362         } else if (strcmp(*argv, "-crlf") == 0) {
1363             s_crlf = 1;
1364         } else if (strcmp(*argv, "-quiet") == 0) {
1365             s_quiet = 1;
1366         } else if (strcmp(*argv, "-brief") == 0) {
1367             s_quiet = 1;
1368             s_brief = 1;
1369             verify_quiet = 1;
1370         } else if (strcmp(*argv, "-no_tmp_rsa") == 0) {
1371             no_tmp_rsa = 1;
1372         } else if (strcmp(*argv, "-no_dhe") == 0) {
1373             no_dhe = 1;
1374         } else if (strcmp(*argv, "-no_ecdhe") == 0) {
1375             no_ecdhe = 1;
1376         } else if (strcmp(*argv, "-no_resume_ephemeral") == 0) {
1377             no_resume_ephemeral = 1;
1378         }
1379 #ifndef OPENSSL_NO_PSK
1380         else if (strcmp(*argv, "-psk_hint") == 0) {
1381             if (--argc < 1)
1382                 goto bad;
1383             psk_identity_hint = *(++argv);
1384         } else if (strcmp(*argv, "-psk") == 0) {
1385             size_t i;
1386
1387             if (--argc < 1)
1388                 goto bad;
1389             psk_key = *(++argv);
1390             for (i = 0; i < strlen(psk_key); i++) {
1391                 if (isxdigit((unsigned char)psk_key[i]))
1392                     continue;
1393                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1394                 goto bad;
1395             }
1396         }
1397 #endif
1398 #ifndef OPENSSL_NO_SRP
1399         else if (strcmp(*argv, "-srpvfile") == 0) {
1400             if (--argc < 1)
1401                 goto bad;
1402             srp_verifier_file = *(++argv);
1403             meth = TLSv1_server_method();
1404         } else if (strcmp(*argv, "-srpuserseed") == 0) {
1405             if (--argc < 1)
1406                 goto bad;
1407             srpuserseed = *(++argv);
1408             meth = TLSv1_server_method();
1409         }
1410 #endif
1411         else if (strcmp(*argv, "-rev") == 0) {
1412             rev = 1;
1413         } else if (strcmp(*argv, "-www") == 0) {
1414             www = 1;
1415         } else if (strcmp(*argv, "-WWW") == 0) {
1416             www = 2;
1417         } else if (strcmp(*argv, "-HTTP") == 0) {
1418             www = 3;
1419         }
1420 #ifndef OPENSSL_NO_SSL2
1421         else if (strcmp(*argv, "-ssl2") == 0) {
1422             no_ecdhe = 1;
1423             meth = SSLv2_server_method();
1424         }
1425 #endif
1426 #ifndef OPENSSL_NO_SSL3_METHOD
1427         else if (strcmp(*argv, "-ssl3") == 0) {
1428             meth = SSLv3_server_method();
1429         }
1430 #endif
1431 #ifndef OPENSSL_NO_TLS1
1432         else if (strcmp(*argv, "-tls1") == 0) {
1433             meth = TLSv1_server_method();
1434         } else if (strcmp(*argv, "-tls1_1") == 0) {
1435             meth = TLSv1_1_server_method();
1436         } else if (strcmp(*argv, "-tls1_2") == 0) {
1437             meth = TLSv1_2_server_method();
1438         }
1439 #endif
1440 #ifndef OPENSSL_NO_DTLS1
1441         else if (strcmp(*argv, "-dtls") == 0) {
1442             meth = DTLS_server_method();
1443             socket_type = SOCK_DGRAM;
1444         } else if (strcmp(*argv, "-dtls1") == 0) {
1445             meth = DTLSv1_server_method();
1446             socket_type = SOCK_DGRAM;
1447         } else if (strcmp(*argv, "-dtls1_2") == 0) {
1448             meth = DTLSv1_2_server_method();
1449             socket_type = SOCK_DGRAM;
1450         } else if (strcmp(*argv, "-timeout") == 0)
1451             enable_timeouts = 1;
1452         else if (strcmp(*argv, "-mtu") == 0) {
1453             if (--argc < 1)
1454                 goto bad;
1455             socket_mtu = atol(*(++argv));
1456         } else if (strcmp(*argv, "-chain") == 0)
1457             cert_chain = 1;
1458 #endif
1459         else if (strcmp(*argv, "-id_prefix") == 0) {
1460             if (--argc < 1)
1461                 goto bad;
1462             session_id_prefix = *(++argv);
1463         }
1464 #ifndef OPENSSL_NO_ENGINE
1465         else if (strcmp(*argv, "-engine") == 0) {
1466             if (--argc < 1)
1467                 goto bad;
1468             engine_id = *(++argv);
1469         }
1470 #endif
1471         else if (strcmp(*argv, "-rand") == 0) {
1472             if (--argc < 1)
1473                 goto bad;
1474             inrand = *(++argv);
1475         }
1476 #ifndef OPENSSL_NO_TLSEXT
1477         else if (strcmp(*argv, "-servername") == 0) {
1478             if (--argc < 1)
1479                 goto bad;
1480             tlsextcbp.servername = *(++argv);
1481         } else if (strcmp(*argv, "-servername_fatal") == 0) {
1482             tlsextcbp.extension_error = SSL_TLSEXT_ERR_ALERT_FATAL;
1483         } else if (strcmp(*argv, "-cert2") == 0) {
1484             if (--argc < 1)
1485                 goto bad;
1486             s_cert_file2 = *(++argv);
1487         } else if (strcmp(*argv, "-key2") == 0) {
1488             if (--argc < 1)
1489                 goto bad;
1490             s_key_file2 = *(++argv);
1491         }
1492 # ifndef OPENSSL_NO_NEXTPROTONEG
1493         else if (strcmp(*argv, "-nextprotoneg") == 0) {
1494             if (--argc < 1)
1495                 goto bad;
1496             next_proto_neg_in = *(++argv);
1497         }
1498 # endif
1499         else if (strcmp(*argv, "-alpn") == 0) {
1500             if (--argc < 1)
1501                 goto bad;
1502             alpn_in = *(++argv);
1503         }
1504 #endif
1505 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1506         else if (strcmp(*argv, "-jpake") == 0) {
1507             if (--argc < 1)
1508                 goto bad;
1509             jpake_secret = *(++argv);
1510         }
1511 #endif
1512 #ifndef OPENSSL_NO_SRTP
1513         else if (strcmp(*argv, "-use_srtp") == 0) {
1514             if (--argc < 1)
1515                 goto bad;
1516             srtp_profiles = *(++argv);
1517         }
1518 #endif
1519         else if (strcmp(*argv, "-keymatexport") == 0) {
1520             if (--argc < 1)
1521                 goto bad;
1522             keymatexportlabel = *(++argv);
1523         } else if (strcmp(*argv, "-keymatexportlen") == 0) {
1524             if (--argc < 1)
1525                 goto bad;
1526             keymatexportlen = atoi(*(++argv));
1527             if (keymatexportlen == 0)
1528                 goto bad;
1529         } else {
1530             BIO_printf(bio_err, "unknown option %s\n", *argv);
1531             badop = 1;
1532             break;
1533         }
1534         argc--;
1535         argv++;
1536     }
1537     if (badop) {
1538  bad:
1539         sv_usage();
1540         goto end;
1541     }
1542 #ifndef OPENSSL_NO_DTLS1
1543     if (www && socket_type == SOCK_DGRAM) {
1544         BIO_printf(bio_err, "Can't use -HTTP, -www or -WWW with DTLS\n");
1545         goto end;
1546     }
1547 #endif
1548
1549 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1550     if (jpake_secret) {
1551         if (psk_key) {
1552             BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1553             goto end;
1554         }
1555         psk_identity = "JPAKE";
1556     }
1557 #endif
1558
1559     SSL_load_error_strings();
1560     OpenSSL_add_ssl_algorithms();
1561
1562 #ifndef OPENSSL_NO_ENGINE
1563     e = setup_engine(bio_err, engine_id, 1);
1564 #endif
1565
1566     if (!app_passwd(bio_err, passarg, dpassarg, &pass, &dpass)) {
1567         BIO_printf(bio_err, "Error getting password\n");
1568         goto end;
1569     }
1570
1571     if (s_key_file == NULL)
1572         s_key_file = s_cert_file;
1573 #ifndef OPENSSL_NO_TLSEXT
1574     if (s_key_file2 == NULL)
1575         s_key_file2 = s_cert_file2;
1576 #endif
1577
1578     if (!load_excert(&exc, bio_err))
1579         goto end;
1580
1581     if (nocert == 0) {
1582         s_key = load_key(bio_err, s_key_file, s_key_format, 0, pass, e,
1583                          "server certificate private key file");
1584         if (!s_key) {
1585             ERR_print_errors(bio_err);
1586             goto end;
1587         }
1588
1589         s_cert = load_cert(bio_err, s_cert_file, s_cert_format,
1590                            NULL, e, "server certificate file");
1591
1592         if (!s_cert) {
1593             ERR_print_errors(bio_err);
1594             goto end;
1595         }
1596         if (s_chain_file) {
1597             s_chain = load_certs(bio_err, s_chain_file, FORMAT_PEM,
1598                                  NULL, e, "server certificate chain");
1599             if (!s_chain)
1600                 goto end;
1601         }
1602 #ifndef OPENSSL_NO_TLSEXT
1603         if (tlsextcbp.servername) {
1604             s_key2 = load_key(bio_err, s_key_file2, s_key_format, 0, pass, e,
1605                               "second server certificate private key file");
1606             if (!s_key2) {
1607                 ERR_print_errors(bio_err);
1608                 goto end;
1609             }
1610
1611             s_cert2 = load_cert(bio_err, s_cert_file2, s_cert_format,
1612                                 NULL, e, "second server certificate file");
1613
1614             if (!s_cert2) {
1615                 ERR_print_errors(bio_err);
1616                 goto end;
1617             }
1618         }
1619 #endif                          /* OPENSSL_NO_TLSEXT */
1620     }
1621 #if !defined(OPENSSL_NO_TLSEXT)
1622 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1623     if (next_proto_neg_in) {
1624         unsigned short len;
1625         next_proto.data = next_protos_parse(&len, next_proto_neg_in);
1626         if (next_proto.data == NULL)
1627             goto end;
1628         next_proto.len = len;
1629     } else {
1630         next_proto.data = NULL;
1631     }
1632 # endif
1633     alpn_ctx.data = NULL;
1634     if (alpn_in) {
1635         unsigned short len;
1636         alpn_ctx.data = next_protos_parse(&len, alpn_in);
1637         if (alpn_ctx.data == NULL)
1638             goto end;
1639         alpn_ctx.len = len;
1640     }
1641 #endif
1642
1643     if (crl_file) {
1644         X509_CRL *crl;
1645         crl = load_crl(crl_file, crl_format);
1646         if (!crl) {
1647             BIO_puts(bio_err, "Error loading CRL\n");
1648             ERR_print_errors(bio_err);
1649             goto end;
1650         }
1651         crls = sk_X509_CRL_new_null();
1652         if (!crls || !sk_X509_CRL_push(crls, crl)) {
1653             BIO_puts(bio_err, "Error adding CRL\n");
1654             ERR_print_errors(bio_err);
1655             X509_CRL_free(crl);
1656             goto end;
1657         }
1658     }
1659
1660     if (s_dcert_file) {
1661
1662         if (s_dkey_file == NULL)
1663             s_dkey_file = s_dcert_file;
1664
1665         s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
1666                           0, dpass, e, "second certificate private key file");
1667         if (!s_dkey) {
1668             ERR_print_errors(bio_err);
1669             goto end;
1670         }
1671
1672         s_dcert = load_cert(bio_err, s_dcert_file, s_dcert_format,
1673                             NULL, e, "second server certificate file");
1674
1675         if (!s_dcert) {
1676             ERR_print_errors(bio_err);
1677             goto end;
1678         }
1679         if (s_dchain_file) {
1680             s_dchain = load_certs(bio_err, s_dchain_file, FORMAT_PEM,
1681                                   NULL, e, "second server certificate chain");
1682             if (!s_dchain)
1683                 goto end;
1684         }
1685
1686     }
1687
1688     if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1689         && !RAND_status()) {
1690         BIO_printf(bio_err,
1691                    "warning, not much extra random data, consider using the -rand option\n");
1692     }
1693     if (inrand != NULL)
1694         BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1695                    app_RAND_load_files(inrand));
1696
1697     if (bio_s_out == NULL) {
1698         if (s_quiet && !s_debug) {
1699             bio_s_out = BIO_new(BIO_s_null());
1700             if (s_msg && !bio_s_msg)
1701                 bio_s_msg = BIO_new_fp(stdout, BIO_NOCLOSE);
1702         } else {
1703             if (bio_s_out == NULL)
1704                 bio_s_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1705         }
1706     }
1707 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
1708     if (nocert)
1709 #endif
1710     {
1711         s_cert_file = NULL;
1712         s_key_file = NULL;
1713         s_dcert_file = NULL;
1714         s_dkey_file = NULL;
1715 #ifndef OPENSSL_NO_TLSEXT
1716         s_cert_file2 = NULL;
1717         s_key_file2 = NULL;
1718 #endif
1719     }
1720
1721     ctx = SSL_CTX_new(meth);
1722     if (ctx == NULL) {
1723         ERR_print_errors(bio_err);
1724         goto end;
1725     }
1726     if (session_id_prefix) {
1727         if (strlen(session_id_prefix) >= 32)
1728             BIO_printf(bio_err,
1729                        "warning: id_prefix is too long, only one new session will be possible\n");
1730         else if (strlen(session_id_prefix) >= 16)
1731             BIO_printf(bio_err,
1732                        "warning: id_prefix is too long if you use SSLv2\n");
1733         if (!SSL_CTX_set_generate_session_id(ctx, generate_session_id)) {
1734             BIO_printf(bio_err, "error setting 'id_prefix'\n");
1735             ERR_print_errors(bio_err);
1736             goto end;
1737         }
1738         BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1739     }
1740     SSL_CTX_set_quiet_shutdown(ctx, 1);
1741     if (hack)
1742         SSL_CTX_set_options(ctx, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1743     if (exc)
1744         ssl_ctx_set_excert(ctx, exc);
1745
1746     if (state)
1747         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1748     if (no_cache)
1749         SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1750     else if (ext_cache)
1751         init_session_cache_ctx(ctx);
1752     else
1753         SSL_CTX_sess_set_cache_size(ctx, 128);
1754
1755 #ifndef OPENSSL_NO_SRTP
1756     if (srtp_profiles != NULL)
1757         SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1758 #endif
1759
1760 #if 0
1761     if (cipher == NULL)
1762         cipher = getenv("SSL_CIPHER");
1763 #endif
1764
1765 #if 0
1766     if (s_cert_file == NULL) {
1767         BIO_printf(bio_err,
1768                    "You must specify a certificate file for the server to use\n");
1769         goto end;
1770     }
1771 #endif
1772
1773     if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
1774         (!SSL_CTX_set_default_verify_paths(ctx))) {
1775         /* BIO_printf(bio_err,"X509_load_verify_locations\n"); */
1776         ERR_print_errors(bio_err);
1777         /* goto end; */
1778     }
1779     if (vpm)
1780         SSL_CTX_set1_param(ctx, vpm);
1781
1782     ssl_ctx_add_crls(ctx, crls, 0);
1783
1784     if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1785         goto end;
1786
1787     if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1788                          crls, crl_download)) {
1789         BIO_printf(bio_err, "Error loading store locations\n");
1790         ERR_print_errors(bio_err);
1791         goto end;
1792     }
1793 #ifndef OPENSSL_NO_TLSEXT
1794     if (s_cert2) {
1795         ctx2 = SSL_CTX_new(meth);
1796         if (ctx2 == NULL) {
1797             ERR_print_errors(bio_err);
1798             goto end;
1799         }
1800     }
1801
1802     if (ctx2) {
1803         BIO_printf(bio_s_out, "Setting secondary ctx parameters\n");
1804
1805         if (session_id_prefix) {
1806             if (strlen(session_id_prefix) >= 32)
1807                 BIO_printf(bio_err,
1808                            "warning: id_prefix is too long, only one new session will be possible\n");
1809             else if (strlen(session_id_prefix) >= 16)
1810                 BIO_printf(bio_err,
1811                            "warning: id_prefix is too long if you use SSLv2\n");
1812             if (!SSL_CTX_set_generate_session_id(ctx2, generate_session_id)) {
1813                 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1814                 ERR_print_errors(bio_err);
1815                 goto end;
1816             }
1817             BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1818         }
1819         SSL_CTX_set_quiet_shutdown(ctx2, 1);
1820         if (hack)
1821             SSL_CTX_set_options(ctx2, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1822         if (exc)
1823             ssl_ctx_set_excert(ctx2, exc);
1824
1825         if (state)
1826             SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1827
1828         if (no_cache)
1829             SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1830         else if (ext_cache)
1831             init_session_cache_ctx(ctx2);
1832         else
1833             SSL_CTX_sess_set_cache_size(ctx2, 128);
1834
1835         if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1836             (!SSL_CTX_set_default_verify_paths(ctx2))) {
1837             ERR_print_errors(bio_err);
1838         }
1839         if (vpm)
1840             SSL_CTX_set1_param(ctx2, vpm);
1841
1842         ssl_ctx_add_crls(ctx2, crls, 0);
1843
1844         if (!args_ssl_call(ctx2, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1845             goto end;
1846
1847     }
1848 # ifndef OPENSSL_NO_NEXTPROTONEG
1849     if (next_proto.data)
1850         SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb,
1851                                               &next_proto);
1852 # endif
1853     if (alpn_ctx.data)
1854         SSL_CTX_set_alpn_select_cb(ctx, alpn_cb, &alpn_ctx);
1855 #endif
1856
1857 #ifndef OPENSSL_NO_DH
1858     if (!no_dhe) {
1859         DH *dh = NULL;
1860
1861         if (dhfile)
1862             dh = load_dh_param(dhfile);
1863         else if (s_cert_file)
1864             dh = load_dh_param(s_cert_file);
1865
1866         if (dh != NULL) {
1867             BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1868         } else {
1869             BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1870             dh = get_dh512();
1871         }
1872         (void)BIO_flush(bio_s_out);
1873
1874         SSL_CTX_set_tmp_dh(ctx, dh);
1875 # ifndef OPENSSL_NO_TLSEXT
1876         if (ctx2) {
1877             if (!dhfile) {
1878                 DH *dh2 = load_dh_param(s_cert_file2);
1879                 if (dh2 != NULL) {
1880                     BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1881                     (void)BIO_flush(bio_s_out);
1882
1883                     DH_free(dh);
1884                     dh = dh2;
1885                 }
1886             }
1887             SSL_CTX_set_tmp_dh(ctx2, dh);
1888         }
1889 # endif
1890         DH_free(dh);
1891     }
1892 #endif
1893
1894     if (!set_cert_key_stuff(ctx, s_cert, s_key, s_chain, build_chain))
1895         goto end;
1896 #ifndef OPENSSL_NO_TLSEXT
1897     if (s_serverinfo_file != NULL
1898         && !SSL_CTX_use_serverinfo_file(ctx, s_serverinfo_file)) {
1899         ERR_print_errors(bio_err);
1900         goto end;
1901     }
1902 #endif
1903 #ifndef OPENSSL_NO_TLSEXT
1904     if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2, NULL, build_chain))
1905         goto end;
1906 #endif
1907     if (s_dcert != NULL) {
1908         if (!set_cert_key_stuff(ctx, s_dcert, s_dkey, s_dchain, build_chain))
1909             goto end;
1910     }
1911 #ifndef OPENSSL_NO_RSA
1912 # if 1
1913     if (!no_tmp_rsa) {
1914         SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1915 #  ifndef OPENSSL_NO_TLSEXT
1916         if (ctx2)
1917             SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1918 #  endif
1919     }
1920 # else
1921     if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1922         RSA *rsa;
1923
1924         BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1925         BIO_flush(bio_s_out);
1926
1927         rsa = RSA_generate_key(512, RSA_F4, NULL);
1928
1929         if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1930             ERR_print_errors(bio_err);
1931             goto end;
1932         }
1933 #  ifndef OPENSSL_NO_TLSEXT
1934         if (ctx2) {
1935             if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1936                 ERR_print_errors(bio_err);
1937                 goto end;
1938             }
1939         }
1940 #  endif
1941         RSA_free(rsa);
1942         BIO_printf(bio_s_out, "\n");
1943     }
1944 # endif
1945 #endif
1946
1947 #ifndef OPENSSL_NO_PSK
1948 # ifdef OPENSSL_NO_JPAKE
1949     if (psk_key != NULL)
1950 # else
1951     if (psk_key != NULL || jpake_secret)
1952 # endif
1953     {
1954         if (s_debug)
1955             BIO_printf(bio_s_out,
1956                        "PSK key given or JPAKE in use, setting server callback\n");
1957         SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1958     }
1959
1960     if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1961         BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1962         ERR_print_errors(bio_err);
1963         goto end;
1964     }
1965 #endif
1966
1967     SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1968     SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1969                                    sizeof s_server_session_id_context);
1970
1971     /* Set DTLS cookie generation and verification callbacks */
1972     SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1973     SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1974
1975 #ifndef OPENSSL_NO_TLSEXT
1976     if (ctx2) {
1977         SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1978         SSL_CTX_set_session_id_context(ctx2,
1979                                        (void *)&s_server_session_id_context,
1980                                        sizeof s_server_session_id_context);
1981
1982         tlsextcbp.biodebug = bio_s_out;
1983         SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1984         SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1985         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1986         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1987     }
1988 #endif
1989
1990 #ifndef OPENSSL_NO_SRP
1991     if (srp_verifier_file != NULL) {
1992         srp_callback_parm.vb = SRP_VBASE_new(srpuserseed);
1993         srp_callback_parm.user = NULL;
1994         srp_callback_parm.login = NULL;
1995         if ((ret =
1996              SRP_VBASE_init(srp_callback_parm.vb,
1997                             srp_verifier_file)) != SRP_NO_ERROR) {
1998             BIO_printf(bio_err,
1999                        "Cannot initialize SRP verifier file \"%s\":ret=%d\n",
2000                        srp_verifier_file, ret);
2001             goto end;
2002         }
2003         SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
2004         SSL_CTX_set_srp_cb_arg(ctx, &srp_callback_parm);
2005         SSL_CTX_set_srp_username_callback(ctx, ssl_srp_server_param_cb);
2006     } else
2007 #endif
2008     if (CAfile != NULL) {
2009         SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
2010 #ifndef OPENSSL_NO_TLSEXT
2011         if (ctx2)
2012             SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
2013 #endif
2014     }
2015
2016     BIO_printf(bio_s_out, "ACCEPT\n");
2017     (void)BIO_flush(bio_s_out);
2018     if (rev)
2019         do_server(port, socket_type, &accept_socket, rev_body, context,
2020                   naccept);
2021     else if (www)
2022         do_server(port, socket_type, &accept_socket, www_body, context,
2023                   naccept);
2024     else
2025         do_server(port, socket_type, &accept_socket, sv_body, context,
2026                   naccept);
2027     print_stats(bio_s_out, ctx);
2028     ret = 0;
2029  end:
2030     if (ctx != NULL)
2031         SSL_CTX_free(ctx);
2032     if (s_cert)
2033         X509_free(s_cert);
2034     if (crls)
2035         sk_X509_CRL_pop_free(crls, X509_CRL_free);
2036     if (s_dcert)
2037         X509_free(s_dcert);
2038     if (s_key)
2039         EVP_PKEY_free(s_key);
2040     if (s_dkey)
2041         EVP_PKEY_free(s_dkey);
2042     if (s_chain)
2043         sk_X509_pop_free(s_chain, X509_free);
2044     if (s_dchain)
2045         sk_X509_pop_free(s_dchain, X509_free);
2046     if (pass)
2047         OPENSSL_free(pass);
2048     if (dpass)
2049         OPENSSL_free(dpass);
2050     if (vpm)
2051         X509_VERIFY_PARAM_free(vpm);
2052     free_sessions();
2053 #ifndef OPENSSL_NO_TLSEXT
2054     if (tlscstatp.host)
2055         OPENSSL_free(tlscstatp.host);
2056     if (tlscstatp.port)
2057         OPENSSL_free(tlscstatp.port);
2058     if (tlscstatp.path)
2059         OPENSSL_free(tlscstatp.path);
2060     if (ctx2 != NULL)
2061         SSL_CTX_free(ctx2);
2062     if (s_cert2)
2063         X509_free(s_cert2);
2064     if (s_key2)
2065         EVP_PKEY_free(s_key2);
2066     if (serverinfo_in != NULL)
2067         BIO_free(serverinfo_in);
2068 # ifndef OPENSSL_NO_NEXTPROTONEG
2069     if (next_proto.data)
2070         OPENSSL_free(next_proto.data);
2071 # endif
2072     if (alpn_ctx.data)
2073         OPENSSL_free(alpn_ctx.data);
2074 #endif
2075     ssl_excert_free(exc);
2076     if (ssl_args)
2077         sk_OPENSSL_STRING_free(ssl_args);
2078     if (cctx)
2079         SSL_CONF_CTX_free(cctx);
2080 #ifndef OPENSSL_NO_JPAKE
2081     if (jpake_secret && psk_key)
2082         OPENSSL_free(psk_key);
2083 #endif
2084     if (bio_s_out != NULL) {
2085         BIO_free(bio_s_out);
2086         bio_s_out = NULL;
2087     }
2088     if (bio_s_msg != NULL) {
2089         BIO_free(bio_s_msg);
2090         bio_s_msg = NULL;
2091     }
2092     apps_shutdown();
2093     OPENSSL_EXIT(ret);
2094 }
2095
2096 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
2097 {
2098     BIO_printf(bio, "%4ld items in the session cache\n",
2099                SSL_CTX_sess_number(ssl_ctx));
2100     BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
2101                SSL_CTX_sess_connect(ssl_ctx));
2102     BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
2103                SSL_CTX_sess_connect_renegotiate(ssl_ctx));
2104     BIO_printf(bio, "%4ld client connects that finished\n",
2105                SSL_CTX_sess_connect_good(ssl_ctx));
2106     BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
2107                SSL_CTX_sess_accept(ssl_ctx));
2108     BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
2109                SSL_CTX_sess_accept_renegotiate(ssl_ctx));
2110     BIO_printf(bio, "%4ld server accepts that finished\n",
2111                SSL_CTX_sess_accept_good(ssl_ctx));
2112     BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
2113     BIO_printf(bio, "%4ld session cache misses\n",
2114                SSL_CTX_sess_misses(ssl_ctx));
2115     BIO_printf(bio, "%4ld session cache timeouts\n",
2116                SSL_CTX_sess_timeouts(ssl_ctx));
2117     BIO_printf(bio, "%4ld callback cache hits\n",
2118                SSL_CTX_sess_cb_hits(ssl_ctx));
2119     BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
2120                SSL_CTX_sess_cache_full(ssl_ctx),
2121                SSL_CTX_sess_get_cache_size(ssl_ctx));
2122 }
2123
2124 static int sv_body(char *hostname, int s, int stype, unsigned char *context)
2125 {
2126     char *buf = NULL;
2127     fd_set readfds;
2128     int ret = 1, width;
2129     int k, i;
2130     unsigned long l;
2131     SSL *con = NULL;
2132     BIO *sbio;
2133 #ifndef OPENSSL_NO_KRB5
2134     KSSL_CTX *kctx;
2135 #endif
2136     struct timeval timeout;
2137 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
2138     struct timeval tv;
2139 #else
2140     struct timeval *timeoutp;
2141 #endif
2142
2143     if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
2144         BIO_printf(bio_err, "out of memory\n");
2145         goto err;
2146     }
2147 #ifdef FIONBIO
2148     if (s_nbio) {
2149         unsigned long sl = 1;
2150
2151         if (!s_quiet)
2152             BIO_printf(bio_err, "turning on non blocking io\n");
2153         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2154             ERR_print_errors(bio_err);
2155     }
2156 #endif
2157
2158     if (con == NULL) {
2159         con = SSL_new(ctx);
2160 #ifndef OPENSSL_NO_TLSEXT
2161         if (s_tlsextdebug) {
2162             SSL_set_tlsext_debug_callback(con, tlsext_cb);
2163             SSL_set_tlsext_debug_arg(con, bio_s_out);
2164         }
2165         if (s_tlsextstatus) {
2166             SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
2167             tlscstatp.err = bio_err;
2168             SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
2169         }
2170 #endif
2171 #ifndef OPENSSL_NO_KRB5
2172         if ((kctx = kssl_ctx_new()) != NULL) {
2173             SSL_set0_kssl_ctx(con, kctx);
2174             kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2175             kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2176         }
2177 #endif                          /* OPENSSL_NO_KRB5 */
2178         if (context)
2179             SSL_set_session_id_context(con, context, strlen((char *)context));
2180     }
2181     SSL_clear(con);
2182 #if 0
2183 # ifdef TLSEXT_TYPE_opaque_prf_input
2184     SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
2185 # endif
2186 #endif
2187
2188     if (stype == SOCK_DGRAM) {
2189
2190         sbio = BIO_new_dgram(s, BIO_NOCLOSE);
2191
2192         if (enable_timeouts) {
2193             timeout.tv_sec = 0;
2194             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2195             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2196
2197             timeout.tv_sec = 0;
2198             timeout.tv_usec = DGRAM_SND_TIMEOUT;
2199             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2200         }
2201
2202         if (socket_mtu) {
2203             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2204                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2205                            DTLS_get_link_min_mtu(con));
2206                 ret = -1;
2207                 BIO_free(sbio);
2208                 goto err;
2209             }
2210             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2211             if (!DTLS_set_link_mtu(con, socket_mtu)) {
2212                 BIO_printf(bio_err, "Failed to set MTU\n");
2213                 ret = -1;
2214                 BIO_free(sbio);
2215                 goto err;
2216             }
2217         } else
2218             /* want to do MTU discovery */
2219             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2220
2221         /* turn on cookie exchange */
2222         SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
2223     } else
2224         sbio = BIO_new_socket(s, BIO_NOCLOSE);
2225
2226     if (s_nbio_test) {
2227         BIO *test;
2228
2229         test = BIO_new(BIO_f_nbio_test());
2230         sbio = BIO_push(test, sbio);
2231     }
2232 #ifndef OPENSSL_NO_JPAKE
2233     if (jpake_secret)
2234         jpake_server_auth(bio_s_out, sbio, jpake_secret);
2235 #endif
2236
2237     SSL_set_bio(con, sbio, sbio);
2238     SSL_set_accept_state(con);
2239     /* SSL_set_fd(con,s); */
2240
2241     if (s_debug) {
2242         SSL_set_debug(con, 1);
2243         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2244         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2245     }
2246     if (s_msg) {
2247 #ifndef OPENSSL_NO_SSL_TRACE
2248         if (s_msg == 2)
2249             SSL_set_msg_callback(con, SSL_trace);
2250         else
2251 #endif
2252             SSL_set_msg_callback(con, msg_cb);
2253         SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2254     }
2255 #ifndef OPENSSL_NO_TLSEXT
2256     if (s_tlsextdebug) {
2257         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2258         SSL_set_tlsext_debug_arg(con, bio_s_out);
2259     }
2260 #endif
2261
2262     width = s + 1;
2263     for (;;) {
2264         int read_from_terminal;
2265         int read_from_sslcon;
2266
2267         read_from_terminal = 0;
2268         read_from_sslcon = SSL_pending(con);
2269
2270         if (!read_from_sslcon) {
2271             FD_ZERO(&readfds);
2272 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
2273             openssl_fdset(fileno(stdin), &readfds);
2274 #endif
2275             openssl_fdset(s, &readfds);
2276             /*
2277              * Note: under VMS with SOCKETSHR the second parameter is
2278              * currently of type (int *) whereas under other systems it is
2279              * (void *) if you don't have a cast it will choke the compiler:
2280              * if you do have a cast then you can either go for (int *) or
2281              * (void *).
2282              */
2283 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
2284             /*
2285              * Under DOS (non-djgpp) and Windows we can't select on stdin:
2286              * only on sockets. As a workaround we timeout the select every
2287              * second and check for any keypress. In a proper Windows
2288              * application we wouldn't do this because it is inefficient.
2289              */
2290             tv.tv_sec = 1;
2291             tv.tv_usec = 0;
2292             i = select(width, (void *)&readfds, NULL, NULL, &tv);
2293             if ((i < 0) || (!i && !_kbhit()))
2294                 continue;
2295             if (_kbhit())
2296                 read_from_terminal = 1;
2297 #elif defined(OPENSSL_SYS_BEOS_R5)
2298             /* Under BeOS-R5 the situation is similar to DOS */
2299             tv.tv_sec = 1;
2300             tv.tv_usec = 0;
2301             (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
2302             i = select(width, (void *)&readfds, NULL, NULL, &tv);
2303             if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
2304                 continue;
2305             if (read(fileno(stdin), buf, 0) >= 0)
2306                 read_from_terminal = 1;
2307             (void)fcntl(fileno(stdin), F_SETFL, 0);
2308 #else
2309             if ((SSL_version(con) == DTLS1_VERSION) &&
2310                 DTLSv1_get_timeout(con, &timeout))
2311                 timeoutp = &timeout;
2312             else
2313                 timeoutp = NULL;
2314
2315             i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
2316
2317             if ((SSL_version(con) == DTLS1_VERSION)
2318                 && DTLSv1_handle_timeout(con) > 0) {
2319                 BIO_printf(bio_err, "TIMEOUT occured\n");
2320             }
2321
2322             if (i <= 0)
2323                 continue;
2324             if (FD_ISSET(fileno(stdin), &readfds))
2325                 read_from_terminal = 1;
2326 #endif
2327             if (FD_ISSET(s, &readfds))
2328                 read_from_sslcon = 1;
2329         }
2330         if (read_from_terminal) {
2331             if (s_crlf) {
2332                 int j, lf_num;
2333
2334                 i = raw_read_stdin(buf, bufsize / 2);
2335                 lf_num = 0;
2336                 /* both loops are skipped when i <= 0 */
2337                 for (j = 0; j < i; j++)
2338                     if (buf[j] == '\n')
2339                         lf_num++;
2340                 for (j = i - 1; j >= 0; j--) {
2341                     buf[j + lf_num] = buf[j];
2342                     if (buf[j] == '\n') {
2343                         lf_num--;
2344                         i++;
2345                         buf[j + lf_num] = '\r';
2346                     }
2347                 }
2348                 assert(lf_num == 0);
2349             } else
2350                 i = raw_read_stdin(buf, bufsize);
2351             if (!s_quiet && !s_brief) {
2352                 if ((i <= 0) || (buf[0] == 'Q')) {
2353                     BIO_printf(bio_s_out, "DONE\n");
2354                     SHUTDOWN(s);
2355                     close_accept_socket();
2356                     ret = -11;
2357                     goto err;
2358                 }
2359                 if ((i <= 0) || (buf[0] == 'q')) {
2360                     BIO_printf(bio_s_out, "DONE\n");
2361                     if (SSL_version(con) != DTLS1_VERSION)
2362                         SHUTDOWN(s);
2363                     /*
2364                      * close_accept_socket(); ret= -11;
2365                      */
2366                     goto err;
2367                 }
2368 #ifndef OPENSSL_NO_HEARTBEATS
2369                 if ((buf[0] == 'B') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2370                     BIO_printf(bio_err, "HEARTBEATING\n");
2371                     SSL_heartbeat(con);
2372                     i = 0;
2373                     continue;
2374                 }
2375 #endif
2376                 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2377                     SSL_renegotiate(con);
2378                     i = SSL_do_handshake(con);
2379                     printf("SSL_do_handshake -> %d\n", i);
2380                     i = 0;      /* 13; */
2381                     continue;
2382                     /*
2383                      * strcpy(buf,"server side RE-NEGOTIATE\n");
2384                      */
2385                 }
2386                 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2387                     SSL_set_verify(con,
2388                                    SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
2389                                    NULL);
2390                     SSL_renegotiate(con);
2391                     i = SSL_do_handshake(con);
2392                     printf("SSL_do_handshake -> %d\n", i);
2393                     i = 0;      /* 13; */
2394                     continue;
2395                     /*
2396                      * strcpy(buf,"server side RE-NEGOTIATE asking for client
2397                      * cert\n");
2398                      */
2399                 }
2400                 if (buf[0] == 'P') {
2401                     static const char *str = "Lets print some clear text\n";
2402                     BIO_write(SSL_get_wbio(con), str, strlen(str));
2403                 }
2404                 if (buf[0] == 'S') {
2405                     print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2406                 }
2407             }
2408 #ifdef CHARSET_EBCDIC
2409             ebcdic2ascii(buf, buf, i);
2410 #endif
2411             l = k = 0;
2412             for (;;) {
2413                 /* should do a select for the write */
2414 #ifdef RENEG
2415                 {
2416                     static count = 0;
2417                     if (++count == 100) {
2418                         count = 0;
2419                         SSL_renegotiate(con);
2420                     }
2421                 }
2422 #endif
2423                 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2424 #ifndef OPENSSL_NO_SRP
2425                 while (SSL_get_error(con, k) == SSL_ERROR_WANT_X509_LOOKUP) {
2426                     BIO_printf(bio_s_out, "LOOKUP renego during write\n");
2427                     srp_callback_parm.user =
2428                         SRP_VBASE_get_by_user(srp_callback_parm.vb,
2429                                               srp_callback_parm.login);
2430                     if (srp_callback_parm.user)
2431                         BIO_printf(bio_s_out, "LOOKUP done %s\n",
2432                                    srp_callback_parm.user->info);
2433                     else
2434                         BIO_printf(bio_s_out, "LOOKUP not successful\n");
2435                     k = SSL_write(con, &(buf[l]), (unsigned int)i);
2436                 }
2437 #endif
2438                 switch (SSL_get_error(con, k)) {
2439                 case SSL_ERROR_NONE:
2440                     break;
2441                 case SSL_ERROR_WANT_WRITE:
2442                 case SSL_ERROR_WANT_READ:
2443                 case SSL_ERROR_WANT_X509_LOOKUP:
2444                     BIO_printf(bio_s_out, "Write BLOCK\n");
2445                     break;
2446                 case SSL_ERROR_SYSCALL:
2447                 case SSL_ERROR_SSL:
2448                     BIO_printf(bio_s_out, "ERROR\n");
2449                     ERR_print_errors(bio_err);
2450                     ret = 1;
2451                     goto err;
2452                     /* break; */
2453                 case SSL_ERROR_ZERO_RETURN:
2454                     BIO_printf(bio_s_out, "DONE\n");
2455                     ret = 1;
2456                     goto err;
2457                 }
2458                 l += k;
2459                 i -= k;
2460                 if (i <= 0)
2461                     break;
2462             }
2463         }
2464         if (read_from_sslcon) {
2465             if (!SSL_is_init_finished(con)) {
2466                 i = init_ssl_connection(con);
2467
2468                 if (i < 0) {
2469                     ret = 0;
2470                     goto err;
2471                 } else if (i == 0) {
2472                     ret = 1;
2473                     goto err;
2474                 }
2475             } else {
2476  again:
2477                 i = SSL_read(con, (char *)buf, bufsize);
2478 #ifndef OPENSSL_NO_SRP
2479                 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2480                     BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2481                     srp_callback_parm.user =
2482                         SRP_VBASE_get_by_user(srp_callback_parm.vb,
2483                                               srp_callback_parm.login);
2484                     if (srp_callback_parm.user)
2485                         BIO_printf(bio_s_out, "LOOKUP done %s\n",
2486                                    srp_callback_parm.user->info);
2487                     else
2488                         BIO_printf(bio_s_out, "LOOKUP not successful\n");
2489                     i = SSL_read(con, (char *)buf, bufsize);
2490                 }
2491 #endif
2492                 switch (SSL_get_error(con, i)) {
2493                 case SSL_ERROR_NONE:
2494 #ifdef CHARSET_EBCDIC
2495                     ascii2ebcdic(buf, buf, i);
2496 #endif
2497                     raw_write_stdout(buf, (unsigned int)i);
2498                     if (SSL_pending(con))
2499                         goto again;
2500                     break;
2501                 case SSL_ERROR_WANT_WRITE:
2502                 case SSL_ERROR_WANT_READ:
2503                     BIO_printf(bio_s_out, "Read BLOCK\n");
2504                     break;
2505                 case SSL_ERROR_SYSCALL:
2506                 case SSL_ERROR_SSL:
2507                     BIO_printf(bio_s_out, "ERROR\n");
2508                     ERR_print_errors(bio_err);
2509                     ret = 1;
2510                     goto err;
2511                 case SSL_ERROR_ZERO_RETURN:
2512                     BIO_printf(bio_s_out, "DONE\n");
2513                     ret = 1;
2514                     goto err;
2515                 }
2516             }
2517         }
2518     }
2519  err:
2520     if (con != NULL) {
2521         BIO_printf(bio_s_out, "shutting down SSL\n");
2522 #if 1
2523         SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2524 #else
2525         SSL_shutdown(con);
2526 #endif
2527         SSL_free(con);
2528     }
2529     BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2530     if (buf != NULL) {
2531         OPENSSL_cleanse(buf, bufsize);
2532         OPENSSL_free(buf);
2533     }
2534     if (ret >= 0)
2535         BIO_printf(bio_s_out, "ACCEPT\n");
2536     return (ret);
2537 }
2538
2539 static void close_accept_socket(void)
2540 {
2541     BIO_printf(bio_err, "shutdown accept socket\n");
2542     if (accept_socket >= 0) {
2543         SHUTDOWN2(accept_socket);
2544     }
2545 }
2546
2547 static int init_ssl_connection(SSL *con)
2548 {
2549     int i;
2550     const char *str;
2551     X509 *peer;
2552     long verify_error;
2553     MS_STATIC char buf[BUFSIZ];
2554 #ifndef OPENSSL_NO_KRB5
2555     char *client_princ;
2556 #endif
2557 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2558     const unsigned char *next_proto_neg;
2559     unsigned next_proto_neg_len;
2560 #endif
2561     unsigned char *exportedkeymat;
2562
2563     i = SSL_accept(con);
2564 #ifdef CERT_CB_TEST_RETRY
2565     {
2566         while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2567                && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2568             fprintf(stderr,
2569                     "LOOKUP from certificate callback during accept\n");
2570             i = SSL_accept(con);
2571         }
2572     }
2573 #endif
2574 #ifndef OPENSSL_NO_SRP
2575     while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2576         BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2577                    srp_callback_parm.login);
2578         srp_callback_parm.user =
2579             SRP_VBASE_get_by_user(srp_callback_parm.vb,
2580                                   srp_callback_parm.login);
2581         if (srp_callback_parm.user)
2582             BIO_printf(bio_s_out, "LOOKUP done %s\n",
2583                        srp_callback_parm.user->info);
2584         else
2585             BIO_printf(bio_s_out, "LOOKUP not successful\n");
2586         i = SSL_accept(con);
2587     }
2588 #endif
2589
2590     if (i <= 0) {
2591         if (BIO_sock_should_retry(i)) {
2592             BIO_printf(bio_s_out, "DELAY\n");
2593             return (1);
2594         }
2595
2596         BIO_printf(bio_err, "ERROR\n");
2597         verify_error = SSL_get_verify_result(con);
2598         if (verify_error != X509_V_OK) {
2599             BIO_printf(bio_err, "verify error:%s\n",
2600                        X509_verify_cert_error_string(verify_error));
2601         }
2602         /* Always print any error messages */
2603         ERR_print_errors(bio_err);
2604         return (0);
2605     }
2606
2607     if (s_brief)
2608         print_ssl_summary(bio_err, con);
2609
2610     PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2611
2612     peer = SSL_get_peer_certificate(con);
2613     if (peer != NULL) {
2614         BIO_printf(bio_s_out, "Client certificate\n");
2615         PEM_write_bio_X509(bio_s_out, peer);
2616         X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2617         BIO_printf(bio_s_out, "subject=%s\n", buf);
2618         X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2619         BIO_printf(bio_s_out, "issuer=%s\n", buf);
2620         X509_free(peer);
2621     }
2622
2623     if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2624         BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2625     str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2626     ssl_print_sigalgs(bio_s_out, con);
2627 #ifndef OPENSSL_NO_EC
2628     ssl_print_point_formats(bio_s_out, con);
2629     ssl_print_curves(bio_s_out, con, 0);
2630 #endif
2631     BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2632
2633 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2634     SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2635     if (next_proto_neg) {
2636         BIO_printf(bio_s_out, "NEXTPROTO is ");
2637         BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2638         BIO_printf(bio_s_out, "\n");
2639     }
2640 #endif
2641 #ifndef OPENSSL_NO_SRTP
2642     {
2643         SRTP_PROTECTION_PROFILE *srtp_profile
2644             = SSL_get_selected_srtp_profile(con);
2645
2646         if (srtp_profile)
2647             BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2648                        srtp_profile->name);
2649     }
2650 #endif
2651     if (SSL_cache_hit(con))
2652         BIO_printf(bio_s_out, "Reused session-id\n");
2653     if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2654         TLS1_FLAGS_TLS_PADDING_BUG)
2655         BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2656 #ifndef OPENSSL_NO_KRB5
2657     client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2658     if (client_princ != NULL) {
2659         BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2660                    client_princ);
2661     }
2662 #endif                          /* OPENSSL_NO_KRB5 */
2663     BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2664                SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2665     if (keymatexportlabel != NULL) {
2666         BIO_printf(bio_s_out, "Keying material exporter:\n");
2667         BIO_printf(bio_s_out, "    Label: '%s'\n", keymatexportlabel);
2668         BIO_printf(bio_s_out, "    Length: %i bytes\n", keymatexportlen);
2669         exportedkeymat = OPENSSL_malloc(keymatexportlen);
2670         if (exportedkeymat != NULL) {
2671             if (!SSL_export_keying_material(con, exportedkeymat,
2672                                             keymatexportlen,
2673                                             keymatexportlabel,
2674                                             strlen(keymatexportlabel),
2675                                             NULL, 0, 0)) {
2676                 BIO_printf(bio_s_out, "    Error\n");
2677             } else {
2678                 BIO_printf(bio_s_out, "    Keying material: ");
2679                 for (i = 0; i < keymatexportlen; i++)
2680                     BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2681                 BIO_printf(bio_s_out, "\n");
2682             }
2683             OPENSSL_free(exportedkeymat);
2684         }
2685     }
2686
2687     return (1);
2688 }
2689
2690 #ifndef OPENSSL_NO_DH
2691 static DH *load_dh_param(const char *dhfile)
2692 {
2693     DH *ret = NULL;
2694     BIO *bio;
2695
2696     if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2697         goto err;
2698     ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2699  err:
2700     if (bio != NULL)
2701         BIO_free(bio);
2702     return (ret);
2703 }
2704 #endif
2705 #ifndef OPENSSL_NO_KRB5
2706 char *client_princ;
2707 #endif
2708
2709 #if 0
2710 static int load_CA(SSL_CTX *ctx, char *file)
2711 {
2712     FILE *in;
2713     X509 *x = NULL;
2714
2715     if ((in = fopen(file, "r")) == NULL)
2716         return (0);
2717
2718     for (;;) {
2719         if (PEM_read_X509(in, &x, NULL) == NULL)
2720             break;
2721         SSL_CTX_add_client_CA(ctx, x);
2722     }
2723     if (x != NULL)
2724         X509_free(x);
2725     fclose(in);
2726     return (1);
2727 }
2728 #endif
2729
2730 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2731 {
2732     char *buf = NULL;
2733     int ret = 1;
2734     int i, j, k, dot;
2735     SSL *con;
2736     const SSL_CIPHER *c;
2737     BIO *io, *ssl_bio, *sbio;
2738 #ifndef OPENSSL_NO_KRB5
2739     KSSL_CTX *kctx;
2740 #endif
2741
2742     buf = OPENSSL_malloc(bufsize);
2743     if (buf == NULL)
2744         return (0);
2745     io = BIO_new(BIO_f_buffer());
2746     ssl_bio = BIO_new(BIO_f_ssl());
2747     if ((io == NULL) || (ssl_bio == NULL))
2748         goto err;
2749
2750 #ifdef FIONBIO
2751     if (s_nbio) {
2752         unsigned long sl = 1;
2753
2754         if (!s_quiet)
2755             BIO_printf(bio_err, "turning on non blocking io\n");
2756         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2757             ERR_print_errors(bio_err);
2758     }
2759 #endif
2760
2761     /* lets make the output buffer a reasonable size */
2762     if (!BIO_set_write_buffer_size(io, bufsize))
2763         goto err;
2764
2765     if ((con = SSL_new(ctx)) == NULL)
2766         goto err;
2767 #ifndef OPENSSL_NO_TLSEXT
2768     if (s_tlsextdebug) {
2769         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2770         SSL_set_tlsext_debug_arg(con, bio_s_out);
2771     }
2772 #endif
2773 #ifndef OPENSSL_NO_KRB5
2774     if ((kctx = kssl_ctx_new()) != NULL) {
2775         kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2776         kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2777     }
2778 #endif                          /* OPENSSL_NO_KRB5 */
2779     if (context)
2780         SSL_set_session_id_context(con, context, strlen((char *)context));
2781
2782     sbio = BIO_new_socket(s, BIO_NOCLOSE);
2783     if (s_nbio_test) {
2784         BIO *test;
2785
2786         test = BIO_new(BIO_f_nbio_test());
2787         sbio = BIO_push(test, sbio);
2788     }
2789     SSL_set_bio(con, sbio, sbio);
2790     SSL_set_accept_state(con);
2791
2792     /* SSL_set_fd(con,s); */
2793     BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2794     BIO_push(io, ssl_bio);
2795 #ifdef CHARSET_EBCDIC
2796     io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2797 #endif
2798
2799     if (s_debug) {
2800         SSL_set_debug(con, 1);
2801         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2802         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2803     }
2804     if (s_msg) {
2805 #ifndef OPENSSL_NO_SSL_TRACE
2806         if (s_msg == 2)
2807             SSL_set_msg_callback(con, SSL_trace);
2808         else
2809 #endif
2810             SSL_set_msg_callback(con, msg_cb);
2811         SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2812     }
2813
2814     for (;;) {
2815         if (hack) {
2816             i = SSL_accept(con);
2817 #ifndef OPENSSL_NO_SRP
2818             while (i <= 0
2819                    && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2820                 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2821                            srp_callback_parm.login);
2822                 srp_callback_parm.user =
2823                     SRP_VBASE_get_by_user(srp_callback_parm.vb,
2824                                           srp_callback_parm.login);
2825                 if (srp_callback_parm.user)
2826                     BIO_printf(bio_s_out, "LOOKUP done %s\n",
2827                                srp_callback_parm.user->info);
2828                 else
2829                     BIO_printf(bio_s_out, "LOOKUP not successful\n");
2830                 i = SSL_accept(con);
2831             }
2832 #endif
2833             switch (SSL_get_error(con, i)) {
2834             case SSL_ERROR_NONE:
2835                 break;
2836             case SSL_ERROR_WANT_WRITE:
2837             case SSL_ERROR_WANT_READ:
2838             case SSL_ERROR_WANT_X509_LOOKUP:
2839                 continue;
2840             case SSL_ERROR_SYSCALL:
2841             case SSL_ERROR_SSL:
2842             case SSL_ERROR_ZERO_RETURN:
2843                 ret = 1;
2844                 goto err;
2845                 /* break; */
2846             }
2847
2848             SSL_renegotiate(con);
2849             SSL_write(con, NULL, 0);
2850         }
2851
2852         i = BIO_gets(io, buf, bufsize - 1);
2853         if (i < 0) {            /* error */
2854             if (!BIO_should_retry(io)) {
2855                 if (!s_quiet)
2856                     ERR_print_errors(bio_err);
2857                 goto err;
2858             } else {
2859                 BIO_printf(bio_s_out, "read R BLOCK\n");
2860 #if defined(OPENSSL_SYS_NETWARE)
2861                 delay(1000);
2862 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2863                 sleep(1);
2864 #endif
2865                 continue;
2866             }
2867         } else if (i == 0) {    /* end of input */
2868             ret = 1;
2869             goto end;
2870         }
2871
2872         /* else we have data */
2873         if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2874             ((www == 2) && (strncmp("GET /stats ", buf, 11) == 0))) {
2875             char *p;
2876             X509 *peer;
2877             STACK_OF(SSL_CIPHER) *sk;
2878             static const char *space = "                          ";
2879
2880             BIO_puts(io,
2881                      "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2882             BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2883             BIO_puts(io, "<pre>\n");
2884 /*                      BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2885             BIO_puts(io, "\n");
2886             for (i = 0; i < local_argc; i++) {
2887                 BIO_puts(io, local_argv[i]);
2888                 BIO_write(io, " ", 1);
2889             }
2890             BIO_puts(io, "\n");
2891
2892             BIO_printf(io,
2893                        "Secure Renegotiation IS%s supported\n",
2894                        SSL_get_secure_renegotiation_support(con) ?
2895                        "" : " NOT");
2896
2897             /*
2898              * The following is evil and should not really be done
2899              */
2900             BIO_printf(io, "Ciphers supported in s_server binary\n");
2901             sk = SSL_get_ciphers(con);
2902             j = sk_SSL_CIPHER_num(sk);
2903             for (i = 0; i < j; i++) {
2904                 c = sk_SSL_CIPHER_value(sk, i);
2905                 BIO_printf(io, "%-11s:%-25s",
2906                            SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2907                 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2908                     BIO_puts(io, "\n");
2909             }
2910             BIO_puts(io, "\n");
2911             p = SSL_get_shared_ciphers(con, buf, bufsize);
2912             if (p != NULL) {
2913                 BIO_printf(io,
2914                            "---\nCiphers common between both SSL end points:\n");
2915                 j = i = 0;
2916                 while (*p) {
2917                     if (*p == ':') {
2918                         BIO_write(io, space, 26 - j);
2919                         i++;
2920                         j = 0;
2921                         BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2922                     } else {
2923                         BIO_write(io, p, 1);
2924                         j++;
2925                     }
2926                     p++;
2927                 }
2928                 BIO_puts(io, "\n");
2929             }
2930             ssl_print_sigalgs(io, con);
2931 #ifndef OPENSSL_NO_EC
2932             ssl_print_curves(io, con, 0);
2933 #endif
2934             BIO_printf(io, (SSL_cache_hit(con)
2935                             ? "---\nReused, " : "---\nNew, "));
2936             c = SSL_get_current_cipher(con);
2937             BIO_printf(io, "%s, Cipher is %s\n",
2938                        SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2939             SSL_SESSION_print(io, SSL_get_session(con));
2940             BIO_printf(io, "---\n");
2941             print_stats(io, SSL_get_SSL_CTX(con));
2942             BIO_printf(io, "---\n");
2943             peer = SSL_get_peer_certificate(con);
2944             if (peer != NULL) {
2945                 BIO_printf(io, "Client certificate\n");
2946                 X509_print(io, peer);
2947                 PEM_write_bio_X509(io, peer);
2948             } else
2949                 BIO_puts(io, "no client certificate available\n");
2950             BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2951             break;
2952         } else if ((www == 2 || www == 3)
2953                    && (strncmp("GET /", buf, 5) == 0)) {
2954             BIO *file;
2955             char *p, *e;
2956             static const char *text =
2957                 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2958
2959             /* skip the '/' */
2960             p = &(buf[5]);
2961
2962             dot = 1;
2963             for (e = p; *e != '\0'; e++) {
2964                 if (e[0] == ' ')
2965                     break;
2966
2967                 switch (dot) {
2968                 case 1:
2969                     dot = (e[0] == '.') ? 2 : 0;
2970                     break;
2971                 case 2:
2972                     dot = (e[0] == '.') ? 3 : 0;
2973                     break;
2974                 case 3:
2975                     dot = (e[0] == '/') ? -1 : 0;
2976                     break;
2977                 }
2978                 if (dot == 0)
2979                     dot = (e[0] == '/') ? 1 : 0;
2980             }
2981             dot = (dot == 3) || (dot == -1); /* filename contains ".."
2982                                               * component */
2983
2984             if (*e == '\0') {
2985                 BIO_puts(io, text);
2986                 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2987                 break;
2988             }
2989             *e = '\0';
2990
2991             if (dot) {
2992                 BIO_puts(io, text);
2993                 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
2994                 break;
2995             }
2996
2997             if (*p == '/') {
2998                 BIO_puts(io, text);
2999                 BIO_printf(io, "'%s' is an invalid path\r\n", p);
3000                 break;
3001             }
3002 #if 0
3003             /* append if a directory lookup */
3004             if (e[-1] == '/')
3005                 strcat(p, "index.html");
3006 #endif
3007
3008             /* if a directory, do the index thang */
3009             if (app_isdir(p) > 0) {
3010 #if 0                           /* must check buffer size */
3011                 strcat(p, "/index.html");
3012 #else
3013                 BIO_puts(io, text);
3014                 BIO_printf(io, "'%s' is a directory\r\n", p);
3015                 break;
3016 #endif
3017             }
3018
3019             if ((file = BIO_new_file(p, "r")) == NULL) {
3020                 BIO_puts(io, text);
3021                 BIO_printf(io, "Error opening '%s'\r\n", p);
3022                 ERR_print_errors(io);
3023                 break;
3024             }
3025
3026             if (!s_quiet)
3027                 BIO_printf(bio_err, "FILE:%s\n", p);
3028
3029             if (www == 2) {
3030                 i = strlen(p);
3031                 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3032                     ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3033                     ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3034                     BIO_puts(io,
3035                              "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3036                 else
3037                     BIO_puts(io,
3038                              "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3039             }
3040             /* send the file */
3041             for (;;) {
3042                 i = BIO_read(file, buf, bufsize);
3043                 if (i <= 0)
3044                     break;
3045
3046 #ifdef RENEG
3047                 total_bytes += i;
3048                 fprintf(stderr, "%d\n", i);
3049                 if (total_bytes > 3 * 1024) {
3050                     total_bytes = 0;
3051                     fprintf(stderr, "RENEGOTIATE\n");
3052                     SSL_renegotiate(con);
3053                 }
3054 #endif
3055
3056                 for (j = 0; j < i;) {
3057 #ifdef RENEG
3058                     {
3059                         static count = 0;
3060                         if (++count == 13) {
3061                             SSL_renegotiate(con);
3062                         }
3063                     }
3064 #endif
3065                     k = BIO_write(io, &(buf[j]), i - j);
3066                     if (k <= 0) {
3067                         if (!BIO_should_retry(io))
3068                             goto write_error;
3069                         else {
3070                             BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3071                         }
3072                     } else {
3073                         j += k;
3074                     }
3075                 }
3076             }
3077  write_error:
3078             BIO_free(file);
3079             break;
3080         }
3081     }
3082
3083     for (;;) {
3084         i = (int)BIO_flush(io);
3085         if (i <= 0) {
3086             if (!BIO_should_retry(io))
3087                 break;
3088         } else
3089             break;
3090     }
3091  end:
3092 #if 1
3093     /* make sure we re-use sessions */
3094     SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3095 #else
3096     /* This kills performance */
3097     /*
3098      * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3099      * procession
3100      */
3101 #endif
3102
3103  err:
3104
3105     if (ret >= 0)
3106         BIO_printf(bio_s_out, "ACCEPT\n");
3107
3108     if (buf != NULL)
3109         OPENSSL_free(buf);
3110     if (io != NULL)
3111         BIO_free_all(io);
3112 /*      if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3113     return (ret);
3114 }
3115
3116 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3117 {
3118     char *buf = NULL;
3119     int i;
3120     int ret = 1;
3121     SSL *con;
3122     BIO *io, *ssl_bio, *sbio;
3123 #ifndef OPENSSL_NO_KRB5
3124     KSSL_CTX *kctx;
3125 #endif
3126
3127     buf = OPENSSL_malloc(bufsize);
3128     if (buf == NULL)
3129         return (0);
3130     io = BIO_new(BIO_f_buffer());
3131     ssl_bio = BIO_new(BIO_f_ssl());
3132     if ((io == NULL) || (ssl_bio == NULL))
3133         goto err;
3134
3135     /* lets make the output buffer a reasonable size */
3136     if (!BIO_set_write_buffer_size(io, bufsize))
3137         goto err;
3138
3139     if ((con = SSL_new(ctx)) == NULL)
3140         goto err;
3141 #ifndef OPENSSL_NO_TLSEXT
3142     if (s_tlsextdebug) {
3143         SSL_set_tlsext_debug_callback(con, tlsext_cb);
3144         SSL_set_tlsext_debug_arg(con, bio_s_out);
3145     }
3146 #endif
3147 #ifndef OPENSSL_NO_KRB5
3148     if ((kctx = kssl_ctx_new()) != NULL) {
3149         kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3150         kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3151     }
3152 #endif                          /* OPENSSL_NO_KRB5 */
3153     if (context)
3154         SSL_set_session_id_context(con, context, strlen((char *)context));
3155
3156     sbio = BIO_new_socket(s, BIO_NOCLOSE);
3157     SSL_set_bio(con, sbio, sbio);
3158     SSL_set_accept_state(con);
3159
3160     BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3161     BIO_push(io, ssl_bio);
3162 #ifdef CHARSET_EBCDIC
3163     io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3164 #endif
3165
3166     if (s_debug) {
3167         SSL_set_debug(con, 1);
3168         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3169         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3170     }
3171     if (s_msg) {
3172 #ifndef OPENSSL_NO_SSL_TRACE
3173         if (s_msg == 2)
3174             SSL_set_msg_callback(con, SSL_trace);
3175         else
3176 #endif
3177             SSL_set_msg_callback(con, msg_cb);
3178         SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3179     }
3180
3181     for (;;) {
3182         i = BIO_do_handshake(io);
3183         if (i > 0)
3184             break;
3185         if (!BIO_should_retry(io)) {
3186             BIO_puts(bio_err, "CONNECTION FAILURE\n");
3187             ERR_print_errors(bio_err);
3188             goto end;
3189         }
3190     }
3191     BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3192     print_ssl_summary(bio_err, con);
3193
3194     for (;;) {
3195         i = BIO_gets(io, buf, bufsize - 1);
3196         if (i < 0) {            /* error */
3197             if (!BIO_should_retry(io)) {
3198                 if (!s_quiet)
3199                     ERR_print_errors(bio_err);
3200                 goto err;
3201             } else {
3202                 BIO_printf(bio_s_out, "read R BLOCK\n");
3203 #if defined(OPENSSL_SYS_NETWARE)
3204                 delay(1000);
3205 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3206                 sleep(1);
3207 #endif
3208                 continue;
3209             }
3210         } else if (i == 0) {    /* end of input */
3211             ret = 1;
3212             BIO_printf(bio_err, "CONNECTION CLOSED\n");
3213             goto end;
3214         } else {
3215             char *p = buf + i - 1;
3216             while (i && (*p == '\n' || *p == '\r')) {
3217                 p--;
3218                 i--;
3219             }
3220             if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3221                 ret = 1;
3222                 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3223                 goto end;
3224             }
3225             BUF_reverse((unsigned char *)buf, NULL, i);
3226             buf[i] = '\n';
3227             BIO_write(io, buf, i + 1);
3228             for (;;) {
3229                 i = BIO_flush(io);
3230                 if (i > 0)
3231                     break;
3232                 if (!BIO_should_retry(io))
3233                     goto end;
3234             }
3235         }
3236     }
3237  end:
3238     /* make sure we re-use sessions */
3239     SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3240
3241  err:
3242
3243     if (buf != NULL)
3244         OPENSSL_free(buf);
3245     if (io != NULL)
3246         BIO_free_all(io);
3247     return (ret);
3248 }
3249
3250 #ifndef OPENSSL_NO_RSA
3251 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3252 {
3253     BIGNUM *bn = NULL;
3254     static RSA *rsa_tmp = NULL;
3255
3256     if (!rsa_tmp && ((bn = BN_new()) == NULL))
3257         BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3258     if (!rsa_tmp && bn) {
3259         if (!s_quiet) {
3260             BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3261                        keylength);
3262             (void)BIO_flush(bio_err);
3263         }
3264         if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3265             !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3266             if (rsa_tmp)
3267                 RSA_free(rsa_tmp);
3268             rsa_tmp = NULL;
3269         }
3270         if (!s_quiet) {
3271             BIO_printf(bio_err, "\n");
3272             (void)BIO_flush(bio_err);
3273         }
3274         BN_free(bn);
3275     }
3276     return (rsa_tmp);
3277 }
3278 #endif
3279
3280 #define MAX_SESSION_ID_ATTEMPTS 10
3281 static int generate_session_id(const SSL *ssl, unsigned char *id,
3282                                unsigned int *id_len)
3283 {
3284     unsigned int count = 0;
3285     do {
3286         if (RAND_pseudo_bytes(id, *id_len) < 0)
3287             return 0;
3288         /*
3289          * Prefix the session_id with the required prefix. NB: If our prefix
3290          * is too long, clip it - but there will be worse effects anyway, eg.
3291          * the server could only possibly create 1 session ID (ie. the
3292          * prefix!) so all future session negotiations will fail due to
3293          * conflicts.
3294          */
3295         memcpy(id, session_id_prefix,
3296                (strlen(session_id_prefix) < *id_len) ?
3297                strlen(session_id_prefix) : *id_len);
3298     }
3299     while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3300            (++count < MAX_SESSION_ID_ATTEMPTS));
3301     if (count >= MAX_SESSION_ID_ATTEMPTS)
3302         return 0;
3303     return 1;
3304 }
3305
3306 /*
3307  * By default s_server uses an in-memory cache which caches SSL_SESSION
3308  * structures without any serialisation. This hides some bugs which only
3309  * become apparent in deployed servers. By implementing a basic external
3310  * session cache some issues can be debugged using s_server.
3311  */
3312
3313 typedef struct simple_ssl_session_st {
3314     unsigned char *id;
3315     unsigned int idlen;
3316     unsigned char *der;
3317     int derlen;
3318     struct simple_ssl_session_st *next;
3319 } simple_ssl_session;
3320
3321 static simple_ssl_session *first = NULL;
3322
3323 static int add_session(SSL *ssl, SSL_SESSION *session)
3324 {
3325     simple_ssl_session *sess;
3326     unsigned char *p;
3327
3328     sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3329     if (!sess) {
3330         BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3331         return 0;
3332     }
3333
3334     SSL_SESSION_get_id(session, &sess->idlen);
3335     sess->derlen = i2d_SSL_SESSION(session, NULL);
3336
3337     sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3338
3339     sess->der = OPENSSL_malloc(sess->derlen);
3340     if (!sess->id || !sess->der) {
3341         BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3342
3343         if (sess->id)
3344             OPENSSL_free(sess->id);
3345         if (sess->der)
3346             OPENSSL_free(sess->der);
3347         OPENSSL_free(sess);
3348         return 0;
3349     }
3350     p = sess->der;
3351     i2d_SSL_SESSION(session, &p);
3352
3353     sess->next = first;
3354     first = sess;
3355     BIO_printf(bio_err, "New session added to external cache\n");
3356     return 0;
3357 }
3358
3359 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3360                                 int *do_copy)
3361 {
3362     simple_ssl_session *sess;
3363     *do_copy = 0;
3364     for (sess = first; sess; sess = sess->next) {
3365         if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3366             const unsigned char *p = sess->der;
3367             BIO_printf(bio_err, "Lookup session: cache hit\n");
3368             return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3369         }
3370     }
3371     BIO_printf(bio_err, "Lookup session: cache miss\n");
3372     return NULL;
3373 }
3374
3375 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3376 {
3377     simple_ssl_session *sess, *prev = NULL;
3378     const unsigned char *id;
3379     unsigned int idlen;
3380     id = SSL_SESSION_get_id(session, &idlen);
3381     for (sess = first; sess; sess = sess->next) {
3382         if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3383             if (prev)
3384                 prev->next = sess->next;
3385             else
3386                 first = sess->next;
3387             OPENSSL_free(sess->id);
3388             OPENSSL_free(sess->der);
3389             OPENSSL_free(sess);
3390             return;
3391         }
3392         prev = sess;
3393     }
3394 }
3395
3396 static void init_session_cache_ctx(SSL_CTX *sctx)
3397 {
3398     SSL_CTX_set_session_cache_mode(sctx,
3399                                    SSL_SESS_CACHE_NO_INTERNAL |
3400                                    SSL_SESS_CACHE_SERVER);
3401     SSL_CTX_sess_set_new_cb(sctx, add_session);
3402     SSL_CTX_sess_set_get_cb(sctx, get_session);
3403     SSL_CTX_sess_set_remove_cb(sctx, del_session);
3404 }
3405
3406 static void free_sessions(void)
3407 {
3408     simple_ssl_session *sess, *tsess;
3409     for (sess = first; sess;) {
3410         OPENSSL_free(sess->id);
3411         OPENSSL_free(sess->der);
3412         tsess = sess;
3413         sess = sess->next;
3414         OPENSSL_free(tsess);
3415     }
3416     first = NULL;
3417 }