*** empty log message ***

3 files changed, 564 insertions, 0 deletions

diff --git a/asn1c/tests/check-41.-fnative-types.c b/asn1c/tests/check-41.-fnative-types.c
new file mode 100644
index 00000000..3b735ccf
--- /dev/null
+++ b/asn1c/tests/check-41.-fnative-types.c
@@ -0,0 +1,219 @@
+#undef	NDEBUG
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <assert.h>
+
+#include <T.h>
+
+
+uint8_t buf1[] = {
+	32 | (2 << 6),		/* [0], constructed */
+	25,	/* L */
+
+	/* string   [0] IMPLICIT UTF8String, */
+	(2 << 6),			/* [0] */
+	16,	/* L */
+ 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
+
+	/* beta    [2] IMPLICIT INTEGER OPTIONAL */
+	(2 << 6) + 2,			/* [2] */
+	5,	/* L */
+  0,
+  75,
+  0x4b,
+  75,
+  75,
+};
+
+uint8_t buf1_reconstr[] = {
+	32 | (2 << 6),		/* [0], constructed */
+	24,	/* L */
+
+	/* string   [0] IMPLICIT UTF8String, */
+	(2 << 6),			/* [0] */
+	16,	/* L */
+ 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
+
+	/* beta    [2] IMPLICIT INTEGER OPTIONAL */
+	(2 << 6) + 2,			/* [2] */
+	4,	/* L */
+  75,
+  75,
+  75,
+  0x4b,
+};
+
+
+static void
+check(T_t *tp, uint8_t *buf, int size, size_t consumed) {
+	asn_dec_rval_t rval;
+
+	tp = memset(tp, 0, sizeof(*tp));
+
+	fprintf(stderr, "Buf %p (%d)\n", buf, size);
+	rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
+	fprintf(stderr, "Returned code %d, consumed %d\n",
+		(int)rval.code, (int)rval.consumed);
+
+	assert(rval.code == RC_OK);
+	assert(rval.consumed == consumed);
+
+	assert(tp->choice.seq.string.size == 16);
+	assert(strcmp(tp->choice.seq.string.buf, "zzzzzzzzzzzzzzzz") == 0);
+	assert(tp->choice.seq.alpha == NULL);
+	assert(tp->choice.seq.beta);
+	assert(*tp->choice.seq.beta == 0x4b4b4b4b);
+}
+
+size_t buf_pos;
+size_t buf_size;
+uint8_t *buf;
+
+static int
+buf_fill(const void *buffer, size_t size, void *app_key) {
+
+	(void)app_key;	/* Unused argument */
+
+	if(buf_pos + size > buf_size) {
+		fprintf(stderr, "%d + %d > %d\n",
+			(int)buf_pos, (int)size, (int)buf_size);
+		return -1;
+	}
+
+	memcpy(buf + buf_pos, buffer, size);
+	buf_pos += size;
+	fprintf(stderr, "   written %d (%d)\n", (int)size, (int)buf_pos);
+
+	return 0;
+}
+
+static void
+compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
+	asn_enc_rval_t erval;
+	int i;
+
+	buf_size = cmp_buf_size + 100;
+	buf = alloca(buf_size);
+	buf_pos = 0;
+
+	/*
+	 * Try to re-create using DER encoding.
+	 */
+	erval = der_encode(&asn_DEF_T, tp, buf_fill, 0);
+	assert(erval.encoded != -1);
+	if(erval.encoded != cmp_buf_size) {
+		printf("%d != %d\n", erval.encoded, cmp_buf_size);
+	}
+	assert(erval.encoded == cmp_buf_size);
+	for(i = 0; i < cmp_buf_size; i++) {
+		if(buf[i] != cmp_buf[i]) {
+			fprintf(stderr, "Recreated buffer content mismatch:\n");
+			fprintf(stderr, "Byte %d, %x != %x (%d != %d)\n",
+				i,
+				buf[i], cmp_buf[i],
+				buf[i], cmp_buf[i]
+			);
+		}
+		assert(buf[i] == cmp_buf[i]);
+	}
+}
+
+static void
+partial_read(uint8_t *buf_0, size_t size) {
+	T_t t, *tp;
+	asn_dec_rval_t rval;
+	size_t i1, i2;
+	uint8_t *buf_1 = alloca(size);
+	uint8_t *buf_2 = alloca(size);
+	uint8_t *buf_3 = alloca(size);
+
+	fprintf(stderr, "\nPartial read sequence...\n");
+
+	/*
+	 * Divide the space (size) into three blocks in various combinations:
+	 *   |<----->i1<----->i2<----->|
+	 *   ^ buf_0                    ^ buf_0+size
+	 * Try to read block by block.
+	 */
+	for(i1 = 0; i1 < size; i1++) {
+		for(i2 = i1; i2 < size; i2++) {
+			uint8_t *chunk1 = buf_0;
+			size_t size1 = i1;
+			uint8_t *chunk2 = buf_0 + size1;
+			size_t size2 = i2 - i1;
+			uint8_t *chunk3 = buf_0 + size1 + size2;
+			size_t size3 = size - size1 - size2;
+
+			fprintf(stderr, "\n%d:{%d, %d, %d}...\n",
+				(int)size, (int)size1, (int)size2, (int)size3);
+
+			memset(buf_1, 0, size);
+			memset(buf_2, 0, size);
+			memset(buf_3, 0, size);
+			memcpy(buf_1, chunk1, size1);
+			memcpy(buf_2, chunk2, size2);
+			memcpy(buf_3, chunk3, size3);
+
+			tp = memset(&t, 0, sizeof(t));
+
+			fprintf(stderr, "=> Chunk 1 (%d):\n", (int)size1);
+			rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
+				buf_1, size1);
+			assert(rval.code == RC_WMORE);
+			assert(rval.consumed <= size1);
+			if(rval.consumed < size1) {
+				int leftover = size1 - rval.consumed;
+				memcpy(buf_2, buf_1 + rval.consumed, leftover);
+				memcpy(buf_2 + leftover, chunk2, size2);
+				size2 += leftover;
+			}
+
+			fprintf(stderr, "=> Chunk 2 (%d):\n", (int)size2);
+			rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
+				buf_2, size2);
+			assert(rval.code == RC_WMORE);
+			assert(rval.consumed <= size2);
+			if(rval.consumed < size2) {
+				int leftover = size2 - rval.consumed;
+				memcpy(buf_3, buf_2 + rval.consumed, leftover);
+				memcpy(buf_3 + leftover, chunk3, size3);
+				size3 += leftover;
+			}
+
+			fprintf(stderr, "=> Chunk 3 (%d):\n", (int)size3);
+			rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
+				buf_3, size3);
+			assert(rval.code == RC_OK);
+			assert(rval.consumed == size3);
+
+			asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
+		}
+	}
+}
+
+int
+main(int ac, char **av) {
+	T_t t;
+
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
+	/* Check exact buf1 */
+	check(&t, buf1, sizeof(buf1), sizeof(buf1));
+	compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
+	asn_fprint(stderr, &asn_DEF_T, &t);
+	asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
+
+	/* Check slightly more than buf1 */
+	check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1));
+	compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
+	asn_fprint(stderr, &asn_DEF_T, &t);
+	asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
+
+	/* Split the buffer in parts and check decoder restartability */
+	partial_read(buf1, sizeof(buf1));
+
+	return 0;
+}
diff --git a/asn1c/tests/check-42.-fnative-types.c b/asn1c/tests/check-42.-fnative-types.c
new file mode 100644
index 00000000..9afa800a
--- /dev/null
+++ b/asn1c/tests/check-42.-fnative-types.c
@@ -0,0 +1,142 @@
+#undef	NDEBUG
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <assert.h>
+
+#include <LogLine.h>
+
+uint8_t buf0[] = {
+	48,	/* LogLine SEQUENCE */
+	24,	/* L */
+	22,	/* IA5String */
+	4,	/* L */
+	/* "zzz\007" */
+  122, 122, 122, 7,
+	48,	/* varsets SEQUENCE OF VariablePartSet */
+	16,	/* L */
+	48,	/* VariablePart */
+	14,	/* L */
+	48,	/* vparts SEQUENCE OF VariablePart */
+	7,	/* L */
+	49,	/* VariablePart */
+	5,
+	26,	/* VisibleString */
+	3,
+	49, 50, 51,	/* 1 2 3 */
+	48,	/* ActionItem SEQUENCE */
+	3,	/* L */
+	10,	/* accept-as ENUMERATED */
+	1,	/* L */
+	0,
+};
+
+uint8_t buf1[] = {
+	48,	/* LogLine SEQUENCE */
+	19,	/* L */
+	22,	/* IA5String */
+	6,	/* L */
+	/* "static" */
+  115, 116, 97, 116, 105, 99,
+	48,	/* varsets SEQUENCE OF VariablePartSet */
+	9,	/* L */
+	48,	/* VariablePart */
+	7,	/* L */
+	48,	/* vparts SEQUENCE OF VariablePart */
+	0,	/* L */
+	48,	/* ActionItem SEQUENCE */
+	3,	/* L */
+	10,	/* accept-as ENUMERATED */
+	1,	/* L */
+	0,
+};
+
+static void
+check(LogLine_t *tp, uint8_t *ptr, int size, size_t consumed) {
+	asn_dec_rval_t rval;
+
+	tp = memset(tp, 0, sizeof(*tp));
+
+	fprintf(stderr, "Buf %p (%d)\n", ptr, size);
+	rval = ber_decode(0, &asn_DEF_LogLine, (void **)&tp, ptr, size);
+	fprintf(stderr, "Returned code %d, consumed %d\n",
+		(int)rval.code, (int)rval.consumed);
+
+	assert(rval.code == RC_OK);
+	assert(rval.consumed == consumed);
+	asn_fprint(stderr, &asn_DEF_LogLine, tp);
+	asn_DEF_LogLine.free_struct(&asn_DEF_LogLine, tp, 1);
+}
+
+uint8_t *buf;
+uint8_t buf_size;
+uint8_t buf_pos;
+
+
+static int
+buf_fill(const void *buffer, size_t size, void *app_key) {
+
+	(void)app_key;	/* Unused argument */
+
+	assert(buf_pos + size <= buf_size);
+
+	memcpy(buf + buf_pos, buffer, size);
+	buf_pos += size;
+
+	return 0;
+}
+
+static void
+check_serialize() {
+	LogLine_t ll;
+	VariablePartSet_t vps;
+	VariablePart_t vp;
+	VisibleString_t vpart;
+	asn_enc_rval_t erval;
+	int i;
+
+	memset(&ll, 0, sizeof(ll));
+	memset(&vps, 0, sizeof(vps));
+	memset(&vp, 0, sizeof(vp));
+	memset(&vpart, 0, sizeof(vpart));
+	vpart.buf = "123";
+	vpart.size = 3;
+
+	vp.present = VariablePart_PR_vset;
+	ASN_SET_ADD(&vp.choice.vset, &vpart);
+	vps.resolution.accept_as = accept_as_unknown;
+	ASN_SEQUENCE_ADD(&vps.vparts, &vp);
+	ASN_SEQUENCE_ADD(&ll.varsets, &vps);
+	ll.line_digest.buf = "zzz\007";
+	ll.line_digest.size = 4;
+
+	asn_fprint(stderr, &asn_DEF_LogLine, &ll);
+	buf_size = 128;
+	buf = alloca(buf_size);
+	erval = der_encode(&asn_DEF_LogLine, &ll, buf_fill, 0);
+	assert(erval.encoded > 1);
+	fprintf(stderr, "Encoded in %d bytes\n", erval.encoded);
+	fprintf(stderr, "\n");
+	for(i = 0; i < buf_pos; i++) {
+		fprintf(stderr, "%d ", buf[i]);
+	}
+	fprintf(stderr, "\n\n");
+	assert(erval.encoded == sizeof(buf0));
+	assert(memcmp(buf0, buf, sizeof(buf0)) == 0);
+}
+
+int
+main(int ac, char **av) {
+	LogLine_t t;
+
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
+	check_serialize();
+
+	check(&t, buf0, sizeof(buf0), sizeof(buf0));
+	check(&t, buf1, sizeof(buf1), sizeof(buf1));
+
+	return 0;
+}
diff --git a/asn1c/tests/check-60.-fnative-types.c b/asn1c/tests/check-60.-fnative-types.c
new file mode 100644
index 00000000..3dc8e539
--- /dev/null
+++ b/asn1c/tests/check-60.-fnative-types.c
@@ -0,0 +1,203 @@
+#undef	NDEBUG
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+
+#include <T1.h>
+#include <T2.h>
+
+static unsigned char buf[4096];
+static int buf_offset;
+
+static int
+_buf_writer(const void *buffer, size_t size, void *app_key) {
+	unsigned char *b, *bend;
+	(void)app_key;
+	assert(buf_offset + size < sizeof(buf));
+	memcpy(buf + buf_offset, buffer, size);
+	b = buf + buf_offset;
+	bend = b + size;
+	printf("=> [");
+	for(; b < bend; b++)
+		printf(" %02X", *b);
+	printf("]:%ld\n", (long)size);
+	buf_offset += size;
+	return 0;
+}
+
+static int
+save_object(void *bs, asn_TYPE_descriptor_t *td) {
+	asn_enc_rval_t rval; /* Return value */
+	int i;
+
+	buf_offset = 0;
+	
+	rval = der_encode(td, bs, _buf_writer, 0);
+	if (rval.encoded == -1) {
+		fprintf(stderr,
+			"Cannot encode %s: %s\n",
+			rval.failed_type->name, strerror(errno));
+		assert(rval.encoded != -1);
+		return -1;	/* JIC */
+	}
+
+	buf[buf_offset++] = 0xab;	/* Finalize with garbage */
+
+	asn_fprint(stderr, td, bs);
+
+	printf("OUT: [");
+	for(i = 0; i < buf_offset; i++)
+		printf(" %02x", buf[i]);
+	printf("]\n");
+
+	return 0;
+}
+
+static int
+load_object(void *bs, asn_TYPE_descriptor_t *td) {
+	asn_dec_rval_t rval;
+
+	fprintf(stderr, "\nLOADING OBJECT OF SIZE %d\n", buf_offset);
+
+	rval = ber_decode(0, td, (void **)&bs, buf, buf_offset);
+	assert(rval.code == RC_OK);
+
+	asn_fprint(stderr, td, bs);
+
+	return (rval.code == RC_OK)?0:-1;
+}
+
+/* [3] IMPLICIT SEQUENCE { b BOOLEAN } */
+uint8_t test_any_buf1[] = { 0xa3, 0x80, /* [3], constructed, indefinite */
+	0x01, 0x01, 0xff,	/* b BOOLEAN ::= TRUE */
+	0x00, 0x00 /* End of content octets */ };
+
+/* b BOOLEAN */
+uint8_t test_any_buf2[] = { 0x01, 0x01, 0x13 };
+
+int
+main() {
+	asn_TYPE_descriptor_t *td1 = &asn_DEF_T1;
+	asn_TYPE_descriptor_t *td2 = &asn_DEF_T2;
+	T1_t t1, t1_new;
+	T2_t t2, t2_new;
+	int ret;
+
+	/*
+	 * Test the T1 with constructed indefinite length ANY encoding.
+	 */
+	memset(&t1, 0, sizeof(t1));
+	memset(&t1_new, 0, sizeof(t1_new));
+
+	t1.i = 112233;
+	t1.any.buf = test_any_buf1;
+	t1.any.size = sizeof(test_any_buf1);
+
+	/* Save->Load must succeed */
+	save_object(&t1, td1);
+	ret = load_object(&t1_new, td1);
+
+	assert(ret == 0);
+	assert(t1_new.i == 112233);
+	assert(t1_new.any.size == sizeof(test_any_buf1));
+	assert(memcmp(t1_new.any.buf, test_any_buf1, sizeof(test_any_buf1)) == 0);
+
+	/*
+	 * Test the T1 with primitive encoding.
+	 */
+	memset(&t1, 0, sizeof(t1));
+	memset(&t1_new, 0, sizeof(t1_new));
+
+	t1.i = -112233;
+	t1.any.buf = test_any_buf2;
+	t1.any.size = sizeof(test_any_buf2);
+
+	/* Save->Load must succeed */
+	save_object(&t1, td1);
+	ret = load_object(&t1_new, td1);
+
+	assert(ret == 0);
+	assert(t1_new.i == -112233);
+	assert(t1_new.any.size == sizeof(test_any_buf2));
+	assert(memcmp(t1_new.any.buf, test_any_buf2, sizeof(test_any_buf2)) == 0);
+
+	/*
+	 * Test the T2 empty sequence.
+	 */
+	memset(&t2, 0, sizeof(t2));
+	memset(&t2_new, 0, sizeof(t2_new));
+
+	t2.i = 332211;
+	t2.any = calloc(1, sizeof(*t2.any));
+	t2.any->buf = 0;
+	t2.any->size = 0;
+
+	/* Save->Load must succeed */
+	save_object(&t2, td2);
+	ret = load_object(&t2_new, td2);
+
+	assert(ret == 0);
+	assert(t2_new.i == 332211);
+	assert(t2_new.any->size == 0);
+
+	/*
+	 * Test the T2 sequence.
+	 */
+	memset(&t2, 0, sizeof(t2));
+	memset(&t2_new, 0, sizeof(t2_new));
+
+	t2.i = 332211;
+	t2.any = calloc(1, sizeof(*t2.any));
+	t2.any->buf = test_any_buf1;
+	t2.any->size = sizeof(test_any_buf1);
+
+	/* Save->Load must succeed */
+	save_object(&t2, td2);
+	ret = load_object(&t2_new, td2);
+
+	assert(ret == 0);
+	assert(t2_new.i == 332211);
+	assert(t2_new.any->size == sizeof(test_any_buf1));
+	assert(memcmp(t2_new.any->buf, test_any_buf1, sizeof(test_any_buf1)) == 0);
+
+	/*
+	 * Test the T2 sequence with primitive encoding.
+	 */
+	memset(&t2, 0, sizeof(t2));
+	memset(&t2_new, 0, sizeof(t2_new));
+
+	t2.i = 0;
+	t2.any = calloc(1, sizeof(*t2.any));
+	t2.any->buf = test_any_buf2;
+	t2.any->size = sizeof(test_any_buf2);
+
+	/* Save->Load must succeed */
+	save_object(&t2, td2);
+	ret = load_object(&t2_new, td2);
+
+	assert(ret == 0);
+	assert(t2_new.i == 0);
+	assert(t2_new.any->size == sizeof(test_any_buf2));
+	assert(memcmp(t2_new.any->buf, test_any_buf2, sizeof(test_any_buf2)) == 0);
+
+	/*
+	 * Test T2 with ANY element omitted.
+	 */
+	free(t2.any);
+	t2.any = 0;
+	memset(&t2_new, 0, sizeof(t2_new));
+
+	save_object(&t2, td2);
+	ret = load_object(&t2_new, td2);
+
+	assert(ret == 0);
+	assert(t2_new.i == 0);
+	assert(t2_new.any == 0);
+
+	printf("OK\n");
+
+	return ret;
+}