/*
 * Copyright (C) 2004-2016 Free Software Foundation, Inc.
 * Copyright (C) 2013 Adam Sampson <ats@offog.org>
 * Copyright (C) 2016-2018 Red Hat, Inc.
 *
 * Author: Simon Josefsson, Nikos Mavrogiannopoulos
 *
 * This file is part of GnuTLS.
 *
 * GnuTLS is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuTLS is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>
 */

/* Parts copied from GnuTLS example programs. */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>

#if defined(_WIN32)

/* socketpair isn't supported on Win32. */
int main(int argc, char **argv)
{
	exit(77);
}

#else

#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#if !defined(_WIN32)
#include <sys/wait.h>
#endif
#include <unistd.h>
#include <gnutls/gnutls.h>
#include <sys/wait.h>
#include <signal.h>
#include <assert.h>
#include "utils.h"
#include "cert-common.h"
#include "virt-time.h"

static void wrap_db_init(void);
static void wrap_db_deinit(void);
static int wrap_db_store(void *dbf, gnutls_datum_t key,
			 gnutls_datum_t data);
static gnutls_datum_t wrap_db_fetch(void *dbf, gnutls_datum_t key);
static int wrap_db_delete(void *dbf, gnutls_datum_t key);

#define TLS_SESSION_CACHE 50

struct params_res {
	const char *desc;
	int enable_db;
	int enable_session_ticket_server;
	int enable_session_ticket_client;
	int expect_resume;
	int call_post_client_hello;
	int client_cert;
	int first_no_ext_master;
	int second_no_ext_master;
	int try_alpn;
	int try_resumed_data;
	int try_diff_sni;
	int try_sni;
	int expire_ticket;
	int change_ciphersuite;
	int early_start;
	int no_early_start;
};

pid_t child;

struct params_res resume_tests[] = {
#ifndef TLS13
	{.desc = "try to resume from db",
	 .enable_db = 1,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 0,
	 .expect_resume = 1},
	{.desc = "try to resume from db with post_client_hello",
	 .enable_db = 1,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 0,
	 .call_post_client_hello = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from db using resumed session's data",
	 .enable_db = 1,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 0,
	 .try_resumed_data = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from db and check ALPN",
	 .enable_db = 1,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 0,
	 .try_alpn = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from db (ext master secret -> none)",
	 .enable_db = 1,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 0,
	 .expect_resume = 0,
	 .first_no_ext_master = 0,
	 .second_no_ext_master = 1},
	{.desc = "try to resume from db (none -> ext master secret)",
	 .enable_db = 1,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 0,
	 .expect_resume = 0,
	 .first_no_ext_master = 1,
	 .second_no_ext_master = 0},
#endif
#if defined(TLS13)
	/* only makes sense under TLS1.3 as negotiation involves a new
	 * handshake with different parameters */
	{.desc = "try to resume from session ticket (different cipher order)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .change_ciphersuite = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from session ticket with post_client_hello",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .call_post_client_hello = 1,
	 .expect_resume = 1},
#endif
#if defined(TLS13) && !defined(USE_PSK)
	{.desc = "try to resume from session ticket (early start)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .early_start = 1,
	 .expect_resume = 1},
#endif
#if defined(TLS13) && defined(USE_PSK)
	/* early start should no happen on PSK. */
	{.desc = "try to resume from session ticket (early start)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .no_early_start = 1,
	 .expect_resume = 1},
#endif
	{.desc = "try to resume from session ticket",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from session ticket (client cert)",
	 .enable_db = 0,
	 .client_cert = 1,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from session ticket (expired)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .expire_ticket = 1,
	 .expect_resume = 0},
	{.desc = "try to resume from session ticket using resumed session's data",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .try_resumed_data = 1,
	 .expect_resume = 1},
#ifndef TLS13
	{.desc = "try to resume from session ticket (ext master secret -> none)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .expect_resume = 0,
	 .first_no_ext_master = 0,
	 .second_no_ext_master = 1},
	{.desc = "try to resume from session ticket (none -> ext master secret)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .expect_resume = 0,
	 .first_no_ext_master = 1,
	 .second_no_ext_master = 0},
	{.desc = "try to resume from session ticket (server only)",
	  .enable_db = 0,
	  .enable_session_ticket_server = 1,
	  .enable_session_ticket_client = 0,
	  .expect_resume = 0},
	{.desc = "try to resume from session ticket (client only)",
	 .enable_db = 0,
	 .enable_session_ticket_server = 0,
	 .enable_session_ticket_client = 1,
	 .expect_resume = 0},
	{.desc = "try to resume from db and ticket",
	 .enable_db = 1,
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .expect_resume = 1},
	{.desc = "try to resume from db and different SNI",
	 .enable_db = 1,
	 .try_sni = 1,
	 .try_diff_sni = 1,
	 .expect_resume = 0},
	{.desc = "try to resume with ticket and different SNI",
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .try_sni = 1,
	 .try_diff_sni = 1,
	 .expect_resume = 0},
	{.desc = "try to resume from db and same SNI",
	 .enable_db = 1,
	 .try_sni = 1,
	 .expect_resume = 1},
#endif
	{.desc = "try to resume with ticket and same SNI",
	 .enable_session_ticket_server = 1,
	 .enable_session_ticket_client = 1,
	 .try_sni = 1,
	 .expect_resume = 1},
	{NULL, -1}
};

