New upstream version 5.5.3

5 files changed, 227 insertions, 44 deletions

diff --git a/src/libstrongswan/tests/Makefile.in b/src/libstrongswan/tests/Makefile.in
index f4c607ca4..279e179ea 100644
--- a/src/libstrongswan/tests/Makefile.in
+++ b/src/libstrongswan/tests/Makefile.in
@@ -396,6 +396,7 @@ docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 fips_mode = @fips_mode@
+fuzz_plugins = @fuzz_plugins@
 gtk_CFLAGS = @gtk_CFLAGS@
 gtk_LIBS = @gtk_LIBS@
 host = @host@
@@ -418,6 +419,7 @@ json_CFLAGS = @json_CFLAGS@
 json_LIBS = @json_LIBS@
 libdir = @libdir@
 libexecdir = @libexecdir@
+libfuzzer = @libfuzzer@
 libiptc_CFLAGS = @libiptc_CFLAGS@
 libiptc_LIBS = @libiptc_LIBS@
 linux_headers = @linux_headers@
diff --git a/src/libstrongswan/tests/suites/test_asn1_parser.c b/src/libstrongswan/tests/suites/test_asn1_parser.c
index 973562bff..ebbe7ddaf 100644
--- a/src/libstrongswan/tests/suites/test_asn1_parser.c
+++ b/src/libstrongswan/tests/suites/test_asn1_parser.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Andreas Steffen
+ * Copyright (C) 2014-2017 Andreas Steffen
  * HSR Hochschule fuer Technik Rapperswil
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -250,6 +250,7 @@ START_TEST(test_asn1_parser_option)
 				i3 = *object.ptr;
 				break;
 			default:
+
 				break;
 		}
 	}
@@ -264,6 +265,105 @@ START_TEST(test_asn1_parser_option)
 }
 END_TEST
 
