/*

 * Copyright (C) 2002-2016 Free Software Foundation, Inc.

 * Copyright (C) 2014-2016 Nikos Mavrogiannopoulos

 * Copyright (C) 2015-2016 Red Hat, Inc.

 *

 * Author: Nikos Mavrogiannopoulos

 *

 * This file is part of GnuTLS.

 *

 * The GnuTLS is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public License

 * as published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser 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 <http://www.gnu.org/licenses/>

 *

 */

/* Functions to manipulate the session (gnutls_int.h), and some other stuff

 * are included here. The file's name is traditionally gnutls_state even if the

 * state has been renamed to session.

 */

#include "gnutls_int.h"

#include "errors.h"

#include <auth.h>

#include <num.h>

#include <datum.h>

#include <db.h>

#include <record.h>

#include <handshake.h>

#include <dh.h>

#include <buffers.h>

#include <mbuffers.h>

#include <state.h>

#include <constate.h>

#include <auth/cert.h>

#include <auth/anon.h>

#include <auth/psk.h>

#include <algorithms.h>

#include <extensions.h>

#include <system.h>

#include <random.h>

#include <fips.h>

#include <intprops.h>

#include <gnutls/dtls.h>

#include "dtls.h"

/* These should really be static, but src/tests.c calls them.  Make

   them public functions?  */

void

_gnutls_rsa_pms_set_version(gnutls_session_t session,

			    unsigned char major, unsigned char minor);

/**

 * gnutls_cipher_get:

 * @session: is a #gnutls_session_t type.

 *

 * Get currently used cipher.

 *

 * Returns: the currently used cipher, a #gnutls_cipher_algorithm_t

 *   type.

 **/

gnutls_cipher_algorithm_t gnutls_cipher_get(gnutls_session_t session)

{

	record_parameters_st *record_params;

	int ret;

	ret =

	    _gnutls_epoch_get(session, EPOCH_READ_CURRENT, &record_params);

	if (ret < 0)

		return gnutls_assert_val(GNUTLS_CIPHER_NULL);

	return record_params->cipher->id;

}

/**

 * gnutls_certificate_type_get:

 * @session: is a #gnutls_session_t type.

 *

 * The certificate type is by default X.509, unless it is negotiated

 * as a TLS extension.

 *

 * Returns: the currently used #gnutls_certificate_type_t certificate

 *   type.

 **/

gnutls_certificate_type_t

gnutls_certificate_type_get(gnutls_session_t session)

{

	return session->security_parameters.cert_type;

}

/**

 * gnutls_kx_get:

 * @session: is a #gnutls_session_t type.

 *

 * Get currently used key exchange algorithm.

 *

 * Returns: the key exchange algorithm used in the last handshake, a

 *   #gnutls_kx_algorithm_t value.

 **/

gnutls_kx_algorithm_t gnutls_kx_get(gnutls_session_t session)

{

	if (session->security_parameters.cs == 0)

		return 0;

	return session->security_parameters.cs->kx_algorithm;

}

/**

 * gnutls_mac_get:

 * @session: is a #gnutls_session_t type.

 *

 * Get currently used MAC algorithm.

 *

 * Returns: the currently used mac algorithm, a

 *   #gnutls_mac_algorithm_t value.

 **/

gnutls_mac_algorithm_t gnutls_mac_get(gnutls_session_t session)

{

	record_parameters_st *record_params;

	int ret;

	ret =

	    _gnutls_epoch_get(session, EPOCH_READ_CURRENT, &record_params);

	if (ret < 0)

		return gnutls_assert_val(GNUTLS_MAC_NULL);

	return record_params->mac->id;

}

/**

 * gnutls_compression_get:

 * @session: is a #gnutls_session_t type.

 *

 * Get currently used compression algorithm.

 *

 * Returns: the currently used compression method, a

 *   #gnutls_compression_method_t value.

 **/

gnutls_compression_method_t

gnutls_compression_get(gnutls_session_t session)

{

	return GNUTLS_COMP_NULL;

}

static void deinit_keys(gnutls_session_t session)