/* A very basic TLS client, with anonymous authentication.
 */

#define SESSIONS 3
#define MAX_BUF 5*1024
#define MSG "Hello TLS"

#define HANDSHAKE_SESSION_ID_POS (2+32)

static void tls_log_func(int level, const char *str)
{
	fprintf(stderr, "%s |<%d>| %s", child ? "server" : "client", level,
		str);
}

static int post_client_hello_callback(gnutls_session_t session)
{
	/* switches the supported ciphersuites to something compatible */
	assert(gnutls_priority_set_direct(session, gnutls_session_get_ptr(session), NULL) >= 0);
	return 0;
}

static int hsk_hook_cb(gnutls_session_t session, unsigned int htype, unsigned post,
			unsigned int incoming, const gnutls_datum_t *_msg)
{
	unsigned size;
	gnutls_datum_t msg = {_msg->data, _msg->size};

	/* skip up to session ID */
	if (msg.size <= HANDSHAKE_SESSION_ID_POS+6) {
		fail("Cannot parse server hello\n");
		return -1;
	}

	msg.data += HANDSHAKE_SESSION_ID_POS;
	msg.size -= HANDSHAKE_SESSION_ID_POS;
	size = msg.data[0];

	if (msg.size <= size) {
		fail("Cannot parse server hello 2\n");
		return -1;
	}

	msg.data += size;
	msg.size -= size;

	if (memmem(msg.data, msg.size, "\x00\x17\x00\x00", 4) == 0) {
		fail("Extended master secret extension was not found in resumed session hello\n");
		exit(1);
	}
	return 0;
}

static void append_alpn(gnutls_session_t session, struct params_res *params, unsigned alpn_counter)
{
	gnutls_datum_t protocol;
	int ret;
	char str[64];

	if (!params->try_alpn)
		return;

	snprintf(str, sizeof(str), "myproto-%d", alpn_counter);

	protocol.data = (void*)str;
	protocol.size = strlen(str);

	ret = gnutls_alpn_set_protocols(session, &protocol, 1, 0);
	if (ret < 0) {
		gnutls_perror(ret);
		exit(1);
	}
}

static void verify_alpn(gnutls_session_t session, struct params_res *params, unsigned alpn_counter)
{
	int ret;
	gnutls_datum_t selected;
	char str[64];

	if (!params->try_alpn)
		return;

	snprintf(str, sizeof(str), "myproto-%d", alpn_counter);

	ret = gnutls_alpn_get_selected_protocol(session, &selected);
	if (ret < 0) {
		gnutls_perror(ret);
		exit(1);
	}

	if (strlen(str) != selected.size || memcmp(str, selected.data, selected.size) != 0) {
		fail("expected protocol %s, got %.*s\n", str, selected.size, selected.data);
		exit(1);
	}

	if (debug)
		success("ALPN got: %s\n", str);
}

