/*

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

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

 *

 * Author: Simon Josefsson, Nikos Mavrogiannopoulos, Martin Ukrop

 *

 * 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 "ip.h"

#include <gnutls/x509.h>

#include <arpa/inet.h>

/*-

 * _gnutls_mask_to_prefix:

 * @mask: CIDR mask

 * @mask_size: number of bytes in @mask

 *

 * Check for mask validity (form of 1*0*) and return its prefix numerically.

 *

 * Returns: Length of 1-prefix (0 -- mask_size*8), -1 in case of invalid mask

 -*/

int _gnutls_mask_to_prefix(const unsigned char *mask, unsigned mask_size)

{

	unsigned i, prefix_length = 0;

	for (i=0; i

		if (mask[i] == 0xFF) {

			prefix_length += 8;

		} else {

			switch(mask[i]) {

				case 0xFE: prefix_length += 7; break;

				case 0xFC: prefix_length += 6; break;

				case 0xF8: prefix_length += 5; break;

				case 0xF0: prefix_length += 4; break;

				case 0xE0: prefix_length += 3; break;

				case 0xC0: prefix_length += 2; break;

				case 0x80: prefix_length += 1; break;

				case 0x00: break;

				default:

					return -1;

			}

			break;

		}

	}

	i++;

	// mask is invalid, if there follows something else than 0x00

	for ( ; i

		if (mask[i] != 0)

			return -1;

	}

	return prefix_length;

}

/*-

 * _gnutls_ip_to_string:

 * @_ip: IP address (RFC5280 format)

 * @ip_size: Size of @_ip (4 or 16)

 * @out: Resulting string

 * @out_size: Size of @out

 *

 * Transform IP address into human-readable string.

 * @string must be already allocated and

 * at least 16/48 bytes for IPv4/v6 address respectively.

 *

 * Returns: Address of result string.

 -*/

const char *_gnutls_ip_to_string(const void *_ip, unsigned int ip_size, char *out, unsigned int out_size)

{

	if (ip_size != 4 && ip_size != 16) {

		gnutls_assert();

		return NULL;

	}

	if (ip_size == 4 && out_size < 16) {

		gnutls_assert();

		return NULL;

	}

	if (ip_size == 16 && out_size < 48) {

		gnutls_assert();

		return NULL;

	}

	if (ip_size == 4)

		return inet_ntop(AF_INET, _ip, out, out_size);

	else

		return inet_ntop(AF_INET6, _ip, out, out_size);

}

/*-

 * _gnutls_cidr_to_string:

 * @_ip: CIDR range (RFC5280 format)

 * @ip_size: Size of @_ip (8 or 32)

 * @out: Resulting string

 * @out_size: Size of @out

 *

 * Transform CIDR IP address range into human-readable string.

 * The input @_ip must be in RFC5280 format (IP address in network byte

 * order, followed by its network mask which is 4 bytes in IPv4 and

 * 16 bytes in IPv6). @string must be already allocated and

 * at least 33/97 bytes for IPv4/v6 address respectively.

 *

 * Returns: Address of result string.

 -*/

const char *_gnutls_cidr_to_string(const void *_ip, unsigned int ip_size, char *out, unsigned int out_size)

{

	const unsigned char *ip = _ip;

	char tmp[64];

	const char *p;

	if (ip_size != 8 && ip_size != 32) {

		gnutls_assert();

		return NULL;

	}

	if (ip_size == 8) {

		p = inet_ntop(AF_INET, ip, tmp, sizeof(tmp));

		if (p)

			snprintf(out, out_size, "%s/%d", tmp, _gnutls_mask_to_prefix(ip+4, 4));

	} else {

		p = inet_ntop(AF_INET6, ip, tmp, sizeof(tmp));

		if (p)

			snprintf(out, out_size, "%s/%d", tmp, _gnutls_mask_to_prefix(ip+16, 16));

	}

	if (p == NULL)

		return NULL;

	return out;

}

static void prefix_to_mask(unsigned prefix, unsigned char *mask, size_t mask_size)