+/*******************************************************************************
+ * choice
+ */
+
+typedef struct {
+	int i1, i2, i3, i4;
+	chunk_t blob;
+} choice_test_t;
+
+static const asn1Object_t choiceObjects[] = {
+	{ 0, "choiceObject",      ASN1_EOC,          ASN1_CHOICE          }, /*  0 */
+	{ 1,   "choiceA",         ASN1_CONTEXT_C_0,  ASN1_OPT|ASN1_CHOICE }, /*  1 */
+	{ 2,     "choice1",       ASN1_OCTET_STRING, ASN1_OPT|ASN1_BODY   }, /*  2 */
+	{ 2,     "end choice1",   ASN1_EOC,          ASN1_END|ASN1_CH     }, /*  3 */
+	{ 2,     "choice2",       ASN1_INTEGER,      ASN1_OPT|ASN1_BODY   }, /*  4 */
+	{ 2,     "end choice2",   ASN1_EOC,          ASN1_END|ASN1_CH     }, /*  5 */
+	{ 1,   "end choiceA",     ASN1_EOC,          ASN1_END|ASN1_CHOICE|
+	                                             ASN1_CH              }, /*  6 */
+	{ 1,   "choiceB",         ASN1_SEQUENCE,     ASN1_OPT|ASN1_LOOP   }, /*  7 */
+	{ 2,     "choiceObject",  ASN1_EOC,          ASN1_CHOICE          }, /*  8 */
+	{ 3,       "choice3",     ASN1_INTEGER,      ASN1_OPT|ASN1_BODY   }, /*  9 */
+	{ 3,       "end choice3", ASN1_EOC,          ASN1_END|ASN1_CH     }, /* 10 */
+	{ 3,       "choice4",     ASN1_OCTET_STRING, ASN1_OPT|ASN1_BODY   }, /* 11 */
+	{ 3,       "end choice4", ASN1_EOC,          ASN1_END|ASN1_CH     }, /* 12 */
+	{ 2,     "end choices",   ASN1_EOC,          ASN1_END|ASN1_CHOICE }, /* 13 */
+	{ 1,   "end loop/choice", ASN1_EOC,          ASN1_END|ASN1_CH     }, /* 14 */
+	{ 0, "end choices",       ASN1_EOC,          ASN1_END|ASN1_CHOICE }, /* 15 */
+	{ 0, "exit",              ASN1_EOC,          ASN1_EXIT            }
+};
+
+choice_test_t choice_tests[] = {
+	{ 0, 0, 0, 0, { NULL, 0 } },
+	{ 0, 0, 0, 0, chunk_from_chars(0xA0, 0x00) },
+	{ 1, 0, 0, 0, chunk_from_chars(0xA0, 0x03, 0x04, 0x01, 0x01) },
+	{ 1, 0, 0, 0, chunk_from_chars(0xA0, 0x06, 0x04, 0x01, 0x01,
+	                                           0x02, 0x01, 0x02) },
+	{ 0, 2, 0, 0, chunk_from_chars(0xA0, 0x03, 0x02, 0x01, 0x02) },
+	{ 0, 2, 0, 0, chunk_from_chars(0xA0, 0x03, 0x02, 0x01, 0x02,
+	                               0x30, 0x03, 0x02, 0x01, 0x03) },
+	{ 0, 0, 0, 0, chunk_from_chars(0xA0, 0x04, 0x03, 0x02, 0x00, 0x04) },
+	{ 0, 0, 3, 0, chunk_from_chars(0x30, 0x03, 0x02, 0x01, 0x03) },
+	{ 0, 0, 0, 4, chunk_from_chars(0x30, 0x03, 0x04, 0x01, 0x04) },
+	{ 0, 0, 3, 4, chunk_from_chars(0x30, 0x06, 0x04, 0x01, 0x04,
+	                                           0x02, 0x01, 0x03) },
+	{ 0, 0, 3, 4, chunk_from_chars(0x30, 0x06, 0x02, 0x01, 0x03,
+	                                           0x04, 0x01, 0x04) },
+	{ 0, 0, 6, 0, chunk_from_chars(0x30, 0x06, 0x02, 0x01, 0x03,
+	                                           0x02, 0x01, 0x03) },
+	{ 0, 0, 0, 8, chunk_from_chars(0x30, 0x06, 0x04, 0x01, 0x04,
+	                                           0x04, 0x01, 0x04) },
+	{ 0, 0, 0, 0, chunk_from_chars(0x30, 0x04, 0x03, 0x02, 0x00, 0x04) },
+	{ 0, 0, 0, 0, chunk_from_chars(0x03, 0x02, 0x00, 0x04) }
+};
+
+START_TEST(test_asn1_parser_choice)
+{
+	asn1_parser_t *parser;
+	chunk_t object;
+	int objectID, i1 = 0, i2 = 0, i3 = 0, i4 = 0;
+	bool success;
+
+	parser = asn1_parser_create(choiceObjects, choice_tests[_i].blob);
+	while (parser->iterate(parser, &objectID, &object))
+	{
+		switch (objectID)
+		{
+			case 2:
+				i1 += *object.ptr;
+				break;
+			case 4:
+				i2 += *object.ptr;
+				break;
+			case 9:
+				i3 += *object.ptr;
+				break;
+			case 11:
+				i4 += *object.ptr;
+				break;
+			default:
+
+				break;
+		}
+	}
+	success = parser->success(parser);
+	parser->destroy(parser);
+
+	ck_assert(success == (choice_tests[_i].i1 ||
+						  choice_tests[_i].i2 ||
+						  choice_tests[_i].i3 ||
+						  choice_tests[_i].i4 ));
+
+	ck_assert(i1 == choice_tests[_i].i1 &&
+			  i2 == choice_tests[_i].i2 &&
+			  i3 == choice_tests[_i].i3 &&
+			  i4 == choice_tests[_i].i4 );
+}
+END_TEST
+
+
 Suite *asn1_parser_suite_create()
 {
 	Suite *s;
@@ -287,5 +387,9 @@ Suite *asn1_parser_suite_create()
 	tcase_add_loop_test(tc, test_asn1_parser_option, 0, countof(option_tests));
 	suite_add_tcase(s, tc);
 
+	tc = tcase_create("choice");
+	tcase_add_loop_test(tc, test_asn1_parser_choice, 0, countof(choice_tests));
+	suite_add_tcase(s, tc);
+
 	return s;
 }