static void verify_group(gnutls_session_t session, gnutls_group_t *group, unsigned counter)
{
	if (counter == 0) {
		*group = gnutls_group_get(session);
		return;
	}

	if (gnutls_group_get(session) != *group) {
		fail("expected group %s, got group %s\n", gnutls_group_get_name(*group),
		     gnutls_group_get_name(gnutls_group_get(session)));
	}
}

static void verify_server_params(gnutls_session_t session, unsigned counter, struct params_res *params)
{
	static char id[GNUTLS_MAX_SESSION_ID];
	static size_t id_size = 0;
#if defined(USE_PSK)
	const char *username;
	username = gnutls_psk_server_get_username(session);
	if (counter != 0) {
		if (username == NULL)
			fail("no username was returned on server side resumption\n");

		if (strcmp(username, "test") != 0)
			fail("wrong username was returned on server side resumption\n");
	}
#endif

	if (counter == 0 && params->early_start) {
		if (!(gnutls_session_get_flags(session) & GNUTLS_SFLAGS_EARLY_START)) {
			fail("early start did not happen on %d!\n", counter);
		}
	}

	if (counter > 0) {
		if (gnutls_session_resumption_requested(session) == 0) {
			fail("client did not request resumption!\n");
		}
	}

	if (params->no_early_start) {
		if (gnutls_session_get_flags(session) & GNUTLS_SFLAGS_EARLY_START) {
			fail("early start did happen on %d but was not expected!\n", counter);
		}
	}

#if defined(USE_X509)
	unsigned int l;

	if (gnutls_certificate_type_get(session) != GNUTLS_CRT_X509)
		fail("did not find the expected X509 certificate type! (%d)\n", gnutls_certificate_type_get(session));

	if (counter == 0 && gnutls_certificate_get_ours(session) == NULL)
		fail("no certificate returned on server side (%s)\n", counter ? "resumed session" : "first session");
	else if (counter != 0 && gnutls_certificate_get_ours(session) != NULL)
		fail("certificate was returned on server side (%s)\n", counter ? "resumed session" : "first session");

	if (params->client_cert) {
		if (gnutls_certificate_get_peers(session, &l) == NULL || l < 1)
			fail("no client certificate returned on server side (%s)\n", counter ? "resumed session" : "first session");
	}
#endif

	/* verify whether the session ID remains the same between sessions */
	if (counter == 0) {
		id_size = sizeof(id);
		assert(gnutls_session_get_id(session, id, &id_size) >= 0);
	} else {
		char id2[GNUTLS_MAX_SESSION_ID];
		size_t id2_size = sizeof(id2);

		if (id_size == 0)
			fail("no session ID was set\n");

		assert(gnutls_session_get_id(session, id2, &id2_size) >= 0);

		if (id_size != id2_size || memcmp(id, id2, id_size) != 0) {
			hexprint(id, id_size);
			printf("\n");
			hexprint(id2, id2_size);
			fail("resumed session ID does not match original\n");
		}
	}

	return;
}

static void verify_client_params(gnutls_session_t session, unsigned counter)
{
#if defined(USE_X509)
	unsigned int l;
	if (gnutls_certificate_get_peers(session, &l) == NULL || l < 1)
		fail("no server certificate returned on client side (%s)\n", counter ? "resumed session" : "first session");
#else
	return;
#endif
}

#ifdef TLS12
# define VERS_STR "+VERS-TLS1.2"
#endif
#ifdef TLS13
# define VERS_STR "-VERS-ALL:+VERS-TLS1.3"
#endif

