/*

 * 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);

}