{

	gnutls_pk_params_release(&session->key.ecdh_params);

	gnutls_pk_params_release(&session->key.dh_params);

	zrelease_temp_mpi_key(&session->key.ecdh_x);

	zrelease_temp_mpi_key(&session->key.ecdh_y);

	_gnutls_free_temp_key_datum(&session->key.ecdhx);

	zrelease_temp_mpi_key(&session->key.client_Y);

	/* SRP */

	zrelease_temp_mpi_key(&session->key.srp_p);

	zrelease_temp_mpi_key(&session->key.srp_g);

	zrelease_temp_mpi_key(&session->key.srp_key);

	zrelease_temp_mpi_key(&session->key.u);

	zrelease_temp_mpi_key(&session->key.a);

	zrelease_temp_mpi_key(&session->key.x);

	zrelease_temp_mpi_key(&session->key.A);

	zrelease_temp_mpi_key(&session->key.B);

	zrelease_temp_mpi_key(&session->key.b);

	_gnutls_free_temp_key_datum(&session->key.key);

	_gnutls_free_temp_key_datum(&session->key.key);

}

/* An internal version of _gnutls_handshake_internal_state_clear(),

 * it will not attempt to deallocate, only initialize */

static void handshake_internal_state_clear1(gnutls_session_t session)

{

	/* by default no selected certificate */

	session->internals.adv_version_major = 0;

	session->internals.adv_version_minor = 0;

	session->internals.direction = 0;

	/* use out of band data for the last

	 * handshake messages received.

	 */

	session->internals.last_handshake_in = -1;

	session->internals.last_handshake_out = -1;

	session->internals.resumable = RESUME_TRUE;

	session->internals.handshake_suspicious_loops = 0;

	session->internals.dtls.hsk_read_seq = 0;

	session->internals.dtls.hsk_write_seq = 0;

	session->internals.have_ffdhe = 0;

	session->internals.cand_ec_group = 0;

	session->internals.cand_dh_group = 0;

}

/* This function will clear all the variables in internals

 * structure within the session, which depend on the current handshake.

 * This is used to allow further handshakes.

 */

void _gnutls_handshake_internal_state_clear(gnutls_session_t session)

{

	handshake_internal_state_clear1(session);

	_gnutls_handshake_hash_buffers_clear(session);

	deinit_keys(session);

	_gnutls_epoch_gc(session);

	session->internals.handshake_endtime = 0;

	session->internals.handshake_in_progress = 0;

	session->internals.tfo.connect_addrlen = 0;

	session->internals.tfo.connect_only = 0;

}

/**

 * gnutls_init:

 * @session: is a pointer to a #gnutls_session_t type.

 * @flags: indicate if this session is to be used for server or client.

 *

 * This function initializes the provided session. Every

 * session must be initialized before use, and must be deinitialized

 * after used by calling gnutls_deinit().

 *

 * @flags can be any combination of flags from %gnutls_init_flags_t.

 *

 * Note that since version 3.1.2 this function enables some common

 * TLS extensions such as session tickets and OCSP certificate status

 * request in client side by default. To prevent that use the %GNUTLS_NO_EXTENSIONS

 * flag.

 *

 * Returns: %GNUTLS_E_SUCCESS on success, or an error code.

 **/

int gnutls_init(gnutls_session_t * session, unsigned int flags)

{

	int ret;

	FAIL_IF_LIB_ERROR;

	*session = gnutls_calloc(1, sizeof(struct gnutls_session_int));

	if (*session == NULL)

		return GNUTLS_E_MEMORY_ERROR;

	ret = _gnutls_epoch_new(*session, 1, NULL);

	if (ret < 0) {

		gnutls_free(*session);

		return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);

	}

	_gnutls_epoch_bump(*session);

	(*session)->security_parameters.entity =

	    (flags & GNUTLS_SERVER ? GNUTLS_SERVER : GNUTLS_CLIENT);

	/* the default certificate type for TLS */

	(*session)->security_parameters.cert_type = DEFAULT_CERT_TYPE;

	/* Initialize buffers */

	_gnutls_buffer_init(&(*session)->internals.handshake_hash_buffer);

	_gnutls_buffer_init(&(*session)->internals.hb_remote_data);

	_gnutls_buffer_init(&(*session)->internals.hb_local_data);

	_gnutls_buffer_init(&(*session)->internals.record_presend_buffer);

	_mbuffer_head_init(&(*session)->internals.record_buffer);

	_mbuffer_head_init(&(*session)->internals.record_send_buffer);

	_mbuffer_head_init(&(*session)->internals.record_recv_buffer);

	_mbuffer_head_init(&(*session)->internals.handshake_send_buffer);

	_gnutls_handshake_recv_buffer_init(*session);

	(*session)->internals.expire_time = DEFAULT_EXPIRE_TIME;	/* one hour default */

	gnutls_handshake_set_max_packet_length((*session),

					       MAX_HANDSHAKE_PACKET_SIZE);

	/* set the socket pointers to -1;

	 */

	(*session)->internals.transport_recv_ptr =

	    (gnutls_transport_ptr_t) - 1;

	(*session)->internals.transport_send_ptr =

	    (gnutls_transport_ptr_t) - 1;

	/* set the default maximum record size for TLS

	 */

	(*session)->security_parameters.max_record_recv_size =

	    DEFAULT_MAX_RECORD_SIZE;

	(*session)->security_parameters.max_record_send_size =

	    DEFAULT_MAX_RECORD_SIZE;

	/* everything else not initialized here is initialized

	 * as NULL or 0. This is why calloc is used.

	 */

	handshake_internal_state_clear1(*session);