static void client(int sds[], struct params_res *params)
{
	int ret, ii;
	gnutls_session_t session;
	char buffer[MAX_BUF + 1];
	unsigned int ext_master_secret_check = 0;
	gnutls_group_t pgroup;
	char prio_str[256];
	const char *dns_name1 = "example.com";
	const char *dns_name2 = "www.example.com";
#ifdef USE_PSK
# define PRIO_STR "NONE:"VERS_STR":+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+PSK:+CURVE-ALL"
	const gnutls_datum_t pskkey = { (void *) "DEADBEEF", 8 };
	gnutls_psk_client_credentials_t pskcred;
#elif defined(USE_ANON)
# define PRIO_STR "NONE:"VERS_STR":+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+ANON-DH:+CURVE-ALL"
	gnutls_anon_client_credentials_t anoncred;
#elif defined(USE_X509)
# define PRIO_STR "NONE:"VERS_STR":+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ECDHE-RSA:+RSA:+CURVE-ALL"
	gnutls_certificate_credentials_t clientx509cred;
#endif

	/* Need to enable anonymous KX specifically. */

	/* variables used in session resuming
	 */
	int t;
	gnutls_datum_t session_data = {NULL, 0};

	if (debug) {
		gnutls_global_set_log_function(tls_log_func);
		gnutls_global_set_log_level(4);
	}

#ifdef USE_PSK
	gnutls_psk_allocate_client_credentials(&pskcred);
	gnutls_psk_set_client_credentials(pskcred, "test", &pskkey, GNUTLS_PSK_KEY_HEX);
#elif defined(USE_ANON)
	gnutls_anon_allocate_client_credentials(&anoncred);
#elif defined(USE_X509)
	gnutls_certificate_allocate_credentials(&clientx509cred);

	if (params->client_cert) {
		assert(gnutls_certificate_set_x509_key_mem(clientx509cred,
							   &cli_cert, &cli_key,
							   GNUTLS_X509_FMT_PEM) >= 0);
	}
#endif

	for (t = 0; t < SESSIONS; t++) {
		int sd = sds[t];

		assert(gnutls_init(&session, GNUTLS_CLIENT)>=0);

		snprintf(prio_str, sizeof(prio_str), "%s", PRIO_STR);

		/* Use default priorities */
		if (params->enable_session_ticket_client == 0) {
			strcat(prio_str, ":%NO_TICKETS");
		}

		if (params->first_no_ext_master && t == 0) {
			strcat(prio_str, ":%NO_SESSION_HASH");
			ext_master_secret_check = 0;
		}

		if (params->second_no_ext_master && t > 0) {
			strcat(prio_str, ":%NO_SESSION_HASH");
			ext_master_secret_check = 0;
		}

		if (params->change_ciphersuite) {
			if (t > 0)
				strcat(prio_str, ":-CIPHER-ALL:+AES-256-GCM:+AES-128-GCM");
			else
				strcat(prio_str, ":-CIPHER-ALL:+AES-128-GCM");
		}

		append_alpn(session, params, t);

		ret = gnutls_priority_set_direct(session, prio_str, NULL);
		if (ret < 0) {
			fail("prio: %s\n", gnutls_strerror(ret));
		}

		/* put the anonymous credentials to the current session
		 */
#ifdef USE_PSK
		gnutls_credentials_set(session, GNUTLS_CRD_PSK, pskcred);
#elif defined(USE_ANON)
		gnutls_credentials_set(session, GNUTLS_CRD_ANON, anoncred);
#elif defined(USE_X509)
		gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, clientx509cred);
#endif

		if (t > 0) {
			/* if this is not the first time we connect */
			gnutls_session_set_data(session, session_data.data,
						session_data.size);
			if (params->try_diff_sni)
				gnutls_server_name_set(session, GNUTLS_NAME_DNS, dns_name1, strlen(dns_name1));
			else if (params->try_sni)
				gnutls_server_name_set(session, GNUTLS_NAME_DNS, dns_name2, strlen(dns_name2));

		} else {
			if (params->try_sni)
				gnutls_server_name_set(session, GNUTLS_NAME_DNS, dns_name2, strlen(dns_name2));
		}

		if (ext_master_secret_check)
			gnutls_handshake_set_hook_function(session, GNUTLS_HANDSHAKE_SERVER_HELLO, GNUTLS_HOOK_PRE, hsk_hook_cb);
		gnutls_transport_set_int(session, sd);

		/* Perform the TLS handshake
		 */
		gnutls_handshake_set_timeout(session, 20 * 1000);
		do {
			ret = gnutls_handshake(session);
		} while (ret < 0 && gnutls_error_is_fatal(ret) == 0);

		if (ret < 0) {
			fail("client: Handshake failed\n");
			gnutls_perror(ret);
			goto end;
		} else {
			if (debug)
				success
				    ("client: Handshake was completed\n");
		}

		ext_master_secret_check = 0;
		if (t == 0) {
			ext_master_secret_check =  gnutls_session_ext_master_secret_status(session);

			/* get the session data size */
			ret =
			    gnutls_session_get_data2(session,
						     &session_data);
			if (ret < 0)
				fail("Getting resume data failed\n");

		} else {	/* the second time we connect */
			if (params->try_resumed_data) {
				gnutls_free(session_data.data);
				ret =
				    gnutls_session_get_data2(session,
							     &session_data);
				if (ret < 0)
					fail("Getting resume data failed\n");
			}

			/* check if we actually resumed the previous session */
			if (gnutls_session_is_resumed(session) != 0) {
				if (params->expect_resume) {
					if (debug)
						success
						    ("- Previous session was resumed\n");
				} else
					fail("- Previous session was resumed but NOT expected\n");
			} else {
				if (params->expect_resume) {
					fail("*** Previous session was NOT resumed\n");
				} else {
					if (debug)
						success
						    ("*** Previous session was NOT resumed (expected)\n");
				}
			}

			if (params->change_ciphersuite) {
				/* check if the expected cipher was negotiated */
				if (gnutls_cipher_get(session) != GNUTLS_CIPHER_AES_128_GCM) {
					fail("negotiated different cipher: %s\n",
					     gnutls_cipher_get_name(gnutls_cipher_get(session)));
				}
			}
		}

		verify_alpn(session, params, t);
		verify_group(session, &pgroup, t);

		if (params->expect_resume)
			verify_client_params(session, t);

		gnutls_record_send(session, MSG, strlen(MSG));

		do {
			ret = gnutls_record_recv(session, buffer, MAX_BUF);
		} while (ret == GNUTLS_E_AGAIN);
		if (ret == 0) {
			if (debug)
				success
				    ("client: Peer has closed the TLS connection\n");
			goto end;
		} else if (ret < 0) {
			fail("client: Error: %s\n", gnutls_strerror(ret));
			goto end;
		}

		if (debug) {
			printf("- Received %d bytes: ", ret);
			for (ii = 0; ii < ret; ii++) {
				fputc(buffer[ii], stdout);
			}
			fputs("\n", stdout);
		}

		gnutls_bye(session, GNUTLS_SHUT_RDWR);

		close(sd);

		gnutls_deinit(session);
	}
	gnutls_free(session_data.data);

      end:
#ifdef USE_PSK
	gnutls_psk_free_client_credentials(pskcred);
#elif defined(USE_ANON)
	gnutls_anon_free_client_credentials(anoncred);
#elif defined(USE_X509)
	gnutls_certificate_free_credentials(clientx509cred);
#endif
}

#define DH_BITS 1024

/* These are global */
static gnutls_datum_t session_ticket_key = { NULL, 0 };


static gnutls_dh_params_t dh_params;

#ifdef USE_PSK
gnutls_psk_server_credentials_t pskcred;
#elif defined(USE_ANON)
gnutls_anon_server_credentials_t anoncred;
#elif defined(USE_X509)
gnutls_certificate_credentials_t serverx509cred;
#endif

static int generate_dh_params(void)
{
	const gnutls_datum_t p3 = { (void *) pkcs3, strlen(pkcs3) };
	/* Generate Diffie-Hellman parameters - for use with DHE
	 * kx algorithms. These should be discarded and regenerated
	 * once a day, once a week or once a month. Depending on the
	 * security requirements.
	 */
	gnutls_dh_params_init(&dh_params);
	return gnutls_dh_params_import_pkcs3(dh_params, &p3,
					     GNUTLS_X509_FMT_PEM);
}


static void global_stop(void)
{
	if (debug)
		success("global stop\n");

#ifdef USE_PSK
	gnutls_psk_free_server_credentials(pskcred);
#elif defined(USE_ANON)
	gnutls_anon_free_server_credentials(anoncred);
#elif defined(USE_X509)
	gnutls_certificate_free_credentials(serverx509cred);
#endif
	gnutls_dh_params_deinit(dh_params);
}

