/*
 * Copyright (C) 2013 Nikos Mavrogiannopoulos
 * Copyright (C) 2017 Red Hat, Inc.
 * 
 * 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 <https://www.gnu.org/licenses/>
 *
 */

#include "gnutls_int.h"
#include "auth.h"
#include "errors.h"
#include "num.h"
#include "ext/alpn.h"

static int _gnutls_alpn_recv_params(gnutls_session_t session,
				    const uint8_t *data, size_t data_size);
static int _gnutls_alpn_send_params(gnutls_session_t session,
				    gnutls_buffer_st *extdata);

static void _gnutls_alpn_deinit_data(gnutls_ext_priv_data_t priv);

const hello_ext_entry_st ext_mod_alpn = {
	.name = "ALPN",
	.tls_id = 16,
	.gid = GNUTLS_EXTENSION_ALPN,
	/* this extension must be parsed even on resumption */
	.client_parse_point = GNUTLS_EXT_MANDATORY,
	.server_parse_point = GNUTLS_EXT_MANDATORY,
	.validity = GNUTLS_EXT_FLAG_TLS | GNUTLS_EXT_FLAG_DTLS |
		    GNUTLS_EXT_FLAG_CLIENT_HELLO | GNUTLS_EXT_FLAG_EE |
		    GNUTLS_EXT_FLAG_TLS12_SERVER_HELLO,
	.recv_func = _gnutls_alpn_recv_params,
	.send_func = _gnutls_alpn_send_params,
	.deinit_func = _gnutls_alpn_deinit_data,
	.cannot_be_overriden = 1
};