#ifdef HAVE_WRITEV

#ifdef MSG_NOSIGNAL

	if (flags & GNUTLS_NO_SIGNAL)

		gnutls_transport_set_vec_push_function(*session, system_writev_nosignal);

	else

#endif

		gnutls_transport_set_vec_push_function(*session, system_writev);

#else

	gnutls_transport_set_push_function(*session, system_write);

#endif

	(*session)->internals.pull_timeout_func = gnutls_system_recv_timeout;

	(*session)->internals.pull_func = system_read;

	(*session)->internals.errno_func = system_errno;

	/* heartbeat timeouts */

	(*session)->internals.hb_retrans_timeout_ms = 1000;

	(*session)->internals.hb_total_timeout_ms = 60000;

	if (flags & GNUTLS_DATAGRAM) {

		(*session)->internals.dtls.mtu = DTLS_DEFAULT_MTU;

		(*session)->internals.transport = GNUTLS_DGRAM;

		gnutls_dtls_set_timeouts(*session, DTLS_RETRANS_TIMEOUT, 60000);

	} else {

		(*session)->internals.transport = GNUTLS_STREAM;

	}

	/* Enable useful extensions */

	if ((flags & GNUTLS_CLIENT) && !(flags & GNUTLS_NO_EXTENSIONS)) {

#ifdef ENABLE_SESSION_TICKETS

		if (!(flags & GNUTLS_NO_TICKETS))

			gnutls_session_ticket_enable_client(*session);

#endif

#ifdef ENABLE_OCSP

		gnutls_ocsp_status_request_enable_client(*session, NULL, 0,

							 NULL);

#endif

	}

	(*session)->internals.flags = flags;

	return 0;

}

/* returns RESUME_FALSE or RESUME_TRUE.

 */

int _gnutls_session_is_resumable(gnutls_session_t session)

{

	return session->internals.resumable;

}

/**

 * gnutls_deinit:

 * @session: is a #gnutls_session_t type.

 *

 * This function clears all buffers associated with the @session.

 * This function will also remove session data from the session

 * database if the session was terminated abnormally.

 **/

void gnutls_deinit(gnutls_session_t session)

{

	unsigned int i;

	if (session == NULL)

		return;

	/* remove auth info firstly */

	_gnutls_free_auth_info(session);

	_gnutls_handshake_internal_state_clear(session);

	_gnutls_handshake_io_buffer_clear(session);

	_gnutls_ext_free_session_data(session);

	for (i = 0; i < MAX_EPOCH_INDEX; i++)

		if (session->record_parameters[i] != NULL) {

			_gnutls_epoch_free(session,

					   session->record_parameters[i]);

			session->record_parameters[i] = NULL;

		}

	_gnutls_buffer_clear(&session->internals.handshake_hash_buffer);

	_gnutls_buffer_clear(&session->internals.hb_remote_data);

	_gnutls_buffer_clear(&session->internals.hb_local_data);

	_gnutls_buffer_clear(&session->internals.record_presend_buffer);

	_mbuffer_head_clear(&session->internals.record_buffer);

	_mbuffer_head_clear(&session->internals.record_recv_buffer);

	_mbuffer_head_clear(&session->internals.record_send_buffer);

	_gnutls_free_datum(&session->internals.resumption_data);

	gnutls_free(session->internals.rexts);

	gnutls_free(session->internals.rsup);

	gnutls_credentials_clear(session);

	_gnutls_selected_certs_deinit(session);

	/* we rely on priorities' internal reference counting */

	gnutls_priority_deinit(session->internals.priorities);

	gnutls_free(session);

}