#ifdef USE_PSK
static int
pskfunc(gnutls_session_t session, const char *username,
	gnutls_datum_t * key)
{
	if (debug)
		printf("psk: username %s\n", username);
	key->data = gnutls_malloc(4);
	key->data[0] = 0xDE;
	key->data[1] = 0xAD;
	key->data[2] = 0xBE;
	key->data[3] = 0xEF;
	key->size = 4;
	return 0;
}
#endif

static void server(int sds[], struct params_res *params)
{
	int t;
	int ret;
	gnutls_session_t session;
	char buffer[MAX_BUF + 1];
	gnutls_group_t pgroup;
	unsigned iflags = GNUTLS_SERVER;

	virt_time_init();

	if (params->early_start || params->no_early_start)
		iflags |= GNUTLS_ENABLE_EARLY_START;

	/* this must be called once in the program, it is mostly for the server.
	 */
	if (debug) {
		gnutls_global_set_log_function(tls_log_func);
		gnutls_global_set_log_level(4);
	}

#ifdef USE_PSK
	gnutls_psk_allocate_server_credentials(&pskcred);
	gnutls_psk_set_server_credentials_function(pskcred, pskfunc);
#elif defined(USE_ANON)
	gnutls_anon_allocate_server_credentials(&anoncred);
#elif defined(USE_X509)
	gnutls_certificate_allocate_credentials(&serverx509cred);
	assert(gnutls_certificate_set_x509_key_mem(serverx509cred,
		&server_cert, &server_key, GNUTLS_X509_FMT_PEM) >= 0);
#endif

	if (debug)
		success("Launched, generating DH parameters...\n");

	generate_dh_params();

#if USE_ANON
	gnutls_anon_set_server_dh_params(anoncred, dh_params);
#endif

	if (params->enable_db) {
		wrap_db_init();
	}

	if (params->enable_session_ticket_server)
		gnutls_session_ticket_key_generate(&session_ticket_key);

	for (t = 0; t < SESSIONS; t++) {
		int sd = sds[t];

		assert(gnutls_init(&session, iflags) >= 0);

		/* avoid calling all the priority functions, since the defaults
		 * are adequate.
		 */
		assert(gnutls_priority_set_direct(session,
						  PRIO_STR,
						  NULL) >= 0);


#if defined(USE_X509)
		if (params->client_cert) {
			gnutls_certificate_server_set_request(session,
							      GNUTLS_CERT_REQUIRE);
		}
#endif

		gnutls_dh_set_prime_bits(session, DH_BITS);

		if (params->enable_db) {
			gnutls_db_set_retrieve_function(session, wrap_db_fetch);
			gnutls_db_set_remove_function(session, wrap_db_delete);
			gnutls_db_set_store_function(session, wrap_db_store);
			gnutls_db_set_ptr(session, NULL);
		}

		if (params->enable_session_ticket_server)
			gnutls_session_ticket_enable_server(session,
							    &session_ticket_key);

		append_alpn(session, params, t);

		if (params->expire_ticket) {
			gnutls_db_set_cache_expiration(session, 45);
			virt_sec_sleep(60);
		}
#ifdef USE_PSK
		gnutls_credentials_set(session, GNUTLS_CRD_PSK, pskcred);
#elif defined(USE_ANON)
		gnutls_credentials_set(session, GNUTLS_CRD_ANON, anoncred);
#elif defined(USE_X509)
		gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, serverx509cred);
#endif
		gnutls_transport_set_int(session, sd);
		gnutls_handshake_set_timeout(session, 20 * 1000);

		if (params->call_post_client_hello) {
			gnutls_session_set_ptr(session, PRIO_STR);
			gnutls_handshake_set_post_client_hello_function(session,
									post_client_hello_callback);
		}


		do {
			ret = gnutls_handshake(session);
		} while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
		if (ret < 0) {
			close(sd);
			gnutls_deinit(session);
			kill(child, SIGTERM);
			fail("server: Handshake has failed (%s)\n\n",
			     gnutls_strerror(ret));
			return;
		}
		if (debug)
			success("server: Handshake was completed\n");

		if (t > 0 && params->expect_resume) {
			ret = gnutls_session_is_resumed(session);
			if (ret == 0) {
				fail("server: session_is_resumed error (%d)\n", t);
			}
		}

		verify_alpn(session, params, t);
		verify_group(session, &pgroup, t);

		if (params->expect_resume)
			verify_server_params(session, t, params);

		/* see the Getting peer's information example */
		/* print_info(session); */

		for (;;) {
			memset(buffer, 0, MAX_BUF + 1);
			ret = gnutls_record_recv(session, buffer, MAX_BUF);

			if (ret == 0) {
				if (debug)
					success
					    ("server: Peer has closed the GnuTLS connection\n");
				break;
			} else if (ret < 0) {
				kill(child, SIGTERM);
				fail("server: Received corrupted data(%d). Closing...\n", ret);
				break;
			} else if (ret > 0) {
				/* echo data back to the client
				 */
				gnutls_record_send(session, buffer,
						   strlen(buffer));
			}
		}
		/* do not wait for the peer to close the connection.
		 */
		gnutls_bye(session, GNUTLS_SHUT_WR);

		close(sd);

		gnutls_deinit(session);
	}

	if (params->enable_db) {
		wrap_db_deinit();
	}

	gnutls_free(session_ticket_key.data);

	if (debug)
		success("server: finished\n");
}