diff --git a/src/libstrongswan/tests/suites/test_enumerator.c b/src/libstrongswan/tests/suites/test_enumerator.c
index 9bd6d24f2..b781ae9fd 100644
--- a/src/libstrongswan/tests/suites/test_enumerator.c
+++ b/src/libstrongswan/tests/suites/test_enumerator.c
@@ -104,25 +104,45 @@ static void destroy_data(void *data)
  * filtered test
  */
 
-static bool filter(int *data, int **v, int *vo, int **w, int *wo,
-				   int **x, int *xo, int **y, int *yo, int **z, int *zo)
+CALLBACK(filter, bool,
+	int *data, enumerator_t *orig, va_list args)
 {
-	int val = **v;
+	int *item, *vo, *wo, *xo, *yo, *zo;
 
-	*vo = val++;
-	*wo = val++;
-	*xo = val++;
-	*yo = val++;
-	*zo = val++;
-	fail_if(data != (void*)101, "data does not match '101' in filter function");
-	return TRUE;
+	VA_ARGS_VGET(args, vo, wo, xo, yo, zo);
+
+	if (orig->enumerate(orig, &item))
+	{
+		int val = *item;
+		*vo = val++;
+		*wo = val++;
+		*xo = val++;
+		*yo = val++;
+		*zo = val++;
+		fail_if(data != (void*)101, "data does not match '101' in filter function");
+		return TRUE;
+	}
+	return FALSE;
 }
 
-static bool filter_odd(void *data, int **item, int *out)
+CALLBACK(filter_odd, bool,
+	void *data, enumerator_t *orig, va_list args)
 {
+	int *item, *out;
+
+	VA_ARGS_VGET(args, out);
+
 	fail_if(data != (void*)101, "data does not match '101' in filter function");
-	*out = **item;
-	return **item % 2 == 0;
+
+	while (orig->enumerate(orig, &item))
+	{
+		if (*item % 2 == 0)
+		{
+			*out = *item;
+			return TRUE;
+		}
+	}
+	return FALSE;
 }
 
 START_TEST(test_filtered)