int _gnutls_dh_set_peer_public(gnutls_session_t session, bigint_t public)

{

	dh_info_st *dh;

	int ret;

	switch (gnutls_auth_get_type(session)) {

	case GNUTLS_CRD_ANON:

		{

			anon_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_ANON);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			dh = &info->dh;

			break;

		}

	case GNUTLS_CRD_PSK:

		{

			psk_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_PSK);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			dh = &info->dh;

			break;

		}

	case GNUTLS_CRD_CERTIFICATE:

		{

			cert_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_CERTIFICATE);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			dh = &info->dh;

			break;

		}

	default:

		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

	}

	if (dh->public_key.data)

		_gnutls_free_datum(&dh->public_key);

	ret = _gnutls_mpi_dprint_lz(public, &dh->public_key);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	return 0;

}

int _gnutls_dh_set_secret_bits(gnutls_session_t session, unsigned bits)

{

	switch (gnutls_auth_get_type(session)) {

	case GNUTLS_CRD_ANON:

		{

			anon_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_ANON);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			info->dh.secret_bits = bits;

			break;

		}

	case GNUTLS_CRD_PSK:

		{

			psk_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_PSK);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			info->dh.secret_bits = bits;

			break;

		}

	case GNUTLS_CRD_CERTIFICATE:

		{

			cert_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_CERTIFICATE);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			info->dh.secret_bits = bits;

			break;

	default:

			return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

		}

	}

	return 0;

}

/* Sets the prime and the generator in the auth info structure.

 */

int

_gnutls_dh_save_group(gnutls_session_t session, bigint_t gen,

		     bigint_t prime)

{

	dh_info_st *dh;

	int ret;

	switch (gnutls_auth_get_type(session)) {

	case GNUTLS_CRD_ANON:

		{

			anon_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_ANON);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			dh = &info->dh;

			break;

		}

	case GNUTLS_CRD_PSK:

		{

			psk_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_PSK);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			dh = &info->dh;

			break;

		}

	case GNUTLS_CRD_CERTIFICATE:

		{

			cert_auth_info_t info;

			info = _gnutls_get_auth_info(session, GNUTLS_CRD_CERTIFICATE);

			if (info == NULL)

				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			dh = &info->dh;

			break;

		}

	default:

		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

	}

	if (dh->prime.data)

		_gnutls_free_datum(&dh->prime);

	if (dh->generator.data)

		_gnutls_free_datum(&dh->generator);

	/* prime

	 */

	ret = _gnutls_mpi_dprint_lz(prime, &dh->prime);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	/* generator

	 */

	ret = _gnutls_mpi_dprint_lz(gen, &dh->generator);

	if (ret < 0) {

		gnutls_assert();

		_gnutls_free_datum(&dh->prime);

		return ret;

	}

	return 0;

}

/**

 * gnutls_certificate_send_x509_rdn_sequence:

 * @session: a #gnutls_session_t type.

 * @status: is 0 or 1

 *

 * If status is non zero, this function will order gnutls not to send

 * the rdnSequence in the certificate request message. That is the

 * server will not advertise its trusted CAs to the peer. If status

 * is zero then the default behaviour will take effect, which is to

 * advertise the server's trusted CAs.

 *

 * This function has no effect in clients, and in authentication

 * methods other than certificate with X.509 certificates.

 **/

void

gnutls_certificate_send_x509_rdn_sequence(gnutls_session_t session,

					  int status)

{

	session->internals.ignore_rdn_sequence = status;

}

/*-

 * _gnutls_record_set_default_version - Used to set the default version for the first record packet

 * @session: is a #gnutls_session_t type.

 * @major: is a tls major version

 * @minor: is a tls minor version

 *

 * This function sets the default version that we will use in the first

 * record packet (client hello). This function is only useful to people

 * that know TLS internals and want to debug other implementations.

 -*/

void

_gnutls_record_set_default_version(gnutls_session_t session,

				   unsigned char major,

				   unsigned char minor)