void doit(void)
{
	int i, err;

	signal(SIGCHLD, SIG_IGN);
	signal(SIGPIPE, SIG_IGN);

	for (i = 0; resume_tests[i].desc; i++) {
		int client_sds[SESSIONS], server_sds[SESSIONS];
		int j;

		printf("%s\n", resume_tests[i].desc);

		for (j = 0; j < SESSIONS; j++) {
			int sockets[2];

			err = socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
			if (err == -1) {
				perror("socketpair");
				fail("socketpair failed\n");
				return;
			}

			server_sds[j] = sockets[0];
			client_sds[j] = sockets[1];
		}

		child = fork();
		if (child < 0) {
			perror("fork");
			fail("fork");
			return;
		}

		if (child) {
			int status = 0;
			/* parent */
			for (j = 0; j < SESSIONS; j++)
				close(client_sds[j]);
			server(server_sds, &resume_tests[i]);

			waitpid(child, &status, 0);
			check_wait_status(status);
			global_stop();
		} else {
			for (j = 0; j < SESSIONS; j++)
				close(server_sds[j]);
			client(client_sds, &resume_tests[i]);
			exit(0);
		}
	}
}

/* Functions and other stuff needed for session resuming.
 * This is done using a very simple list which holds session ids
 * and session data.
 */

#define MAX_SESSION_ID_SIZE 32
#define MAX_SESSION_DATA_SIZE 1024

typedef struct {
	unsigned char session_id[MAX_SESSION_ID_SIZE];
	unsigned int session_id_size;

	char session_data[MAX_SESSION_DATA_SIZE];
	int session_data_size;
} CACHE;

static CACHE *cache_db;
static int cache_db_ptr = 0;

static void wrap_db_init(void)
{

	/* allocate cache_db */
	cache_db = calloc(1, TLS_SESSION_CACHE * sizeof(CACHE));
}

