Add EXTERNAL support. vlmgh-140

- Add EXTERNAL ASN.1 defintion from ITU-T X.208 in
  skeletons/standard-modules/ASN1C-UsefulInformationObjectClasses.asn1
- Remove EXTERNAL from asn1p_l.l and asn1p_y.y
- Add a test case:
  tests/135-EXTERNAL-OK.asn and
  asn1c/tests/check-src/check-135.c
- Regeneragte all tests/*.asn1.-Pfwide-types files

TODO

@@ -7,5 +7,5 @@
 
 2. MEDIUM:
 
-2.1 Support for EXTERNAL, EMBEDDED-PDV and CHARACTER STRING types.
+2.1 Support for EMBEDDED-PDV and CHARACTER STRING types.
 	Requires something from 1.2 (Information Object Classes).

asn1c/tests/Makefile.am

@@ -15,6 +15,7 @@ TESTS += check-src/check-127.-gen-PER.c
 TESTS += check-src/check-131.-gen-PER.c
 TESTS += check-src/check-132.-gen-PER.c
 TESTS += check-src/check-133.-gen-PER.c
+TESTS += check-src/check-135.c
 TESTS += check-src/check-19.c
 TESTS += check-src/check-22.-fwide-types.c
 TESTS += check-src/check-24.-fwide-types.c

asn1c/tests/check-assembly.sh

@@ -68,7 +68,7 @@ check-executable: compiled-module *.c*
 # Compile the corresponding .asn1 spec.
 compiled-module: ${asn_module} ${abs_top_builddir}/asn1c/asn1c
 	${abs_top_builddir}/asn1c/asn1c		\\
-		-S /tmp/do/not/copy/skeletons	\\
+		-S ${abs_top_srcdir}/skeletons	\\
 		-Wdebug-compiler		\\
 		${AFLAGS} ${asn_module}
 	rm -f converter-sample.c

asn1c/tests/check-src/check-135.c

@@ -0,0 +1,135 @@
+#undef	NDEBUG
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <assert.h>
+
+#include "T.h"
+
+
+uint8_t buf1[] = {
+	0x28,0x18,
+		0x06,0x07,0x00,0x11,0x86,0x05,0x01,0x01,0x01,
+		0xa0,0x0d,
+			0x60,0x0b,
+				0xa1,0x09,
+					0x06,0x07,0x04,0x00,0x00,0x01,0x00,0x05,0x03
+};
+
+
+uint8_t buf1_reconstr[] = {
+	0x28,0x18,
+		0x06,0x07,0x00,0x11,0x86,0x05,0x01,0x01,0x01,
+		0xa0,0x0d,
+			0x60,0x0b,
+				0xa1,0x09,
+					0x06,0x07,0x04,0x00,0x00,0x01,0x00,0x05,0x03
+};
+
+
+static void
+check(T_t *tp, uint8_t *buf, size_t size, size_t consumed) {
+	asn_dec_rval_t rval;
+
+	tp = memset(tp, 0, sizeof(*tp));
+
+	fprintf(stderr, "Buf %p (%zd)\n", buf, size);
+	rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
+	fprintf(stderr, "Returned code %d, consumed %zd\n",
+		(int)rval.code, rval.consumed);
+
+	assert(rval.code == RC_OK);
+	assert(rval.consumed == consumed);
+
+	const uint8_t direct_reference[] = {0x00,0x11,0x86,0x05,0x01,0x01,0x01};
+	assert(tp->direct_reference);
+	assert(tp->direct_reference->size == sizeof(direct_reference));
+	assert(memcmp(tp->direct_reference->buf, direct_reference,
+				sizeof(direct_reference)) == 0);
+
+	assert(tp->indirect_reference == NULL);
+	assert(tp->data_value_descriptor == NULL);
+
+	const uint8_t single_asn1_type[] = {
+		0x60,0x0b,0xa1,0x09,0x06,0x07,0x04,0x00,0x00,0x01,0x00,0x05,0x03};
+	assert(tp->encoding.present == encoding_PR_single_ASN1_type);
+	assert(tp->encoding.choice.single_ASN1_type.size == sizeof(single_asn1_type));
+	assert(memcmp(tp->encoding.choice.single_ASN1_type.buf, single_asn1_type,
+				sizeof(single_asn1_type)) == 0);
+}
+
+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, "%zd + %zd > %zd\n",
+			buf_pos, size, buf_size);
+		return -1;
+	}
+
+	memcpy(buf + buf_pos, buffer, size);
+	buf_pos += size;
+	fprintf(stderr, "   written %zd (%zd)\n", size, buf_pos);
+
+	return 0;
+}
+
+static void
+compare(T_t *tp, uint8_t *cmp_buf, ssize_t 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("%zd != %zd\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]);
+	}
+}
+
+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);
+
+	return 0;
+}

libasn1parser/asn1p_l.l

@@ -296,7 +296,6 @@ EXCEPT			return TOK_EXCEPT;
 EXPLICIT		return TOK_EXPLICIT;
 EXPORTS			return TOK_EXPORTS;
 EXTENSIBILITY		return TOK_EXTENSIBILITY;
-EXTERNAL		return TOK_EXTERNAL;
 FALSE			return TOK_FALSE;
 FROM			return TOK_FROM;
 GeneralizedTime		return TOK_GeneralizedTime;

libasn1parser/asn1p_y.y

@@ -174,7 +174,6 @@ static asn1p_module_t *currentModule;
 %token			TOK_EXPLICIT
 %token			TOK_EXPORTS
 %token			TOK_EXTENSIBILITY
-%token			TOK_EXTERNAL
 %token			TOK_FALSE
 %token			TOK_FROM
 %token			TOK_GeneralizedTime
@@ -1607,7 +1606,6 @@ BasicTypeId:
 	| TOK_OCTET TOK_STRING { $$ = ASN_BASIC_OCTET_STRING; }
 	| TOK_OBJECT TOK_IDENTIFIER { $$ = ASN_BASIC_OBJECT_IDENTIFIER; }
 	| TOK_RELATIVE_OID { $$ = ASN_BASIC_RELATIVE_OID; }
-	| TOK_EXTERNAL { $$ = ASN_BASIC_EXTERNAL; }
 	| TOK_EMBEDDED TOK_PDV { $$ = ASN_BASIC_EMBEDDED_PDV; }
 	| TOK_CHARACTER TOK_STRING { $$ = ASN_BASIC_CHARACTER_STRING; }
 	| TOK_UTCTime { $$ = ASN_BASIC_UTCTime; }

skeletons/standard-modules/ASN1C-UsefulInformationObjectClasses.asn1

@@ -28,4 +28,16 @@ DEFINITIONS ::= BEGIN
 	    &property	BIT STRING { handles-invalid-encodings(0) } DEFAULT {}
 	} WITH SYNTAX { &Type IDENTIFIED BY &id [HAS PROPERTY &property] }
 
+	--
+	-- From "ITU-T Recommendation X.208", "34 The external type"
+	--
+	EXTERNAL ::= [UNIVERSAL 8] IMPLICIT SEQUENCE
+	{direct-reference OBJECT IDENTIFIER OPTIONAL,
+		indirect-reference INTEGER OPTIONAL,
+		data-value-descriptor ObjectDescriptor OPTIONAL,
+		encoding CHOICE
+		{single-ASN1-type [0] ANY,
+			octet-aligned [1] IMPLICIT OCTET STRING,
+			arbitrary [2] IMPLICIT BIT STRING}}
+
 END