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