static void wrap_db_deinit(void)
{
	free(cache_db);
	cache_db = NULL;
	return;
}

static int
wrap_db_store(void *dbf, gnutls_datum_t key, gnutls_datum_t data)
{
	time_t t, e, now = time(0);

#ifdef DEBUG_CACHE
	if (debug) {
		unsigned int i;
		fprintf(stderr, "resume db storing (%d-%d): ", key.size,
			data.size);
		for (i = 0; i < key.size; i++) {
			fprintf(stderr, "%02x", key.data[i] & 0xFF);
		}
		fprintf(stderr, "\n");
		fprintf(stderr, "data: ");
		for (i = 0; i < data.size; i++) {
			fprintf(stderr, "%02x", data.data[i] & 0xFF);
		}
		fprintf(stderr, "\n");
	}
#endif

	/* check the correctness of gnutls_db_check_entry_time() */
	t = gnutls_db_check_entry_time(&data);
	if (t < now - 10 || t > now + 10) {
		fail("Time returned by gnutls_db_check_entry_time is bogus\n");
		exit(1);
	}

	/* check the correctness of gnutls_db_check_entry_expire_time() */
	e = gnutls_db_check_entry_expire_time(&data);
	if (e < t) {
		fail("Time returned by gnutls_db_check_entry_expire_time is bogus\n");
		exit(1);
	}

	if (cache_db == NULL)
		return -1;

	if (key.size > MAX_SESSION_ID_SIZE) {
		fail("Key size is too large\n");
		return -1;
	}

	if (data.size > MAX_SESSION_DATA_SIZE) {
		fail("Data size is too large\n");
		return -1;
	}

	memcpy(cache_db[cache_db_ptr].session_id, key.data, key.size);
	cache_db[cache_db_ptr].session_id_size = key.size;

	memcpy(cache_db[cache_db_ptr].session_data, data.data, data.size);
	cache_db[cache_db_ptr].session_data_size = data.size;

	cache_db_ptr++;
	cache_db_ptr %= TLS_SESSION_CACHE;

	return 0;
}

static gnutls_datum_t wrap_db_fetch(void *dbf, gnutls_datum_t key)
{
	gnutls_datum_t res = { NULL, 0 };
	unsigned i;

	if (debug) {
		fprintf(stderr, "resume db looking for (%d): ", key.size);
		for (i = 0; i < key.size; i++) {
			fprintf(stderr, "%02x", key.data[i] & 0xFF);
		}
		fprintf(stderr, "\n");
	}

	if (cache_db == NULL)
		return res;

	for (i = 0; i < TLS_SESSION_CACHE; i++) {
		if (key.size == cache_db[i].session_id_size &&
		    memcmp(key.data, cache_db[i].session_id,
			   key.size) == 0) {
			if (debug)
				success
				    ("resume db fetch... return info\n");

			res.size = cache_db[i].session_data_size;

			res.data = gnutls_malloc(res.size);
			if (res.data == NULL)
				return res;

			memcpy(res.data, cache_db[i].session_data,
				res.size);

#ifdef DEBUG_CACHE
			if (debug) {
				unsigned int j;
				printf("data:\n");
				for (j = 0; j < res.size; j++) {
					printf("%02x ",
						res.data[j] & 0xFF);
					if ((j + 1) % 16 == 0)
						printf("\n");
				}
				printf("\n");
			}
#endif
			return res;
		}
	}

	if (debug)
		success("resume db fetch... NOT FOUND\n");
	return res;
}

static int wrap_db_delete(void *dbf, gnutls_datum_t key)
{
	int i;

	if (cache_db == NULL)
		return -1;

	for (i = 0; i < TLS_SESSION_CACHE; i++) {
		if (key.size == cache_db[i].session_id_size &&
		    memcmp(key.data, cache_db[i].session_id,
			   key.size) == 0) {

			cache_db[i].session_id_size = 0;
			cache_db[i].session_data_size = 0;

			return 0;
		}
	}

	return -1;

}

#endif				/* _WIN32 */