{

	session->internals.default_record_version[0] = major;

	session->internals.default_record_version[1] = minor;

}

/*-

 * _gnutls_hello_set_default_version - Used to set the default version for the first record packet

 * @session: is a #gnutls_session_t type.

 * @major: is a tls major version

 * @minor: is a tls minor version

 *

 * This function sets the default version that we will use in the first

 * record packet (client hello). This function is only useful to people

 * that know TLS internals and want to debug other implementations.

 -*/

void

_gnutls_hello_set_default_version(gnutls_session_t session,

				   unsigned char major,

				   unsigned char minor)

{

	session->internals.default_hello_version[0] = major;

	session->internals.default_hello_version[1] = minor;

}

/**

 * gnutls_handshake_set_private_extensions:

 * @session: is a #gnutls_session_t type.

 * @allow: is an integer (0 or 1)

 *

 * This function will enable or disable the use of private cipher

 * suites (the ones that start with 0xFF).  By default or if @allow

 * is 0 then these cipher suites will not be advertised nor used.

 *

 * Currently GnuTLS does not include such cipher-suites or

 * compression algorithms.

 *

 * Enabling the private ciphersuites when talking to other than

 * gnutls servers and clients may cause interoperability problems.

 **/

void

gnutls_handshake_set_private_extensions(gnutls_session_t session,

					int allow)

{

	/* we have no private extensions */

	return;

}

/**

 * gnutls_session_is_resumed:

 * @session: is a #gnutls_session_t type.

 *

 * Check whether session is resumed or not.

 *

 * Returns: non zero if this session is resumed, or a zero if this is

 *   a new session.

 **/

int gnutls_session_is_resumed(gnutls_session_t session)

{

	if (session->security_parameters.entity == GNUTLS_CLIENT) {

		if (session->security_parameters.session_id_size > 0 &&

		    session->security_parameters.session_id_size ==

		    session->internals.resumed_security_parameters.

		    session_id_size

		    && memcmp(session->security_parameters.session_id,

			      session->

			      internals.resumed_security_parameters.

			      session_id,

			      session->security_parameters.

			      session_id_size) == 0)

			return 1;

	} else {

		if (session->internals.resumed != RESUME_FALSE)

			return 1;

	}

	return 0;

}

/**

 * gnutls_session_resumption_requested:

 * @session: is a #gnutls_session_t type.

 *

 * Check whether the client has asked for session resumption.

 * This function is valid only on server side.

 *

 * Returns: non zero if session resumption was asked, or a zero if not.

 **/

int gnutls_session_resumption_requested(gnutls_session_t session)

{

	if (session->security_parameters.entity == GNUTLS_CLIENT) {

		return 0;

	} else {

		return session->internals.resumption_requested;

	}

}

/*-

 * _gnutls_session_is_psk - Used to check whether this session uses PSK kx

 * @session: is a #gnutls_session_t type.

 *

 * This function will return non zero if this session uses a PSK key

 * exchange algorithm.

 -*/

int _gnutls_session_is_psk(gnutls_session_t session)

{

	gnutls_kx_algorithm_t kx;

	kx = session->security_parameters.cs->kx_algorithm;

	if (kx == GNUTLS_KX_PSK || kx == GNUTLS_KX_DHE_PSK

	    || kx == GNUTLS_KX_RSA_PSK)

		return 1;

	return 0;

}

/*-

 * _gnutls_session_is_ecc - Used to check whether this session uses ECC kx

 * @session: is a #gnutls_session_t type.

 *

 * This function will return non zero if this session uses an elliptic

 * curves key exchange exchange algorithm.

 -*/

int _gnutls_session_is_ecc(gnutls_session_t session)

{

	gnutls_kx_algorithm_t kx;

	/* We get the key exchange algorithm through the ciphersuite because

	 * the negotiated key exchange might not have been set yet.

	 */

	kx = session->security_parameters.cs->kx_algorithm;

	return _gnutls_kx_is_ecc(kx);

}

/**

 * gnutls_session_get_ptr:

 * @session: is a #gnutls_session_t type.

 *

 * Get user pointer for session.  Useful in callbacks.  This is the

 *   pointer set with gnutls_session_set_ptr().

 *

 * Returns: the user given pointer from the session structure, or

 *   %NULL if it was never set.

 **/

void *gnutls_session_get_ptr(gnutls_session_t session)

