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