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