static int _gnutls_alpn_recv_params(gnutls_session_t session,
				    const uint8_t *data, size_t data_size)
{
	unsigned int i;
	int ret;
	const uint8_t *p = data;
	unsigned len1, len;
	alpn_ext_st *priv;
	gnutls_ext_priv_data_t epriv;
	int selected_protocol_index;

	ret = _gnutls_hello_ext_get_priv(session, GNUTLS_EXTENSION_ALPN,
					 &epriv);
	if (ret < 0)
		return 0;

	priv = epriv;

	DECR_LENGTH_RET(data_size, 2, GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
	len = _gnutls_read_uint16(p);
	p += 2;

	if (len == 0 || len > (size_t)data_size)
		return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

	if (session->security_parameters.entity == GNUTLS_SERVER) {
		selected_protocol_index = MAX_ALPN_PROTOCOLS + 1;

		while (data_size > 0) {
			DECR_LENGTH_RET(data_size, 1,
					GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
			len1 = *p;
			p += 1;
			DECR_LENGTH_RET(data_size, len1,
					GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

			if (len1 == 0)
				return gnutls_assert_val(
					GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

			for (i = 0; i < priv->size; i++) {
				if (priv->protocol_size[i] == len1 &&
				    memcmp(p, priv->protocols[i], len1) == 0) {
					if (priv->flags &
					    GNUTLS_ALPN_SERVER_PRECEDENCE) {
						if (selected_protocol_index >
						    (int)i) {
							selected_protocol_index =
								i;
							priv->selected_protocol =
								priv->protocols
									[i];
							priv->selected_protocol_size =
								priv->protocol_size
									[i];
							break;
						}
					} else {
						priv->selected_protocol =
							priv->protocols[i];
						priv->selected_protocol_size =
							priv->protocol_size[i];
						return 0;
					}
				}
			}
			p += len1;
		}
	} else {
		DECR_LENGTH_RET(data_size, 1,
				GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
		len1 = *p;
		p += 1;
		DECR_LENGTH_RET(data_size, len1,
				GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

		for (i = 0; i < priv->size; i++) {
			if (priv->protocol_size[i] == len1 &&
			    memcmp(p, priv->protocols[i], len1) == 0) {
				priv->selected_protocol = priv->protocols[i];
				priv->selected_protocol_size =
					priv->protocol_size[i];
				break;
			}
		}
		/*p += len1; */
	}

	if (priv->selected_protocol == NULL && (priv->flags & GNUTLS_ALPN_MAND))
		return gnutls_assert_val(GNUTLS_E_NO_APPLICATION_PROTOCOL);

	return 0;
}

static int _gnutls_alpn_send_params(gnutls_session_t session,
				    gnutls_buffer_st *extdata)
{
	unsigned i;
	int total_size = 0, ret;
	alpn_ext_st *priv;
	gnutls_ext_priv_data_t epriv;

	ret = _gnutls_hello_ext_get_priv(session, GNUTLS_EXTENSION_ALPN,
					 &epriv);
	if (ret < 0)
		return 0;

	priv = epriv;

	if (priv->size == 0)
		return 0;

	if (session->security_parameters.entity == GNUTLS_SERVER) {
		if (priv->selected_protocol_size == 0)
			return 0;

		ret = _gnutls_buffer_append_prefix(
			extdata, 16, priv->selected_protocol_size + 1);
		if (ret < 0)
			return gnutls_assert_val(ret);

		total_size += 2;

		ret = _gnutls_buffer_append_data_prefix(
			extdata, 8, priv->selected_protocol,
			priv->selected_protocol_size);
		if (ret < 0)
			return gnutls_assert_val(ret);

		total_size += 1 + priv->selected_protocol_size;
	} else {
		int t = 0;
		for (i = 0; i < priv->size; i++)
			t += priv->protocol_size[i] + 1;

		ret = _gnutls_buffer_append_prefix(extdata, 16, t);
		if (ret < 0)
			return gnutls_assert_val(ret);

		total_size += 2;

		for (i = 0; i < priv->size; i++) {
			ret = _gnutls_buffer_append_data_prefix(
				extdata, 8, priv->protocols[i],
				priv->protocol_size[i]);
			if (ret < 0)
				return gnutls_assert_val(ret);

			total_size += 1 + priv->protocol_size[i];
		}
	}

	return total_size;
}

/**
 * gnutls_alpn_get_selected_protocol:
 * @session: is a #gnutls_session_t type.
 * @protocol: will hold the protocol name
 *
 * This function allows you to get the negotiated protocol name. The
 * returned protocol should be treated as opaque, constant value and
 * only valid during the session life.
 *
 * The selected protocol is the first supported by the list sent
 * by the client.
 *
 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
 *   otherwise a negative error code is returned.
 *
 * Since 3.2.0
 **/
int gnutls_alpn_get_selected_protocol(gnutls_session_t session,
				      gnutls_datum_t *protocol)
{
	alpn_ext_st *priv;
	int ret;
	gnutls_ext_priv_data_t epriv;

	ret = _gnutls_hello_ext_get_priv(session, GNUTLS_EXTENSION_ALPN,
					 &epriv);
	if (ret < 0) {
		gnutls_assert();
		return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
	}

	priv = epriv;

	if (priv->selected_protocol_size == 0)
		return gnutls_assert_val(GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE);

	protocol->data = priv->selected_protocol;
	protocol->size = priv->selected_protocol_size;

	return 0;
}

/**
 * gnutls_alpn_set_protocols:
 * @session: is a #gnutls_session_t type.
 * @protocols: is the protocol names to add.
 * @protocols_size: the number of protocols to add.
 * @flags: zero or a sequence of %gnutls_alpn_flags_t
 *
 * This function is to be used by both clients and servers, to declare
 * the supported ALPN protocols, which are used during negotiation with peer.
 *
 * See %gnutls_alpn_flags_t description for the documentation of available
 * flags.
 *
 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
 *   otherwise a negative error code is returned.
 *
 * Since 3.2.0
 **/
int gnutls_alpn_set_protocols(gnutls_session_t session,
			      const gnutls_datum_t *protocols,
			      unsigned protocols_size, unsigned int flags)
{
	int ret;
	alpn_ext_st *priv;
	gnutls_ext_priv_data_t epriv;
	unsigned i;

	ret = _gnutls_hello_ext_get_priv(session, GNUTLS_EXTENSION_ALPN,
					 &epriv);
	if (ret < 0) {
		priv = gnutls_calloc(1, sizeof(*priv));
		if (priv == NULL) {
			gnutls_assert();
			return GNUTLS_E_MEMORY_ERROR;
		}
		epriv = priv;
		_gnutls_hello_ext_set_priv(session, GNUTLS_EXTENSION_ALPN,
					   epriv);
	} else
		priv = epriv;

	if (protocols_size > MAX_ALPN_PROTOCOLS)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	for (i = 0; i < protocols_size; i++) {
		if (protocols[i].size >= MAX_ALPN_PROTOCOL_NAME)
			return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

		memcpy(priv->protocols[i], protocols[i].data,
		       protocols[i].size);
		priv->protocol_size[i] = protocols[i].size;
		priv->size++;
	}
	priv->flags = flags;

	return 0;
}

static void _gnutls_alpn_deinit_data(gnutls_ext_priv_data_t priv)
{
	gnutls_free(priv);
}