{

	return session->internals.user_ptr;

}

/**

 * gnutls_session_set_ptr:

 * @session: is a #gnutls_session_t type.

 * @ptr: is the user pointer

 *

 * This function will set (associate) the user given pointer @ptr to

 * the session structure.  This pointer can be accessed with

 * gnutls_session_get_ptr().

 **/

void gnutls_session_set_ptr(gnutls_session_t session, void *ptr)

{

	session->internals.user_ptr = ptr;

}

/**

 * gnutls_session_set_verify_function:

 * @session: is a #gnutls_session_t type.

 * @func: is the callback function

 *

 * This function sets a callback to be called when peer's certificate

 * has been received in order to verify it on receipt rather than

 * doing after the handshake is completed. This overrides any callback

 * set using gnutls_certificate_set_verify_function().

 *

 * The callback's function prototype is:

 * int (*callback)(gnutls_session_t);

 *

 * If the callback function is provided then gnutls will call it, in the

 * handshake, just after the certificate message has been received.

 * To verify or obtain the certificate the gnutls_certificate_verify_peers2(),

 * gnutls_certificate_type_get(), gnutls_certificate_get_peers() functions

 * can be used.

 *

 * The callback function should return 0 for the handshake to continue

 * or non-zero to terminate.

 *

 * Since: 3.4.6

 **/

void

 gnutls_session_set_verify_function

    (gnutls_session_t session,

     gnutls_certificate_verify_function * func)

{

	session->internals.verify_callback = func;

}

/**

 * gnutls_record_get_direction:

 * @session: is a #gnutls_session_t type.

 *

 * This function provides information about the internals of the

 * record protocol and is only useful if a prior gnutls function call,

 * e.g.  gnutls_handshake(), was interrupted for some reason. That

 * is, if a function returned %GNUTLS_E_INTERRUPTED or

 * %GNUTLS_E_AGAIN. In such a case, you might want to call select()

 * or poll() before restoring the interrupted gnutls function.

 *

 * This function's output is unreliable if you are using the same

 * @session in different threads, for sending and receiving.

 *

 * Returns: 0 if interrupted while trying to read data, or 1 while trying to write data.

 **/

int gnutls_record_get_direction(gnutls_session_t session)

{

	return session->internals.direction;

}

/*-

 * _gnutls_rsa_pms_set_version - Sets a version to be used at the RSA PMS

 * @session: is a #gnutls_session_t type.

 * @major: is the major version to use

 * @minor: is the minor version to use

 *

 * This function will set the given version number to be used at the

 * RSA PMS secret. This is only useful to clients, which want to

 * test server's capabilities.

 -*/

void

_gnutls_rsa_pms_set_version(gnutls_session_t session,

			    unsigned char major, unsigned char minor)

{

	session->internals.rsa_pms_version[0] = major;

	session->internals.rsa_pms_version[1] = minor;

}

/**

 * gnutls_handshake_set_post_client_hello_function:

 * @session: is a #gnutls_session_t type.

 * @func: is the function to be called

 *

 * This function will set a callback to be called after the client

 * hello has been received (callback valid in server side only). This

 * allows the server to adjust settings based on received extensions.

 *

 * Those settings could be ciphersuites, requesting certificate, or

 * anything else except for version negotiation (this is done before

 * the hello message is parsed).

 *

 * This callback must return 0 on success or a gnutls error code to

 * terminate the handshake.

 *

 * Since GnuTLS 3.3.5 the callback is

 * allowed to return %GNUTLS_E_AGAIN or %GNUTLS_E_INTERRUPTED to

 * put the handshake on hold. In that case gnutls_handshake()

 * will return %GNUTLS_E_INTERRUPTED and can be resumed when needed.

 *

 * Warning: You should not use this function to terminate the

 * handshake based on client input unless you know what you are

 * doing. Before the handshake is finished there is no way to know if

 * there is a man-in-the-middle attack being performed.

 **/

void

gnutls_handshake_set_post_client_hello_function(gnutls_session_t session,

						gnutls_handshake_simple_hook_func func)

{

	session->internals.user_hello_func = func;

}

/**

 * gnutls_session_enable_compatibility_mode:

 * @session: is a #gnutls_session_t type.

 *

 * This function can be used to disable certain (security) features in

 * TLS in order to maintain maximum compatibility with buggy