{

	int i;

	unsigned j;

	memset(mask, 0, mask_size);

	for (i = prefix, j = 0; i > 0 && j < mask_size; i -= 8, j++) {

		if (i >= 8) {

			mask[j] = 0xff;

		} else {

			mask[j] = (unsigned long)(0xffU << (8 - i));

		}

	}

}

/*-

 * _gnutls_mask_ip:

 * @ip: IP of @ipsize bytes

 * @mask: netmask of @ipsize bytes

 * @ipsize: IP length (4 or 16)

 *

 * Mask given IP in place according to the given mask.

 *

 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a negative error value.

 -*/

int _gnutls_mask_ip(unsigned char *ip, const unsigned char *mask, unsigned ipsize)

{

	unsigned i;

	if (ipsize != 4 && ipsize != 16)

		return GNUTLS_E_MALFORMED_CIDR;

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

		ip[i] &= mask[i];

	return GNUTLS_E_SUCCESS;

}

/**

 * gnutls_x509_cidr_to_rfc5280:

 * @cidr: CIDR in RFC4632 format (IP/prefix), null-terminated

 * @cidr_rfc5280: CIDR range converted to RFC5280 format

 *

 * This function will convert text CIDR range with prefix (such as '10.0.0.0/8')

 * to RFC5280 (IP address in network byte order followed by its network mask).

 * Works for both IPv4 and IPv6.

 *

 * The resulting object is directly usable for IP name constraints usage,

 * for example in functions %gnutls_x509_name_constraints_add_permitted

 * or %gnutls_x509_name_constraints_add_excluded.

 *

 * The data in datum needs to be deallocated using gnutls_free().

 *

 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a negative error value.

 *

 * Since: 3.5.4

 */

int gnutls_x509_cidr_to_rfc5280(const char *cidr, gnutls_datum_t *cidr_rfc5280)

{

	unsigned iplength, prefix;

	int ret;

	char *p;

	char *p_end = NULL;

	char *cidr_tmp;

	p = strchr(cidr, '/');

	if (p != NULL) {

		prefix = strtol(p+1, &p_end, 10);

		if (prefix == 0 && p_end == p+1) {

			_gnutls_debug_log("Cannot parse prefix given in CIDR %s\n", cidr);

			gnutls_assert();

			return GNUTLS_E_MALFORMED_CIDR;

		}

		unsigned length = p-cidr+1;

		cidr_tmp = gnutls_malloc(length);

		if (cidr_tmp == NULL) {

			return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);

		}

		memcpy(cidr_tmp, cidr, length);

		cidr_tmp[length-1] = 0;

	} else {

		_gnutls_debug_log("No prefix given in CIDR %s\n", cidr);

		gnutls_assert();

		return GNUTLS_E_MALFORMED_CIDR;

	}

	if (strchr(cidr, ':') != 0) { /* IPv6 */

		iplength = 16;

	} else { /* IPv4 */

		iplength = 4;

	}

	cidr_rfc5280->size = 2*iplength;

	if (prefix > iplength*8) {

		_gnutls_debug_log("Invalid prefix given in CIDR %s (%d)\n", cidr, prefix);

		ret = gnutls_assert_val(GNUTLS_E_MALFORMED_CIDR);

		goto cleanup;

	}

	cidr_rfc5280->data = gnutls_malloc(cidr_rfc5280->size);

	if (cidr_rfc5280->data == NULL) {

		ret = gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);

		goto cleanup;

	}

	ret = inet_pton(iplength == 4 ? AF_INET : AF_INET6, cidr_tmp, cidr_rfc5280->data);

	if (ret == 0) {

		_gnutls_debug_log("Cannot parse IP from CIDR %s\n", cidr_tmp);

		ret = gnutls_assert_val(GNUTLS_E_MALFORMED_CIDR);

		goto cleanup;

	}

	prefix_to_mask(prefix, &cidr_rfc5280->data[iplength], iplength);

	_gnutls_mask_ip(cidr_rfc5280->data, &cidr_rfc5280->data[iplength], iplength);

	ret = GNUTLS_E_SUCCESS;

cleanup:

	gnutls_free(cidr_tmp);

	return ret;

}