@@ -136,7 +156,7 @@ START_TEST(test_filtered)
 
 	round = 1;
 	enumerator = enumerator_create_filter(list->create_enumerator(list),
-									(void*)filter, (void*)101, destroy_data);
+										  filter, (void*)101, destroy_data);
 	while (enumerator->enumerate(enumerator, &v, &w, &x, &y, &z))
 	{
 		ck_assert_int_eq(v, round);
@@ -166,7 +186,7 @@ START_TEST(test_filtered_filter)
 	/* should also work without destructor, so set this manually */
 	destroy_data_called = 1;
 	enumerator = enumerator_create_filter(list->create_enumerator(list),
-										 (void*)filter_odd, (void*)101, NULL);
+										  filter_odd, (void*)101, NULL);
 	while (enumerator->enumerate(enumerator, &x))
 	{
 		ck_assert(x % 2 == 0);
diff --git a/src/libstrongswan/tests/suites/test_linked_list.c b/src/libstrongswan/tests/suites/test_linked_list.c
index 7a161817c..aa1e0429f 100644
--- a/src/libstrongswan/tests/suites/test_linked_list.c
+++ b/src/libstrongswan/tests/suites/test_linked_list.c
@@ -183,26 +183,48 @@ END_TEST
  * find
  */
 
-static bool match_a_b(void *item, void *a, void *b)
+CALLBACK(find_a_b, bool,
+	void *item, va_list args)
 {
+	void *a, *b;
+
+	VA_ARGS_VGET(args, a, b);
 	ck_assert(a == (void*)1);
 	ck_assert(b == (void*)2);
 	return item == a || item == b;
 }
 
+CALLBACK(find_a, bool,
+	void *item, va_list args)
+{
+	void *a;
+
+	VA_ARGS_VGET(args, a);
+	return match_a(item, a);
+}
+
+CALLBACK(find_b, bool,
+	void *item, va_list args)
+{
+	void *b;
+
+	VA_ARGS_VGET(args, b);
+	return match_b(item, b);
+}
+
 START_TEST(test_find)
 {
 	void *a = (void*)1, *b = (void*)2;
 
-	ck_assert(list->find_first(list, NULL, &a) == NOT_FOUND);
+	ck_assert(!list->find_first(list, NULL, &a));
 	list->insert_last(list, a);
-	ck_assert(list->find_first(list, NULL, &a) == SUCCESS);
-	ck_assert(list->find_first(list, NULL, &b) == NOT_FOUND);
+	ck_assert(list->find_first(list, NULL, &a));
+	ck_assert(!list->find_first(list, NULL, &b));
 	list->insert_last(list, b);
-	ck_assert(list->find_first(list, NULL, &a) == SUCCESS);
-	ck_assert(list->find_first(list, NULL, &b) == SUCCESS);
+	ck_assert(list->find_first(list, NULL, &a));
+	ck_assert(list->find_first(list, NULL, &b));
 
-	ck_assert(list->find_first(list, NULL, NULL) == NOT_FOUND);
+	ck_assert(!list->find_first(list, NULL, NULL));
 }
 END_TEST
 
@@ -210,29 +232,57 @@ START_TEST(test_find_callback)
 {
 	void *a = (void*)1, *b = (void*)2, *x = NULL;
 
-	ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == NOT_FOUND);
+	ck_assert(!list->find_first(list, find_a_b, &x, a, b));
 	list->insert_last(list, a);
-	ck_assert(list->find_first(list, (linked_list_match_t)match_a, NULL, a) == SUCCESS);
+	ck_assert(list->find_first(list, find_a, NULL, a));
 	x = NULL;
-	ck_assert(list->find_first(list, (linked_list_match_t)match_a, &x, a) == SUCCESS);
+	ck_assert(list->find_first(list, find_a, &x, a));
 	ck_assert(a == x);
-	ck_assert(list->find_first(list, (linked_list_match_t)match_b, &x, b) == NOT_FOUND);
+	ck_assert(!list->find_first(list, find_b, &x, b));
 	ck_assert(a == x);
 	x = NULL;
-	ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == SUCCESS);
+	ck_assert(list->find_first(list, find_a_b, &x, a, b));
 	ck_assert(a == x);
 
 	list->insert_last(list, b);
-	ck_assert(list->find_first(list, (linked_list_match_t)match_a, &x, a) == SUCCESS);
+	ck_assert(list->find_first(list, find_a, &x, a));
 	ck_assert(a == x);
-	ck_assert(list->find_first(list, (linked_list_match_t)match_b, &x, b) == SUCCESS);
+	ck_assert(list->find_first(list, find_b, &x, b));
 	ck_assert(b == x);
 	x = NULL;
-	ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == SUCCESS);
+	ck_assert(list->find_first(list, find_a_b, &x, a, b));
 	ck_assert(a == x);
 }
 END_TEST
 
+CALLBACK(find_args, bool,
+	void *item, va_list args)
+{
+	uint64_t d, e;
+	level_t c;
+	int *a, b;
+
+	VA_ARGS_VGET(args, a, b, c, d, e);
+	ck_assert_int_eq(*a, 1);
+	ck_assert_int_eq(b, 2);
+	ck_assert_int_eq(c, LEVEL_PRIVATE);
+	ck_assert_int_eq(d, UINT64_MAX);
+	ck_assert_int_eq(e, UINT64_MAX-1);
+	return item == a;
+}
+
+START_TEST(test_find_callback_args)
+{
+	int a = 1, b = 2, *x;
+	uint64_t d = UINT64_MAX;
+
+	list->insert_last(list, &a);
+	ck_assert(list->find_first(list, find_args, (void**)&x, &a, b,
+							   LEVEL_PRIVATE, d, UINT64_MAX-1));
+	ck_assert_int_eq(a, *x);
+}
+END_TEST
+
 /*******************************************************************************
  * invoke
  */
