/* $OpenBSD: ber_test_int_i.c,v 1.6 2019/10/24 12:39:26 tb Exp $
*/
/*
 * Copyright (c) Rob Pierce <rob@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <ber.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>

#define SUCCEED	0
#define FAIL	1

struct test_vector {
	int		 fail;		/* 1 means test is expected to fail */
	char		 title[128];
	size_t		 input_length;
	long long	 value;
	unsigned char	 input[1024];
	size_t		 expect_length;
	unsigned char	 expect[1024];
};

struct test_vector test_vectors[] = {
	{
		SUCCEED,
		"integer (-9223372036854775807)",
		10,
		-9223372036854775807,
		{
			0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x01
		},
		10,
		{
			0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x01
		},
	},
	{
		SUCCEED,
		"integer (-9223372036854775806)",
		10,
		-9223372036854775806,
		{
			0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x02
		},
		10,
		{
			0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x02
		},
	},
	{
		FAIL,
		"integer (-2147483650) (expected failure)",
		10,
		-2147483650,
		{
			0x02, 0x08, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff,
			0xff, 0xfe
		},
		7,
		{
			0x02, 0x05, 0xff, 0x7f, 0xff, 0xff, 0xfe
		},
	},
	{
		SUCCEED,
		"integer (-2147483650)",
		7,
		-2147483650,
		{
			0x02, 0x05, 0xff, 0x7f, 0xff, 0xff, 0xfe
		},
		7,
		{
			0x02, 0x05, 0xff, 0x7f, 0xff, 0xff, 0xfe
		},
	},
	{
		SUCCEED,
		"integer (-2147483649)",
		7,
		-2147483649,
		{
			0x02, 0x05, 0xff, 0x7f, 0xff, 0xff, 0xff
		},
		7,
		{
			0x02, 0x05, 0xff, 0x7f, 0xff, 0xff, 0xff
		},
	},
	{
		FAIL,
		"integer (-2147483648) (expected failure)",
		8,
		-2147483648,
		{
			0x02, 0x06, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00
		},
		6,
		{
			0x02, 0x04, 0x80, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-2147483648)",
		6,
		-2147483648,
		{
			0x02, 0x04, 0x80, 0x00, 0x00, 0x00
		},
		6,
		{
			0x02, 0x04, 0x80, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-1073741824)",
		6,
		-1073741824,
		{
			0x02, 0x04, 0xc0, 0x00, 0x00, 0x00
		},
		6,
		{
			0x02, 0x04, 0xc0, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-536870912)",
		6,
		-536870912,
		{
			0x02, 0x04, 0xe0, 0x00, 0x00, 0x00
		},
		6,
		{
			0x02, 0x04, 0xe0, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-268435456)",
		6,
		-268435456,
		{
			0x02, 0x04, 0xf0, 0x00, 0x00, 0x00
		},
		6,
		{
			0x02, 0x04, 0xf0, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-1342177728)",
		6,
		-1342177728,
		{
			0x02, 0x04, 0xaf, 0xff, 0xfe, 0x40
		},
		6,
		{
			0x02, 0x04, 0xaf, 0xff, 0xfe, 0x40
		},
	},
	{
		SUCCEED,
		"integer (-67108865)",
		6,
		-67108865,
		{
			0x02, 0x04, 0xfb, 0xff, 0xff, 0xff
		},
		6,
		{
			0x02, 0x04, 0xfb, 0xff, 0xff, 0xff
		},
	},
	{
		SUCCEED,
		"integer (-67108864)",
		6,
		-67108864,
		{
			0x02, 0x04, 0xfc, 0x00, 0x00, 0x00
		},
		6,
		{
			0x02, 0x04, 0xfc, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-67108863)",
		6,
		-67108863,
		{
			0x02, 0x04, 0xfc, 0x00, 0x00, 0x01
		},
		6,
		{
			0x02, 0x04, 0xfc, 0x00, 0x00, 0x01
		},
	},
	{
		SUCCEED,
		"integer (-3554432)",
		5,
		-3554432,
		{
			0x02, 0x03, 0xc9, 0xc3, 0x80
		},
		5,
		{
			0x02, 0x03, 0xc9, 0xc3, 0x80
		},
	},
	{
		SUCCEED,
		"integer (-65535)",
		5,
		-65535,
		{
			0x02, 0x03, 0xff, 0x00, 0x01,
		},
		5,
		{
			0x02, 0x03, 0xff, 0x00, 0x01,
		},
	},
	{
		SUCCEED,
		"integer (-32769)",
		5,
		-32769,
		{
			0x02, 0x03, 0xff, 0x7f, 0xff
		},
		5,
		{
			0x02, 0x03, 0xff, 0x7f, 0xff
		},
	},
	{
		SUCCEED,
		"integer (-32768)",
		4,
		-32768,
		{
			0x02, 0x02, 0x80, 0x00
		},
		4,
		{
			0x02, 0x02, 0x80, 0x00
		},
	},
	{
		SUCCEED,
		"integer (-128)",
		3,
		-128,
		{
			0x02, 0x01, 0x80
		},
		3,
		{
			0x02, 0x01, 0x80
		},
	},
	{
		SUCCEED,
		"integer (-1)",
		3,
		-1,
		{
			0x02, 0x01, 0xff
		},
		3,
		{
			0x02, 0x01, 0xff
		},
	},
	{
		SUCCEED,
		"integer (0)",
		3,
		0,
		{
			0x02, 0x01, 0x00
		},
		3,
		{
			0x02, 0x01, 0x00
		},
	},
	{
		SUCCEED,
		"integer (127)",
		3,
		127,
		{
			0x02, 0x01, 0x7f
		},
		3,
		{
			0x02, 0x01, 0x7f
		},
	},
	{
		SUCCEED,
		"integer (128)",
		4,
		128,
		{
			0x02, 0x02, 0x00, 0x80
		},
		4,
		{
			0x02, 0x02, 0x00, 0x80
		},
	},
	{
		SUCCEED,
		"integer (32767)",
		4,
		32767,
		{
			0x02, 0x02, 0x7f, 0xff
		},
		4,
		{
			0x02, 0x02, 0x7f, 0xff
		},
	},
	{
		SUCCEED,
		"integer (32768)",
		5,
		32768,
		{
			0x02, 0x03, 0x00, 0x80, 0x00
		},
		5,
		{
			0x02, 0x03, 0x00, 0x80, 0x00
		},
	},
	{
		SUCCEED,
		"integer (65535)",
		5,
		65535,
		{
			0x02, 0x03, 0x00, 0xff, 0xff
		},
		5,
		{
			0x02, 0x03, 0x00, 0xff, 0xff
		},
	},
	{
		SUCCEED,
		"integer (65536)",
		5,
		65536,
		{
			0x02, 0x03, 0x01, 0x00, 0x00
		},
		5,
		{
			0x02, 0x03, 0x01, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (2147483647)",
		6,
		2147483647,
		{
			0x02, 0x04, 0x7f, 0xff, 0xff, 0xff
		},
		6,
		{
			0x02, 0x04, 0x7f, 0xff, 0xff, 0xff
		},
	},
	{
		SUCCEED,
		"integer (2147483648)",
		7,
		2147483648,
		{
			0x02, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00
		},
		7,
		{
			0x02, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (2147483649)",
		7,
		2147483649,
		{
			0x02, 0x05, 0x00, 0x80, 0x00, 0x00, 0x01
		},
		7,
		{
			0x02, 0x05, 0x00, 0x80, 0x00, 0x00, 0x01
		},
	},
	{
		SUCCEED,
		"integer (4294967295)",
		7,
		4294967295,
		{
			0x02, 0x05, 0x00, 0xff, 0xff, 0xff, 0xff
		},
		7,
		{
			0x02, 0x05, 0x00, 0xff, 0xff, 0xff, 0xff
		},
	},
	{
		SUCCEED,
		"integer (4294967296)",
		7,
		4294967296,
		{
			0x02, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00
		},
		7,
		{
			0x02, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00
		},
	},
	{
		SUCCEED,
		"integer (4294967297)",
		7,
		4294967297,
		{
			0x02, 0x05, 0x01, 0x00, 0x00, 0x00, 0x01
		},
		7,
		{
			0x02, 0x05, 0x01, 0x00, 0x00, 0x00, 0x01
		},
	},
	{
		SUCCEED,
		"integer (9223372036854775806)",
		10,
		9223372036854775806,
		{
			0x02, 0x08, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff,
			0xff, 0xfe
		},
		10,
		{
			0x02, 0x08, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff,
			0xff, 0xfe
		},
	},
	{
		SUCCEED,
		"integer (9223372036854775807)",
		10,
		9223372036854775807,
		{
			0x02, 0x08, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff,
			0xff, 0xff
		},
		10,
		{
			0x02, 0x08, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff,
			0xff, 0xff
		},
	},
};

static void
hexdump(const unsigned char *buf, size_t len)
{
	size_t	i;

	for (i = 1; i < len; i++)
		fprintf(stderr, " 0x%02hhx,%s", buf[i - 1], i % 8 ? "": "\n");

	fprintf(stderr, " 0x%02hhx", buf[i - 1]);
	fprintf(stderr, "\n");
}

static int
test_read_elements(int i)
{
	int			 pos, b;
	char			*string;
	void			*p = NULL;
	ssize_t			 len = 0;
	struct ber_element	*elm = NULL, *ptr = NULL;
	struct ber		 ber;
	long long		 val;
	void			*bstring = NULL;
	struct ber_oid		 oid;
	struct ber_octetstring	 ostring;

	bzero(&ber, sizeof(ber));
	ober_set_readbuf(&ber, test_vectors[i].input,
	    test_vectors[i].input_length);

	elm = ober_read_elements(&ber, elm);
	if (elm != NULL && test_vectors[i].fail == FAIL) {
		printf("unexpectedly passed ober_read_elements\n");
		return 1;
	} else if (elm == NULL && test_vectors[i].fail != FAIL) {
		printf("unexpectedly failed ober_read_elements\n");
		return 1;
	} else if (elm == NULL && test_vectors[i].fail == FAIL)
		return 0;

	pos = ober_getpos(elm);
	if (pos != 2) {
		printf("unexpected element position within "
		    "byte stream (%d)\n", pos);
		return 1;
	}

	switch (elm->be_encoding) {
	case BER_TYPE_INTEGER:
		if (ober_get_integer(elm, &val) == -1) {
			printf("failed (int) encoding check\n");
			return 1;
		}
		if (val != test_vectors[i].value) {
			printf("(ober_get_integer) got %lld, expected %lld\n",
			    val, test_vectors[i].value);
			return 1;
		}
		if (ober_scanf_elements(elm, "i", &val) == -1) {
			printf("(ober_scanf_elements) failed (int)"
			    " ober_scanf_elements (i)\n");
			return 1;
		}
		if (val != test_vectors[i].value) {
			printf("got %lld, expected %lld\n", val,
			    test_vectors[i].value);
			return 1;
		}
		break;
	default:
		printf("failed with unexpected encoding (%ud)\n",
		    elm->be_encoding);
		return 1;
	}

	len = ober_calc_len(elm);
	if (len != test_vectors[i].expect_length) {
		printf("failed to calculate length\n");
		printf("was %zd want %zu\n", len,
		    test_vectors[i].expect_length);
		return 1;
	}

	ber.br_wbuf = NULL;
	len = ober_write_elements(&ber, elm);
	if (len != test_vectors[i].expect_length) {
		printf("failed length check (was %zd want "
		    "%zd)\n", len, test_vectors[i].expect_length);
		return 1;
	}

	if (memcmp(ber.br_wbuf, test_vectors[i].expect,
	    test_vectors[i].expect_length) != 0) {
		printf("failed byte stream compare\n");
		printf("Got:\n");
		hexdump(ber.br_wbuf, len);
		printf("Expected:\n");
		hexdump(test_vectors[i].expect, test_vectors[i].expect_length);
		return 1;
	}
	ober_free(&ber);

	ober_free_elements(elm);

	return 0;
}

static int
test_printf_elements(int i)
{
	int			 pos, b;
	char			*string;
	void			*p = NULL;
	ssize_t			 len = 0;
	struct ber_element	*elm = NULL, *ptr = NULL;
	struct ber		 ber;
	long long		 val;
	void			*bstring = NULL;
	struct ber_oid		 oid;
	struct ber_octetstring	 ostring;

	bzero(&ber, sizeof(ber));
	ober_set_readbuf(&ber, test_vectors[i].input,
	    test_vectors[i].input_length);

	elm = ober_printf_elements(elm, "i", test_vectors[i].value);
	if (elm == NULL) {
		printf("unexpectedly failed ober_printf_elements\n");
		return 1;
	}

	switch (elm->be_encoding) {
	case BER_TYPE_INTEGER:
		if (ober_get_integer(elm, &val) == -1) {
			printf("failed (int) encoding check\n");
			return 1;
		}
		if (val != test_vectors[i].value) {
			printf("(ober_get_integer) got %lld, expected %lld\n",
			    val, test_vectors[i].value);
			return 1;
		}
		if (ober_scanf_elements(elm, "i", &val) == -1) {
			printf("(ober_scanf_elements) failed (int)"
			    " ober_scanf_elements (i)\n");
			return 1;
		}
		if (val != test_vectors[i].value) {
			printf("got %lld, expected %lld\n", val,
			    test_vectors[i].value);
			return 1;
		}
		break;
	default:
		printf("failed with unexpected encoding (%ud)\n",
		    elm->be_encoding);
		return 1;
	}

	len = ober_calc_len(elm);
	if (len != test_vectors[i].expect_length) {
		printf("failed to calculate length\n");
		printf("was %zd want %zu\n", len,
		    test_vectors[i].expect_length);
		return 1;
	}

	ber.br_wbuf = NULL;
	len = ober_write_elements(&ber, elm);
	if (len != test_vectors[i].expect_length) {
		printf("failed length check (was %zd want "
		    "%zd)\n", len, test_vectors[i].expect_length);
		return 1;
	}

	if (memcmp(ber.br_wbuf, test_vectors[i].expect,
	    test_vectors[i].expect_length) != 0) {
		printf("failed byte stream compare\n");
		printf("Got:\n");
		hexdump(ber.br_wbuf, len);
		printf("Expected:\n");
		hexdump(test_vectors[i].expect, test_vectors[i].expect_length);
		return 1;
	}
	ober_free(&ber);

	ober_free_elements(elm);

	return 0;
}

int
main(void)
{
	extern char *__progname;

	ssize_t		len = 0;
	int		i, ret = 0;

	/*
	 * drive test vectors for ber byte stream input validation, etc.
	 */
	printf("= = = = = test_read_elements\n");
	for (i = 0; i < sizeof(test_vectors) / sizeof(test_vectors[0]); i++) {
		if (test_read_elements(i) != 0) {
			printf("FAILED: %s\n", test_vectors[i].title);
			ret = 1;
		} else
			printf("SUCCESS: %s\n", test_vectors[i].title);
	}

	printf("= = = = = test_printf_elements\n");
	for (i = 0; i < sizeof(test_vectors) / sizeof(test_vectors[0]); i++) {
		/*
		 * skip test cases known to fail under ober_read_elements as
		 * they are not applicable to ober_printf_elements
		 */
		if (test_vectors[i].fail)
			continue;
		if (test_printf_elements(i) != 0) {
			printf("FAILED: %s\n", test_vectors[i].title);
			ret = 1;
		} else
			printf("SUCCESS: %s\n", test_vectors[i].title);
	}

	if (ret != 0) {
		printf("FAILED: %s\n", __progname);
		return 1;
	}

	return 0;
}