@@ -241,11 +291,16 @@ typedef struct invoke_t invoke_t;
 
 struct invoke_t {
 	int val;
-	void (*invoke)(invoke_t *item, void *a, void *b, void *c, void *d, int *sum);
+	void (*invoke)(invoke_t *item);
 };
 
-static void invoke(intptr_t item, void *a, void *b, void *c, void *d, int *sum)
+CALLBACK(invoke, void,
+	intptr_t item, va_list args)
 {
+	void *a, *b, *c, *d;
+	int *sum;
+
+	VA_ARGS_VGET(args, a, b, c, d, sum);
 	ck_assert_int_eq((uintptr_t)a, 1);
 	ck_assert_int_eq((uintptr_t)b, 2);
 	ck_assert_int_eq((uintptr_t)c, 3);
@@ -253,9 +308,9 @@ static void invoke(intptr_t item, void *a, void *b, void *c, void *d, int *sum)
 	*sum += item;
 }
 
-static void invoke_offset(invoke_t *item, void *a, void *b, void *c, void *d, int *sum)
+static void invoke_offset(invoke_t *item)
 {
-	invoke(item->val, a, b, c, d, sum);
+	item->val++;
 }
 
 START_TEST(test_invoke_function)
@@ -267,8 +322,7 @@ START_TEST(test_invoke_function)
 	list->insert_last(list, (void*)3);
 	list->insert_last(list, (void*)4);
 	list->insert_last(list, (void*)5);
-	list->invoke_function(list, (linked_list_invoke_t)invoke,
-						  (uintptr_t)1, (uintptr_t)2,
+	list->invoke_function(list, invoke, (uintptr_t)1, (uintptr_t)2,
 						  (uintptr_t)3, (uintptr_t)4, &sum);
 	ck_assert_int_eq(sum, 15);
 }
@@ -282,17 +336,19 @@ START_TEST(test_invoke_offset)
 		{ .val = 3, .invoke = invoke_offset, },
 		{ .val = 4, .invoke = invoke_offset, },
 		{ .val = 5, .invoke = invoke_offset, },
-	};
-	int i, sum = 0;
+	}, *item;
+	int i;
 
 	for (i = 0; i < countof(items); i++)
 	{
 		list->insert_last(list, &items[i]);
 	}
-	list->invoke_offset(list, offsetof(invoke_t, invoke),
-						(uintptr_t)1, (uintptr_t)2,
-						(uintptr_t)3, (uintptr_t)4, &sum);
-	ck_assert_int_eq(sum, 15);
+	list->invoke_offset(list, offsetof(invoke_t, invoke));
+	i = 2;
+	while (list->remove_first(list, (void**)&item) == SUCCESS)
+	{
+		ck_assert_int_eq(item->val, i++);
+	}
 }
 END_TEST
 
@@ -458,6 +514,7 @@ Suite *linked_list_suite_create()
 	tcase_add_checked_fixture(tc, setup_list, teardown_list);
 	tcase_add_test(tc, test_find);
 	tcase_add_test(tc, test_find_callback);
+	tcase_add_test(tc, test_find_callback_args);
 	suite_add_tcase(s, tc);
 
 	tc = tcase_create("invoke");
diff --git a/src/libstrongswan/tests/test_suite.h b/src/libstrongswan/tests/test_suite.h
index 66c68465a..97c1b42c1 100644
--- a/src/libstrongswan/tests/test_suite.h
+++ b/src/libstrongswan/tests/test_suite.h
@@ -298,7 +298,7 @@ void test_fail_if_worker_failed();
 	chunk_t _a = (chunk_t)a; \
 	chunk_t _b = (chunk_t)b; \
 	test_fail_if_worker_failed(); \
-	if (_a.len != _b.len || !memeq(a.ptr, b.ptr, a.len)) \
+	if (_a.len != _b.len || !memeq(_a.ptr, _b.ptr, _a.len)) \
 	{ \
 		test_fail_msg(__FILE__, __LINE__, \
 					  #a " != " #b " (\"%#B\" != \"%#B\")", &_a, &_b); \