add initial code for S1AP encoder/decoder

configure.ac

@@ -244,11 +244,8 @@ AC_SUBST(OSLIBS)
 #### Conclusion. ####
 #####################
 
-AC_CONFIG_FILES([Makefile])
-AC_CONFIG_FILES([src/Makefile])
 AC_CONFIG_FILES([lib/Makefile])
 AC_CONFIG_FILES([lib/core/include/core.h])
-AC_CONFIG_FILES([lib/core/Makefile])
 AC_CONFIG_FILES([lib/core/src/Makefile])
 case $host in
    *)
@@ -256,7 +253,12 @@ case $host in
        ;;
 esac
 AC_CONFIG_FILES([lib/core/test/Makefile])
+AC_CONFIG_FILES([lib/core/Makefile])
 AC_CONFIG_FILES([lib/logger/Makefile])
+AC_CONFIG_FILES([lib/asn/asn1c/Makefile])
+AC_CONFIG_FILES([lib/asn/Makefile])
+AC_CONFIG_FILES([src/Makefile])
+AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
 
 echo "

lib/Makefile.am

@@ -1,6 +1,6 @@
 ## Process this file with automake to produce Makefile.in
 
-SUBDIRS = core logger 
+SUBDIRS = core logger asn
 
 MAINTAINERCLEANFILES = Makefile.in 
 MOSTLYCLEANFILES = *.stackdump

lib/asn/Makefile.am

@@ -0,0 +1,33 @@
+## Process this file with automake to produce Makefile.in
+
+SUBDIRS = asn1c
+
+noinst_LTLIBRARIES = libasn.la
+
+libasn_la_SOURCES = \
+	s1ap_ies_defs.h s1ap_common.h
+
+nodist_libasn_la_SOURCES = \
+	s1ap_encoder.c s1ap_decoder.c s1ap_xer_print.c \
+	s1ap_common.c
+
+libasn_la_DEPENDENCIES = \
+    $(top_srcdir)/lib/core/src/libcore.la \
+    $(top_srcdir)/lib/core/src/@OSDIR@/libcore@OSDIR@.la
+
+libasn_la_LIBADD = \
+    $(top_srcdir)/lib/core/src/libcore.la \
+    $(top_srcdir)/lib/core/src/@OSDIR@/libcore@OSDIR@.la
+
+AM_CPPFLAGS = \
+    -I$(top_srcdir)/lib/core/include/arch/@OSDIR@ \
+    -I$(top_srcdir)/lib/core/include \
+    -I$(top_srcdir)/lib/asn/asn1c
+
+AM_CFLAGS = \
+	-Wall -Werror
+
+MAINTAINERCLEANFILES = Makefile.in 
+MOSTLYCLEANFILES = *.stackdump
+
+EXTRA_DIST = .libs $(noinst_LTLIBRARIES)

lib/asn/README

@@ -0,0 +1,19 @@
+* Use AuthenticEshkinKot's fork for asn1c
+user@host ~/Documents/git/AuthenticEshkinKot$ \
+    git clone https://github.com/AuthenticEshkinKot/asn1c.git
+user@host Documents/~/git/AuthenticEshkinKot$ \
+    autoreconf -iv;./configure;make
+
+* Add prefix S1AP to the 3GPP S1AP specification
+user@host ~/Documents/git/cellwire/lib/asn/support$ \
+    python asn1prefix.py -i 36413-a90.asn -o S1AP-PDU.asn
+
+* ASN.1 encoder/decoder
+user@host ~/Documents/git/cellwire/lib/asn/asn1c$ \
+    ../../../../AuthenticEshkinKot/asn1c/asn1c/asn1c \
+    -fcompound-names -gen-PER ../support/S1AP-PDU.asn
+
+* EUROCOM S1AP-IEs support files
+user@host ~/Documents/git/cellwire/lib/asn/support$ \
+    python asn1tostruct.py -f S1AP-PDU.asn -o ..
+

lib/asn/asn1c/ANY.c

@@ -0,0 +1,243 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <ANY.h>
+#include <errno.h>
+
+static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = {
+	sizeof(ANY_t),
+	offsetof(ANY_t, _asn_ctx),
+	ASN_OSUBV_ANY
+};
+asn_TYPE_descriptor_t asn_DEF_ANY = {
+	"ANY",
+	"ANY",
+	OCTET_STRING_free,
+	OCTET_STRING_print,
+	asn_generic_no_constraint,
+	OCTET_STRING_decode_ber,
+	OCTET_STRING_encode_der,
+	OCTET_STRING_decode_xer_hex,
+	ANY_encode_xer,
+	OCTET_STRING_decode_uper,
+	OCTET_STRING_encode_uper,
+	OCTET_STRING_decode_aper,
+	OCTET_STRING_encode_aper,
+	0, /* Use generic outmost tag fetcher */
+	0, 0, 0, 0,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_DEF_ANY_specs,
+};
+
+
+asn_enc_rval_t
+ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+
+	if(flags & XER_F_CANONICAL) {
+		/*
+		 * Canonical XER-encoding of ANY type is not supported.
+		 */
+		ASN__ENCODE_FAILED;
+	}
+
+	/* Dump as binary */
+	return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
+}
+
+struct _callback_arg {
+	uint8_t *buffer;
+	size_t offset;
+	size_t size;
+};
+
+static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
+
+int
+ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
+	struct _callback_arg arg;
+	asn_enc_rval_t erval;
+
+	if(!st || !td) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(!sptr) {
+		if(st->buf) FREEMEM(st->buf);
+		st->size = 0;
+		return 0;
+	}
+
+	arg.offset = arg.size = 0;
+	arg.buffer = 0;
+
+	erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
+	if(erval.encoded == -1) {
+		if(arg.buffer) FREEMEM(arg.buffer);
+		return -1;
+	}
+	assert((size_t)erval.encoded == arg.offset);
+
+	if(st->buf) FREEMEM(st->buf);
+	st->buf = arg.buffer;
+	st->size = arg.offset;
+
+	return 0;
+}
+
+int
+ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
+	uint8_t *buffer = NULL;
+	ssize_t erval;
+
+	if(!st || !td) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(!sptr) {
+		if(st->buf) FREEMEM(st->buf);
+		st->size = 0;
+		return 0;
+	}
+
+	erval = aper_encode_to_new_buffer(td, td->per_constraints, sptr, (void**)&buffer);
+
+	if(erval == -1) {
+		if(buffer) FREEMEM(buffer);
+		return -1;
+	}
+	assert((size_t)erval > 0);
+
+	if(st->buf) FREEMEM(st->buf);
+	st->buf = buffer;
+	st->size = erval;
+
+	return 0;
+}
+
+ANY_t *
+ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
+	ANY_t tmp;
+	ANY_t *st;
+
+	if(!td || !sptr) {
+		errno = EINVAL;
+		return 0;
+	}
+
+	memset(&tmp, 0, sizeof(tmp));
+
+	if(ANY_fromType(&tmp, td, sptr)) return 0;
+
+	st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
+	if(st) {
+		*st = tmp;
+		return st;
+	} else {
+		FREEMEM(tmp.buf);
+		return 0;
+	}
+}
+
+ANY_t *
+ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr) {
+	ANY_t tmp;
+	ANY_t *st;
+
+	if(!td || !sptr) {
+		errno = EINVAL;
+		return 0;
+	}
+
+	memset(&tmp, 0, sizeof(tmp));
+
+	if(ANY_fromType_aper(&tmp, td, sptr)) return 0;
+
+	st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
+	if(st) {
+		*st = tmp;
+		return st;
+	} else {
+		FREEMEM(tmp.buf);
+		return 0;
+	}
+}
+
+int
+ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
+	asn_dec_rval_t rval;
+	void *newst = 0;
+
+	if(!st || !td || !struct_ptr) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(st->buf == 0) {
+		/* Nothing to convert, make it empty. */
+		*struct_ptr = (void *)0;
+		return 0;
+	}
+
+	rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
+	if(rval.code == RC_OK) {
+		*struct_ptr = newst;
+		return 0;
+	} else {
+		/* Remove possibly partially decoded data. */
+		ASN_STRUCT_FREE(*td, newst);
+		return -1;
+	}
+}
+
+int
+ANY_to_type_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
+	asn_dec_rval_t rval;
+	void *newst = 0;
+
+	if(!st || !td || !struct_ptr) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(st->buf == 0) {
+		/* Nothing to convert, make it empty. */
+		*struct_ptr = (void *)0;
+		return 0;
+	}
+
+	rval = aper_decode(0, td, (void **)&newst, st->buf, st->size, 0, 0);
+	if(rval.code == RC_OK) {
+		*struct_ptr = newst;
+		return 0;
+	} else {
+		/* Remove possibly partially decoded data. */
+		ASN_STRUCT_FREE(*td, newst);
+		return -1;
+	}
+}
+
+static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
+	struct _callback_arg *arg = (struct _callback_arg *)key;
+
+	if((arg->offset + size) >= arg->size) {
+		size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
+		void *p = REALLOC(arg->buffer, nsize);
+		if(!p) return -1;
+		arg->buffer = (uint8_t *)p;
+		arg->size = nsize;
+	}
+
+	memcpy(arg->buffer + arg->offset, buffer, size);
+	arg->offset += size;
+	assert(arg->offset < arg->size);
+
+	return 0;
+}
+

lib/asn/asn1c/ANY.h

@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_TYPE_ANY_H
+#define ASN_TYPE_ANY_H
+
+#include <OCTET_STRING.h>	/* Implemented via OCTET STRING type */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ANY {
+	uint8_t *buf;	/* BER-encoded ANY contents */
+	int size;	/* Size of the above buffer */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} ANY_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_ANY;
+
+asn_struct_free_f ANY_free;
+asn_struct_print_f ANY_print;
+ber_type_decoder_f ANY_decode_ber;
+der_type_encoder_f ANY_encode_der;
+xer_type_encoder_f ANY_encode_xer;
+
+/******************************
+ * Handy conversion routines. *
+ ******************************/
+
+/* Convert another ASN.1 type into the ANY. This implies DER encoding. */
+int ANY_fromType(ANY_t *, asn_TYPE_descriptor_t *td, void *struct_ptr);
+int ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr);
+ANY_t *ANY_new_fromType(asn_TYPE_descriptor_t *td, void *struct_ptr);
+ANY_t *ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr);
+
+/* Convert the contents of the ANY type into the specified type. */
+int ANY_to_type(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
+int ANY_to_type_aper(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
+
+#define	ANY_fromBuf(s, buf, size)	OCTET_STRING_fromBuf((s), (buf), (size))
+#define	ANY_new_fromBuf(buf, size)	OCTET_STRING_new_fromBuf(	\
+						&asn_DEF_ANY, (buf), (size))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* ASN_TYPE_ANY_H */

lib/asn/asn1c/BIT_STRING.c

@@ -0,0 +1,191 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+#include <asn_internal.h>
+
+/*
+ * BIT STRING basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
+	sizeof(BIT_STRING_t),
+	offsetof(BIT_STRING_t, _asn_ctx),
+	ASN_OSUBV_BIT
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+	"BIT STRING",
+	"BIT_STRING",
+	OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+	BIT_STRING_print,
+	BIT_STRING_constraint,
+	OCTET_STRING_decode_ber,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_encode_der,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_decode_xer_binary,
+	BIT_STRING_encode_xer,
+	OCTET_STRING_decode_uper,	/* Unaligned PER decoder */
+	OCTET_STRING_encode_uper,	/* Unaligned PER encoder */
+	OCTET_STRING_decode_aper,	/* Aligned PER decoder */
+	OCTET_STRING_encode_aper,	/* Aligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BIT_STRING_tags,
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	asn_DEF_BIT_STRING_tags,	/* Same as above */
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_DEF_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+
+	if(st && st->buf) {
+		if((st->size == 0 && st->bits_unused)
+		|| st->bits_unused < 0 || st->bits_unused > 7) {
+			ASN__CTFAIL(app_key, td, sptr,
+				"%s: invalid padding byte (%s:%d)",
+				td->name, __FILE__, __LINE__);
+			return -1;
+		}
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}
+
+static char *_bit_pattern[16] = {
+	"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+	"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t er;
+	char scratch[128];
+	char *p = scratch;
+	char *scend = scratch + (sizeof(scratch) - 10);
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	int xcan = (flags & XER_F_CANONICAL);
+	uint8_t *buf;
+	uint8_t *end;
+
+	if(!st || !st->buf)
+		ASN__ENCODE_FAILED;
+
+	er.encoded = 0;
+
+	buf = st->buf;
+	end = buf + st->size - 1;	/* Last byte is special */
+
+	/*
+	 * Binary dump
+	 */
+	for(; buf < end; buf++) {
+		int v = *buf;
+		int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+		if(p >= scend || nline) {
+			er.encoded += p - scratch;
+			ASN__CALLBACK(scratch, p - scratch);
+			p = scratch;
+			if(nline) ASN__TEXT_INDENT(1, ilevel);
+		}
+		memcpy(p + 0, _bit_pattern[v >> 4], 4);
+		memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+		p += 8;
+	}
+
+	if(!xcan && ((buf - st->buf) % 8) == 0)
+		ASN__TEXT_INDENT(1, ilevel);
+	er.encoded += p - scratch;
+	ASN__CALLBACK(scratch, p - scratch);
+	p = scratch;
+
+	if(buf == end) {
+		int v = *buf;
+		int ubits = st->bits_unused;
+		int i;
+		for(i = 7; i >= ubits; i--)
+			*p++ = (v & (1 << i)) ? 0x31 : 0x30;
+		er.encoded += p - scratch;
+		ASN__CALLBACK(scratch, p - scratch);
+	}
+
+	if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+
+	ASN__ENCODED_OK(er);
+cb_failed:
+	ASN__ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const char * const h2c = "0123456789ABCDEF";
+	char scratch[64];
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	uint8_t *buf;
+	uint8_t *end;
+	char *p = scratch;
+
+	(void)td;	/* Unused argument */
+
+	if(!st || !st->buf)
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+	ilevel++;
+	buf = st->buf;
+	end = buf + st->size;
+
+	/*
+	 * Hexadecimal dump.
+	 */
+	for(; buf < end; buf++) {
+		if((buf - st->buf) % 16 == 0 && (st->size > 16)
+				&& buf != st->buf) {
+			_i_INDENT(1);
+			/* Dump the string */
+			if(cb(scratch, p - scratch, app_key) < 0) return -1;
+			p = scratch;
+		}
+		*p++ = h2c[*buf >> 4];
+		*p++ = h2c[*buf & 0x0F];
+		*p++ = 0x20;
+	}
+
+	if(p > scratch) {
+		p--;	/* Eat the tailing space */
+
+		if((st->size > 16)) {
+			_i_INDENT(1);
+		}
+
+		/* Dump the incomplete 16-bytes row */
+		if(cb(scratch, p - scratch, app_key) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+

lib/asn/asn1c/BIT_STRING.h

@@ -0,0 +1,33 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BIT_STRING_H_
+#define	_BIT_STRING_H_
+
+#include <OCTET_STRING.h>	/* Some help from OCTET STRING */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BIT_STRING_s {
+	uint8_t *buf;	/* BIT STRING body */
+	int size;	/* Size of the above buffer */
+
+	int bits_unused;/* Unused trailing bits in the last octet (0..7) */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} BIT_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */

lib/asn/asn1c/BOOLEAN.c

@@ -0,0 +1,328 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <BOOLEAN.h>
+
+/*
+ * BOOLEAN basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {
+	"BOOLEAN",
+	"BOOLEAN",
+	BOOLEAN_free,
+	BOOLEAN_print,
+	asn_generic_no_constraint,
+	BOOLEAN_decode_ber,
+	BOOLEAN_encode_der,
+	BOOLEAN_decode_xer,
+	BOOLEAN_encode_xer,
+	BOOLEAN_decode_uper,	/* Unaligned PER decoder */
+	BOOLEAN_encode_uper,	/* Unaligned PER encoder */
+	BOOLEAN_decode_aper,	/* Aligned PER decoder */
+	BOOLEAN_encode_aper,	/* Aligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BOOLEAN_tags,
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	asn_DEF_BOOLEAN_tags,	/* Same as above */
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode BOOLEAN type.
+ */
+asn_dec_rval_t
+BOOLEAN_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+		asn_TYPE_descriptor_t *td,
+		void **bool_value, const void *buf_ptr, size_t size,
+		int tag_mode) {
+	BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+	ber_tlv_len_t lidx;
+
+	if(st == NULL) {
+		st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
+		if(st == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+		tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("Boolean length is %d bytes", (int)length);
+
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * Compute boolean value.
+	 */
+	for(*st = 0, lidx = 0;
+		(lidx < length) && *st == 0; lidx++) {
+		/*
+		 * Very simple approach: read bytes until the end or
+		 * value is already TRUE.
+		 * BOOLEAN is not supposed to contain meaningful data anyway.
+		 */
+		*st |= ((const uint8_t *)buf_ptr)[lidx];
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
+		(long)rval.consumed, (long)length,
+		td->name, *st);
+	
+	return rval;
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
+	int tag_mode, ber_tlv_tag_t tag,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t erval;
+	BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+
+	erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		erval.failed_type = td;
+		erval.structure_ptr = sptr;
+		return erval;
+	}
+
+	if(cb) {
+		uint8_t bool_value;
+
+		bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
+
+		if(cb(&bool_value, 1, app_key) < 0) {
+			erval.encoded = -1;
+			erval.failed_type = td;
+			erval.structure_ptr = sptr;
+			return erval;
+		}
+	}
+
+	erval.encoded += 1;
+
+	ASN__ENCODED_OK(erval);
+}
+
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+static enum xer_pbd_rval
+BOOLEAN__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
+	BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+	const char *p = (const char *)chunk_buf;
+
+	(void)td;
+
+	if(chunk_size && p[0] == 0x3c /* '<' */) {
+		switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
+		case XCT_BOTH:
+			/* "<false/>" */
+			*st = 0;
+			break;
+		case XCT_UNKNOWN_BO:
+			if(xer_check_tag(chunk_buf, chunk_size, "true")
+					!= XCT_BOTH)
+				return XPBD_BROKEN_ENCODING;
+			/* "<true/>" */
+			*st = 1;	/* Or 0xff as in DER?.. */
+			break;
+		default:
+			return XPBD_BROKEN_ENCODING;
+		}
+		return XPBD_BODY_CONSUMED;
+	} else {
+		return XPBD_BROKEN_ENCODING;
+	}
+}
+
+
+asn_dec_rval_t
+BOOLEAN_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+
+	return xer_decode_primitive(opt_codec_ctx, td,
+		sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,
+		BOOLEAN__xer_body_decode);
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!st) ASN__ENCODE_FAILED;
+
+	if(*st) {
+		ASN__CALLBACK("<true/>", 7);
+		er.encoded = 7;
+	} else {
+		ASN__CALLBACK("<false/>", 8);
+		er.encoded = 8;
+	}
+
+	ASN__ENCODED_OK(er);
+cb_failed:
+	ASN__ENCODE_FAILED;
+}
+
+int
+BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	const char *buf;
+	size_t buflen;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(st) {
+		if(*st) {
+			buf = "TRUE";
+			buflen = 4;
+		} else {
+			buf = "FALSE";
+			buflen = 5;
+		}
+	} else {
+		buf = "<absent>";
+		buflen = 8;
+	}
+
+	return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
+}
+
+void
+BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+	if(td && ptr && !contents_only) {
+		FREEMEM(ptr);
+	}
+}
+
+asn_dec_rval_t
+BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
+
+	(void)opt_codec_ctx;
+	(void)constraints;
+
+	if(!st) {
+		st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
+		if(!st) ASN__DECODE_FAILED;
+	}
+
+	/*
+	 * Extract a single bit
+	 */
+	switch(per_get_few_bits(pd, 1)) {
+	case 1: *st = 1; break;
+	case 0: *st = 0; break;
+	case -1: default: ASN__DECODE_STARVED;
+	}
+
+	ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
+
+	rv.code = RC_OK;
+	rv.consumed = 1;
+	return rv;
+}
+
+asn_dec_rval_t
+BOOLEAN_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
+
+	(void)opt_codec_ctx;
+	(void)constraints;
+
+	if(!st) {
+		st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
+		if(!st) ASN__DECODE_FAILED;
+	}
+
+	/*
+	 * Extract a single bit
+	 */
+	switch(per_get_few_bits(pd, 1)) {
+	case 1: *st = 1; break;
+	case 0: *st = 0; break;
+	case -1: default: ASN__DECODE_STARVED;
+	}
+
+	ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
+
+	rv.code = RC_OK;
+	rv.consumed = 1;
+	return rv;
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er = { 0, 0, 0 };
+
+	(void)constraints;
+
+	if(!st) ASN__ENCODE_FAILED;
+
+	if(per_put_few_bits(po, *st ? 1 : 0, 1))
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_aper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er;
+
+	(void)constraints;
+
+	if(!st) ASN__ENCODE_FAILED;
+
+	per_put_few_bits(po, *st ? 1 : 0, 1);
+
+	ASN__ENCODED_OK(er);
+}

lib/asn/asn1c/BOOLEAN.h

@@ -0,0 +1,38 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BOOLEAN_H_
+#define	_BOOLEAN_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The underlying integer may contain various values, but everything
+ * non-zero is capped to 0xff by the DER encoder. The BER decoder may
+ * yield non-zero values different from 1, beware.
+ */
+typedef int BOOLEAN_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BOOLEAN;
+
+asn_struct_free_f BOOLEAN_free;
+asn_struct_print_f BOOLEAN_print;
+ber_type_decoder_f BOOLEAN_decode_ber;
+der_type_encoder_f BOOLEAN_encode_der;
+xer_type_decoder_f BOOLEAN_decode_xer;
+xer_type_encoder_f BOOLEAN_encode_xer;
+per_type_decoder_f BOOLEAN_decode_uper;
+per_type_encoder_f BOOLEAN_encode_uper;
+per_type_decoder_f BOOLEAN_decode_aper;
+per_type_encoder_f BOOLEAN_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BOOLEAN_H_ */

lib/asn/asn1c/E-RAB-S1ap-IE-ContainerList.c

@@ -0,0 +1,927 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Contents"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "E-RAB-S1ap-IE-ContainerList.h"
+
+int
+E_RAB_S1ap_IE_ContainerList_992P0_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size >= 1LL && size <= 256LL)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using ProtocolIE_ContainerList_5732P0,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ProtocolIE_ContainerList_5732P0.free_struct;
+	td->print_struct   = asn_DEF_ProtocolIE_ContainerList_5732P0.print_struct;
+	td->check_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.check_constraints;
+	td->ber_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.ber_decoder;
+	td->der_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.der_encoder;
+	td->xer_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_decoder;
+	td->xer_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_encoder;
+	td->uper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_decoder;
+	td->uper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_encoder;
+	td->aper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_decoder;
+	td->aper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.per_constraints;
+	td->elements       = asn_DEF_ProtocolIE_ContainerList_5732P0.elements;
+	td->elements_count = asn_DEF_ProtocolIE_ContainerList_5732P0.elements_count;
+	td->specifics      = asn_DEF_ProtocolIE_ContainerList_5732P0.specifics;
+}
+
+void
+E_RAB_S1ap_IE_ContainerList_992P0_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P0_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P0_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P0_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size >= 1LL && size <= 256LL)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using ProtocolIE_ContainerList_5732P0,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ProtocolIE_ContainerList_5732P0.free_struct;
+	td->print_struct   = asn_DEF_ProtocolIE_ContainerList_5732P0.print_struct;
+	td->check_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.check_constraints;
+	td->ber_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.ber_decoder;
+	td->der_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.der_encoder;
+	td->xer_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_decoder;
+	td->xer_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_encoder;
+	td->uper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_decoder;
+	td->uper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_encoder;
+	td->aper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_decoder;
+	td->aper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.per_constraints;
+	td->elements       = asn_DEF_ProtocolIE_ContainerList_5732P0.elements;
+	td->elements_count = asn_DEF_ProtocolIE_ContainerList_5732P0.elements_count;
+	td->specifics      = asn_DEF_ProtocolIE_ContainerList_5732P0.specifics;
+}
+
+void
+E_RAB_S1ap_IE_ContainerList_992P1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P1_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P1_2_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size >= 1LL && size <= 256LL)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using ProtocolIE_ContainerList_5732P0,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ProtocolIE_ContainerList_5732P0.free_struct;
+	td->print_struct   = asn_DEF_ProtocolIE_ContainerList_5732P0.print_struct;
+	td->check_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.check_constraints;
+	td->ber_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.ber_decoder;
+	td->der_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.der_encoder;
+	td->xer_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_decoder;
+	td->xer_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_encoder;
+	td->uper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_decoder;
+	td->uper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_encoder;
+	td->aper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_decoder;
+	td->aper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.per_constraints;
+	td->elements       = asn_DEF_ProtocolIE_ContainerList_5732P0.elements;
+	td->elements_count = asn_DEF_ProtocolIE_ContainerList_5732P0.elements_count;
+	td->specifics      = asn_DEF_ProtocolIE_ContainerList_5732P0.specifics;
+}
+
+void
+E_RAB_S1ap_IE_ContainerList_992P2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P2_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P2_3_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size >= 1LL && size <= 256LL)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using ProtocolIE_ContainerList_5732P0,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ProtocolIE_ContainerList_5732P0.free_struct;
+	td->print_struct   = asn_DEF_ProtocolIE_ContainerList_5732P0.print_struct;
+	td->check_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.check_constraints;
+	td->ber_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.ber_decoder;
+	td->der_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.der_encoder;
+	td->xer_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_decoder;
+	td->xer_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_encoder;
+	td->uper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_decoder;
+	td->uper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_encoder;
+	td->aper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_decoder;
+	td->aper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.per_constraints;
+	td->elements       = asn_DEF_ProtocolIE_ContainerList_5732P0.elements;
+	td->elements_count = asn_DEF_ProtocolIE_ContainerList_5732P0.elements_count;
+	td->specifics      = asn_DEF_ProtocolIE_ContainerList_5732P0.specifics;
+}
+
+void
+E_RAB_S1ap_IE_ContainerList_992P3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P3_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P3_4_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size >= 1LL && size <= 256LL)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using ProtocolIE_ContainerList_5732P0,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ProtocolIE_ContainerList_5732P0.free_struct;
+	td->print_struct   = asn_DEF_ProtocolIE_ContainerList_5732P0.print_struct;
+	td->check_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.check_constraints;
+	td->ber_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.ber_decoder;
+	td->der_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.der_encoder;
+	td->xer_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_decoder;
+	td->xer_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_encoder;
+	td->uper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_decoder;
+	td->uper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_encoder;
+	td->aper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_decoder;
+	td->aper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.per_constraints;
+	td->elements       = asn_DEF_ProtocolIE_ContainerList_5732P0.elements;
+	td->elements_count = asn_DEF_ProtocolIE_ContainerList_5732P0.elements_count;
+	td->specifics      = asn_DEF_ProtocolIE_ContainerList_5732P0.specifics;
+}
+
+void
+E_RAB_S1ap_IE_ContainerList_992P4_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P4_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P4_5_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size >= 1LL && size <= 256LL)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using ProtocolIE_ContainerList_5732P0,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ProtocolIE_ContainerList_5732P0.free_struct;
+	td->print_struct   = asn_DEF_ProtocolIE_ContainerList_5732P0.print_struct;
+	td->check_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.check_constraints;
+	td->ber_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.ber_decoder;
+	td->der_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.der_encoder;
+	td->xer_decoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_decoder;
+	td->xer_encoder    = asn_DEF_ProtocolIE_ContainerList_5732P0.xer_encoder;
+	td->uper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_decoder;
+	td->uper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.uper_encoder;
+	td->aper_decoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_decoder;
+	td->aper_encoder   = asn_DEF_ProtocolIE_ContainerList_5732P0.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ProtocolIE_ContainerList_5732P0.per_constraints;
+	td->elements       = asn_DEF_ProtocolIE_ContainerList_5732P0.elements;
+	td->elements_count = asn_DEF_ProtocolIE_ContainerList_5732P0.elements_count;
+	td->specifics      = asn_DEF_ProtocolIE_ContainerList_5732P0.specifics;
+}
+
+void
+E_RAB_S1ap_IE_ContainerList_992P5_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_RAB_S1ap_IE_ContainerList_992P5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+E_RAB_S1ap_IE_ContainerList_992P5_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	E_RAB_S1ap_IE_ContainerList_992P5_6_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static const ber_tlv_tag_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0 = {
+	"E-RAB-S1ap-IE-ContainerList",
+	"E-RAB-S1ap-IE-ContainerList",
+	E_RAB_S1ap_IE_ContainerList_992P0_free,
+	E_RAB_S1ap_IE_ContainerList_992P0_print,
+	E_RAB_S1ap_IE_ContainerList_992P0_constraint,
+	E_RAB_S1ap_IE_ContainerList_992P0_decode_ber,
+	E_RAB_S1ap_IE_ContainerList_992P0_encode_der,
+	E_RAB_S1ap_IE_ContainerList_992P0_decode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P0_encode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P0_decode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P0_encode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P0_decode_aper,
+	E_RAB_S1ap_IE_ContainerList_992P0_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1,
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1[0]), /* 1 */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
+static const ber_tlv_tag_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1 = {
+	"E-RAB-S1ap-IE-ContainerList",
+	"E-RAB-S1ap-IE-ContainerList",
+	E_RAB_S1ap_IE_ContainerList_992P1_free,
+	E_RAB_S1ap_IE_ContainerList_992P1_print,
+	E_RAB_S1ap_IE_ContainerList_992P1_constraint,
+	E_RAB_S1ap_IE_ContainerList_992P1_decode_ber,
+	E_RAB_S1ap_IE_ContainerList_992P1_encode_der,
+	E_RAB_S1ap_IE_ContainerList_992P1_decode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P1_encode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P1_decode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P1_encode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P1_decode_aper,
+	E_RAB_S1ap_IE_ContainerList_992P1_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2,
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2[0]), /* 1 */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2,	/* Same as above */
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
+static const ber_tlv_tag_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2 = {
+	"E-RAB-S1ap-IE-ContainerList",
+	"E-RAB-S1ap-IE-ContainerList",
+	E_RAB_S1ap_IE_ContainerList_992P2_free,
+	E_RAB_S1ap_IE_ContainerList_992P2_print,
+	E_RAB_S1ap_IE_ContainerList_992P2_constraint,
+	E_RAB_S1ap_IE_ContainerList_992P2_decode_ber,
+	E_RAB_S1ap_IE_ContainerList_992P2_encode_der,
+	E_RAB_S1ap_IE_ContainerList_992P2_decode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P2_encode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P2_decode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P2_encode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P2_decode_aper,
+	E_RAB_S1ap_IE_ContainerList_992P2_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3,
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3[0]), /* 1 */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3,	/* Same as above */
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2_tags_3[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
+static const ber_tlv_tag_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3 = {
+	"E-RAB-S1ap-IE-ContainerList",
+	"E-RAB-S1ap-IE-ContainerList",
+	E_RAB_S1ap_IE_ContainerList_992P3_free,
+	E_RAB_S1ap_IE_ContainerList_992P3_print,
+	E_RAB_S1ap_IE_ContainerList_992P3_constraint,
+	E_RAB_S1ap_IE_ContainerList_992P3_decode_ber,
+	E_RAB_S1ap_IE_ContainerList_992P3_encode_der,
+	E_RAB_S1ap_IE_ContainerList_992P3_decode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P3_encode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P3_decode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P3_encode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P3_decode_aper,
+	E_RAB_S1ap_IE_ContainerList_992P3_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4,
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4[0]), /* 1 */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4,	/* Same as above */
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3_tags_4[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
+static const ber_tlv_tag_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4 = {
+	"E-RAB-S1ap-IE-ContainerList",
+	"E-RAB-S1ap-IE-ContainerList",
+	E_RAB_S1ap_IE_ContainerList_992P4_free,
+	E_RAB_S1ap_IE_ContainerList_992P4_print,
+	E_RAB_S1ap_IE_ContainerList_992P4_constraint,
+	E_RAB_S1ap_IE_ContainerList_992P4_decode_ber,
+	E_RAB_S1ap_IE_ContainerList_992P4_encode_der,
+	E_RAB_S1ap_IE_ContainerList_992P4_decode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P4_encode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P4_decode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P4_encode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P4_decode_aper,
+	E_RAB_S1ap_IE_ContainerList_992P4_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5,
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5[0]), /* 1 */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5,	/* Same as above */
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4_tags_5[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
+static const ber_tlv_tag_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5 = {
+	"E-RAB-S1ap-IE-ContainerList",
+	"E-RAB-S1ap-IE-ContainerList",
+	E_RAB_S1ap_IE_ContainerList_992P5_free,
+	E_RAB_S1ap_IE_ContainerList_992P5_print,
+	E_RAB_S1ap_IE_ContainerList_992P5_constraint,
+	E_RAB_S1ap_IE_ContainerList_992P5_decode_ber,
+	E_RAB_S1ap_IE_ContainerList_992P5_encode_der,
+	E_RAB_S1ap_IE_ContainerList_992P5_decode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P5_encode_xer,
+	E_RAB_S1ap_IE_ContainerList_992P5_decode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P5_encode_uper,
+	E_RAB_S1ap_IE_ContainerList_992P5_decode_aper,
+	E_RAB_S1ap_IE_ContainerList_992P5_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6,
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6[0]), /* 1 */
+	asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6,	/* Same as above */
+	sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6)
+		/sizeof(asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5_tags_6[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+

lib/asn/asn1c/E-RAB-S1ap-IE-ContainerList.h

@@ -0,0 +1,108 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Contents"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_E_RAB_S1ap_IE_ContainerList_H_
+#define	_E_RAB_S1ap_IE_ContainerList_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProtocolIE-ContainerList.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E-RAB-S1ap-IE-ContainerList */
+typedef ProtocolIE_ContainerList_5732P0_t	 E_RAB_S1ap_IE_ContainerList_992P0_t;
+typedef ProtocolIE_ContainerList_5732P0_t	 E_RAB_S1ap_IE_ContainerList_992P1_t;
+typedef ProtocolIE_ContainerList_5732P0_t	 E_RAB_S1ap_IE_ContainerList_992P2_t;
+typedef ProtocolIE_ContainerList_5732P0_t	 E_RAB_S1ap_IE_ContainerList_992P3_t;
+typedef ProtocolIE_ContainerList_5732P0_t	 E_RAB_S1ap_IE_ContainerList_992P4_t;
+typedef ProtocolIE_ContainerList_5732P0_t	 E_RAB_S1ap_IE_ContainerList_992P5_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P0;
+asn_struct_free_f E_RAB_S1ap_IE_ContainerList_992P0_free;
+asn_struct_print_f E_RAB_S1ap_IE_ContainerList_992P0_print;
+asn_constr_check_f E_RAB_S1ap_IE_ContainerList_992P0_constraint;
+ber_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P0_decode_ber;
+der_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P0_encode_der;
+xer_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P0_decode_xer;
+xer_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P0_encode_xer;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P0_decode_uper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P0_encode_uper;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P0_decode_aper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P0_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P1;
+asn_struct_free_f E_RAB_S1ap_IE_ContainerList_992P1_free;
+asn_struct_print_f E_RAB_S1ap_IE_ContainerList_992P1_print;
+asn_constr_check_f E_RAB_S1ap_IE_ContainerList_992P1_constraint;
+ber_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P1_decode_ber;
+der_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P1_encode_der;
+xer_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P1_decode_xer;
+xer_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P1_encode_xer;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P1_decode_uper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P1_encode_uper;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P1_decode_aper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P1_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P2;
+asn_struct_free_f E_RAB_S1ap_IE_ContainerList_992P2_free;
+asn_struct_print_f E_RAB_S1ap_IE_ContainerList_992P2_print;
+asn_constr_check_f E_RAB_S1ap_IE_ContainerList_992P2_constraint;
+ber_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P2_decode_ber;
+der_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P2_encode_der;
+xer_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P2_decode_xer;
+xer_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P2_encode_xer;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P2_decode_uper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P2_encode_uper;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P2_decode_aper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P2_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P3;
+asn_struct_free_f E_RAB_S1ap_IE_ContainerList_992P3_free;
+asn_struct_print_f E_RAB_S1ap_IE_ContainerList_992P3_print;
+asn_constr_check_f E_RAB_S1ap_IE_ContainerList_992P3_constraint;
+ber_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P3_decode_ber;
+der_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P3_encode_der;
+xer_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P3_decode_xer;
+xer_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P3_encode_xer;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P3_decode_uper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P3_encode_uper;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P3_decode_aper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P3_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P4;
+asn_struct_free_f E_RAB_S1ap_IE_ContainerList_992P4_free;
+asn_struct_print_f E_RAB_S1ap_IE_ContainerList_992P4_print;
+asn_constr_check_f E_RAB_S1ap_IE_ContainerList_992P4_constraint;
+ber_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P4_decode_ber;
+der_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P4_encode_der;
+xer_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P4_decode_xer;
+xer_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P4_encode_xer;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P4_decode_uper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P4_encode_uper;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P4_decode_aper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P4_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_E_RAB_S1ap_IE_ContainerList_992P5;
+asn_struct_free_f E_RAB_S1ap_IE_ContainerList_992P5_free;
+asn_struct_print_f E_RAB_S1ap_IE_ContainerList_992P5_print;
+asn_constr_check_f E_RAB_S1ap_IE_ContainerList_992P5_constraint;
+ber_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P5_decode_ber;
+der_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P5_encode_der;
+xer_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P5_decode_xer;
+xer_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P5_encode_xer;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P5_decode_uper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P5_encode_uper;
+per_type_decoder_f E_RAB_S1ap_IE_ContainerList_992P5_decode_aper;
+per_type_encoder_f E_RAB_S1ap_IE_ContainerList_992P5_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E_RAB_S1ap_IE_ContainerList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/E-RAB-S1ap-IE-ContainerPairList.c

@@ -0,0 +1,9 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Contents"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "E-RAB-S1ap-IE-ContainerPairList.h"
+

lib/asn/asn1c/E-RAB-S1ap-IE-ContainerPairList.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Contents"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_E_RAB_S1ap_IE_ContainerPairList_H_
+#define	_E_RAB_S1ap_IE_ContainerPairList_H_
+
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E_RAB_S1ap_IE_ContainerPairList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/INTEGER.h

@@ -0,0 +1,88 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_INTEGER_H_
+#define	_INTEGER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+
+/* Map with <tag> to integer value association */
+typedef struct asn_INTEGER_enum_map_s {
+	long long	 nat_value;	/* associated native integer value */
+	size_t		 enum_len;	/* strlen("tag") */
+	const char	*enum_name;	/* "tag" */
+} asn_INTEGER_enum_map_t;
+
+/* This type describes an enumeration for INTEGER and ENUMERATED types */
+typedef const struct asn_INTEGER_specifics_s {
+	const asn_INTEGER_enum_map_t *value2enum;	/* N -> "tag"; sorted by N */
+	const unsigned int *enum2value;		/* "tag" => N; sorted by tag */
+	int map_count;				/* Elements in either map */
+	int extension;				/* This map is extensible */
+	int strict_enumeration;			/* Enumeration set is fixed */
+	int field_width;			/* Size of native integer */
+	int field_unsigned;			/* Signed=0, unsigned=1 */
+} asn_INTEGER_specifics_t;
+
+asn_struct_print_f INTEGER_print;
+ber_type_decoder_f INTEGER_decode_ber;
+der_type_encoder_f INTEGER_encode_der;
+xer_type_decoder_f INTEGER_decode_xer;
+xer_type_encoder_f INTEGER_encode_xer;
+per_type_decoder_f INTEGER_decode_uper;
+per_type_encoder_f INTEGER_encode_uper;
+per_type_decoder_f INTEGER_decode_aper;
+per_type_encoder_f INTEGER_encode_aper;
+
+/***********************************
+ * Some handy conversion routines. *
+ ***********************************/
+
+/*
+ * Returns 0 if it was possible to convert, -1 otherwise.
+ * -1/EINVAL: Mandatory argument missing
+ * -1/ERANGE: Value encoded is out of range for long representation
+ * -1/ENOMEM: Memory allocation failed (in asn_long2INTEGER()).
+ */
+int asn_INTEGER2int64(const INTEGER_t *i, int64_t *l);
+int asn_INTEGER2uint64(const INTEGER_t *i, uint64_t *l);
+int asn_INTEGER2long(const INTEGER_t *i, long long *l);
+int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long long *l);
+int asn_int642INTEGER(INTEGER_t *i, int64_t l);
+int asn_uint642INTEGER(INTEGER_t *i, uint64_t l);
+int asn_long2INTEGER(INTEGER_t *i, long long l);
+int asn_ulong2INTEGER(INTEGER_t *i, unsigned long long l);
+
+/* A a reified version of strtol(3) with nicer error reporting. */
+enum asn_strtol_result_e {
+    ASN_STRTOL_ERROR_RANGE = -3,  /* Input outside of numeric range for long type */
+    ASN_STRTOL_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOL_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOL_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOL_EXTRA_DATA  =  1   /* Conversion succeded, but the string has extra stuff */
+};
+enum asn_strtol_result_e asn_strtol_lim(const char *str, const char **end, long long *l);
+
+/* The asn_strtol is going to be DEPRECATED soon */
+enum asn_strtol_result_e asn_strtol(const char *str, const char *end, long long *l);
+
+/*
+ * Convert the integer value into the corresponding enumeration map entry.
+ */
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long long value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _INTEGER_H_ */

lib/asn/asn1c/Makefile.am

@@ -0,0 +1,827 @@
+ASN_MODULE_NODIST_SOURCES=	\
+	S1AP-PDU.c	\
+	S1ap-InitiatingMessage.c	\
+	S1ap-SuccessfulOutcome.c	\
+	S1ap-UnsuccessfulOutcome.c	\
+	E-RAB-S1ap-IE-ContainerList.c	\
+	E-RAB-S1ap-IE-ContainerPairList.c	\
+	ProtocolError-S1ap-IE-ContainerList.c	\
+	S1ap-HandoverRequired.c	\
+	S1ap-HandoverCommand.c	\
+	S1ap-E-RABSubjecttoDataForwardingList.c	\
+	S1ap-E-RABDataForwardingItem.c	\
+	S1ap-HandoverPreparationFailure.c	\
+	S1ap-HandoverRequest.c	\
+	S1ap-E-RABToBeSetupListHOReq.c	\
+	S1ap-E-RABToBeSetupItemHOReq.c	\
+	S1ap-HandoverRequestAcknowledge.c	\
+	S1ap-E-RABAdmittedList.c	\
+	S1ap-E-RABAdmittedItem.c	\
+	S1ap-E-RABFailedtoSetupListHOReqAck.c	\
+	S1ap-E-RABFailedToSetupItemHOReqAck.c	\
+	S1ap-HandoverFailure.c	\
+	S1ap-HandoverNotify.c	\
+	S1ap-PathSwitchRequest.c	\
+	S1ap-E-RABToBeSwitchedDLList.c	\
+	S1ap-E-RABToBeSwitchedDLItem.c	\
+	S1ap-PathSwitchRequestAcknowledge.c	\
+	S1ap-E-RABToBeSwitchedULList.c	\
+	S1ap-E-RABToBeSwitchedULItem.c	\
+	S1ap-PathSwitchRequestFailure.c	\
+	S1ap-HandoverCancel.c	\
+	S1ap-HandoverCancelAcknowledge.c	\
+	S1ap-E-RABSetupRequest.c	\
+	S1ap-E-RABToBeSetupListBearerSUReq.c	\
+	S1ap-E-RABToBeSetupItemBearerSUReq.c	\
+	S1ap-E-RABSetupResponse.c	\
+	S1ap-E-RABSetupListBearerSURes.c	\
+	S1ap-E-RABSetupItemBearerSURes.c	\
+	S1ap-E-RABModifyRequest.c	\
+	S1ap-E-RABToBeModifiedListBearerModReq.c	\
+	S1ap-E-RABToBeModifiedItemBearerModReq.c	\
+	S1ap-E-RABModifyResponse.c	\
+	S1ap-E-RABModifyListBearerModRes.c	\
+	S1ap-E-RABModifyItemBearerModRes.c	\
+	S1ap-E-RABReleaseCommand.c	\
+	S1ap-E-RABReleaseResponse.c	\
+	S1ap-E-RABReleaseListBearerRelComp.c	\
+	S1ap-E-RABReleaseItemBearerRelComp.c	\
+	S1ap-E-RABReleaseIndication.c	\
+	S1ap-InitialContextSetupRequest.c	\
+	S1ap-E-RABToBeSetupListCtxtSUReq.c	\
+	S1ap-E-RABToBeSetupItemCtxtSUReq.c	\
+	S1ap-InitialContextSetupResponse.c	\
+	S1ap-E-RABSetupListCtxtSURes.c	\
+	S1ap-E-RABSetupItemCtxtSURes.c	\
+	S1ap-InitialContextSetupFailure.c	\
+	S1ap-Paging.c	\
+	S1ap-TAIList.c	\
+	S1ap-TAIItem.c	\
+	S1ap-UEContextReleaseRequest.c	\
+	S1ap-UEContextReleaseCommand.c	\
+	S1ap-UEContextReleaseComplete.c	\
+	S1ap-UEContextModificationRequest.c	\
+	S1ap-UEContextModificationResponse.c	\
+	S1ap-UEContextModificationFailure.c	\
+	S1ap-DownlinkNASTransport.c	\
+	S1ap-InitialUEMessage.c	\
+	S1ap-UplinkNASTransport.c	\
+	S1ap-NASNonDeliveryIndication.c	\
+	S1ap-Reset.c	\
+	S1ap-ResetType.c	\
+	S1ap-ResetAll.c	\
+	S1ap-UE-associatedLogicalS1-ConnectionListRes.c	\
+	S1ap-ResetAcknowledge.c	\
+	S1ap-UE-associatedLogicalS1-ConnectionListResAck.c	\
+	S1ap-ErrorIndication.c	\
+	S1ap-S1SetupRequest.c	\
+	S1ap-S1SetupResponse.c	\
+	S1ap-S1SetupFailure.c	\
+	S1ap-ENBConfigurationUpdate.c	\
+	S1ap-ENBConfigurationUpdateAcknowledge.c	\
+	S1ap-ENBConfigurationUpdateFailure.c	\
+	S1ap-MMEConfigurationUpdate.c	\
+	S1ap-MMEConfigurationUpdateAcknowledge.c	\
+	S1ap-MMEConfigurationUpdateFailure.c	\
+	S1ap-DownlinkS1cdma2000tunneling.c	\
+	S1ap-UplinkS1cdma2000tunneling.c	\
+	S1ap-UECapabilityInfoIndication.c	\
+	S1ap-ENBStatusTransfer.c	\
+	S1ap-MMEStatusTransfer.c	\
+	S1ap-TraceStart.c	\
+	S1ap-TraceFailureIndication.c	\
+	S1ap-DeactivateTrace.c	\
+	S1ap-CellTrafficTrace.c	\
+	S1ap-LocationReportingControl.c	\
+	S1ap-LocationReportingFailureIndication.c	\
+	S1ap-LocationReport.c	\
+	S1ap-OverloadStart.c	\
+	S1ap-OverloadStop.c	\
+	S1ap-WriteReplaceWarningRequest.c	\
+	S1ap-WriteReplaceWarningResponse.c	\
+	S1ap-ENBDirectInformationTransfer.c	\
+	S1ap-Inter-SystemInformationTransferType.c	\
+	S1ap-MMEDirectInformationTransfer.c	\
+	S1ap-ENBConfigurationTransfer.c	\
+	S1ap-MMEConfigurationTransfer.c	\
+	S1ap-PrivateMessage.c	\
+	S1ap-KillRequest.c	\
+	S1ap-KillResponse.c	\
+	S1ap-DownlinkUEAssociatedLPPaTransport.c	\
+	S1ap-UplinkUEAssociatedLPPaTransport.c	\
+	S1ap-DownlinkNonUEAssociatedLPPaTransport.c	\
+	S1ap-UplinkNonUEAssociatedLPPaTransport.c	\
+	S1ap-AreaScopeOfMDT.c	\
+	S1ap-AllocationAndRetentionPriority.c	\
+	S1ap-Bearers-SubjectToStatusTransferList.c	\
+	S1ap-Bearers-SubjectToStatusTransfer-Item.c	\
+	S1ap-BitRate.c	\
+	S1ap-BPLMNs.c	\
+	S1ap-BroadcastCancelledAreaList.c	\
+	S1ap-BroadcastCompletedAreaList.c	\
+	S1ap-CancelledCellinEAI.c	\
+	S1ap-CancelledCellinEAI-Item.c	\
+	S1ap-CancelledCellinTAI.c	\
+	S1ap-CancelledCellinTAI-Item.c	\
+	S1ap-Cause.c	\
+	S1ap-CauseMisc.c	\
+	S1ap-CauseProtocol.c	\
+	S1ap-CauseRadioNetwork.c	\
+	S1ap-CauseTransport.c	\
+	S1ap-CauseNas.c	\
+	S1ap-CellAccessMode.c	\
+	S1ap-CellIdentity.c	\
+	S1ap-CellID-Broadcast.c	\
+	S1ap-CellID-Broadcast-Item.c	\
+	S1ap-CellID-Cancelled.c	\
+	S1ap-CellID-Cancelled-Item.c	\
+	S1ap-CellBasedMDT.c	\
+	S1ap-CellIdListforMDT.c	\
+	S1ap-Cdma2000PDU.c	\
+	S1ap-Cdma2000RATType.c	\
+	S1ap-Cdma2000SectorID.c	\
+	S1ap-Cdma2000HOStatus.c	\
+	S1ap-Cdma2000HORequiredIndication.c	\
+	S1ap-Cdma2000OneXSRVCCInfo.c	\
+	S1ap-Cdma2000OneXMEID.c	\
+	S1ap-Cdma2000OneXMSI.c	\
+	S1ap-Cdma2000OneXPilot.c	\
+	S1ap-Cdma2000OneXRAND.c	\
+	S1ap-Cell-Size.c	\
+	S1ap-CellType.c	\
+	S1ap-CGI.c	\
+	S1ap-CI.c	\
+	S1ap-CNDomain.c	\
+	S1ap-ConcurrentWarningMessageIndicator.c	\
+	S1ap-Correlation-ID.c	\
+	S1ap-CSFallbackIndicator.c	\
+	S1ap-CSG-Id.c	\
+	S1ap-CSG-IdList.c	\
+	S1ap-CSG-IdList-Item.c	\
+	S1ap-CSGMembershipStatus.c	\
+	S1ap-COUNTvalue.c	\
+	S1ap-CriticalityDiagnostics.c	\
+	S1ap-CriticalityDiagnostics-IE-List.c	\
+	S1ap-CriticalityDiagnostics-S1ap-IE-Item.c	\
+	S1ap-DataCodingScheme.c	\
+	S1ap-DL-Forwarding.c	\
+	S1ap-Direct-Forwarding-Path-Availability.c	\
+	S1ap-Data-Forwarding-Not-Possible.c	\
+	S1ap-ECGIList.c	\
+	S1ap-EmergencyAreaIDList.c	\
+	S1ap-EmergencyAreaID.c	\
+	S1ap-EmergencyAreaID-Broadcast.c	\
+	S1ap-EmergencyAreaID-Broadcast-Item.c	\
+	S1ap-EmergencyAreaID-Cancelled.c	\
+	S1ap-EmergencyAreaID-Cancelled-Item.c	\
+	S1ap-CompletedCellinEAI.c	\
+	S1ap-CompletedCellinEAI-Item.c	\
+	S1ap-ENB-ID.c	\
+	S1ap-GERAN-Cell-ID.c	\
+	S1ap-Global-ENB-ID.c	\
+	S1ap-GUMMEIList.c	\
+	S1ap-ENB-StatusTransfer-TransparentContainer.c	\
+	S1ap-ENB-UE-S1AP-ID.c	\
+	S1ap-ENBname.c	\
+	S1ap-ENBX2TLAs.c	\
+	S1ap-EncryptionAlgorithms.c	\
+	S1ap-EPLMNs.c	\
+	S1ap-EventType.c	\
+	S1ap-E-RAB-ID.c	\
+	S1ap-E-RABInformationList.c	\
+	S1ap-E-RABInformationListItem.c	\
+	S1ap-E-RABList.c	\
+	S1ap-E-RABItem.c	\
+	S1ap-E-RABLevelQoSParameters.c	\
+	S1ap-EUTRAN-CGI.c	\
+	S1ap-EUTRANRoundTripDelayEstimationInfo.c	\
+	S1ap-ExtendedRNC-ID.c	\
+	S1ap-ExtendedRepetitionPeriod.c	\
+	S1ap-ForbiddenInterRATs.c	\
+	S1ap-ForbiddenTAs.c	\
+	S1ap-ForbiddenTAs-Item.c	\
+	S1ap-ForbiddenTACs.c	\
+	S1ap-ForbiddenLAs.c	\
+	S1ap-ForbiddenLAs-Item.c	\
+	S1ap-ForbiddenLACs.c	\
+	S1ap-GBR-QosInformation.c	\
+	S1ap-GTP-TEID.c	\
+	S1ap-GUMMEI.c	\
+	S1ap-GWContextReleaseIndication.c	\
+	S1ap-HandoverRestrictionList.c	\
+	S1ap-HandoverType.c	\
+	S1ap-HFN.c	\
+	S1ap-ImmediateMDT.c	\
+	S1ap-IMSI.c	\
+	S1ap-IntegrityProtectionAlgorithms.c	\
+	S1ap-InterfacesToTrace.c	\
+	S1ap-LAC.c	\
+	S1ap-LAI.c	\
+	S1ap-LastVisitedCell-Item.c	\
+	S1ap-LastVisitedEUTRANCellInformation.c	\
+	S1ap-LastVisitedUTRANCellInformation.c	\
+	S1ap-LastVisitedGERANCellInformation.c	\
+	S1ap-L3-Information.c	\
+	S1ap-LPPa-PDU.c	\
+	S1ap-LoggedMDT.c	\
+	S1ap-LoggingInterval.c	\
+	S1ap-LoggingDuration.c	\
+	S1ap-MDT-Activation.c	\
+	S1ap-MDT-Configuration.c	\
+	S1ap-ManagementBasedMDTAllowed.c	\
+	S1ap-PrivacyIndicator.c	\
+	S1ap-MDTMode.c	\
+	S1ap-MeasurementsToActivate.c	\
+	S1ap-MeasurementThresholdA2.c	\
+	S1ap-MessageIdentifier.c	\
+	S1ap-MMEname.c	\
+	S1ap-MMERelaySupportIndicator.c	\
+	S1ap-MME-Group-ID.c	\
+	S1ap-MME-Code.c	\
+	S1ap-MME-UE-S1AP-ID.c	\
+	S1ap-M-TMSI.c	\
+	S1ap-MSClassmark2.c	\
+	S1ap-MSClassmark3.c	\
+	S1ap-NAS-PDU.c	\
+	S1ap-NASSecurityParametersfromE-UTRAN.c	\
+	S1ap-NASSecurityParameterstoE-UTRAN.c	\
+	S1ap-NumberofBroadcastRequest.c	\
+	S1ap-NumberOfBroadcasts.c	\
+	S1ap-OldBSS-ToNewBSS-Information.c	\
+	S1ap-OverloadAction.c	\
+	S1ap-OverloadResponse.c	\
+	S1ap-PagingDRX.c	\
+	S1ap-PagingPriority.c	\
+	S1ap-PDCP-SN.c	\
+	S1ap-PeriodicReportingMDT.c	\
+	S1ap-PLMNidentity.c	\
+	S1ap-Pre-emptionCapability.c	\
+	S1ap-Pre-emptionVulnerability.c	\
+	S1ap-PriorityLevel.c	\
+	S1ap-PS-ServiceNotAvailable.c	\
+	S1ap-QCI.c	\
+	S1ap-ReceiveStatusofULPDCPSDUs.c	\
+	S1ap-RelativeMMECapacity.c	\
+	S1ap-RelayNode-Indicator.c	\
+	S1ap-RAC.c	\
+	S1ap-ReportAmountMDT.c	\
+	S1ap-ReportIntervalMDT.c	\
+	S1ap-ReportingTriggerMDT.c	\
+	S1ap-RequestType.c	\
+	S1ap-RIMTransfer.c	\
+	S1ap-RIMInformation.c	\
+	S1ap-RIMRoutingAddress.c	\
+	S1ap-ReportArea.c	\
+	S1ap-RepetitionPeriod.c	\
+	S1ap-RNC-ID.c	\
+	S1ap-RRC-Container.c	\
+	S1ap-RRC-Establishment-Cause.c	\
+	S1ap-Routing-ID.c	\
+	S1ap-SecurityKey.c	\
+	S1ap-SecurityContext.c	\
+	S1ap-SerialNumber.c	\
+	S1ap-SONInformation.c	\
+	S1ap-SONInformationRequest.c	\
+	S1ap-SONInformationReply.c	\
+	S1ap-SONConfigurationTransfer.c	\
+	S1ap-Source-ToTarget-TransparentContainer.c	\
+	S1ap-SourceBSS-ToTargetBSS-TransparentContainer.c	\
+	S1ap-SourceeNB-ID.c	\
+	S1ap-SRVCCOperationPossible.c	\
+	S1ap-SRVCCHOIndication.c	\
+	S1ap-SourceeNB-ToTargeteNB-TransparentContainer.c	\
+	S1ap-SourceRNC-ToTargetRNC-TransparentContainer.c	\
+	S1ap-ServedGUMMEIs.c	\
+	S1ap-ServedGUMMEIsItem.c	\
+	S1ap-ServedGroupIDs.c	\
+	S1ap-ServedMMECs.c	\
+	S1ap-ServedPLMNs.c	\
+	S1ap-SubscriberProfileIDforRFP.c	\
+	S1ap-SupportedTAs.c	\
+	S1ap-SupportedTAs-Item.c	\
+	S1ap-StratumLevel.c	\
+	S1ap-SynchronizationStatus.c	\
+	S1ap-TimeSynchronizationInfo.c	\
+	S1ap-S-TMSI.c	\
+	S1ap-TAC.c	\
+	S1ap-TAIListforWarning.c	\
+	S1ap-TAI.c	\
+	S1ap-TAI-Broadcast.c	\
+	S1ap-TAI-Broadcast-Item.c	\
+	S1ap-TAI-Cancelled.c	\
+	S1ap-TAI-Cancelled-Item.c	\
+	S1ap-TABasedMDT.c	\
+	S1ap-TAListforMDT.c	\
+	S1ap-CompletedCellinTAI.c	\
+	S1ap-CompletedCellinTAI-Item.c	\
+	S1ap-TBCD-STRING.c	\
+	S1ap-TargetID.c	\
+	S1ap-TargeteNB-ID.c	\
+	S1ap-TargetRNC-ID.c	\
+	S1ap-TargeteNB-ToSourceeNB-TransparentContainer.c	\
+	S1ap-Target-ToSource-TransparentContainer.c	\
+	S1ap-TargetRNC-ToSourceRNC-TransparentContainer.c	\
+	S1ap-TargetBSS-ToSourceBSS-TransparentContainer.c	\
+	S1ap-ThresholdEventA2.c	\
+	S1ap-Threshold-RSRP.c	\
+	S1ap-Threshold-RSRQ.c	\
+	S1ap-TimeToWait.c	\
+	S1ap-Time-UE-StayedInCell.c	\
+	S1ap-TransportLayerAddress.c	\
+	S1ap-TraceActivation.c	\
+	S1ap-TraceDepth.c	\
+	S1ap-E-UTRAN-Trace-ID.c	\
+	S1ap-TrafficLoadReductionIndication.c	\
+	S1ap-TypeOfError.c	\
+	S1ap-UEAggregateMaximumBitrate.c	\
+	S1ap-UE-S1AP-IDs.c	\
+	S1ap-UE-S1AP-ID-pair.c	\
+	S1ap-UE-associatedLogicalS1-ConnectionItem.c	\
+	S1ap-UEIdentityIndexValue.c	\
+	S1ap-UE-HistoryInformation.c	\
+	S1ap-UEPagingID.c	\
+	S1ap-UERadioCapability.c	\
+	S1ap-UESecurityCapabilities.c	\
+	S1ap-WarningAreaList.c	\
+	S1ap-WarningType.c	\
+	S1ap-WarningSecurityInfo.c	\
+	S1ap-WarningMessageContents.c	\
+	S1ap-X2TNLConfigurationInfo.c	\
+	S1ap-ENBX2ExtTLAs.c	\
+	S1ap-ENBX2ExtTLA.c	\
+	S1ap-ENBX2GTPTLAs.c	\
+	S1ap-Criticality.c	\
+	S1ap-Presence.c	\
+	S1ap-PrivateIE-ID.c	\
+	S1ap-ProcedureCode.c	\
+	S1ap-ProtocolExtensionID.c	\
+	S1ap-ProtocolIE-ID.c	\
+	S1ap-TriggeringMessage.c	\
+	ProtocolIE-Container.c	\
+	ProtocolIE-SingleContainer.c	\
+	ProtocolIE-Field.c	\
+	ProtocolIE-ContainerPair.c	\
+	ProtocolIE-FieldPair.c	\
+	ProtocolIE-ContainerList.c	\
+	ProtocolIE-ContainerPairList.c	\
+	ProtocolExtensionContainer.c	\
+	ProtocolExtensionField.c	\
+	PrivateIE-Container.c	\
+	PrivateIE-Field.c	\
+	S1ap-IE.c
+
+ASN_MODULE_SOURCES=	\
+	S1AP-PDU.h	\
+	S1ap-InitiatingMessage.h	\
+	S1ap-SuccessfulOutcome.h	\
+	S1ap-UnsuccessfulOutcome.h	\
+	E-RAB-S1ap-IE-ContainerList.h	\
+	E-RAB-S1ap-IE-ContainerPairList.h	\
+	ProtocolError-S1ap-IE-ContainerList.h	\
+	S1ap-HandoverRequired.h	\
+	S1ap-HandoverCommand.h	\
+	S1ap-E-RABSubjecttoDataForwardingList.h	\
+	S1ap-E-RABDataForwardingItem.h	\
+	S1ap-HandoverPreparationFailure.h	\
+	S1ap-HandoverRequest.h	\
+	S1ap-E-RABToBeSetupListHOReq.h	\
+	S1ap-E-RABToBeSetupItemHOReq.h	\
+	S1ap-HandoverRequestAcknowledge.h	\
+	S1ap-E-RABAdmittedList.h	\
+	S1ap-E-RABAdmittedItem.h	\
+	S1ap-E-RABFailedtoSetupListHOReqAck.h	\
+	S1ap-E-RABFailedToSetupItemHOReqAck.h	\
+	S1ap-HandoverFailure.h	\
+	S1ap-HandoverNotify.h	\
+	S1ap-PathSwitchRequest.h	\
+	S1ap-E-RABToBeSwitchedDLList.h	\
+	S1ap-E-RABToBeSwitchedDLItem.h	\
+	S1ap-PathSwitchRequestAcknowledge.h	\
+	S1ap-E-RABToBeSwitchedULList.h	\
+	S1ap-E-RABToBeSwitchedULItem.h	\
+	S1ap-PathSwitchRequestFailure.h	\
+	S1ap-HandoverCancel.h	\
+	S1ap-HandoverCancelAcknowledge.h	\
+	S1ap-E-RABSetupRequest.h	\
+	S1ap-E-RABToBeSetupListBearerSUReq.h	\
+	S1ap-E-RABToBeSetupItemBearerSUReq.h	\
+	S1ap-E-RABSetupResponse.h	\
+	S1ap-E-RABSetupListBearerSURes.h	\
+	S1ap-E-RABSetupItemBearerSURes.h	\
+	S1ap-E-RABModifyRequest.h	\
+	S1ap-E-RABToBeModifiedListBearerModReq.h	\
+	S1ap-E-RABToBeModifiedItemBearerModReq.h	\
+	S1ap-E-RABModifyResponse.h	\
+	S1ap-E-RABModifyListBearerModRes.h	\
+	S1ap-E-RABModifyItemBearerModRes.h	\
+	S1ap-E-RABReleaseCommand.h	\
+	S1ap-E-RABReleaseResponse.h	\
+	S1ap-E-RABReleaseListBearerRelComp.h	\
+	S1ap-E-RABReleaseItemBearerRelComp.h	\
+	S1ap-E-RABReleaseIndication.h	\
+	S1ap-InitialContextSetupRequest.h	\
+	S1ap-E-RABToBeSetupListCtxtSUReq.h	\
+	S1ap-E-RABToBeSetupItemCtxtSUReq.h	\
+	S1ap-InitialContextSetupResponse.h	\
+	S1ap-E-RABSetupListCtxtSURes.h	\
+	S1ap-E-RABSetupItemCtxtSURes.h	\
+	S1ap-InitialContextSetupFailure.h	\
+	S1ap-Paging.h	\
+	S1ap-TAIList.h	\
+	S1ap-TAIItem.h	\
+	S1ap-UEContextReleaseRequest.h	\
+	S1ap-UEContextReleaseCommand.h	\
+	S1ap-UEContextReleaseComplete.h	\
+	S1ap-UEContextModificationRequest.h	\
+	S1ap-UEContextModificationResponse.h	\
+	S1ap-UEContextModificationFailure.h	\
+	S1ap-DownlinkNASTransport.h	\
+	S1ap-InitialUEMessage.h	\
+	S1ap-UplinkNASTransport.h	\
+	S1ap-NASNonDeliveryIndication.h	\
+	S1ap-Reset.h	\
+	S1ap-ResetType.h	\
+	S1ap-ResetAll.h	\
+	S1ap-UE-associatedLogicalS1-ConnectionListRes.h	\
+	S1ap-ResetAcknowledge.h	\
+	S1ap-UE-associatedLogicalS1-ConnectionListResAck.h	\
+	S1ap-ErrorIndication.h	\
+	S1ap-S1SetupRequest.h	\
+	S1ap-S1SetupResponse.h	\
+	S1ap-S1SetupFailure.h	\
+	S1ap-ENBConfigurationUpdate.h	\
+	S1ap-ENBConfigurationUpdateAcknowledge.h	\
+	S1ap-ENBConfigurationUpdateFailure.h	\
+	S1ap-MMEConfigurationUpdate.h	\
+	S1ap-MMEConfigurationUpdateAcknowledge.h	\
+	S1ap-MMEConfigurationUpdateFailure.h	\
+	S1ap-DownlinkS1cdma2000tunneling.h	\
+	S1ap-UplinkS1cdma2000tunneling.h	\
+	S1ap-UECapabilityInfoIndication.h	\
+	S1ap-ENBStatusTransfer.h	\
+	S1ap-MMEStatusTransfer.h	\
+	S1ap-TraceStart.h	\
+	S1ap-TraceFailureIndication.h	\
+	S1ap-DeactivateTrace.h	\
+	S1ap-CellTrafficTrace.h	\
+	S1ap-LocationReportingControl.h	\
+	S1ap-LocationReportingFailureIndication.h	\
+	S1ap-LocationReport.h	\
+	S1ap-OverloadStart.h	\
+	S1ap-OverloadStop.h	\
+	S1ap-WriteReplaceWarningRequest.h	\
+	S1ap-WriteReplaceWarningResponse.h	\
+	S1ap-ENBDirectInformationTransfer.h	\
+	S1ap-Inter-SystemInformationTransferType.h	\
+	S1ap-MMEDirectInformationTransfer.h	\
+	S1ap-ENBConfigurationTransfer.h	\
+	S1ap-MMEConfigurationTransfer.h	\
+	S1ap-PrivateMessage.h	\
+	S1ap-KillRequest.h	\
+	S1ap-KillResponse.h	\
+	S1ap-DownlinkUEAssociatedLPPaTransport.h	\
+	S1ap-UplinkUEAssociatedLPPaTransport.h	\
+	S1ap-DownlinkNonUEAssociatedLPPaTransport.h	\
+	S1ap-UplinkNonUEAssociatedLPPaTransport.h	\
+	S1ap-AreaScopeOfMDT.h	\
+	S1ap-AllocationAndRetentionPriority.h	\
+	S1ap-Bearers-SubjectToStatusTransferList.h	\
+	S1ap-Bearers-SubjectToStatusTransfer-Item.h	\
+	S1ap-BitRate.h	\
+	S1ap-BPLMNs.h	\
+	S1ap-BroadcastCancelledAreaList.h	\
+	S1ap-BroadcastCompletedAreaList.h	\
+	S1ap-CancelledCellinEAI.h	\
+	S1ap-CancelledCellinEAI-Item.h	\
+	S1ap-CancelledCellinTAI.h	\
+	S1ap-CancelledCellinTAI-Item.h	\
+	S1ap-Cause.h	\
+	S1ap-CauseMisc.h	\
+	S1ap-CauseProtocol.h	\
+	S1ap-CauseRadioNetwork.h	\
+	S1ap-CauseTransport.h	\
+	S1ap-CauseNas.h	\
+	S1ap-CellAccessMode.h	\
+	S1ap-CellIdentity.h	\
+	S1ap-CellID-Broadcast.h	\
+	S1ap-CellID-Broadcast-Item.h	\
+	S1ap-CellID-Cancelled.h	\
+	S1ap-CellID-Cancelled-Item.h	\
+	S1ap-CellBasedMDT.h	\
+	S1ap-CellIdListforMDT.h	\
+	S1ap-Cdma2000PDU.h	\
+	S1ap-Cdma2000RATType.h	\
+	S1ap-Cdma2000SectorID.h	\
+	S1ap-Cdma2000HOStatus.h	\
+	S1ap-Cdma2000HORequiredIndication.h	\
+	S1ap-Cdma2000OneXSRVCCInfo.h	\
+	S1ap-Cdma2000OneXMEID.h	\
+	S1ap-Cdma2000OneXMSI.h	\
+	S1ap-Cdma2000OneXPilot.h	\
+	S1ap-Cdma2000OneXRAND.h	\
+	S1ap-Cell-Size.h	\
+	S1ap-CellType.h	\
+	S1ap-CGI.h	\
+	S1ap-CI.h	\
+	S1ap-CNDomain.h	\
+	S1ap-ConcurrentWarningMessageIndicator.h	\
+	S1ap-Correlation-ID.h	\
+	S1ap-CSFallbackIndicator.h	\
+	S1ap-CSG-Id.h	\
+	S1ap-CSG-IdList.h	\
+	S1ap-CSG-IdList-Item.h	\
+	S1ap-CSGMembershipStatus.h	\
+	S1ap-COUNTvalue.h	\
+	S1ap-CriticalityDiagnostics.h	\
+	S1ap-CriticalityDiagnostics-IE-List.h	\
+	S1ap-CriticalityDiagnostics-S1ap-IE-Item.h	\
+	S1ap-DataCodingScheme.h	\
+	S1ap-DL-Forwarding.h	\
+	S1ap-Direct-Forwarding-Path-Availability.h	\
+	S1ap-Data-Forwarding-Not-Possible.h	\
+	S1ap-ECGIList.h	\
+	S1ap-EmergencyAreaIDList.h	\
+	S1ap-EmergencyAreaID.h	\
+	S1ap-EmergencyAreaID-Broadcast.h	\
+	S1ap-EmergencyAreaID-Broadcast-Item.h	\
+	S1ap-EmergencyAreaID-Cancelled.h	\
+	S1ap-EmergencyAreaID-Cancelled-Item.h	\
+	S1ap-CompletedCellinEAI.h	\
+	S1ap-CompletedCellinEAI-Item.h	\
+	S1ap-ENB-ID.h	\
+	S1ap-GERAN-Cell-ID.h	\
+	S1ap-Global-ENB-ID.h	\
+	S1ap-GUMMEIList.h	\
+	S1ap-ENB-StatusTransfer-TransparentContainer.h	\
+	S1ap-ENB-UE-S1AP-ID.h	\
+	S1ap-ENBname.h	\
+	S1ap-ENBX2TLAs.h	\
+	S1ap-EncryptionAlgorithms.h	\
+	S1ap-EPLMNs.h	\
+	S1ap-EventType.h	\
+	S1ap-E-RAB-ID.h	\
+	S1ap-E-RABInformationList.h	\
+	S1ap-E-RABInformationListItem.h	\
+	S1ap-E-RABList.h	\
+	S1ap-E-RABItem.h	\
+	S1ap-E-RABLevelQoSParameters.h	\
+	S1ap-EUTRAN-CGI.h	\
+	S1ap-EUTRANRoundTripDelayEstimationInfo.h	\
+	S1ap-ExtendedRNC-ID.h	\
+	S1ap-ExtendedRepetitionPeriod.h	\
+	S1ap-ForbiddenInterRATs.h	\
+	S1ap-ForbiddenTAs.h	\
+	S1ap-ForbiddenTAs-Item.h	\
+	S1ap-ForbiddenTACs.h	\
+	S1ap-ForbiddenLAs.h	\
+	S1ap-ForbiddenLAs-Item.h	\
+	S1ap-ForbiddenLACs.h	\
+	S1ap-GBR-QosInformation.h	\
+	S1ap-GTP-TEID.h	\
+	S1ap-GUMMEI.h	\
+	S1ap-GWContextReleaseIndication.h	\
+	S1ap-HandoverRestrictionList.h	\
+	S1ap-HandoverType.h	\
+	S1ap-HFN.h	\
+	S1ap-ImmediateMDT.h	\
+	S1ap-IMSI.h	\
+	S1ap-IntegrityProtectionAlgorithms.h	\
+	S1ap-InterfacesToTrace.h	\
+	S1ap-LAC.h	\
+	S1ap-LAI.h	\
+	S1ap-LastVisitedCell-Item.h	\
+	S1ap-LastVisitedEUTRANCellInformation.h	\
+	S1ap-LastVisitedUTRANCellInformation.h	\
+	S1ap-LastVisitedGERANCellInformation.h	\
+	S1ap-L3-Information.h	\
+	S1ap-LPPa-PDU.h	\
+	S1ap-LoggedMDT.h	\
+	S1ap-LoggingInterval.h	\
+	S1ap-LoggingDuration.h	\
+	S1ap-MDT-Activation.h	\
+	S1ap-MDT-Configuration.h	\
+	S1ap-ManagementBasedMDTAllowed.h	\
+	S1ap-PrivacyIndicator.h	\
+	S1ap-MDTMode.h	\
+	S1ap-MeasurementsToActivate.h	\
+	S1ap-MeasurementThresholdA2.h	\
+	S1ap-MessageIdentifier.h	\
+	S1ap-MMEname.h	\
+	S1ap-MMERelaySupportIndicator.h	\
+	S1ap-MME-Group-ID.h	\
+	S1ap-MME-Code.h	\
+	S1ap-MME-UE-S1AP-ID.h	\
+	S1ap-M-TMSI.h	\
+	S1ap-MSClassmark2.h	\
+	S1ap-MSClassmark3.h	\
+	S1ap-NAS-PDU.h	\
+	S1ap-NASSecurityParametersfromE-UTRAN.h	\
+	S1ap-NASSecurityParameterstoE-UTRAN.h	\
+	S1ap-NumberofBroadcastRequest.h	\
+	S1ap-NumberOfBroadcasts.h	\
+	S1ap-OldBSS-ToNewBSS-Information.h	\
+	S1ap-OverloadAction.h	\
+	S1ap-OverloadResponse.h	\
+	S1ap-PagingDRX.h	\
+	S1ap-PagingPriority.h	\
+	S1ap-PDCP-SN.h	\
+	S1ap-PeriodicReportingMDT.h	\
+	S1ap-PLMNidentity.h	\
+	S1ap-Pre-emptionCapability.h	\
+	S1ap-Pre-emptionVulnerability.h	\
+	S1ap-PriorityLevel.h	\
+	S1ap-PS-ServiceNotAvailable.h	\
+	S1ap-QCI.h	\
+	S1ap-ReceiveStatusofULPDCPSDUs.h	\
+	S1ap-RelativeMMECapacity.h	\
+	S1ap-RelayNode-Indicator.h	\
+	S1ap-RAC.h	\
+	S1ap-ReportAmountMDT.h	\
+	S1ap-ReportIntervalMDT.h	\
+	S1ap-ReportingTriggerMDT.h	\
+	S1ap-RequestType.h	\
+	S1ap-RIMTransfer.h	\
+	S1ap-RIMInformation.h	\
+	S1ap-RIMRoutingAddress.h	\
+	S1ap-ReportArea.h	\
+	S1ap-RepetitionPeriod.h	\
+	S1ap-RNC-ID.h	\
+	S1ap-RRC-Container.h	\
+	S1ap-RRC-Establishment-Cause.h	\
+	S1ap-Routing-ID.h	\
+	S1ap-SecurityKey.h	\
+	S1ap-SecurityContext.h	\
+	S1ap-SerialNumber.h	\
+	S1ap-SONInformation.h	\
+	S1ap-SONInformationRequest.h	\
+	S1ap-SONInformationReply.h	\
+	S1ap-SONConfigurationTransfer.h	\
+	S1ap-Source-ToTarget-TransparentContainer.h	\
+	S1ap-SourceBSS-ToTargetBSS-TransparentContainer.h	\
+	S1ap-SourceeNB-ID.h	\
+	S1ap-SRVCCOperationPossible.h	\
+	S1ap-SRVCCHOIndication.h	\
+	S1ap-SourceeNB-ToTargeteNB-TransparentContainer.h	\
+	S1ap-SourceRNC-ToTargetRNC-TransparentContainer.h	\
+	S1ap-ServedGUMMEIs.h	\
+	S1ap-ServedGUMMEIsItem.h	\
+	S1ap-ServedGroupIDs.h	\
+	S1ap-ServedMMECs.h	\
+	S1ap-ServedPLMNs.h	\
+	S1ap-SubscriberProfileIDforRFP.h	\
+	S1ap-SupportedTAs.h	\
+	S1ap-SupportedTAs-Item.h	\
+	S1ap-StratumLevel.h	\
+	S1ap-SynchronizationStatus.h	\
+	S1ap-TimeSynchronizationInfo.h	\
+	S1ap-S-TMSI.h	\
+	S1ap-TAC.h	\
+	S1ap-TAIListforWarning.h	\
+	S1ap-TAI.h	\
+	S1ap-TAI-Broadcast.h	\
+	S1ap-TAI-Broadcast-Item.h	\
+	S1ap-TAI-Cancelled.h	\
+	S1ap-TAI-Cancelled-Item.h	\
+	S1ap-TABasedMDT.h	\
+	S1ap-TAListforMDT.h	\
+	S1ap-CompletedCellinTAI.h	\
+	S1ap-CompletedCellinTAI-Item.h	\
+	S1ap-TBCD-STRING.h	\
+	S1ap-TargetID.h	\
+	S1ap-TargeteNB-ID.h	\
+	S1ap-TargetRNC-ID.h	\
+	S1ap-TargeteNB-ToSourceeNB-TransparentContainer.h	\
+	S1ap-Target-ToSource-TransparentContainer.h	\
+	S1ap-TargetRNC-ToSourceRNC-TransparentContainer.h	\
+	S1ap-TargetBSS-ToSourceBSS-TransparentContainer.h	\
+	S1ap-ThresholdEventA2.h	\
+	S1ap-Threshold-RSRP.h	\
+	S1ap-Threshold-RSRQ.h	\
+	S1ap-TimeToWait.h	\
+	S1ap-Time-UE-StayedInCell.h	\
+	S1ap-TransportLayerAddress.h	\
+	S1ap-TraceActivation.h	\
+	S1ap-TraceDepth.h	\
+	S1ap-E-UTRAN-Trace-ID.h	\
+	S1ap-TrafficLoadReductionIndication.h	\
+	S1ap-TypeOfError.h	\
+	S1ap-UEAggregateMaximumBitrate.h	\
+	S1ap-UE-S1AP-IDs.h	\
+	S1ap-UE-S1AP-ID-pair.h	\
+	S1ap-UE-associatedLogicalS1-ConnectionItem.h	\
+	S1ap-UEIdentityIndexValue.h	\
+	S1ap-UE-HistoryInformation.h	\
+	S1ap-UEPagingID.h	\
+	S1ap-UERadioCapability.h	\
+	S1ap-UESecurityCapabilities.h	\
+	S1ap-WarningAreaList.h	\
+	S1ap-WarningType.h	\
+	S1ap-WarningSecurityInfo.h	\
+	S1ap-WarningMessageContents.h	\
+	S1ap-X2TNLConfigurationInfo.h	\
+	S1ap-ENBX2ExtTLAs.h	\
+	S1ap-ENBX2ExtTLA.h	\
+	S1ap-ENBX2GTPTLAs.h	\
+	S1ap-Criticality.h	\
+	S1ap-Presence.h	\
+	S1ap-PrivateIE-ID.h	\
+	S1ap-ProcedureCode.h	\
+	S1ap-ProtocolExtensionID.h	\
+	S1ap-ProtocolIE-ID.h	\
+	S1ap-TriggeringMessage.h	\
+	ProtocolIE-Container.h	\
+	ProtocolIE-SingleContainer.h	\
+	ProtocolIE-Field.h	\
+	ProtocolIE-ContainerPair.h	\
+	ProtocolIE-FieldPair.h	\
+	ProtocolIE-ContainerList.h	\
+	ProtocolIE-ContainerPairList.h	\
+	ProtocolExtensionContainer.h	\
+	ProtocolExtensionField.h	\
+	PrivateIE-Container.h	\
+	PrivateIE-Field.h	\
+	S1ap-IE.h
+
+ASN_MODULE_SOURCES+=ANY.h
+ASN_MODULE_NODIST_SOURCES+=ANY.c
+ASN_MODULE_SOURCES+=BOOLEAN.h
+ASN_MODULE_NODIST_SOURCES+=BOOLEAN.c
+ASN_MODULE_SOURCES+=INTEGER.h
+ASN_MODULE_SOURCES+=NativeEnumerated.h
+ASN_MODULE_NODIST_SOURCES+=INTEGER.c
+ASN_MODULE_SOURCES+=NULL.h
+ASN_MODULE_NODIST_SOURCES+=NULL.c
+ASN_MODULE_NODIST_SOURCES+=NativeEnumerated.c
+ASN_MODULE_SOURCES+=NativeInteger.h
+ASN_MODULE_NODIST_SOURCES+=NativeInteger.c
+ASN_MODULE_SOURCES+=OBJECT_IDENTIFIER.h
+ASN_MODULE_NODIST_SOURCES+=OBJECT_IDENTIFIER.c
+ASN_MODULE_SOURCES+=PrintableString.h
+ASN_MODULE_NODIST_SOURCES+=PrintableString.c
+ASN_MODULE_SOURCES+=asn_SEQUENCE_OF.h
+ASN_MODULE_NODIST_SOURCES+=asn_SEQUENCE_OF.c
+ASN_MODULE_SOURCES+=asn_SET_OF.h
+ASN_MODULE_NODIST_SOURCES+=asn_SET_OF.c
+ASN_MODULE_SOURCES+=constr_CHOICE.h
+ASN_MODULE_NODIST_SOURCES+=constr_CHOICE.c
+ASN_MODULE_SOURCES+=constr_SEQUENCE.h
+ASN_MODULE_NODIST_SOURCES+=constr_SEQUENCE.c
+ASN_MODULE_SOURCES+=constr_SEQUENCE_OF.h
+ASN_MODULE_NODIST_SOURCES+=constr_SEQUENCE_OF.c
+ASN_MODULE_SOURCES+=constr_SET_OF.h
+ASN_MODULE_NODIST_SOURCES+=constr_SET_OF.c
+ASN_MODULE_SOURCES+=asn_application.h
+ASN_MODULE_SOURCES+=asn_system.h
+ASN_MODULE_SOURCES+=asn_codecs.h
+ASN_MODULE_SOURCES+=asn_internal.h
+ASN_MODULE_SOURCES+=OCTET_STRING.h
+ASN_MODULE_NODIST_SOURCES+=OCTET_STRING.c
+ASN_MODULE_SOURCES+=BIT_STRING.h
+ASN_MODULE_NODIST_SOURCES+=BIT_STRING.c
+ASN_MODULE_NODIST_SOURCES+=asn_codecs_prim.c
+ASN_MODULE_SOURCES+=asn_codecs_prim.h
+ASN_MODULE_SOURCES+=ber_tlv_length.h
+ASN_MODULE_NODIST_SOURCES+=ber_tlv_length.c
+ASN_MODULE_SOURCES+=ber_tlv_tag.h
+ASN_MODULE_NODIST_SOURCES+=ber_tlv_tag.c
+ASN_MODULE_SOURCES+=ber_decoder.h
+ASN_MODULE_NODIST_SOURCES+=ber_decoder.c
+ASN_MODULE_SOURCES+=der_encoder.h
+ASN_MODULE_NODIST_SOURCES+=der_encoder.c
+ASN_MODULE_SOURCES+=constr_TYPE.h
+ASN_MODULE_NODIST_SOURCES+=constr_TYPE.c
+ASN_MODULE_SOURCES+=constraints.h
+ASN_MODULE_NODIST_SOURCES+=constraints.c
+ASN_MODULE_SOURCES+=xer_support.h
+ASN_MODULE_NODIST_SOURCES+=xer_support.c
+ASN_MODULE_SOURCES+=xer_decoder.h
+ASN_MODULE_NODIST_SOURCES+=xer_decoder.c
+ASN_MODULE_SOURCES+=xer_encoder.h
+ASN_MODULE_NODIST_SOURCES+=xer_encoder.c
+ASN_MODULE_SOURCES+=per_support.h
+ASN_MODULE_NODIST_SOURCES+=per_support.c
+ASN_MODULE_SOURCES+=per_decoder.h
+ASN_MODULE_NODIST_SOURCES+=per_decoder.c
+ASN_MODULE_SOURCES+=per_encoder.h
+ASN_MODULE_NODIST_SOURCES+=per_encoder.c
+ASN_MODULE_SOURCES+=per_opentype.h
+ASN_MODULE_NODIST_SOURCES+=per_opentype.c
+
+
+lib_LTLIBRARIES=libasn1c.la
+libasn1c_la_SOURCES=$(ASN_MODULE_SOURCES)
+nodist_libasn1c_la_SOURCES=$(ASN_MODULE_NODIST_SOURCES)
+
+AM_CFLAGS = \
+	-Wall -Werror -Wno-parentheses-equality
+
+MAINTAINERCLEANFILES = Makefile.in 
+MOSTLYCLEANFILES = core *.stackdump
+
+EXTRA_DIST = .libs $(noinst_LTLIBRARIES)
+
+regen: regenerate-from-asn1-source
+
+regenerate-from-asn1-source:
+	../../../../AuthenticEshkinKot/asn1c/asn1c/asn1c -fcompound-names -gen-PER ../support/S1AP-PDU.asn
+

lib/asn/asn1c/NULL.c

@@ -0,0 +1,195 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <NULL.h>
+#include <BOOLEAN.h>	/* Implemented in terms of BOOLEAN type */
+
+/*
+ * NULL basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_NULL_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (5 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NULL = {
+	"NULL",
+	"NULL",
+	BOOLEAN_free,
+	NULL_print,
+	asn_generic_no_constraint,
+	BOOLEAN_decode_ber,	/* Implemented in terms of BOOLEAN */
+	NULL_encode_der,	/* Special handling of DER encoding */
+	NULL_decode_xer,
+	NULL_encode_xer,
+	NULL_decode_uper,	/* Unaligned PER decoder */
+	NULL_encode_uper,	/* Unaligned PER encoder */
+	NULL_decode_aper,	/* Aligned PER decoder */
+	NULL_encode_aper,	/* Aligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_NULL_tags,
+	sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
+	asn_DEF_NULL_tags,	/* Same as above */
+	sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+asn_enc_rval_t
+NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
+	int tag_mode, ber_tlv_tag_t tag,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t erval;
+
+	erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		erval.failed_type = td;
+		erval.structure_ptr = ptr;
+	}
+
+	ASN__ENCODED_OK(erval);
+}
+
+asn_enc_rval_t
+NULL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t er;
+
+	(void)td;
+	(void)sptr;
+	(void)ilevel;
+	(void)flags;
+	(void)cb;
+	(void)app_key;
+
+	/* XMLNullValue is empty */
+	er.encoded = 0;
+	ASN__ENCODED_OK(er);
+}
+
+
+static enum xer_pbd_rval
+NULL__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
+	(void)td;
+	(void)sptr;
+	(void)chunk_buf;    /* Going to be empty according to the rules below. */
+
+	/*
+	 * There must be no content in self-terminating <NULL/> tag.
+	 */
+	if(chunk_size)
+		return XPBD_BROKEN_ENCODING;
+	else
+		return XPBD_BODY_CONSUMED;
+}
+
+asn_dec_rval_t
+NULL_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+
+	return xer_decode_primitive(opt_codec_ctx, td,
+		sptr, sizeof(NULL_t), opt_mname, buf_ptr, size,
+		NULL__xer_body_decode);
+}
+
+int
+NULL_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(sptr) {
+		return (cb("<present>", 9, app_key) < 0) ? -1 : 0;
+	} else {
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+	}
+}
+
+asn_dec_rval_t
+NULL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+
+	(void)opt_codec_ctx;
+	(void)td;
+	(void)constraints;
+	(void)pd;
+
+	if(!*sptr) {
+		*sptr = MALLOC(sizeof(NULL_t));
+		if(*sptr) {
+			*(NULL_t *)*sptr = 0;
+		} else {
+			ASN__DECODE_FAILED;
+		}
+	}
+
+	/*
+	 * NULL type does not have content octets.
+	 */
+
+	rv.code = RC_OK;
+	rv.consumed = 0;
+	return rv;
+}
+
+asn_dec_rval_t
+NULL_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+
+	(void)opt_codec_ctx;
+	(void)td;
+	(void)constraints;
+	(void)pd;
+
+	if(!*sptr) {
+		*sptr = MALLOC(sizeof(NULL_t));
+		if(*sptr) {
+			*(NULL_t *)*sptr = 0;
+		} else {
+			ASN__DECODE_FAILED;
+		}
+	}
+
+	/*
+	 * NULL type does not have content octets.
+	 */
+
+	rv.code = RC_OK;
+	rv.consumed = 0;
+	return rv;
+}
+
+asn_enc_rval_t
+NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+		void *sptr, asn_per_outp_t *po) {
+	asn_enc_rval_t er;
+
+	(void)td;
+	(void)constraints;
+	(void)sptr;
+	(void)po;
+
+	er.encoded = 0;
+	ASN__ENCODED_OK(er);
+}
+
+asn_enc_rval_t
+NULL_encode_aper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+		void *sptr, asn_per_outp_t *po) {
+	asn_enc_rval_t er;
+
+	(void)td;
+	(void)constraints;
+	(void)sptr;
+	(void)po;
+
+	er.encoded = 0;
+	ASN__ENCODED_OK(er);
+}

lib/asn/asn1c/NULL.h

@@ -0,0 +1,35 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	ASN_TYPE_NULL_H
+#define	ASN_TYPE_NULL_H
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The value of the NULL type is meaningless: see BOOLEAN if you want to
+ * carry true/false semantics.
+ */
+typedef int NULL_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_NULL;
+
+asn_struct_print_f NULL_print;
+der_type_encoder_f NULL_encode_der;
+xer_type_decoder_f NULL_decode_xer;
+xer_type_encoder_f NULL_encode_xer;
+per_type_decoder_f NULL_decode_uper;
+per_type_encoder_f NULL_encode_uper;
+per_type_decoder_f NULL_decode_aper;
+per_type_encoder_f NULL_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* NULL_H */

lib/asn/asn1c/NativeEnumerated.c

@@ -0,0 +1,332 @@
+/*-
+ * Copyright (c) 2004, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeEnumerated.h>
+
+/*
+ * NativeEnumerated basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_NativeEnumerated_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NativeEnumerated = {
+	"ENUMERATED",			/* The ASN.1 type is still ENUMERATED */
+	"ENUMERATED",
+	NativeInteger_free,
+	NativeInteger_print,
+	asn_generic_no_constraint,
+	NativeInteger_decode_ber,
+	NativeInteger_encode_der,
+	NativeInteger_decode_xer,
+	NativeEnumerated_encode_xer,
+	NativeEnumerated_decode_uper,
+	NativeEnumerated_encode_uper,
+	NativeEnumerated_decode_aper,
+	NativeEnumerated_encode_aper,
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_NativeEnumerated_tags,
+	sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
+	asn_DEF_NativeEnumerated_tags,	/* Same as above */
+	sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+asn_enc_rval_t
+NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+        int ilevel, enum xer_encoder_flags_e flags,
+                asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+        asn_enc_rval_t er;
+        const long *native = (const long *)sptr;
+	const asn_INTEGER_enum_map_t *el;
+
+        (void)ilevel;
+        (void)flags;
+
+        if(!native) ASN__ENCODE_FAILED;
+
+	el = INTEGER_map_value2enum(specs, *native);
+	if(el) {
+		size_t srcsize = el->enum_len + 5;
+		char *src = (char *)alloca(srcsize);
+
+		er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
+		assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
+		if(cb(src, er.encoded, app_key) < 0) ASN__ENCODE_FAILED;
+		ASN__ENCODED_OK(er);
+	} else {
+		ASN_DEBUG("ASN.1 forbids dealing with "
+			"unknown value of ENUMERATED type");
+		ASN__ENCODE_FAILED;
+	}
+}
+
+asn_dec_rval_t
+NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+	void **sptr, asn_per_data_t *pd) {
+	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval = { RC_OK, 0 };
+	long *native = (long *)*sptr;
+	asn_per_constraint_t *ct;
+	long value;
+
+	(void)opt_codec_ctx;
+
+	if(constraints) ct = &constraints->value;
+	else if(td->per_constraints) ct = &td->per_constraints->value;
+	else ASN__DECODE_FAILED;	/* Mandatory! */
+	if(!specs) ASN__DECODE_FAILED;
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
+
+	if(ct->flags & APC_EXTENSIBLE) {
+		int inext = per_get_few_bits(pd, 1);
+		if(inext < 0) ASN__DECODE_STARVED;
+		if(inext) ct = 0;
+	}
+
+	if(ct && ct->range_bits >= 0) {
+		value = per_get_few_bits(pd, ct->range_bits);
+		if(value < 0) ASN__DECODE_STARVED;
+		if(value >= (specs->extension
+			? specs->extension - 1 : specs->map_count))
+			ASN__DECODE_FAILED;
+	} else {
+		if(!specs->extension)
+			ASN__DECODE_FAILED;
+		/*
+		 * X.691, #10.6: normally small non-negative whole number;
+		 */
+		value = uper_get_nsnnwn(pd);
+		if(value < 0) ASN__DECODE_STARVED;
+		value += specs->extension - 1;
+		if(value >= specs->map_count)
+			ASN__DECODE_FAILED;
+	}
+
+	*native = specs->value2enum[value].nat_value;
+	ASN_DEBUG("Decoded %s = %ld", td->name, *native);
+
+	return rval;
+}
+
+asn_dec_rval_t
+NativeEnumerated_decode_aper(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+	void **sptr, asn_per_data_t *pd) {
+	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval = { RC_OK, 0 };
+	long *native = (long *)*sptr;
+	asn_per_constraint_t *ct;
+	long value;
+
+	(void)opt_codec_ctx;
+
+	if(constraints) ct = &constraints->value;
+	else if(td->per_constraints) ct = &td->per_constraints->value;
+	else ASN__DECODE_FAILED;	/* Mandatory! */
+	if(!specs) ASN__DECODE_FAILED;
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
+
+	if(ct->flags & APC_EXTENSIBLE) {
+		int inext = per_get_few_bits(pd, 1);
+		if(inext < 0) ASN__DECODE_STARVED;
+		if(inext) ct = 0;
+	}
+
+	if(ct && ct->range_bits >= 0) {
+		value = per_get_few_bits(pd, ct->range_bits);
+		if(value < 0) ASN__DECODE_STARVED;
+		if(value >= (specs->extension
+			? specs->extension - 1 : specs->map_count))
+			ASN__DECODE_FAILED;
+	} else {
+		if(!specs->extension)
+			ASN__DECODE_FAILED;
+		/*
+		 * X.691, #10.6: normally small non-negative whole number;
+		 */
+		value = uper_get_nsnnwn(pd);
+		if(value < 0) ASN__DECODE_STARVED;
+		value += specs->extension - 1;
+		if(value >= specs->map_count)
+			ASN__DECODE_FAILED;
+	}
+
+	*native = specs->value2enum[value].nat_value;
+	ASN_DEBUG("Decoded %s = %ld", td->name, *native);
+
+	return rval;
+}
+
+static int
+NativeEnumerated__compar_value2enum(const void *ap, const void *bp) {
+	const asn_INTEGER_enum_map_t *a = ap;
+	const asn_INTEGER_enum_map_t *b = bp;
+	if(a->nat_value == b->nat_value)
+		return 0;
+	if(a->nat_value < b->nat_value)
+		return -1;
+	return 1;
+}
+
+asn_enc_rval_t
+NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+	asn_enc_rval_t er;
+	long native, value;
+	asn_per_constraint_t *ct;
+	int inext = 0;
+	asn_INTEGER_enum_map_t key;
+	const asn_INTEGER_enum_map_t *kf;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+	if(!specs) ASN__ENCODE_FAILED;
+
+	if(constraints) ct = &constraints->value;
+	else if(td->per_constraints) ct = &td->per_constraints->value;
+	else ASN__ENCODE_FAILED;	/* Mandatory! */
+
+	ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
+
+	er.encoded = 0;
+
+	native = *(long *)sptr;
+	if(native < 0) ASN__ENCODE_FAILED;
+
+	key.nat_value = native;
+	kf = bsearch(&key, specs->value2enum, specs->map_count,
+		sizeof(key), NativeEnumerated__compar_value2enum);
+	if(!kf) {
+		ASN_DEBUG("No element corresponds to %ld", native);
+		ASN__ENCODE_FAILED;
+	}
+	value = kf - specs->value2enum;
+
+	if(ct->range_bits >= 0) {
+		int cmpWith = specs->extension
+				? specs->extension - 1 : specs->map_count;
+		if(value >= cmpWith)
+			inext = 1;
+	}
+	if(ct->flags & APC_EXTENSIBLE) {
+		if(per_put_few_bits(po, inext, 1))
+			ASN__ENCODE_FAILED;
+		if(inext) ct = 0;
+	} else if(inext) {
+		ASN__ENCODE_FAILED;
+	}
+
+	if(ct && ct->range_bits >= 0) {
+		if(per_put_few_bits(po, value, ct->range_bits))
+			ASN__ENCODE_FAILED;
+		ASN__ENCODED_OK(er);
+	}
+
+	if(!specs->extension)
+		ASN__ENCODE_FAILED;
+
+	/*
+	 * X.691, #10.6: normally small non-negative whole number;
+	 */
+	ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
+		value, specs->extension, inext,
+		value - (inext ? (specs->extension - 1) : 0));
+	if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+asn_enc_rval_t
+NativeEnumerated_encode_aper(asn_TYPE_descriptor_t *td,
+        asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+       asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+        asn_enc_rval_t er;
+        long native, value;
+        asn_per_constraint_t *ct;
+        int inext = 0;
+        asn_INTEGER_enum_map_t key;
+        asn_INTEGER_enum_map_t *kf;
+
+        if(!sptr) ASN__ENCODE_FAILED;
+        if(!specs) ASN__ENCODE_FAILED;
+
+        if(constraints) ct = &constraints->value;
+        else if(td->per_constraints) ct = &td->per_constraints->value;
+        else ASN__ENCODE_FAILED;        /* Mandatory! */
+
+        ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
+
+        er.encoded = 0;
+
+        native = *(long *)sptr;
+        if(native < 0) ASN__ENCODE_FAILED;
+
+        key.nat_value = native;
+        kf = bsearch(&key, specs->value2enum, specs->map_count,
+                sizeof(key), NativeEnumerated__compar_value2enum);
+        if(!kf) {
+                ASN_DEBUG("No element corresponds to %ld", native);
+                ASN__ENCODE_FAILED;
+        }
+        value = kf - specs->value2enum;
+
+        if(ct->range_bits >= 0) {
+                int cmpWith = specs->extension
+                                ? specs->extension - 1 : specs->map_count;
+                if(value >= cmpWith)
+                        inext = 1;
+        }
+        if(ct->flags & APC_EXTENSIBLE) {
+                if(per_put_few_bits(po, inext, 1))
+                        ASN__ENCODE_FAILED;
+                if(inext) ct = 0;
+        } else if(inext) {
+                ASN__ENCODE_FAILED;
+        }
+
+        if(ct && ct->range_bits >= 0) {
+                if(per_put_few_bits(po, value, ct->range_bits))
+                        ASN__ENCODE_FAILED;
+                ASN__ENCODED_OK(er);
+        }
+
+        if(!specs->extension)
+                ASN__ENCODE_FAILED;
+
+        /*
+         * X.691, #10.6: normally small non-negative whole number;
+         */
+        ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
+                value, specs->extension, inext,
+                value - (inext ? (specs->extension - 1) : 0));
+        if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
+                ASN__ENCODE_FAILED;
+
+        ASN__ENCODED_OK(er);
+}

lib/asn/asn1c/NativeEnumerated.h

@@ -0,0 +1,34 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard ENUMERATED in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeEnumerated_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef	_NativeEnumerated_H_
+#define	_NativeEnumerated_H_
+
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeEnumerated;
+
+xer_type_encoder_f NativeEnumerated_encode_xer;
+per_type_decoder_f NativeEnumerated_decode_uper;
+per_type_encoder_f NativeEnumerated_encode_uper;
+per_type_decoder_f NativeEnumerated_decode_aper;
+per_type_encoder_f NativeEnumerated_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NativeEnumerated_H_ */

lib/asn/asn1c/NativeInteger.c

@@ -0,0 +1,396 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeInteger.h>
+
+/*
+ * NativeInteger basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
+	"INTEGER",			/* The ASN.1 type is still INTEGER */
+	"INTEGER",
+	NativeInteger_free,
+	NativeInteger_print,
+	asn_generic_no_constraint,
+	NativeInteger_decode_ber,
+	NativeInteger_encode_der,
+	NativeInteger_decode_xer,
+	NativeInteger_encode_xer,
+	NativeInteger_decode_uper,	/* Unaligned PER decoder */
+	NativeInteger_encode_uper,	/* Unaligned PER encoder */
+	NativeInteger_decode_aper,	/* Aligned PER decoder */
+	NativeInteger_encode_aper,	/* Aligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_NativeInteger_tags,
+	sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+	asn_DEF_NativeInteger_tags,	/* Same as above */
+	sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode INTEGER type.
+ */
+asn_dec_rval_t
+NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td,
+	void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	long *native = (long *)*nint_ptr;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+
+	/*
+	 * If the structure is not there, allocate it.
+	 */
+	if(native == NULL) {
+		native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
+		if(native == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+			tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
+
+	/*
+	 * Make sure we have this length.
+	 */
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * ASN.1 encoded INTEGER: buf_ptr, length
+	 * Fill the native, at the same time checking for overflow.
+	 * If overflow occured, return with RC_FAIL.
+	 */
+	{
+		INTEGER_t tmp;
+		union {
+			const void *constbuf;
+			void *nonconstbuf;
+		} unconst_buf;
+		long long l;
+
+		unconst_buf.constbuf = buf_ptr;
+		tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
+		tmp.size = length;
+
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmp, (unsigned long long *)&l) /* sic */
+			: asn_INTEGER2long(&tmp, &l)) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+
+		*native = l;
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",
+		(long)rval.consumed, (long)length, td->name, (long)*native);
+
+	return rval;
+}
+
+/*
+ * Encode the NativeInteger using the standard INTEGER type DER encoder.
+ */
+asn_enc_rval_t
+NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
+	int tag_mode, ber_tlv_tag_t tag,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	unsigned long native = *(unsigned long *)ptr;	/* Disable sign ext. */
+	asn_enc_rval_t erval;
+	INTEGER_t tmp;
+
+#ifdef	WORDS_BIGENDIAN		/* Opportunistic optimization */
+
+	tmp.buf = (uint8_t *)&native;
+	tmp.size = sizeof(native);
+
+#else	/* Works even if WORDS_BIGENDIAN is not set where should've been */
+	uint8_t buf[sizeof(native)];
+	uint8_t *p;
+
+	/* Prepare a fake INTEGER */
+	for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
+		*p = (uint8_t)native;
+
+	tmp.buf = buf;
+	tmp.size = sizeof(buf);
+#endif	/* WORDS_BIGENDIAN */
+	
+	/* Encode fake INTEGER */
+	erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		assert(erval.structure_ptr == &tmp);
+		erval.structure_ptr = ptr;
+	}
+	return erval;
+}
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+asn_dec_rval_t
+NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval;
+	INTEGER_t st;
+	void *st_ptr = (void *)&st;
+	long *native = (long *)*sptr;
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&st, 0, sizeof(st));
+	rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, 
+		opt_mname, buf_ptr, size);
+	if(rval.code == RC_OK) {
+		long long l;
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&st, (unsigned long long *)&l) /* sic */
+			: asn_INTEGER2long(&st, &l)) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+		} else {
+			*native = l;
+		}
+	} else {
+		/*
+		 * Cannot restart from the middle;
+		 * there is no place to save state in the native type.
+		 * Request a continuation from the very beginning.
+		 */
+		rval.consumed = 0;
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
+	return rval;
+}
+
+
+asn_enc_rval_t
+NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	char scratch[32];	/* Enough for 64-bit int */
+	asn_enc_rval_t er;
+	const long *native = (const long *)sptr;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!native) ASN__ENCODE_FAILED;
+
+	er.encoded = snprintf(scratch, sizeof(scratch),
+			(specs && specs->field_unsigned)
+			? "%lu" : "%ld", *native);
+	if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
+		|| cb(scratch, er.encoded, app_key) < 0)
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+asn_dec_rval_t
+NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval;
+	long long *native = (long long *)*sptr;
+	INTEGER_t tmpint;
+	void *tmpintptr = &tmpint;
+
+	(void)opt_codec_ctx;
+	ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
+
+	if(!native) {
+		native = (long long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&tmpint, 0, sizeof tmpint);
+	rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
+				   &tmpintptr, pd);
+	if(rval.code == RC_OK) {
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmpint, (unsigned long long *)native)
+			: asn_INTEGER2long(&tmpint, native))
+			rval.code = RC_FAIL;
+		else
+			ASN_DEBUG("NativeInteger %s got value %lld",
+				td->name, *native);
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+
+	return rval;
+}
+
+asn_dec_rval_t
+NativeInteger_decode_aper(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval;
+	long long *native = (long long *)*sptr;
+	INTEGER_t tmpint;
+	void *tmpintptr = &tmpint;
+
+	(void)opt_codec_ctx;
+	ASN_DEBUG("Decoding NativeInteger %s (APER)", td->name);
+
+	if(!native) {
+		native = (long long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&tmpint, 0, sizeof tmpint);
+	rval = INTEGER_decode_aper(opt_codec_ctx, td, constraints,
+				   &tmpintptr, pd);
+	if(rval.code == RC_OK) {
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmpint, (unsigned long long *)native)
+			: asn_INTEGER2long(&tmpint, native))
+			rval.code = RC_FAIL;
+		else
+			ASN_DEBUG("NativeInteger %s got value %lld",
+				td->name, *native);
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+
+	return rval;
+}
+
+asn_enc_rval_t
+NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_enc_rval_t er;
+	long native;
+	INTEGER_t tmpint;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+
+	native = *(long *)sptr;
+
+	ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
+
+	memset(&tmpint, 0, sizeof(tmpint));
+	if((specs&&specs->field_unsigned)
+		? asn_ulong2INTEGER(&tmpint, native)
+		: asn_long2INTEGER(&tmpint, native))
+		ASN__ENCODE_FAILED;
+	er = INTEGER_encode_uper(td, constraints, &tmpint, po);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+	return er;
+}
+
+asn_enc_rval_t
+NativeInteger_encode_aper(
+	asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_enc_rval_t er;
+	long native;
+	INTEGER_t tmpint;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+
+	native = *(long *)sptr;
+
+	ASN_DEBUG("Encoding NativeInteger %s %ld (APER)", td->name, native);
+
+	memset(&tmpint, 0, sizeof(tmpint));
+	if((specs&&specs->field_unsigned)
+		? asn_ulong2INTEGER(&tmpint, native)
+		: asn_long2INTEGER(&tmpint, native))
+		ASN__ENCODE_FAILED;
+	er = INTEGER_encode_aper(td, constraints, &tmpint, po);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+	return er;
+}
+
+/*
+ * INTEGER specific human-readable output.
+ */
+int
+NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	const long *native = (const long *)sptr;
+	char scratch[32];	/* Enough for 64-bit int */
+	int ret;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(native) {
+		ret = snprintf(scratch, sizeof(scratch),
+			(specs && specs->field_unsigned)
+			? "%lu" : "%ld", *native);
+		assert(ret > 0 && (size_t)ret < sizeof(scratch));
+		return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
+	} else {
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+	}
+}
+
+void
+NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+
+	if(!td || !ptr)
+		return;
+
+	ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
+		td->name, contents_only, ptr);
+
+	if(!contents_only) {
+		FREEMEM(ptr);
+	}
+}
+

lib/asn/asn1c/NativeInteger.h

@@ -0,0 +1,39 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard INTEGER in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeInteger_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef	_NativeInteger_H_
+#define	_NativeInteger_H_
+
+#include <asn_application.h>
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
+
+asn_struct_free_f  NativeInteger_free;
+asn_struct_print_f NativeInteger_print;
+ber_type_decoder_f NativeInteger_decode_ber;
+der_type_encoder_f NativeInteger_encode_der;
+xer_type_decoder_f NativeInteger_decode_xer;
+xer_type_encoder_f NativeInteger_encode_xer;
+per_type_decoder_f NativeInteger_decode_uper;
+per_type_encoder_f NativeInteger_encode_uper;
+per_type_decoder_f NativeInteger_decode_aper;
+per_type_encoder_f NativeInteger_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NativeInteger_H_ */

lib/asn/asn1c/OBJECT_IDENTIFIER.c

@@ -0,0 +1,766 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <INTEGER.h>
+#include <OBJECT_IDENTIFIER.h>
+#include <OCTET_STRING.h>
+#include <limits.h>	/* for CHAR_BIT */
+#include <errno.h>
+
+/*
+ * OBJECT IDENTIFIER basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
+	"OBJECT IDENTIFIER",
+	"OBJECT_IDENTIFIER",
+	ASN__PRIMITIVE_TYPE_free,
+	OBJECT_IDENTIFIER_print,
+	OBJECT_IDENTIFIER_constraint,
+	ber_decode_primitive,
+	der_encode_primitive,
+	OBJECT_IDENTIFIER_decode_xer,
+	OBJECT_IDENTIFIER_encode_xer,
+	OCTET_STRING_decode_uper,
+	OCTET_STRING_encode_uper,
+	OCTET_STRING_decode_aper,
+	OCTET_STRING_encode_aper,
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_OBJECT_IDENTIFIER_tags,
+	sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
+	    / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
+	asn_DEF_OBJECT_IDENTIFIER_tags,	/* Same as above */
+	sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
+	    / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+int
+OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+
+	if(st && st->buf) {
+		if(st->size < 1) {
+			ASN__CTFAIL(app_key, td, sptr,
+				"%s: at least one numerical value "
+				"expected (%s:%d)",
+				td->name, __FILE__, __LINE__);
+			return -1;
+		}
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}
+
+
+int
+OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) {
+	unsigned LE GCC_NOTUSED = 1; /* Little endian (x86) */
+	const uint8_t *arcend = arcbuf + arclen;	/* End of arc */
+	unsigned int cache = 0;	/* No more than 14 significant bits */
+	unsigned char *rvbuf = (unsigned char *)rvbufp;
+	unsigned char *rvstart = rvbuf;	/* Original start of the value buffer */
+	int inc;	/* Return value growth direction */
+
+	rvsize *= CHAR_BIT;	/* bytes to bits */
+	arclen *= 7;		/* bytes to bits */
+
+	/*
+	 * The arc has the number of bits
+	 * cannot be represented using supplied return value type.
+	 */
+	if(arclen > rvsize) {
+		if(arclen > (rvsize + CHAR_BIT)) {
+			errno = ERANGE;	/* Overflow */
+			return -1;
+		} else {
+			/*
+			 * Even if the number of bits in the arc representation
+			 * is higher than the width of supplied * return value
+			 * type, there is still possible to fit it when there
+			 * are few unused high bits in the arc value
+			 * representaion.
+			 * 
+			 * Moreover, there is a possibility that the
+			 * number could actually fit the arc space, given
+			 * that add is negative, but we don't handle
+			 * such "temporary lack of precision" situation here.
+			 * May be considered as a bug.
+			 */
+			uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f;
+			if((*arcbuf & mask)) {
+				errno = ERANGE;	/* Overflow */
+				return -1;
+			}
+			/* Fool the routine computing unused bits */
+			arclen -= 7;
+			cache = *arcbuf & 0x7f;
+			arcbuf++;
+		}
+	}
+
+	/* Faster path for common size */
+	if(rvsize == (CHAR_BIT * sizeof(unsigned long))) {
+		unsigned long accum;
+		/* Gather all bits into the accumulator */
+		for(accum = cache; arcbuf < arcend; arcbuf++)
+			accum = (accum << 7) | (*arcbuf & ~0x80);
+		if(accum < (unsigned)-add) {
+			errno = ERANGE;	/* Overflow */
+			return -1;
+		}
+		*(unsigned long *)(void *)rvbuf = accum + add;	/* alignment OK! */
+		return 0;
+	}
+
+#ifndef	WORDS_BIGENDIAN
+	if(*(unsigned char *)&LE) {	/* Little endian (x86) */
+		/* "Convert" to big endian */
+		rvbuf += rvsize / CHAR_BIT - 1;
+		rvstart--;
+		inc = -1;	/* Descending */
+	} else
+#endif	/* !WORDS_BIGENDIAN */
+		inc = +1;	/* Big endian is known [at compile time] */
+
+	{
+		int bits;	/* typically no more than 3-4 bits */
+
+		/* Clear the high unused bits */
+		for(bits = rvsize - arclen;
+			bits > CHAR_BIT;
+				rvbuf += inc, bits -= CHAR_BIT)
+				*rvbuf = 0;
+
+		/* Fill the body of a value */
+		for(; arcbuf < arcend; arcbuf++) {
+			cache = (cache << 7) | (*arcbuf & 0x7f);
+			bits += 7;
+			if(bits >= CHAR_BIT) {
+				bits -= CHAR_BIT;
+				*rvbuf = (cache >> bits);
+				rvbuf += inc;
+			}
+		}
+		if(bits) {
+			*rvbuf = cache;
+			rvbuf += inc;
+		}
+	}
+
+	if(add) {
+		for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) {
+			int v = add + *rvbuf;
+			if(v & ((unsigned)~0 << CHAR_BIT)) {
+				*rvbuf = (unsigned char)(v + (1 << CHAR_BIT));
+				add = -1;
+			} else {
+				*rvbuf = v;
+				break;
+			}
+		}
+		if(rvbuf == rvstart) {
+			/* No space to carry over */
+			errno = ERANGE;	/* Overflow */
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+ssize_t
+OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	char scratch[64];	/* Conservative estimate */
+	unsigned long accum;	/* Bits accumulator */
+	char *p;		/* Position in the scratch buffer */
+
+	if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add,
+			&accum, sizeof(accum)))
+		return -1;
+
+	if(accum) {
+		ssize_t len;
+
+		/* Fill the scratch buffer in reverse. */
+		p = scratch + sizeof(scratch);
+		for(; accum; accum /= 10)
+			*(--p) = (char)(accum % 10) + 0x30; /* Put a digit */
+
+		len = sizeof(scratch) - (p - scratch);
+		if(cb(p, len, app_key) < 0)
+			return -1;
+		return len;
+	} else {
+		*scratch = 0x30;
+		if(cb(scratch, 1, app_key) < 0)
+			return -1;
+		return 1;
+	}
+}
+
+int
+OBJECT_IDENTIFIER_print_arc(const uint8_t *arcbuf, int arclen, int add,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+
+	if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0)
+		return -1;
+
+	return 0;
+}
+
+static ssize_t
+OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
+	ssize_t wrote_len = 0;
+	int startn;
+	int add = 0;
+	int i;
+
+	for(i = 0, startn = 0; i < st->size; i++) {
+		uint8_t b = st->buf[i];
+		if((b & 0x80))			/* Continuation expected */
+			continue;
+
+		if(startn == 0) {
+			/*
+			 * First two arcs are encoded through the backdoor.
+			 */
+			if(i) {
+				add = -80;
+				if(cb("2", 1, app_key) < 0) return -1;
+			} else if(b <= 39) {
+				add = 0;
+				if(cb("0", 1, app_key) < 0) return -1;
+			} else if(b < 79) {
+				add = -40;
+				if(cb("1", 1, app_key) < 0) return -1;
+			} else {
+				add = -80;
+				if(cb("2", 1, app_key) < 0) return -1;
+			}
+			wrote_len += 1;
+		}
+
+		if(cb(".", 1, app_key) < 0)	/* Separate arcs */
+			return -1;
+
+		add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn],
+				i - startn + 1, add, cb, app_key);
+		if(add < 0) return -1;
+		wrote_len += 1 + add;
+		startn = i + 1;
+		add = 0;
+	}
+
+	return wrote_len;
+}
+
+static enum xer_pbd_rval
+OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
+	OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
+	const char *chunk_end = (const char *)chunk_buf + chunk_size;
+	const char *endptr;
+	long s_arcs[10];
+	long *arcs = s_arcs;
+	int arcs_count;
+	int ret;
+
+	(void)td;
+
+	arcs_count = OBJECT_IDENTIFIER_parse_arcs(
+		(const char *)chunk_buf, chunk_size, arcs,
+			sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr);
+	if(arcs_count < 0) {
+		/* Expecting more than zero arcs */
+		return XPBD_BROKEN_ENCODING;
+	} else if(arcs_count == 0) {
+		return XPBD_NOT_BODY_IGNORE;
+	}
+	assert(endptr == chunk_end);
+
+	if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) {
+		arcs = (long *)MALLOC(arcs_count * sizeof(long));
+		if(!arcs) return XPBD_SYSTEM_FAILURE;
+		ret = OBJECT_IDENTIFIER_parse_arcs(
+			(const char *)chunk_buf, chunk_size,
+			arcs, arcs_count, &endptr);
+		if(ret != arcs_count)
+			return XPBD_SYSTEM_FAILURE;	/* assert?.. */
+	}
+
+	/*
+	 * Convert arcs into BER representation.
+	 */
+	ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count);
+	if(arcs != s_arcs) FREEMEM(arcs);
+
+	return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
+}
+
+asn_dec_rval_t
+OBJECT_IDENTIFIER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+
+	return xer_decode_primitive(opt_codec_ctx, td,
+		sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
+			buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
+}
+
+asn_enc_rval_t
+OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+	asn_enc_rval_t er;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!st || !st->buf)
+		ASN__ENCODE_FAILED;
+
+	er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
+	if(er.encoded < 0) ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+int
+OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
+	int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(!st || !st->buf)
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+	/* Dump preamble */
+	if(cb("{ ", 2, app_key) < 0)
+		return -1;
+
+	if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0)
+		return -1;
+
+	return (cb(" }", 2, app_key) < 0) ? -1 : 0;
+}
+
+int
+OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *oid, void *arcs,
+		unsigned int arc_type_size, unsigned int arc_slots) {
+	void *arcs_end = (char *)arcs + (arc_type_size * arc_slots);
+	int num_arcs = 0;
+	int startn = 0;
+	int add = 0;
+	int i;
+
+	if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	for(i = 0; i < oid->size; i++) {
+		uint8_t b = oid->buf[i];
+		if((b & 0x80))			/* Continuation expected */
+			continue;
+
+		if(num_arcs == 0) {
+			/*
+			 * First two arcs are encoded through the backdoor.
+			 */
+			unsigned LE = 1;	/* Little endian */
+			int first_arc;
+			num_arcs++;
+			if(!arc_slots) { num_arcs++; continue; }
+
+			if(i) first_arc = 2;
+			else if(b <= 39) first_arc = 0;
+			else if(b < 79)	first_arc = 1;
+			else first_arc = 2;
+
+			add = -40 * first_arc;
+			memset(arcs, 0, arc_type_size);
+			*(unsigned char *)((char *)arcs
+				+ ((*(char *)&LE)?0:(arc_type_size - 1)))
+					= first_arc;
+			arcs = ((char *)arcs) + arc_type_size;
+		}
+
+		/* Decode, if has space */
+		if(arcs < arcs_end) {
+			if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn],
+				i - startn + 1, add,
+					arcs, arc_type_size))
+				return -1;
+			startn = i + 1;
+			arcs = ((char *)arcs) + arc_type_size;
+			add = 0;
+		}
+		num_arcs++;
+	}
+
+	return num_arcs;
+}
+
+
+/*
+ * Save the single value as an object identifier arc.
+ */
+int
+OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) {
+	/*
+	 * The following conditions must hold:
+	 * assert(arcval);
+	 * assert(arcval_size > 0);
+	 * assert(arcval_size <= 16);
+	 * assert(arcbuf);
+	 */
+#ifdef	WORDS_BIGENDIAN
+	const unsigned isLittleEndian = 0;
+#else
+	unsigned LE = 1;
+	unsigned isLittleEndian = *(char *)&LE;
+#endif
+	const uint8_t *tend, *tp;
+	unsigned int cache;
+	uint8_t *bp = arcbuf;
+	int bits;
+	uint8_t buffer[16];
+
+	if(isLittleEndian && !prepared_order) {
+		const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1;
+		const uint8_t *aend = (const uint8_t *)arcval;
+		uint8_t *msb = buffer + arcval_size - 1;
+		uint8_t *tb;
+		for(tb = buffer; a >= aend; tb++, a--)
+			if((*tb = *a) && (tb < msb))
+				msb = tb;
+		tend = &buffer[arcval_size];
+		tp = msb;	/* Most significant non-zero byte */
+	} else {
+		/* Look for most significant non-zero byte */
+		tend = (const unsigned char *)arcval + arcval_size;
+		for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++)
+			if(*tp) break;
+	}
+
+	/*
+	 * Split the value in 7-bits chunks.
+	 */
+	bits = ((tend - tp) * CHAR_BIT) % 7;
+	if(bits) {
+		cache = *tp >> (CHAR_BIT - bits);
+		if(cache) {
+			*bp++ = cache | 0x80;
+			cache = *tp++;
+			bits = CHAR_BIT - bits;
+		} else {
+			bits = -bits;
+		}
+	} else {
+		cache = 0;
+	}
+	for(; tp < tend; tp++) {
+		cache = (cache << CHAR_BIT) + *tp;
+		bits += CHAR_BIT;
+		while(bits >= 7) {
+			bits -= 7;
+			*bp++ = 0x80 | (cache >> bits);
+		}
+	}
+	if(bits) *bp++ = cache;
+	bp[-1] &= 0x7f;	/* Clear the last bit */
+
+	return bp - arcbuf;
+}
+
+int
+OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
+	uint8_t *buf;
+	uint8_t *bp;
+	unsigned LE = 1;	/* Little endian (x86) */
+	unsigned isLittleEndian = *((char *)&LE);
+	unsigned int arc0;
+	unsigned int arc1;
+	unsigned size;
+	unsigned i;
+
+	if(!oid || !arcs || arc_type_size < 1
+	|| arc_type_size > 16
+	|| arc_slots < 2) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch(arc_type_size) {
+	case sizeof(char):
+		arc0 = ((const unsigned char *)arcs)[0];
+		arc1 = ((const unsigned char *)arcs)[1];
+		break;
+	case sizeof(short):
+		arc0 = ((const unsigned short *)arcs)[0];
+		arc1 = ((const unsigned short *)arcs)[1];
+		break;
+	case sizeof(int):
+		arc0 = ((const unsigned int *)arcs)[0];
+		arc1 = ((const unsigned int *)arcs)[1];
+		break;
+	default:
+		arc1 = arc0 = 0;
+		if(isLittleEndian) {	/* Little endian (x86) */
+			const unsigned char *ps, *pe;
+			/* If more significant bytes are present,
+			 * make them > 255 quick */
+			for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size;
+					ps < pe; ps++)
+				arc0 |= *ps, arc1 |= *(ps + arc_type_size);
+			arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT;
+			arc0 = *((const unsigned char *)arcs + 0);
+			arc1 = *((const unsigned char *)arcs + arc_type_size);
+		} else {
+			const unsigned char *ps, *pe;
+			/* If more significant bytes are present,
+			 * make them > 255 quick */
+			for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++)
+				arc0 |= *ps, arc1 |= *(ps + arc_type_size);
+			arc0 = *((const unsigned char *)arcs + arc_type_size - 1);
+			arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1);
+		}
+	}
+
+	/*
+	 * The previous chapter left us with the first and the second arcs.
+	 * The values are not precise (that is, they are valid only if
+	 * they're less than 255), but OK for the purposes of making
+	 * the sanity test below.
+	 */
+	if(arc0 <= 1) {
+		if(arc1 >= 39) {
+			/* 8.19.4: At most 39 subsequent values (including 0) */
+			errno = ERANGE;
+			return -1;
+		}
+	} else if(arc0 > 2) {
+		/* 8.19.4: Only three values are allocated from the root node */
+		errno = ERANGE;
+		return -1;
+	}
+	/*
+	 * After above tests it is known that the value of arc0 is completely
+	 * trustworthy (0..2). However, the arc1's value is still meaningless.
+	 */
+
+	/*
+	 * Roughly estimate the maximum size necessary to encode these arcs.
+	 * This estimation implicitly takes in account the following facts,
+	 * that cancel each other:
+	 * 	* the first two arcs are encoded in a single value.
+	 * 	* the first value may require more space (+1 byte)
+	 * 	* the value of the first arc which is in range (0..2)
+	 */
+	size = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots;
+	bp = buf = (uint8_t *)MALLOC(size + 1);
+	if(!buf) {
+		/* ENOMEM */
+		return -1;
+	}
+
+	/*
+	 * Encode the first two arcs.
+	 * These require special treatment.
+	 */
+	{
+		uint8_t *tp;
+		uint8_t first_value[1 + 16];	/* of two arcs */
+		uint8_t *fv = first_value;
+
+		/*
+		 * Simulate first_value = arc0 * 40 + arc1;
+		 */
+		/* Copy the second (1'st) arcs[1] into the first_value */
+		*fv++ = 0;
+		arcs = ((const char *)arcs) + arc_type_size;
+		if(isLittleEndian) {
+			const uint8_t *aend = (const unsigned char *)arcs - 1;
+			const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1;
+			for(; a1 > aend; fv++, a1--) *fv = *a1;
+		} else {
+			const uint8_t *a1 = (const uint8_t *)arcs;
+			const uint8_t *aend = a1 + arc_type_size;
+			for(; a1 < aend; fv++, a1++) *fv = *a1;
+		}
+		/* Increase the first_value by arc0 */
+		arc0 *= 40;	/* (0..80) */
+		for(tp = first_value + arc_type_size; tp >= first_value; tp--) {
+			unsigned int v = *tp;
+			v += arc0;
+			*tp = v;
+			if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT;
+			else break;
+		}
+
+		assert(tp >= first_value);
+
+		bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value,
+			fv - first_value, 1);
+ 	}
+
+	/*
+	 * Save the rest of arcs.
+	 */
+	for(arcs = ((const char *)arcs) + arc_type_size, i = 2;
+		i < arc_slots;
+			i++, arcs = ((const char *)arcs) + arc_type_size) {
+		bp += OBJECT_IDENTIFIER_set_single_arc(bp,
+			arcs, arc_type_size, 0);
+	}
+
+	assert((unsigned)(bp - buf) <= size);
+
+	/*
+	 * Replace buffer.
+	 */
+	oid->size = bp - buf;
+	bp = oid->buf;
+	oid->buf = buf;
+	if(bp) FREEMEM(bp);
+
+	return 0;
+}
+
+
+int
+OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
+	long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) {
+	unsigned int arcs_count = 0;
+	const char *oid_end;
+	enum {
+		ST_LEADSPACE,
+		ST_TAILSPACE,
+		ST_AFTERVALUE,	/* Next character ought to be '.' or a space */
+		ST_WAITDIGITS 	/* Next character is expected to be a digit */
+	} state = ST_LEADSPACE;
+
+	if(!oid_text || oid_txt_length < -1 || (arcs_slots && !arcs)) {
+		if(opt_oid_text_end) *opt_oid_text_end = oid_text;
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(oid_txt_length == -1)
+		oid_txt_length = strlen(oid_text);
+
+#define	_OID_CAPTURE_ARC(oid_text, oid_end)		do {	\
+	const char *endp = oid_end;				\
+	long long value;						\
+	switch(asn_strtol_lim(oid_text, &endp, &value)) {	\
+	case ASN_STRTOL_EXTRA_DATA:				\
+	case ASN_STRTOL_OK:					\
+		if(arcs_count < arcs_slots)			\
+			arcs[arcs_count] = value;		\
+		arcs_count++;					\
+		oid_text = endp - 1;				\
+		break;						\
+	case ASN_STRTOL_ERROR_RANGE:				\
+		if(opt_oid_text_end)				\
+			*opt_oid_text_end = oid_text;		\
+		errno = ERANGE;					\
+		return -1;					\
+	case ASN_STRTOL_ERROR_INVAL:				\
+	case ASN_STRTOL_EXPECT_MORE:				\
+		if(opt_oid_text_end)				\
+			*opt_oid_text_end = oid_text;		\
+		errno = EINVAL;					\
+		return -1;					\
+	}							\
+  } while(0)
+
+	for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
+	    switch(*oid_text) {
+	    case 0x09: case 0x0a: case 0x0d: case 0x20:	/* whitespace */
+		switch(state) {
+		case ST_LEADSPACE:
+		case ST_TAILSPACE:
+			continue;
+		case ST_AFTERVALUE:
+			state = ST_TAILSPACE;
+			continue;
+		case ST_WAITDIGITS:
+			break;	/* Digits expected after ".", got whitespace */
+		}
+		break;
+	    case 0x2e:	/* '.' */
+		switch(state) {
+		case ST_LEADSPACE:
+		case ST_TAILSPACE:
+		case ST_WAITDIGITS:
+			if(opt_oid_text_end)
+				*opt_oid_text_end = oid_text;
+			errno = EINVAL;	/* Broken OID */
+			return -1;
+			break;
+		case ST_AFTERVALUE:
+			state = ST_WAITDIGITS;
+			continue;
+		}
+		break;
+	    case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
+	    case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
+		switch(state) {
+		case ST_TAILSPACE:
+		case ST_AFTERVALUE:
+			if(opt_oid_text_end)
+				*opt_oid_text_end = oid_text;
+			errno = EINVAL;	/* "1. 1" => broken OID */
+			return -1;
+		case ST_LEADSPACE:
+		case ST_WAITDIGITS:
+			_OID_CAPTURE_ARC(oid_text, oid_end);
+			state = ST_AFTERVALUE;
+			continue;
+		}
+		break;
+	    default:
+		/* Unexpected symbols */
+		state = ST_WAITDIGITS;
+		break;
+	    } /* switch() */
+	    break;
+	} /* for() */
+
+
+	if(opt_oid_text_end) *opt_oid_text_end = oid_text;
+
+	/* Finalize last arc */
+	switch(state) {
+	case ST_LEADSPACE:
+		return 0; /* No OID found in input data */
+	case ST_WAITDIGITS:
+		errno = EINVAL;	/* Broken OID */
+		return -1;
+	case ST_AFTERVALUE:
+	case ST_TAILSPACE:
+		return arcs_count;
+	}
+
+	errno = EINVAL;	/* Broken OID */
+	return -1;
+}
+
+

lib/asn/asn1c/OBJECT_IDENTIFIER.h

@@ -0,0 +1,139 @@
+/*-
+ * Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
+ * 	All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_OBJECT_IDENTIFIER_H_
+#define	_OBJECT_IDENTIFIER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t OBJECT_IDENTIFIER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER;
+
+asn_struct_print_f OBJECT_IDENTIFIER_print;
+asn_constr_check_f OBJECT_IDENTIFIER_constraint;
+der_type_encoder_f OBJECT_IDENTIFIER_encode_der;
+xer_type_decoder_f OBJECT_IDENTIFIER_decode_xer;
+xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer;
+
+/**********************************
+ * Some handy conversion routines *
+ **********************************/
+
+/*
+ * This function fills an (_arcs) array with OBJECT IDENTIFIER arcs
+ * up to specified (_arc_slots) elements.
+ * 
+ * EXAMPLE:
+ * 	void print_arcs(OBJECT_IDENTIFIER_t *oid) {
+ * 		unsigned long fixed_arcs[10];	// Try with fixed space first
+ * 		unsigned long *arcs = fixed_arcs;
+ * 		int arc_type_size = sizeof(fixed_arcs[0]);	// sizeof(long)
+ * 		int arc_slots = sizeof(fixed_arcs)/sizeof(fixed_arcs[0]); // 10
+ * 		int count;	// Real number of arcs.
+ * 		int i;
+ * 
+ * 		count = OBJECT_IDENTIFIER_get_arcs(oid, arcs,
+ * 			arc_type_size, arc_slots);
+ * 		// If necessary, reallocate arcs array and try again.
+ * 		if(count > arc_slots) {
+ * 			arc_slots = count;
+ * 			arcs = malloc(arc_type_size * arc_slots);
+ * 			if(!arcs) return;
+ * 			count = OBJECT_IDENTIFIER_get_arcs(oid, arcs,
+ * 				arc_type_size, arc_slots);
+ * 			assert(count == arc_slots);
+ * 		}
+ * 
+ * 		// Print the contents of the arcs array.
+ * 		for(i = 0; i < count; i++)
+ * 			printf("%d\n", arcs[i]);
+ * 
+ * 		// Avoid memory leak.
+ * 		if(arcs != fixed_arcs) free(arcs);
+ * 	}
+ * 
+ * RETURN VALUES:
+ * -1/EINVAL:	Invalid arguments (oid is missing)
+ * -1/ERANGE:	One or more arcs have value out of array cell type range.
+ * >=0:		Number of arcs contained in the OBJECT IDENTIFIER
+ * 
+ * WARNING: The function always returns the real number of arcs,
+ * even if there is no sufficient (_arc_slots) provided.
+ */
+int OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *_oid,
+	void *_arcs,			/* e.g., unsigned int arcs[N] */
+	unsigned int _arc_type_size,	/* e.g., sizeof(arcs[0]) */
+	unsigned int _arc_slots		/* e.g., N */);
+
+/*
+ * This functions initializes the OBJECT IDENTIFIER object with
+ * the given set of arcs.
+ * The minimum of two arcs must be present; some restrictions apply.
+ * RETURN VALUES:
+ * -1/EINVAL:	Invalid arguments
+ * -1/ERANGE:	The first two arcs do not conform to ASN.1 restrictions.
+ * -1/ENOMEM:	Memory allocation failed
+ * 0:		The object was initialized with new arcs.
+ */
+int OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *_oid,
+	const void *_arcs,		/* e.g., unsigned int arcs[N] */
+	unsigned int _arc_type_size,	/* e.g., sizeof(arcs[0]) */
+	unsigned int _arc_slots		/* e.g., N */);
+
+/*
+ * Print the specified OBJECT IDENTIFIER arc.
+ */
+int OBJECT_IDENTIFIER_print_arc(const uint8_t *arcbuf, int arclen,
+	int add, /* Arbitrary offset, required to process the first two arcs */
+	asn_app_consume_bytes_f *cb, void *app_key);
+
+/* Same as above, but returns the number of written digits, instead of 0 */
+ssize_t OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
+	asn_app_consume_bytes_f *cb, void *app_key);
+
+/*
+ * Parse the OBJECT IDENTIFIER textual representation ("1.3.6.1.4.1.9363").
+ * No arc can exceed the (0..signed_long_max) range (typically, 0..2G if L32).
+ * This function is not specific to OBJECT IDENTIFIER, it may be used to parse
+ * the RELATIVE-OID data, or any other data consisting of dot-separated
+ * series of numeric values.
+ *
+ * If (oid_txt_length == -1), the strlen() will be invoked to determine the
+ * size of the (oid_text) string.
+ * 
+ * After return, the optional (opt_oid_text_end) is set to the character after
+ * the last parsed one. (opt_oid_text_end) is never less than (oid_text).
+ * 
+ * RETURN VALUES:
+ *   -1:	Parse error.
+ * >= 0:	Number of arcs contained in the OBJECT IDENTIFIER.
+ * 
+ * WARNING: The function always returns the real number of arcs,
+ * even if there is no sufficient (_arc_slots) provided.
+ * This is useful for (_arc_slots) value estimation.
+ */
+int OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
+	long arcs[], unsigned int arcs_slots, const char **opt_oid_text_end);
+
+/*
+ * Internal functions.
+ * Used by RELATIVE-OID implementation in particular.
+ */
+int OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen,
+	signed int add, void *value, unsigned int value_size);
+int OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf,
+	const void *arcval, unsigned int arcval_size, int _prepared_order);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _OBJECT_IDENTIFIER_H_ */

lib/asn/asn1c/OCTET_STRING.h

@@ -0,0 +1,88 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_OCTET_STRING_H_
+#define	_OCTET_STRING_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OCTET_STRING {
+	uint8_t *buf;	/* Buffer with consecutive OCTET_STRING bits */
+	int size;	/* Size of the buffer */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} OCTET_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING;
+
+asn_struct_free_f OCTET_STRING_free;
+asn_struct_print_f OCTET_STRING_print;
+asn_struct_print_f OCTET_STRING_print_utf8;
+ber_type_decoder_f OCTET_STRING_decode_ber;
+der_type_encoder_f OCTET_STRING_encode_der;
+xer_type_decoder_f OCTET_STRING_decode_xer_hex;		/* Hexadecimal */
+xer_type_decoder_f OCTET_STRING_decode_xer_binary;	/* 01010111010 */
+xer_type_decoder_f OCTET_STRING_decode_xer_utf8;	/* ASCII/UTF-8 */
+xer_type_encoder_f OCTET_STRING_encode_xer;
+xer_type_encoder_f OCTET_STRING_encode_xer_utf8;
+per_type_decoder_f OCTET_STRING_decode_uper;
+per_type_encoder_f OCTET_STRING_encode_uper;
+per_type_decoder_f OCTET_STRING_decode_aper;
+per_type_encoder_f OCTET_STRING_encode_aper;
+
+/******************************
+ * Handy conversion routines. *
+ ******************************/
+
+/*
+ * This function clears the previous value of the OCTET STRING (if any)
+ * and then allocates a new memory with the specified content (str/size).
+ * If size = -1, the size of the original string will be determined
+ * using strlen(str).
+ * If str equals to NULL, the function will silently clear the
+ * current contents of the OCTET STRING.
+ * Returns 0 if it was possible to perform operation, -1 otherwise.
+ */
+int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size);
+
+/* Handy conversion from the C string into the OCTET STRING. */
+#define	OCTET_STRING_fromString(s, str)	OCTET_STRING_fromBuf(s, str, -1)
+
+/*
+ * Allocate and fill the new OCTET STRING and return a pointer to the newly
+ * allocated object. NULL is permitted in str: the function will just allocate
+ * empty OCTET STRING.
+ */
+OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td,
+	const char *str, int size);
+
+/****************************
+ * Internally useful stuff. *
+ ****************************/
+
+typedef const struct asn_OCTET_STRING_specifics_s {
+	/*
+	 * Target structure description.
+	 */
+	int struct_size;	/* Size of the structure */
+	int ctx_offset;		/* Offset of the asn_struct_ctx_t member */
+
+	enum asn_OS_Subvariant {
+		ASN_OSUBV_ANY,	/* The open type (ANY) */
+		ASN_OSUBV_BIT,	/* BIT STRING */
+		ASN_OSUBV_STR,	/* String types, not {BMP,Universal}String  */
+		ASN_OSUBV_U16,	/* 16-bit character (BMPString) */
+		ASN_OSUBV_U32	/* 32-bit character (UniversalString) */
+	} subvariant;
+} asn_OCTET_STRING_specifics_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _OCTET_STRING_H_ */

lib/asn/asn1c/PrintableString.c

@@ -0,0 +1,111 @@
+/*-
+ * Copyright (c) 2003, 2004, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <PrintableString.h>
+
+/*
+ * ASN.1:1984 (X.409)
+ */
+static const int _PrintableString_alphabet[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int _PrintableString_code2value[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122};
+
+/*
+ * PrintableString basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_PrintableString_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (19 << 2)),	/* [UNIVERSAL 19] IMPLICIT ...*/
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))	/* ... OCTET STRING */
+};
+static int asn_DEF_PrintableString_v2c(unsigned int value) {
+	return _PrintableString_alphabet[value > 255 ? 0 : value] - 1;
+}
+static int asn_DEF_PrintableString_c2v(unsigned int code) {
+	if(code < 74)
+		return _PrintableString_code2value[code];
+	return -1;
+}
+static const asn_per_constraints_t asn_DEF_PrintableString_constraints = {
+	{ APC_CONSTRAINED, 4, 4, 0x20, 0x39 },	/* Value */
+	{ APC_SEMI_CONSTRAINED, -1, -1, 0, 0 },	/* Size */
+	asn_DEF_PrintableString_v2c,
+	asn_DEF_PrintableString_c2v
+};
+asn_TYPE_descriptor_t asn_DEF_PrintableString = {
+	"PrintableString",
+	"PrintableString",
+	OCTET_STRING_free,
+	OCTET_STRING_print_utf8,	/* ASCII subset */
+	PrintableString_constraint,
+	OCTET_STRING_decode_ber,      /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_encode_der,
+	OCTET_STRING_decode_xer_utf8,
+	OCTET_STRING_encode_xer_utf8,
+	OCTET_STRING_decode_uper,
+	OCTET_STRING_encode_uper,
+	OCTET_STRING_decode_aper,
+	OCTET_STRING_encode_aper,
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_PrintableString_tags,
+	sizeof(asn_DEF_PrintableString_tags)
+	  / sizeof(asn_DEF_PrintableString_tags[0]) - 1,
+	asn_DEF_PrintableString_tags,
+	sizeof(asn_DEF_PrintableString_tags)
+	  / sizeof(asn_DEF_PrintableString_tags[0]),
+	&asn_DEF_PrintableString_constraints,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+int
+PrintableString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+
+	if(st && st->buf) {
+		uint8_t *buf = st->buf;
+		uint8_t *end = buf + st->size;
+
+		/*
+		 * Check the alphabet of the PrintableString.
+		 * ASN.1:1984 (X.409)
+		 */
+		for(; buf < end; buf++) {
+			if(!_PrintableString_alphabet[*buf]) {
+				ASN__CTFAIL(app_key, td, sptr,
+					"%s: value byte %ld (%d) "
+					"not in PrintableString alphabet "
+					"(%s:%d)",
+					td->name,
+					(long)((buf - st->buf) + 1),
+					*buf,
+					__FILE__, __LINE__);
+				return -1;
+			}
+		}
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}

lib/asn/asn1c/PrintableString.h

@@ -0,0 +1,24 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_PrintableString_H_
+#define	_PrintableString_H_
+
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef OCTET_STRING_t PrintableString_t;  /* Implemented via OCTET STRING */
+
+extern asn_TYPE_descriptor_t asn_DEF_PrintableString;
+
+asn_constr_check_f PrintableString_constraint;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _PrintableString_H_ */

lib/asn/asn1c/PrivateIE-Container.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "PrivateIE-Container.h"
+
+static asn_per_constraints_t asn_PER_type_PrivateIE_Container_5768P0_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_PrivateIE_Container_5768P0_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_PrivateIE_Field_5772P0,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_PrivateIE_Container_5768P0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_PrivateIE_Container_5768P0_specs_1 = {
+	sizeof(struct PrivateIE_Container_5768P0),
+	offsetof(struct PrivateIE_Container_5768P0, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_PrivateIE_Container_5768P0 = {
+	"PrivateIE-Container",
+	"PrivateIE-Container",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PrivateIE_Container_5768P0_tags_1,
+	sizeof(asn_DEF_PrivateIE_Container_5768P0_tags_1)
+		/sizeof(asn_DEF_PrivateIE_Container_5768P0_tags_1[0]), /* 1 */
+	asn_DEF_PrivateIE_Container_5768P0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PrivateIE_Container_5768P0_tags_1)
+		/sizeof(asn_DEF_PrivateIE_Container_5768P0_tags_1[0]), /* 1 */
+	&asn_PER_type_PrivateIE_Container_5768P0_constr_1,
+	asn_MBR_PrivateIE_Container_5768P0_1,
+	1,	/* Single element */
+	&asn_SPC_PrivateIE_Container_5768P0_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/PrivateIE-Container.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_PrivateIE_Container_H_
+#define	_PrivateIE_Container_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct PrivateIE_Field;
+
+/* PrivateIE-Container */
+typedef struct PrivateIE_Container_5768P0 {
+	A_SEQUENCE_OF(struct PrivateIE_Field) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} PrivateIE_Container_5768P0_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_PrivateIE_Container_5768P0;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "PrivateIE-Field.h"
+
+#endif	/* _PrivateIE_Container_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/PrivateIE-Field.c

@@ -0,0 +1,154 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "PrivateIE-Field.h"
+
+static int
+memb_id_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+static int
+memb_criticality_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+static int
+memb_value_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+static asn_per_constraints_t asn_PER_memb_id_constr_2 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 1,  1,  0l,  1l }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_criticality_constr_3 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0l,  2l }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_value_constr_4 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_PrivateIE_Field_5772P0_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct PrivateIE_Field_5772P0, id),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_S1ap_PrivateIE_ID,
+		memb_id_constraint_1,
+		&asn_PER_memb_id_constr_2,
+		0,
+		"id"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct PrivateIE_Field_5772P0, criticality),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_Criticality,
+		memb_criticality_constraint_1,
+		&asn_PER_memb_criticality_constr_3,
+		0,
+		"criticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct PrivateIE_Field_5772P0, value),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ANY,
+		memb_value_constraint_1,
+		&asn_PER_memb_value_constr_4,
+		0,
+		"value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_PrivateIE_Field_5772P0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_PrivateIE_Field_5772P0_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_PrivateIE_Field_5772P0_specs_1 = {
+	sizeof(struct PrivateIE_Field_5772P0),
+	offsetof(struct PrivateIE_Field_5772P0, _asn_ctx),
+	asn_MAP_PrivateIE_Field_5772P0_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_PrivateIE_Field_5772P0 = {
+	"PrivateIE-Field",
+	"PrivateIE-Field",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PrivateIE_Field_5772P0_tags_1,
+	sizeof(asn_DEF_PrivateIE_Field_5772P0_tags_1)
+		/sizeof(asn_DEF_PrivateIE_Field_5772P0_tags_1[0]), /* 1 */
+	asn_DEF_PrivateIE_Field_5772P0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PrivateIE_Field_5772P0_tags_1)
+		/sizeof(asn_DEF_PrivateIE_Field_5772P0_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_PrivateIE_Field_5772P0_1,
+	3,	/* Elements count */
+	&asn_SPC_PrivateIE_Field_5772P0_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/PrivateIE-Field.h

@@ -0,0 +1,42 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_PrivateIE_Field_H_
+#define	_PrivateIE_Field_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-PrivateIE-ID.h"
+#include "S1ap-Criticality.h"
+#include <ANY.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* PrivateIE-Field */
+typedef struct PrivateIE_Field_5772P0 {
+	S1ap_PrivateIE_ID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 value;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} PrivateIE_Field_5772P0_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_PrivateIE_Field_5772P0;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _PrivateIE_Field_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolError-S1ap-IE-ContainerList.c

@@ -0,0 +1,9 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Contents"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolError-S1ap-IE-ContainerList.h"
+

lib/asn/asn1c/ProtocolError-S1ap-IE-ContainerList.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Contents"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolError_S1ap_IE_ContainerList_H_
+#define	_ProtocolError_S1ap_IE_ContainerList_H_
+
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolError_S1ap_IE_ContainerList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolExtensionContainer.h

@@ -0,0 +1,569 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolExtensionContainer_H_
+#define	_ProtocolExtensionContainer_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionField;
+
+/* ProtocolExtensionContainer */
+typedef struct ProtocolExtensionContainer_5749P0 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P0_t;
+typedef struct ProtocolExtensionContainer_5749P1 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P1_t;
+typedef struct ProtocolExtensionContainer_5749P2 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P2_t;
+typedef struct ProtocolExtensionContainer_5749P3 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P3_t;
+typedef struct ProtocolExtensionContainer_5749P4 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P4_t;
+typedef struct ProtocolExtensionContainer_5749P5 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P5_t;
+typedef struct ProtocolExtensionContainer_5749P6 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P6_t;
+typedef struct ProtocolExtensionContainer_5749P7 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P7_t;
+typedef struct ProtocolExtensionContainer_5749P8 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P8_t;
+typedef struct ProtocolExtensionContainer_5749P9 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P9_t;
+typedef struct ProtocolExtensionContainer_5749P10 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P10_t;
+typedef struct ProtocolExtensionContainer_5749P11 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P11_t;
+typedef struct ProtocolExtensionContainer_5749P12 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P12_t;
+typedef struct ProtocolExtensionContainer_5749P13 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P13_t;
+typedef struct ProtocolExtensionContainer_5749P14 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P14_t;
+typedef struct ProtocolExtensionContainer_5749P15 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P15_t;
+typedef struct ProtocolExtensionContainer_5749P16 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P16_t;
+typedef struct ProtocolExtensionContainer_5749P17 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P17_t;
+typedef struct ProtocolExtensionContainer_5749P18 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P18_t;
+typedef struct ProtocolExtensionContainer_5749P19 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P19_t;
+typedef struct ProtocolExtensionContainer_5749P20 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P20_t;
+typedef struct ProtocolExtensionContainer_5749P21 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P21_t;
+typedef struct ProtocolExtensionContainer_5749P22 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P22_t;
+typedef struct ProtocolExtensionContainer_5749P23 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P23_t;
+typedef struct ProtocolExtensionContainer_5749P24 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P24_t;
+typedef struct ProtocolExtensionContainer_5749P25 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P25_t;
+typedef struct ProtocolExtensionContainer_5749P26 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P26_t;
+typedef struct ProtocolExtensionContainer_5749P27 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P27_t;
+typedef struct ProtocolExtensionContainer_5749P28 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P28_t;
+typedef struct ProtocolExtensionContainer_5749P29 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P29_t;
+typedef struct ProtocolExtensionContainer_5749P30 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P30_t;
+typedef struct ProtocolExtensionContainer_5749P31 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P31_t;
+typedef struct ProtocolExtensionContainer_5749P32 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P32_t;
+typedef struct ProtocolExtensionContainer_5749P33 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P33_t;
+typedef struct ProtocolExtensionContainer_5749P34 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P34_t;
+typedef struct ProtocolExtensionContainer_5749P35 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P35_t;
+typedef struct ProtocolExtensionContainer_5749P36 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P36_t;
+typedef struct ProtocolExtensionContainer_5749P37 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P37_t;
+typedef struct ProtocolExtensionContainer_5749P38 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P38_t;
+typedef struct ProtocolExtensionContainer_5749P39 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P39_t;
+typedef struct ProtocolExtensionContainer_5749P40 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P40_t;
+typedef struct ProtocolExtensionContainer_5749P41 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P41_t;
+typedef struct ProtocolExtensionContainer_5749P42 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P42_t;
+typedef struct ProtocolExtensionContainer_5749P43 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P43_t;
+typedef struct ProtocolExtensionContainer_5749P44 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P44_t;
+typedef struct ProtocolExtensionContainer_5749P45 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P45_t;
+typedef struct ProtocolExtensionContainer_5749P46 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P46_t;
+typedef struct ProtocolExtensionContainer_5749P47 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P47_t;
+typedef struct ProtocolExtensionContainer_5749P48 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P48_t;
+typedef struct ProtocolExtensionContainer_5749P49 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P49_t;
+typedef struct ProtocolExtensionContainer_5749P50 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P50_t;
+typedef struct ProtocolExtensionContainer_5749P51 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P51_t;
+typedef struct ProtocolExtensionContainer_5749P52 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P52_t;
+typedef struct ProtocolExtensionContainer_5749P53 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P53_t;
+typedef struct ProtocolExtensionContainer_5749P54 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P54_t;
+typedef struct ProtocolExtensionContainer_5749P55 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P55_t;
+typedef struct ProtocolExtensionContainer_5749P56 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P56_t;
+typedef struct ProtocolExtensionContainer_5749P57 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P57_t;
+typedef struct ProtocolExtensionContainer_5749P58 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P58_t;
+typedef struct ProtocolExtensionContainer_5749P59 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P59_t;
+typedef struct ProtocolExtensionContainer_5749P60 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P60_t;
+typedef struct ProtocolExtensionContainer_5749P61 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P61_t;
+typedef struct ProtocolExtensionContainer_5749P62 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P62_t;
+typedef struct ProtocolExtensionContainer_5749P63 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P63_t;
+typedef struct ProtocolExtensionContainer_5749P64 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P64_t;
+typedef struct ProtocolExtensionContainer_5749P65 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P65_t;
+typedef struct ProtocolExtensionContainer_5749P66 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P66_t;
+typedef struct ProtocolExtensionContainer_5749P67 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P67_t;
+typedef struct ProtocolExtensionContainer_5749P68 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P68_t;
+typedef struct ProtocolExtensionContainer_5749P69 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P69_t;
+typedef struct ProtocolExtensionContainer_5749P70 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P70_t;
+typedef struct ProtocolExtensionContainer_5749P71 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P71_t;
+typedef struct ProtocolExtensionContainer_5749P72 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P72_t;
+typedef struct ProtocolExtensionContainer_5749P73 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P73_t;
+typedef struct ProtocolExtensionContainer_5749P74 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P74_t;
+typedef struct ProtocolExtensionContainer_5749P75 {
+	A_SEQUENCE_OF(struct ProtocolExtensionField) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionContainer_5749P75_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P0;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P1;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P2;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P3;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P4;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P5;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P6;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P7;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P8;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P9;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P10;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P11;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P12;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P13;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P14;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P15;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P16;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P17;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P18;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P19;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P20;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P21;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P22;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P23;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P24;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P25;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P26;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P27;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P28;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P29;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P30;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P31;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P32;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P33;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P34;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P35;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P36;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P37;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P38;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P39;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P40;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P41;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P42;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P43;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P44;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P45;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P46;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P47;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P48;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P49;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P50;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P51;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P52;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P53;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P54;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P55;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P56;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P57;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P58;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P59;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P60;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P61;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P62;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P63;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P64;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P65;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P66;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P67;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P68;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P69;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P70;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P71;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P72;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P73;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P74;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionContainer_5749P75;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionField.h"
+
+#endif	/* _ProtocolExtensionContainer_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolExtensionField.h

@@ -0,0 +1,717 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolExtensionField_H_
+#define	_ProtocolExtensionField_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-ProtocolExtensionID.h"
+#include "S1ap-Criticality.h"
+#include <ANY.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ProtocolExtensionField */
+typedef struct ProtocolExtensionField_5753P0 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P0_t;
+typedef struct ProtocolExtensionField_5753P1 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P1_t;
+typedef struct ProtocolExtensionField_5753P2 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P2_t;
+typedef struct ProtocolExtensionField_5753P3 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P3_t;
+typedef struct ProtocolExtensionField_5753P4 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P4_t;
+typedef struct ProtocolExtensionField_5753P5 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P5_t;
+typedef struct ProtocolExtensionField_5753P6 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P6_t;
+typedef struct ProtocolExtensionField_5753P7 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P7_t;
+typedef struct ProtocolExtensionField_5753P8 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P8_t;
+typedef struct ProtocolExtensionField_5753P9 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P9_t;
+typedef struct ProtocolExtensionField_5753P10 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P10_t;
+typedef struct ProtocolExtensionField_5753P11 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P11_t;
+typedef struct ProtocolExtensionField_5753P12 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P12_t;
+typedef struct ProtocolExtensionField_5753P13 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P13_t;
+typedef struct ProtocolExtensionField_5753P14 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P14_t;
+typedef struct ProtocolExtensionField_5753P15 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P15_t;
+typedef struct ProtocolExtensionField_5753P16 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P16_t;
+typedef struct ProtocolExtensionField_5753P17 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P17_t;
+typedef struct ProtocolExtensionField_5753P18 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P18_t;
+typedef struct ProtocolExtensionField_5753P19 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P19_t;
+typedef struct ProtocolExtensionField_5753P20 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P20_t;
+typedef struct ProtocolExtensionField_5753P21 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P21_t;
+typedef struct ProtocolExtensionField_5753P22 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P22_t;
+typedef struct ProtocolExtensionField_5753P23 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P23_t;
+typedef struct ProtocolExtensionField_5753P24 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P24_t;
+typedef struct ProtocolExtensionField_5753P25 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P25_t;
+typedef struct ProtocolExtensionField_5753P26 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P26_t;
+typedef struct ProtocolExtensionField_5753P27 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P27_t;
+typedef struct ProtocolExtensionField_5753P28 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P28_t;
+typedef struct ProtocolExtensionField_5753P29 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P29_t;
+typedef struct ProtocolExtensionField_5753P30 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P30_t;
+typedef struct ProtocolExtensionField_5753P31 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P31_t;
+typedef struct ProtocolExtensionField_5753P32 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P32_t;
+typedef struct ProtocolExtensionField_5753P33 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P33_t;
+typedef struct ProtocolExtensionField_5753P34 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P34_t;
+typedef struct ProtocolExtensionField_5753P35 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P35_t;
+typedef struct ProtocolExtensionField_5753P36 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P36_t;
+typedef struct ProtocolExtensionField_5753P37 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P37_t;
+typedef struct ProtocolExtensionField_5753P38 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P38_t;
+typedef struct ProtocolExtensionField_5753P39 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P39_t;
+typedef struct ProtocolExtensionField_5753P40 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P40_t;
+typedef struct ProtocolExtensionField_5753P41 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P41_t;
+typedef struct ProtocolExtensionField_5753P42 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P42_t;
+typedef struct ProtocolExtensionField_5753P43 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P43_t;
+typedef struct ProtocolExtensionField_5753P44 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P44_t;
+typedef struct ProtocolExtensionField_5753P45 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P45_t;
+typedef struct ProtocolExtensionField_5753P46 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P46_t;
+typedef struct ProtocolExtensionField_5753P47 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P47_t;
+typedef struct ProtocolExtensionField_5753P48 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P48_t;
+typedef struct ProtocolExtensionField_5753P49 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P49_t;
+typedef struct ProtocolExtensionField_5753P50 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P50_t;
+typedef struct ProtocolExtensionField_5753P51 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P51_t;
+typedef struct ProtocolExtensionField_5753P52 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P52_t;
+typedef struct ProtocolExtensionField_5753P53 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P53_t;
+typedef struct ProtocolExtensionField_5753P54 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P54_t;
+typedef struct ProtocolExtensionField_5753P55 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P55_t;
+typedef struct ProtocolExtensionField_5753P56 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P56_t;
+typedef struct ProtocolExtensionField_5753P57 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P57_t;
+typedef struct ProtocolExtensionField_5753P58 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P58_t;
+typedef struct ProtocolExtensionField_5753P59 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P59_t;
+typedef struct ProtocolExtensionField_5753P60 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P60_t;
+typedef struct ProtocolExtensionField_5753P61 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P61_t;
+typedef struct ProtocolExtensionField_5753P62 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P62_t;
+typedef struct ProtocolExtensionField_5753P63 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P63_t;
+typedef struct ProtocolExtensionField_5753P64 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P64_t;
+typedef struct ProtocolExtensionField_5753P65 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P65_t;
+typedef struct ProtocolExtensionField_5753P66 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P66_t;
+typedef struct ProtocolExtensionField_5753P67 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P67_t;
+typedef struct ProtocolExtensionField_5753P68 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P68_t;
+typedef struct ProtocolExtensionField_5753P69 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P69_t;
+typedef struct ProtocolExtensionField_5753P70 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P70_t;
+typedef struct ProtocolExtensionField_5753P71 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P71_t;
+typedef struct ProtocolExtensionField_5753P72 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P72_t;
+typedef struct ProtocolExtensionField_5753P73 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P73_t;
+typedef struct ProtocolExtensionField_5753P74 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P74_t;
+typedef struct ProtocolExtensionField_5753P75 {
+	S1ap_ProtocolExtensionID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 extensionValue;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolExtensionField_5753P75_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P0;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P1;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P2;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P3;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P4;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P5;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P6;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P7;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P8;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P9;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P10;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P11;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P12;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P13;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P14;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P15;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P16;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P17;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P18;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P19;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P20;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P21;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P22;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P23;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P24;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P25;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P26;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P27;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P28;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P29;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P30;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P31;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P32;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P33;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P34;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P35;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P36;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P37;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P38;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P39;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P40;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P41;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P42;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P43;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P44;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P45;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P46;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P47;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P48;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P49;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P50;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P51;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P52;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P53;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P54;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P55;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P56;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P57;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P58;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P59;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P60;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P61;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P62;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P63;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P64;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P65;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P66;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P67;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P68;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P69;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P70;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P71;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P72;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P73;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P74;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolExtensionField_5753P75;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolExtensionField_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-Container.c

@@ -0,0 +1,9 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolIE-Container.h"
+

lib/asn/asn1c/ProtocolIE-Container.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_Container_H_
+#define	_ProtocolIE_Container_H_
+
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolIE_Container_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-ContainerList.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolIE-ContainerList.h"
+
+static asn_per_constraints_t asn_PER_type_ProtocolIE_ContainerList_5732P0_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1l,  256l }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_ProtocolIE_ContainerList_5732P0_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_ProtocolIE_Field_5696P0,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ProtocolIE_ContainerList_5732P0_specs_1 = {
+	sizeof(struct ProtocolIE_ContainerList_5732P0),
+	offsetof(struct ProtocolIE_ContainerList_5732P0, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_ProtocolIE_ContainerList_5732P0 = {
+	"ProtocolIE-ContainerList",
+	"ProtocolIE-ContainerList",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1,
+	sizeof(asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1)
+		/sizeof(asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1[0]), /* 1 */
+	asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1)
+		/sizeof(asn_DEF_ProtocolIE_ContainerList_5732P0_tags_1[0]), /* 1 */
+	&asn_PER_type_ProtocolIE_ContainerList_5732P0_constr_1,
+	asn_MBR_ProtocolIE_ContainerList_5732P0_1,
+	1,	/* Single element */
+	&asn_SPC_ProtocolIE_ContainerList_5732P0_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/ProtocolIE-ContainerList.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_ContainerList_H_
+#define	_ProtocolIE_ContainerList_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolIE_Field;
+
+/* ProtocolIE-ContainerList */
+typedef struct ProtocolIE_ContainerList_5732P0 {
+	A_SEQUENCE_OF(struct ProtocolIE_Field) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolIE_ContainerList_5732P0_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_ContainerList_5732P0;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolIE-Field.h"
+
+#endif	/* _ProtocolIE_ContainerList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-ContainerPair.c

@@ -0,0 +1,9 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolIE-ContainerPair.h"
+

lib/asn/asn1c/ProtocolIE-ContainerPair.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_ContainerPair_H_
+#define	_ProtocolIE_ContainerPair_H_
+
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolIE_ContainerPair_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-ContainerPairList.c

@@ -0,0 +1,9 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolIE-ContainerPairList.h"
+

lib/asn/asn1c/ProtocolIE-ContainerPairList.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_ContainerPairList_H_
+#define	_ProtocolIE_ContainerPairList_H_
+
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolIE_ContainerPairList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-Field.c

@@ -0,0 +1,160 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolIE-Field.h"
+
+static int
+memb_id_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long long *)sptr;
+	
+	if((value >= 0LL && value <= 65535LL)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_criticality_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+static int
+memb_value_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+static asn_per_constraints_t asn_PER_memb_id_constr_2 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_criticality_constr_3 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0l,  2l }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_value_constr_4 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_ProtocolIE_Field_5696P0_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ProtocolIE_Field_5696P0, id),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_ProtocolIE_ID,
+		memb_id_constraint_1,
+		&asn_PER_memb_id_constr_2,
+		0,
+		"id"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ProtocolIE_Field_5696P0, criticality),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_Criticality,
+		memb_criticality_constraint_1,
+		&asn_PER_memb_criticality_constr_3,
+		0,
+		"criticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ProtocolIE_Field_5696P0, value),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ANY,
+		memb_value_constraint_1,
+		&asn_PER_memb_value_constr_4,
+		0,
+		"value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ProtocolIE_Field_5696P0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_ProtocolIE_Field_5696P0_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_ProtocolIE_Field_5696P0_specs_1 = {
+	sizeof(struct ProtocolIE_Field_5696P0),
+	offsetof(struct ProtocolIE_Field_5696P0, _asn_ctx),
+	asn_MAP_ProtocolIE_Field_5696P0_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_ProtocolIE_Field_5696P0 = {
+	"ProtocolIE-Field",
+	"ProtocolIE-Field",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ProtocolIE_Field_5696P0_tags_1,
+	sizeof(asn_DEF_ProtocolIE_Field_5696P0_tags_1)
+		/sizeof(asn_DEF_ProtocolIE_Field_5696P0_tags_1[0]), /* 1 */
+	asn_DEF_ProtocolIE_Field_5696P0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ProtocolIE_Field_5696P0_tags_1)
+		/sizeof(asn_DEF_ProtocolIE_Field_5696P0_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_ProtocolIE_Field_5696P0_1,
+	3,	/* Elements count */
+	&asn_SPC_ProtocolIE_Field_5696P0_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/ProtocolIE-Field.h

@@ -0,0 +1,42 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_Field_H_
+#define	_ProtocolIE_Field_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-ProtocolIE-ID.h"
+#include "S1ap-Criticality.h"
+#include <ANY.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ProtocolIE-Field */
+typedef struct ProtocolIE_Field_5696P0 {
+	S1ap_ProtocolIE_ID_t	 id;
+	S1ap_Criticality_t	 criticality;
+	ANY_t	 value;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ProtocolIE_Field_5696P0_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_Field_5696P0;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolIE_Field_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-FieldPair.c

@@ -0,0 +1,9 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "ProtocolIE-FieldPair.h"
+

lib/asn/asn1c/ProtocolIE-FieldPair.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_FieldPair_H_
+#define	_ProtocolIE_FieldPair_H_
+
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolIE_FieldPair_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/ProtocolIE-SingleContainer.h

@@ -0,0 +1,212 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-Containers"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_ProtocolIE_SingleContainer_H_
+#define	_ProtocolIE_SingleContainer_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProtocolIE-Field.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ProtocolIE-SingleContainer */
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P0_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P1_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P2_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P3_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P4_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P5_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P6_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P7_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P8_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P9_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P10_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P11_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P12_t;
+typedef ProtocolIE_Field_5696P0_t	 ProtocolIE_SingleContainer_5692P13_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P0;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P0_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P0_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P0_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P0_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P0_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P0_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P0_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P0_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P0_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P0_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P0_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P1;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P1_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P1_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P1_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P1_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P1_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P1_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P1_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P1_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P1_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P1_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P1_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P2;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P2_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P2_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P2_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P2_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P2_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P2_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P2_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P2_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P2_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P2_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P2_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P3;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P3_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P3_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P3_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P3_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P3_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P3_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P3_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P3_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P3_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P3_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P3_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P4;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P4_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P4_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P4_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P4_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P4_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P4_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P4_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P4_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P4_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P4_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P4_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P5;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P5_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P5_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P5_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P5_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P5_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P5_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P5_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P5_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P5_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P5_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P5_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P6;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P6_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P6_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P6_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P6_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P6_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P6_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P6_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P6_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P6_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P6_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P6_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P7;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P7_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P7_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P7_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P7_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P7_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P7_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P7_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P7_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P7_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P7_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P7_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P8;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P8_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P8_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P8_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P8_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P8_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P8_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P8_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P8_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P8_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P8_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P8_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P9;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P9_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P9_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P9_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P9_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P9_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P9_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P9_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P9_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P9_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P9_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P9_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P10;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P10_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P10_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P10_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P10_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P10_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P10_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P10_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P10_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P10_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P10_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P10_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P11;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P11_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P11_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P11_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P11_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P11_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P11_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P11_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P11_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P11_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P11_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P11_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P12;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P12_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P12_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P12_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P12_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P12_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P12_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P12_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P12_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P12_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P12_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P12_encode_aper;
+extern asn_TYPE_descriptor_t asn_DEF_ProtocolIE_SingleContainer_5692P13;
+asn_struct_free_f ProtocolIE_SingleContainer_5692P13_free;
+asn_struct_print_f ProtocolIE_SingleContainer_5692P13_print;
+asn_constr_check_f ProtocolIE_SingleContainer_5692P13_constraint;
+ber_type_decoder_f ProtocolIE_SingleContainer_5692P13_decode_ber;
+der_type_encoder_f ProtocolIE_SingleContainer_5692P13_encode_der;
+xer_type_decoder_f ProtocolIE_SingleContainer_5692P13_decode_xer;
+xer_type_encoder_f ProtocolIE_SingleContainer_5692P13_encode_xer;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P13_decode_uper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P13_encode_uper;
+per_type_decoder_f ProtocolIE_SingleContainer_5692P13_decode_aper;
+per_type_encoder_f ProtocolIE_SingleContainer_5692P13_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ProtocolIE_SingleContainer_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1AP-PDU.c

@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Descriptions"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1AP-PDU.h"
+
+static asn_per_constraints_t asn_PER_type_S1AP_PDU_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  2l }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1AP_PDU_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1AP_PDU, choice.initiatingMessage),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_InitiatingMessage,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"initiatingMessage"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1AP_PDU, choice.successfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_SuccessfulOutcome,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"successfulOutcome"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1AP_PDU, choice.unsuccessfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_UnsuccessfulOutcome,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"unsuccessfulOutcome"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1AP_PDU_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* initiatingMessage */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* successfulOutcome */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* unsuccessfulOutcome */
+};
+static asn_CHOICE_specifics_t asn_SPC_S1AP_PDU_specs_1 = {
+	sizeof(struct S1AP_PDU),
+	offsetof(struct S1AP_PDU, _asn_ctx),
+	offsetof(struct S1AP_PDU, present),
+	sizeof(((struct S1AP_PDU *)0)->present),
+	asn_MAP_S1AP_PDU_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_S1AP_PDU = {
+	"S1AP-PDU",
+	"S1AP-PDU",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_decode_aper,
+	CHOICE_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_S1AP_PDU_constr_1,
+	asn_MBR_S1AP_PDU_1,
+	3,	/* Elements count */
+	&asn_SPC_S1AP_PDU_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1AP-PDU.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-PDU-Descriptions"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1AP_PDU_H_
+#define	_S1AP_PDU_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-InitiatingMessage.h"
+#include "S1ap-SuccessfulOutcome.h"
+#include "S1ap-UnsuccessfulOutcome.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1AP_PDU_PR {
+	S1AP_PDU_PR_NOTHING,	/* No components present */
+	S1AP_PDU_PR_initiatingMessage,
+	S1AP_PDU_PR_successfulOutcome,
+	S1AP_PDU_PR_unsuccessfulOutcome,
+	/* Extensions may appear below */
+	
+} S1AP_PDU_PR;
+
+/* S1AP-PDU */
+typedef struct S1AP_PDU {
+	S1AP_PDU_PR present;
+	union S1AP_PDU_u {
+		S1ap_InitiatingMessage_t	 initiatingMessage;
+		S1ap_SuccessfulOutcome_t	 successfulOutcome;
+		S1ap_UnsuccessfulOutcome_t	 unsuccessfulOutcome;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1AP_PDU_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1AP_PDU;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1AP_PDU_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-AllocationAndRetentionPriority.c

@@ -0,0 +1,94 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-AllocationAndRetentionPriority.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_AllocationAndRetentionPriority_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_AllocationAndRetentionPriority, priorityLevel),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_PriorityLevel,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"priorityLevel"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_AllocationAndRetentionPriority, pre_emptionCapability),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_Pre_emptionCapability,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pre-emptionCapability"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_AllocationAndRetentionPriority, pre_emptionVulnerability),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_Pre_emptionVulnerability,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pre-emptionVulnerability"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_AllocationAndRetentionPriority, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P14,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_AllocationAndRetentionPriority_oms_1[] = { 3 };
+static const ber_tlv_tag_t asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_AllocationAndRetentionPriority_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* priorityLevel */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* pre-emptionCapability */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* pre-emptionVulnerability */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_AllocationAndRetentionPriority_specs_1 = {
+	sizeof(struct S1ap_AllocationAndRetentionPriority),
+	offsetof(struct S1ap_AllocationAndRetentionPriority, _asn_ctx),
+	asn_MAP_S1ap_AllocationAndRetentionPriority_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_S1ap_AllocationAndRetentionPriority_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	3,	/* Start extensions */
+	5	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_AllocationAndRetentionPriority = {
+	"S1ap-AllocationAndRetentionPriority",
+	"S1ap-AllocationAndRetentionPriority",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1,
+	sizeof(asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1)
+		/sizeof(asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1)
+		/sizeof(asn_DEF_S1ap_AllocationAndRetentionPriority_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_AllocationAndRetentionPriority_1,
+	4,	/* Elements count */
+	&asn_SPC_S1ap_AllocationAndRetentionPriority_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-AllocationAndRetentionPriority.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_AllocationAndRetentionPriority_H_
+#define	_S1ap_AllocationAndRetentionPriority_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-PriorityLevel.h"
+#include "S1ap-Pre-emptionCapability.h"
+#include "S1ap-Pre-emptionVulnerability.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-AllocationAndRetentionPriority */
+typedef struct S1ap_AllocationAndRetentionPriority {
+	S1ap_PriorityLevel_t	 priorityLevel;
+	S1ap_Pre_emptionCapability_t	 pre_emptionCapability;
+	S1ap_Pre_emptionVulnerability_t	 pre_emptionVulnerability;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_AllocationAndRetentionPriority_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_AllocationAndRetentionPriority;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_AllocationAndRetentionPriority_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-AreaScopeOfMDT.c

@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-AreaScopeOfMDT.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_AreaScopeOfMDT_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  2l }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_AreaScopeOfMDT_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_AreaScopeOfMDT, choice.cellBased),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CellBasedMDT,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cellBased"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_AreaScopeOfMDT, choice.tABased),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_TABasedMDT,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"tABased"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_AreaScopeOfMDT, choice.pLMNWide),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NULL,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pLMNWide"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_AreaScopeOfMDT_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* cellBased */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* tABased */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* pLMNWide */
+};
+static asn_CHOICE_specifics_t asn_SPC_S1ap_AreaScopeOfMDT_specs_1 = {
+	sizeof(struct S1ap_AreaScopeOfMDT),
+	offsetof(struct S1ap_AreaScopeOfMDT, _asn_ctx),
+	offsetof(struct S1ap_AreaScopeOfMDT, present),
+	sizeof(((struct S1ap_AreaScopeOfMDT *)0)->present),
+	asn_MAP_S1ap_AreaScopeOfMDT_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_AreaScopeOfMDT = {
+	"S1ap-AreaScopeOfMDT",
+	"S1ap-AreaScopeOfMDT",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_decode_aper,
+	CHOICE_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_S1ap_AreaScopeOfMDT_constr_1,
+	asn_MBR_S1ap_AreaScopeOfMDT_1,
+	3,	/* Elements count */
+	&asn_SPC_S1ap_AreaScopeOfMDT_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-AreaScopeOfMDT.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_AreaScopeOfMDT_H_
+#define	_S1ap_AreaScopeOfMDT_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-CellBasedMDT.h"
+#include "S1ap-TABasedMDT.h"
+#include <NULL.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_AreaScopeOfMDT_PR {
+	S1ap_AreaScopeOfMDT_PR_NOTHING,	/* No components present */
+	S1ap_AreaScopeOfMDT_PR_cellBased,
+	S1ap_AreaScopeOfMDT_PR_tABased,
+	S1ap_AreaScopeOfMDT_PR_pLMNWide,
+	/* Extensions may appear below */
+	
+} S1ap_AreaScopeOfMDT_PR;
+
+/* S1ap-AreaScopeOfMDT */
+typedef struct S1ap_AreaScopeOfMDT {
+	S1ap_AreaScopeOfMDT_PR present;
+	union S1ap_AreaScopeOfMDT_u {
+		S1ap_CellBasedMDT_t	 cellBased;
+		S1ap_TABasedMDT_t	 tABased;
+		NULL_t	 pLMNWide;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_AreaScopeOfMDT_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_AreaScopeOfMDT;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_AreaScopeOfMDT_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-BPLMNs.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-BPLMNs.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_BPLMNs_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 3,  3,  1l,  6l }	/* (SIZE(1..6)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_BPLMNs_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
+		0,
+		&asn_DEF_S1ap_PLMNidentity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_BPLMNs_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_S1ap_BPLMNs_specs_1 = {
+	sizeof(struct S1ap_BPLMNs),
+	offsetof(struct S1ap_BPLMNs, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_BPLMNs = {
+	"S1ap-BPLMNs",
+	"S1ap-BPLMNs",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_BPLMNs_tags_1,
+	sizeof(asn_DEF_S1ap_BPLMNs_tags_1)
+		/sizeof(asn_DEF_S1ap_BPLMNs_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_BPLMNs_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_BPLMNs_tags_1)
+		/sizeof(asn_DEF_S1ap_BPLMNs_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_BPLMNs_constr_1,
+	asn_MBR_S1ap_BPLMNs_1,
+	1,	/* Single element */
+	&asn_SPC_S1ap_BPLMNs_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-BPLMNs.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_BPLMNs_H_
+#define	_S1ap_BPLMNs_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-PLMNidentity.h"
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* S1ap-BPLMNs */
+typedef struct S1ap_BPLMNs {
+	A_SEQUENCE_OF(S1ap_PLMNidentity_t) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_BPLMNs_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_BPLMNs;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_BPLMNs_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-Bearers-SubjectToStatusTransfer-Item.c

@@ -0,0 +1,104 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-Bearers-SubjectToStatusTransfer-Item.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_Bearers_SubjectToStatusTransfer_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Bearers_SubjectToStatusTransfer_Item, e_RAB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_E_RAB_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"e-RAB-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Bearers_SubjectToStatusTransfer_Item, uL_S1ap_COUNTvalue),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_COUNTvalue,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"uL-S1ap-COUNTvalue"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Bearers_SubjectToStatusTransfer_Item, dL_S1ap_COUNTvalue),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_COUNTvalue,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"dL-S1ap-COUNTvalue"
+		},
+	{ ATF_POINTER, 2, offsetof(struct S1ap_Bearers_SubjectToStatusTransfer_Item, receiveStatusofULPDCPSDUs),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_ReceiveStatusofULPDCPSDUs,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"receiveStatusofULPDCPSDUs"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_Bearers_SubjectToStatusTransfer_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P15,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_Bearers_SubjectToStatusTransfer_Item_oms_1[] = { 3, 4 };
+static const ber_tlv_tag_t asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_Bearers_SubjectToStatusTransfer_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* e-RAB-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* uL-S1ap-COUNTvalue */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* dL-S1ap-COUNTvalue */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* receiveStatusofULPDCPSDUs */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_Bearers_SubjectToStatusTransfer_Item_specs_1 = {
+	sizeof(struct S1ap_Bearers_SubjectToStatusTransfer_Item),
+	offsetof(struct S1ap_Bearers_SubjectToStatusTransfer_Item, _asn_ctx),
+	asn_MAP_S1ap_Bearers_SubjectToStatusTransfer_Item_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_S1ap_Bearers_SubjectToStatusTransfer_Item_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	4,	/* Start extensions */
+	6	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item = {
+	"S1ap-Bearers-SubjectToStatusTransfer-Item",
+	"S1ap-Bearers-SubjectToStatusTransfer-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1,
+	sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_Bearers_SubjectToStatusTransfer_Item_1,
+	5,	/* Elements count */
+	&asn_SPC_S1ap_Bearers_SubjectToStatusTransfer_Item_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-Bearers-SubjectToStatusTransfer-Item.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_Bearers_SubjectToStatusTransfer_Item_H_
+#define	_S1ap_Bearers_SubjectToStatusTransfer_Item_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-E-RAB-ID.h"
+#include "S1ap-COUNTvalue.h"
+#include "S1ap-ReceiveStatusofULPDCPSDUs.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-Bearers-SubjectToStatusTransfer-Item */
+typedef struct S1ap_Bearers_SubjectToStatusTransfer_Item {
+	S1ap_E_RAB_ID_t	 e_RAB_ID;
+	S1ap_COUNTvalue_t	 uL_S1ap_COUNTvalue;
+	S1ap_COUNTvalue_t	 dL_S1ap_COUNTvalue;
+	S1ap_ReceiveStatusofULPDCPSDUs_t	*receiveStatusofULPDCPSDUs	/* OPTIONAL */;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_Bearers_SubjectToStatusTransfer_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_Bearers_SubjectToStatusTransfer_Item;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_Bearers_SubjectToStatusTransfer_Item_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-Bearers-SubjectToStatusTransferList.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-Bearers-SubjectToStatusTransferList.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_Bearers_SubjectToStatusTransferList_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1l,  256l }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_Bearers_SubjectToStatusTransferList_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_ProtocolIE_Field_5696P0,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_S1ap_Bearers_SubjectToStatusTransferList_specs_1 = {
+	sizeof(struct S1ap_Bearers_SubjectToStatusTransferList),
+	offsetof(struct S1ap_Bearers_SubjectToStatusTransferList, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_Bearers_SubjectToStatusTransferList = {
+	"S1ap-Bearers-SubjectToStatusTransferList",
+	"S1ap-Bearers-SubjectToStatusTransferList",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1,
+	sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1)
+		/sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1)
+		/sizeof(asn_DEF_S1ap_Bearers_SubjectToStatusTransferList_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_Bearers_SubjectToStatusTransferList_constr_1,
+	asn_MBR_S1ap_Bearers_SubjectToStatusTransferList_1,
+	1,	/* Single element */
+	&asn_SPC_S1ap_Bearers_SubjectToStatusTransferList_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-Bearers-SubjectToStatusTransferList.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_Bearers_SubjectToStatusTransferList_H_
+#define	_S1ap_Bearers_SubjectToStatusTransferList_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolIE_Field;
+
+/* S1ap-Bearers-SubjectToStatusTransferList */
+typedef struct S1ap_Bearers_SubjectToStatusTransferList {
+	A_SEQUENCE_OF(struct ProtocolIE_Field) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_Bearers_SubjectToStatusTransferList_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_Bearers_SubjectToStatusTransferList;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolIE-Field.h"
+
+#endif	/* _S1ap_Bearers_SubjectToStatusTransferList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-BitRate.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-BitRate.h"
+
+int
+S1ap_BitRate_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 0LL && value <= 10000000000LL)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_BitRate_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_INTEGER.free_struct;
+	td->print_struct   = asn_DEF_INTEGER.print_struct;
+	td->check_constraints = asn_DEF_INTEGER.check_constraints;
+	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
+	td->der_encoder    = asn_DEF_INTEGER.der_encoder;
+	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
+	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
+	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
+	td->aper_decoder   = asn_DEF_INTEGER.aper_decoder;
+	td->aper_encoder   = asn_DEF_INTEGER.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+S1ap_BitRate_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_BitRate_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_BitRate_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_BitRate_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_BitRate_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_BitRate_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_BitRate_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_BitRate_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_BitRate_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_BitRate_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_BitRate_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_BitRate_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 34, -1,  0l, 10000000000ull }	/* (0..10000000000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_BitRate_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_BitRate = {
+	"S1ap-BitRate",
+	"S1ap-BitRate",
+	S1ap_BitRate_free,
+	S1ap_BitRate_print,
+	S1ap_BitRate_constraint,
+	S1ap_BitRate_decode_ber,
+	S1ap_BitRate_encode_der,
+	S1ap_BitRate_decode_xer,
+	S1ap_BitRate_encode_xer,
+	S1ap_BitRate_decode_uper,
+	S1ap_BitRate_encode_uper,
+	S1ap_BitRate_decode_aper,
+	S1ap_BitRate_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_BitRate_tags_1,
+	sizeof(asn_DEF_S1ap_BitRate_tags_1)
+		/sizeof(asn_DEF_S1ap_BitRate_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_BitRate_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_BitRate_tags_1)
+		/sizeof(asn_DEF_S1ap_BitRate_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_BitRate_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

lib/asn/asn1c/S1ap-BitRate.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_BitRate_H_
+#define	_S1ap_BitRate_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* S1ap-BitRate */
+typedef INTEGER_t	 S1ap_BitRate_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_BitRate;
+asn_struct_free_f S1ap_BitRate_free;
+asn_struct_print_f S1ap_BitRate_print;
+asn_constr_check_f S1ap_BitRate_constraint;
+ber_type_decoder_f S1ap_BitRate_decode_ber;
+der_type_encoder_f S1ap_BitRate_encode_der;
+xer_type_decoder_f S1ap_BitRate_decode_xer;
+xer_type_encoder_f S1ap_BitRate_encode_xer;
+per_type_decoder_f S1ap_BitRate_decode_uper;
+per_type_encoder_f S1ap_BitRate_encode_uper;
+per_type_decoder_f S1ap_BitRate_decode_aper;
+per_type_encoder_f S1ap_BitRate_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_BitRate_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-BroadcastCancelledAreaList.c

@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-BroadcastCancelledAreaList.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_BroadcastCancelledAreaList_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  2l }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_BroadcastCancelledAreaList_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_BroadcastCancelledAreaList, choice.cellID_Cancelled),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CellID_Cancelled,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cellID-Cancelled"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_BroadcastCancelledAreaList, choice.tAI_Cancelled),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_TAI_Cancelled,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"tAI-Cancelled"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_BroadcastCancelledAreaList, choice.emergencyAreaID_Cancelled),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_EmergencyAreaID_Cancelled,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"emergencyAreaID-Cancelled"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_BroadcastCancelledAreaList_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* cellID-Cancelled */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* tAI-Cancelled */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* emergencyAreaID-Cancelled */
+};
+static asn_CHOICE_specifics_t asn_SPC_S1ap_BroadcastCancelledAreaList_specs_1 = {
+	sizeof(struct S1ap_BroadcastCancelledAreaList),
+	offsetof(struct S1ap_BroadcastCancelledAreaList, _asn_ctx),
+	offsetof(struct S1ap_BroadcastCancelledAreaList, present),
+	sizeof(((struct S1ap_BroadcastCancelledAreaList *)0)->present),
+	asn_MAP_S1ap_BroadcastCancelledAreaList_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_BroadcastCancelledAreaList = {
+	"S1ap-BroadcastCancelledAreaList",
+	"S1ap-BroadcastCancelledAreaList",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_decode_aper,
+	CHOICE_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_S1ap_BroadcastCancelledAreaList_constr_1,
+	asn_MBR_S1ap_BroadcastCancelledAreaList_1,
+	3,	/* Elements count */
+	&asn_SPC_S1ap_BroadcastCancelledAreaList_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-BroadcastCancelledAreaList.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_BroadcastCancelledAreaList_H_
+#define	_S1ap_BroadcastCancelledAreaList_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-CellID-Cancelled.h"
+#include "S1ap-TAI-Cancelled.h"
+#include "S1ap-EmergencyAreaID-Cancelled.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_BroadcastCancelledAreaList_PR {
+	S1ap_BroadcastCancelledAreaList_PR_NOTHING,	/* No components present */
+	S1ap_BroadcastCancelledAreaList_PR_cellID_Cancelled,
+	S1ap_BroadcastCancelledAreaList_PR_tAI_Cancelled,
+	S1ap_BroadcastCancelledAreaList_PR_emergencyAreaID_Cancelled,
+	/* Extensions may appear below */
+	
+} S1ap_BroadcastCancelledAreaList_PR;
+
+/* S1ap-BroadcastCancelledAreaList */
+typedef struct S1ap_BroadcastCancelledAreaList {
+	S1ap_BroadcastCancelledAreaList_PR present;
+	union S1ap_BroadcastCancelledAreaList_u {
+		S1ap_CellID_Cancelled_t	 cellID_Cancelled;
+		S1ap_TAI_Cancelled_t	 tAI_Cancelled;
+		S1ap_EmergencyAreaID_Cancelled_t	 emergencyAreaID_Cancelled;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_BroadcastCancelledAreaList_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_BroadcastCancelledAreaList;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_BroadcastCancelledAreaList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-BroadcastCompletedAreaList.c

@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-BroadcastCompletedAreaList.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_BroadcastCompletedAreaList_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  2l }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_BroadcastCompletedAreaList_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_BroadcastCompletedAreaList, choice.cellID_Broadcast),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CellID_Broadcast,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cellID-Broadcast"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_BroadcastCompletedAreaList, choice.tAI_Broadcast),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_TAI_Broadcast,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"tAI-Broadcast"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_BroadcastCompletedAreaList, choice.emergencyAreaID_Broadcast),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_EmergencyAreaID_Broadcast,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"emergencyAreaID-Broadcast"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_BroadcastCompletedAreaList_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* cellID-Broadcast */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* tAI-Broadcast */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* emergencyAreaID-Broadcast */
+};
+static asn_CHOICE_specifics_t asn_SPC_S1ap_BroadcastCompletedAreaList_specs_1 = {
+	sizeof(struct S1ap_BroadcastCompletedAreaList),
+	offsetof(struct S1ap_BroadcastCompletedAreaList, _asn_ctx),
+	offsetof(struct S1ap_BroadcastCompletedAreaList, present),
+	sizeof(((struct S1ap_BroadcastCompletedAreaList *)0)->present),
+	asn_MAP_S1ap_BroadcastCompletedAreaList_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_BroadcastCompletedAreaList = {
+	"S1ap-BroadcastCompletedAreaList",
+	"S1ap-BroadcastCompletedAreaList",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_decode_aper,
+	CHOICE_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_S1ap_BroadcastCompletedAreaList_constr_1,
+	asn_MBR_S1ap_BroadcastCompletedAreaList_1,
+	3,	/* Elements count */
+	&asn_SPC_S1ap_BroadcastCompletedAreaList_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-BroadcastCompletedAreaList.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_BroadcastCompletedAreaList_H_
+#define	_S1ap_BroadcastCompletedAreaList_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-CellID-Broadcast.h"
+#include "S1ap-TAI-Broadcast.h"
+#include "S1ap-EmergencyAreaID-Broadcast.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_BroadcastCompletedAreaList_PR {
+	S1ap_BroadcastCompletedAreaList_PR_NOTHING,	/* No components present */
+	S1ap_BroadcastCompletedAreaList_PR_cellID_Broadcast,
+	S1ap_BroadcastCompletedAreaList_PR_tAI_Broadcast,
+	S1ap_BroadcastCompletedAreaList_PR_emergencyAreaID_Broadcast,
+	/* Extensions may appear below */
+	
+} S1ap_BroadcastCompletedAreaList_PR;
+
+/* S1ap-BroadcastCompletedAreaList */
+typedef struct S1ap_BroadcastCompletedAreaList {
+	S1ap_BroadcastCompletedAreaList_PR present;
+	union S1ap_BroadcastCompletedAreaList_u {
+		S1ap_CellID_Broadcast_t	 cellID_Broadcast;
+		S1ap_TAI_Broadcast_t	 tAI_Broadcast;
+		S1ap_EmergencyAreaID_Broadcast_t	 emergencyAreaID_Broadcast;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_BroadcastCompletedAreaList_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_BroadcastCompletedAreaList;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_BroadcastCompletedAreaList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CGI.c

@@ -0,0 +1,104 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CGI.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_CGI_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CGI, pLMNidentity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_PLMNidentity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pLMNidentity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CGI, lAC),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_LAC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"lAC"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CGI, cI),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CI,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cI"
+		},
+	{ ATF_POINTER, 2, offsetof(struct S1ap_CGI, rAC),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_RAC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"rAC"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_CGI, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P23,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_CGI_oms_1[] = { 3, 4 };
+static const ber_tlv_tag_t asn_DEF_S1ap_CGI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_CGI_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMNidentity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* lAC */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* cI */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* rAC */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_CGI_specs_1 = {
+	sizeof(struct S1ap_CGI),
+	offsetof(struct S1ap_CGI, _asn_ctx),
+	asn_MAP_S1ap_CGI_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_S1ap_CGI_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	4,	/* Start extensions */
+	6	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CGI = {
+	"S1ap-CGI",
+	"S1ap-CGI",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CGI_tags_1,
+	sizeof(asn_DEF_S1ap_CGI_tags_1)
+		/sizeof(asn_DEF_S1ap_CGI_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CGI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CGI_tags_1)
+		/sizeof(asn_DEF_S1ap_CGI_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_CGI_1,
+	5,	/* Elements count */
+	&asn_SPC_S1ap_CGI_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CGI.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CGI_H_
+#define	_S1ap_CGI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-PLMNidentity.h"
+#include "S1ap-LAC.h"
+#include "S1ap-CI.h"
+#include "S1ap-RAC.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-CGI */
+typedef struct S1ap_CGI {
+	S1ap_PLMNidentity_t	 pLMNidentity;
+	S1ap_LAC_t	 lAC;
+	S1ap_CI_t	 cI;
+	S1ap_RAC_t	*rAC	/* OPTIONAL */;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CGI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CGI;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_CGI_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CI.c

@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CI.h"
+
+int
+S1ap_CI_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 2LL)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_CI_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_OCTET_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_OCTET_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+S1ap_CI_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_CI_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CI_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_CI_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CI_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_CI_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CI_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_CI_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_CI_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_CI_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CI_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_CI_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  2l,  2l }	/* (SIZE(2..2)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CI = {
+	"S1ap-CI",
+	"S1ap-CI",
+	S1ap_CI_free,
+	S1ap_CI_print,
+	S1ap_CI_constraint,
+	S1ap_CI_decode_ber,
+	S1ap_CI_encode_der,
+	S1ap_CI_decode_xer,
+	S1ap_CI_encode_xer,
+	S1ap_CI_decode_uper,
+	S1ap_CI_encode_uper,
+	S1ap_CI_decode_aper,
+	S1ap_CI_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CI_tags_1,
+	sizeof(asn_DEF_S1ap_CI_tags_1)
+		/sizeof(asn_DEF_S1ap_CI_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CI_tags_1)
+		/sizeof(asn_DEF_S1ap_CI_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CI_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

lib/asn/asn1c/S1ap-CI.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CI_H_
+#define	_S1ap_CI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* S1ap-CI */
+typedef OCTET_STRING_t	 S1ap_CI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CI;
+asn_struct_free_f S1ap_CI_free;
+asn_struct_print_f S1ap_CI_print;
+asn_constr_check_f S1ap_CI_constraint;
+ber_type_decoder_f S1ap_CI_decode_ber;
+der_type_encoder_f S1ap_CI_encode_der;
+xer_type_decoder_f S1ap_CI_decode_xer;
+xer_type_encoder_f S1ap_CI_encode_xer;
+per_type_decoder_f S1ap_CI_decode_uper;
+per_type_encoder_f S1ap_CI_encode_uper;
+per_type_decoder_f S1ap_CI_decode_aper;
+per_type_encoder_f S1ap_CI_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_CI_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CNDomain.c

@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CNDomain.h"
+
+int
+S1ap_CNDomain_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_CNDomain_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+S1ap_CNDomain_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_CNDomain_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CNDomain_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_CNDomain_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CNDomain_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_CNDomain_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CNDomain_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_CNDomain_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_CNDomain_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_CNDomain_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CNDomain_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_CNDomain_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 1,  1,  0l,  1l }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_S1ap_CNDomain_value2enum_1[] = {
+	{ 0,	2,	"ps" },
+	{ 1,	2,	"cs" }
+};
+static const unsigned int asn_MAP_S1ap_CNDomain_enum2value_1[] = {
+	1,	/* cs(1) */
+	0	/* ps(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_S1ap_CNDomain_specs_1 = {
+	asn_MAP_S1ap_CNDomain_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_S1ap_CNDomain_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CNDomain_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CNDomain = {
+	"S1ap-CNDomain",
+	"S1ap-CNDomain",
+	S1ap_CNDomain_free,
+	S1ap_CNDomain_print,
+	S1ap_CNDomain_constraint,
+	S1ap_CNDomain_decode_ber,
+	S1ap_CNDomain_encode_der,
+	S1ap_CNDomain_decode_xer,
+	S1ap_CNDomain_encode_xer,
+	S1ap_CNDomain_decode_uper,
+	S1ap_CNDomain_encode_uper,
+	S1ap_CNDomain_decode_aper,
+	S1ap_CNDomain_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CNDomain_tags_1,
+	sizeof(asn_DEF_S1ap_CNDomain_tags_1)
+		/sizeof(asn_DEF_S1ap_CNDomain_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CNDomain_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CNDomain_tags_1)
+		/sizeof(asn_DEF_S1ap_CNDomain_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CNDomain_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_S1ap_CNDomain_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CNDomain.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CNDomain_H_
+#define	_S1ap_CNDomain_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_CNDomain {
+	S1ap_CNDomain_ps	= 0,
+	S1ap_CNDomain_cs	= 1
+} e_S1ap_CNDomain;
+
+/* S1ap-CNDomain */
+typedef long	 S1ap_CNDomain_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CNDomain;
+asn_struct_free_f S1ap_CNDomain_free;
+asn_struct_print_f S1ap_CNDomain_print;
+asn_constr_check_f S1ap_CNDomain_constraint;
+ber_type_decoder_f S1ap_CNDomain_decode_ber;
+der_type_encoder_f S1ap_CNDomain_encode_der;
+xer_type_decoder_f S1ap_CNDomain_decode_xer;
+xer_type_encoder_f S1ap_CNDomain_encode_xer;
+per_type_decoder_f S1ap_CNDomain_decode_uper;
+per_type_encoder_f S1ap_CNDomain_encode_uper;
+per_type_decoder_f S1ap_CNDomain_decode_aper;
+per_type_encoder_f S1ap_CNDomain_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_CNDomain_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-COUNTvalue.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-COUNTvalue.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_COUNTvalue_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_COUNTvalue, pDCP_SN),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_PDCP_SN,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pDCP-SN"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_COUNTvalue, hFN),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_HFN,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"hFN"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_COUNTvalue, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P25,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_COUNTvalue_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_S1ap_COUNTvalue_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_COUNTvalue_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pDCP-SN */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* hFN */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_COUNTvalue_specs_1 = {
+	sizeof(struct S1ap_COUNTvalue),
+	offsetof(struct S1ap_COUNTvalue, _asn_ctx),
+	asn_MAP_S1ap_COUNTvalue_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_S1ap_COUNTvalue_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_COUNTvalue = {
+	"S1ap-COUNTvalue",
+	"S1ap-COUNTvalue",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_COUNTvalue_tags_1,
+	sizeof(asn_DEF_S1ap_COUNTvalue_tags_1)
+		/sizeof(asn_DEF_S1ap_COUNTvalue_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_COUNTvalue_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_COUNTvalue_tags_1)
+		/sizeof(asn_DEF_S1ap_COUNTvalue_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_COUNTvalue_1,
+	3,	/* Elements count */
+	&asn_SPC_S1ap_COUNTvalue_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-COUNTvalue.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_COUNTvalue_H_
+#define	_S1ap_COUNTvalue_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-PDCP-SN.h"
+#include "S1ap-HFN.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-COUNTvalue */
+typedef struct S1ap_COUNTvalue {
+	S1ap_PDCP_SN_t	 pDCP_SN;
+	S1ap_HFN_t	 hFN;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_COUNTvalue_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_COUNTvalue;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_COUNTvalue_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CSFallbackIndicator.c

@@ -0,0 +1,168 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CSFallbackIndicator.h"
+
+int
+S1ap_CSFallbackIndicator_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+S1ap_CSFallbackIndicator_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_CSFallbackIndicator_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSFallbackIndicator_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_CSFallbackIndicator_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSFallbackIndicator_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_CSFallbackIndicator_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSFallbackIndicator_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_CSFallbackIndicator_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_CSFallbackIndicator_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_CSFallbackIndicator_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CSFallbackIndicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_CSFallbackIndicator_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0l,  0l }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_S1ap_CSFallbackIndicator_value2enum_1[] = {
+	{ 0,	20,	"cs-fallback-required" },
+	{ 1,	25,	"cs-fallback-high-priority" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_S1ap_CSFallbackIndicator_enum2value_1[] = {
+	1,	/* cs-fallback-high-priority(1) */
+	0	/* cs-fallback-required(0) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_S1ap_CSFallbackIndicator_specs_1 = {
+	asn_MAP_S1ap_CSFallbackIndicator_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_S1ap_CSFallbackIndicator_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	2,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CSFallbackIndicator_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CSFallbackIndicator = {
+	"S1ap-CSFallbackIndicator",
+	"S1ap-CSFallbackIndicator",
+	S1ap_CSFallbackIndicator_free,
+	S1ap_CSFallbackIndicator_print,
+	S1ap_CSFallbackIndicator_constraint,
+	S1ap_CSFallbackIndicator_decode_ber,
+	S1ap_CSFallbackIndicator_encode_der,
+	S1ap_CSFallbackIndicator_decode_xer,
+	S1ap_CSFallbackIndicator_encode_xer,
+	S1ap_CSFallbackIndicator_decode_uper,
+	S1ap_CSFallbackIndicator_encode_uper,
+	S1ap_CSFallbackIndicator_decode_aper,
+	S1ap_CSFallbackIndicator_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CSFallbackIndicator_tags_1,
+	sizeof(asn_DEF_S1ap_CSFallbackIndicator_tags_1)
+		/sizeof(asn_DEF_S1ap_CSFallbackIndicator_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CSFallbackIndicator_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CSFallbackIndicator_tags_1)
+		/sizeof(asn_DEF_S1ap_CSFallbackIndicator_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CSFallbackIndicator_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_S1ap_CSFallbackIndicator_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CSFallbackIndicator.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CSFallbackIndicator_H_
+#define	_S1ap_CSFallbackIndicator_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_CSFallbackIndicator {
+	S1ap_CSFallbackIndicator_cs_fallback_required	= 0,
+	/*
+	 * Enumeration is extensible
+	 */
+	S1ap_CSFallbackIndicator_cs_fallback_high_priority	= 1
+} e_S1ap_CSFallbackIndicator;
+
+/* S1ap-CSFallbackIndicator */
+typedef long	 S1ap_CSFallbackIndicator_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CSFallbackIndicator;
+asn_struct_free_f S1ap_CSFallbackIndicator_free;
+asn_struct_print_f S1ap_CSFallbackIndicator_print;
+asn_constr_check_f S1ap_CSFallbackIndicator_constraint;
+ber_type_decoder_f S1ap_CSFallbackIndicator_decode_ber;
+der_type_encoder_f S1ap_CSFallbackIndicator_encode_der;
+xer_type_decoder_f S1ap_CSFallbackIndicator_decode_xer;
+xer_type_encoder_f S1ap_CSFallbackIndicator_encode_xer;
+per_type_decoder_f S1ap_CSFallbackIndicator_decode_uper;
+per_type_encoder_f S1ap_CSFallbackIndicator_encode_uper;
+per_type_decoder_f S1ap_CSFallbackIndicator_decode_aper;
+per_type_encoder_f S1ap_CSFallbackIndicator_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_CSFallbackIndicator_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CSG-Id.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CSG-Id.h"
+
+int
+S1ap_CSG_Id_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 27LL)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_CSG_Id_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_BIT_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_BIT_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+S1ap_CSG_Id_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_CSG_Id_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSG_Id_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_CSG_Id_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSG_Id_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_CSG_Id_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSG_Id_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_CSG_Id_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_CSG_Id_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_CSG_Id_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CSG_Id_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_CSG_Id_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  27l,  27l }	/* (SIZE(27..27)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CSG_Id_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CSG_Id = {
+	"S1ap-CSG-Id",
+	"S1ap-CSG-Id",
+	S1ap_CSG_Id_free,
+	S1ap_CSG_Id_print,
+	S1ap_CSG_Id_constraint,
+	S1ap_CSG_Id_decode_ber,
+	S1ap_CSG_Id_encode_der,
+	S1ap_CSG_Id_decode_xer,
+	S1ap_CSG_Id_encode_xer,
+	S1ap_CSG_Id_decode_uper,
+	S1ap_CSG_Id_encode_uper,
+	S1ap_CSG_Id_decode_aper,
+	S1ap_CSG_Id_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CSG_Id_tags_1,
+	sizeof(asn_DEF_S1ap_CSG_Id_tags_1)
+		/sizeof(asn_DEF_S1ap_CSG_Id_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CSG_Id_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CSG_Id_tags_1)
+		/sizeof(asn_DEF_S1ap_CSG_Id_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CSG_Id_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

lib/asn/asn1c/S1ap-CSG-Id.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CSG_Id_H_
+#define	_S1ap_CSG_Id_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* S1ap-CSG-Id */
+typedef BIT_STRING_t	 S1ap_CSG_Id_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CSG_Id;
+asn_struct_free_f S1ap_CSG_Id_free;
+asn_struct_print_f S1ap_CSG_Id_print;
+asn_constr_check_f S1ap_CSG_Id_constraint;
+ber_type_decoder_f S1ap_CSG_Id_decode_ber;
+der_type_encoder_f S1ap_CSG_Id_encode_der;
+xer_type_decoder_f S1ap_CSG_Id_decode_xer;
+xer_type_encoder_f S1ap_CSG_Id_encode_xer;
+per_type_decoder_f S1ap_CSG_Id_decode_uper;
+per_type_encoder_f S1ap_CSG_Id_encode_uper;
+per_type_decoder_f S1ap_CSG_Id_decode_aper;
+per_type_encoder_f S1ap_CSG_Id_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_CSG_Id_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CSG-IdList-Item.c

@@ -0,0 +1,74 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CSG-IdList-Item.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_CSG_IdList_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CSG_IdList_Item, cSG_Id),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CSG_Id,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cSG-Id"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_CSG_IdList_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P24,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_CSG_IdList_Item_oms_1[] = { 1 };
+static const ber_tlv_tag_t asn_DEF_S1ap_CSG_IdList_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_CSG_IdList_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* cSG-Id */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_CSG_IdList_Item_specs_1 = {
+	sizeof(struct S1ap_CSG_IdList_Item),
+	offsetof(struct S1ap_CSG_IdList_Item, _asn_ctx),
+	asn_MAP_S1ap_CSG_IdList_Item_tag2el_1,
+	2,	/* Count of tags in the map */
+	asn_MAP_S1ap_CSG_IdList_Item_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	1,	/* Start extensions */
+	3	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CSG_IdList_Item = {
+	"S1ap-CSG-IdList-Item",
+	"S1ap-CSG-IdList-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CSG_IdList_Item_tags_1,
+	sizeof(asn_DEF_S1ap_CSG_IdList_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_CSG_IdList_Item_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CSG_IdList_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CSG_IdList_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_CSG_IdList_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_CSG_IdList_Item_1,
+	2,	/* Elements count */
+	&asn_SPC_S1ap_CSG_IdList_Item_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CSG-IdList-Item.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CSG_IdList_Item_H_
+#define	_S1ap_CSG_IdList_Item_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-CSG-Id.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-CSG-IdList-Item */
+typedef struct S1ap_CSG_IdList_Item {
+	S1ap_CSG_Id_t	 cSG_Id;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CSG_IdList_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CSG_IdList_Item;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_CSG_IdList_Item_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CSG-IdList.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CSG-IdList.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_CSG_IdList_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1l,  256l }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_CSG_IdList_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_S1ap_CSG_IdList_Item,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CSG_IdList_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_S1ap_CSG_IdList_specs_1 = {
+	sizeof(struct S1ap_CSG_IdList),
+	offsetof(struct S1ap_CSG_IdList, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CSG_IdList = {
+	"S1ap-CSG-IdList",
+	"S1ap-CSG-IdList",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CSG_IdList_tags_1,
+	sizeof(asn_DEF_S1ap_CSG_IdList_tags_1)
+		/sizeof(asn_DEF_S1ap_CSG_IdList_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CSG_IdList_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CSG_IdList_tags_1)
+		/sizeof(asn_DEF_S1ap_CSG_IdList_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CSG_IdList_constr_1,
+	asn_MBR_S1ap_CSG_IdList_1,
+	1,	/* Single element */
+	&asn_SPC_S1ap_CSG_IdList_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CSG-IdList.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CSG_IdList_H_
+#define	_S1ap_CSG_IdList_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct S1ap_CSG_IdList_Item;
+
+/* S1ap-CSG-IdList */
+typedef struct S1ap_CSG_IdList {
+	A_SEQUENCE_OF(struct S1ap_CSG_IdList_Item) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CSG_IdList_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CSG_IdList;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "S1ap-CSG-IdList-Item.h"
+
+#endif	/* _S1ap_CSG_IdList_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CSGMembershipStatus.c

@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CSGMembershipStatus.h"
+
+int
+S1ap_CSGMembershipStatus_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+S1ap_CSGMembershipStatus_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_CSGMembershipStatus_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSGMembershipStatus_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_CSGMembershipStatus_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSGMembershipStatus_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_CSGMembershipStatus_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CSGMembershipStatus_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_CSGMembershipStatus_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_CSGMembershipStatus_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_CSGMembershipStatus_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_CSGMembershipStatus_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 1,  1,  0l,  1l }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_S1ap_CSGMembershipStatus_value2enum_1[] = {
+	{ 0,	6,	"member" },
+	{ 1,	10,	"not-member" }
+};
+static const unsigned int asn_MAP_S1ap_CSGMembershipStatus_enum2value_1[] = {
+	0,	/* member(0) */
+	1	/* not-member(1) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_S1ap_CSGMembershipStatus_specs_1 = {
+	asn_MAP_S1ap_CSGMembershipStatus_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_S1ap_CSGMembershipStatus_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CSGMembershipStatus_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CSGMembershipStatus = {
+	"S1ap-CSGMembershipStatus",
+	"S1ap-CSGMembershipStatus",
+	S1ap_CSGMembershipStatus_free,
+	S1ap_CSGMembershipStatus_print,
+	S1ap_CSGMembershipStatus_constraint,
+	S1ap_CSGMembershipStatus_decode_ber,
+	S1ap_CSGMembershipStatus_encode_der,
+	S1ap_CSGMembershipStatus_decode_xer,
+	S1ap_CSGMembershipStatus_encode_xer,
+	S1ap_CSGMembershipStatus_decode_uper,
+	S1ap_CSGMembershipStatus_encode_uper,
+	S1ap_CSGMembershipStatus_decode_aper,
+	S1ap_CSGMembershipStatus_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CSGMembershipStatus_tags_1,
+	sizeof(asn_DEF_S1ap_CSGMembershipStatus_tags_1)
+		/sizeof(asn_DEF_S1ap_CSGMembershipStatus_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CSGMembershipStatus_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CSGMembershipStatus_tags_1)
+		/sizeof(asn_DEF_S1ap_CSGMembershipStatus_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CSGMembershipStatus_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_S1ap_CSGMembershipStatus_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CSGMembershipStatus.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CSGMembershipStatus_H_
+#define	_S1ap_CSGMembershipStatus_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_CSGMembershipStatus {
+	S1ap_CSGMembershipStatus_member	= 0,
+	S1ap_CSGMembershipStatus_not_member	= 1
+} e_S1ap_CSGMembershipStatus;
+
+/* S1ap-CSGMembershipStatus */
+typedef long	 S1ap_CSGMembershipStatus_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CSGMembershipStatus;
+asn_struct_free_f S1ap_CSGMembershipStatus_free;
+asn_struct_print_f S1ap_CSGMembershipStatus_print;
+asn_constr_check_f S1ap_CSGMembershipStatus_constraint;
+ber_type_decoder_f S1ap_CSGMembershipStatus_decode_ber;
+der_type_encoder_f S1ap_CSGMembershipStatus_encode_der;
+xer_type_decoder_f S1ap_CSGMembershipStatus_decode_xer;
+xer_type_encoder_f S1ap_CSGMembershipStatus_encode_xer;
+per_type_decoder_f S1ap_CSGMembershipStatus_decode_uper;
+per_type_encoder_f S1ap_CSGMembershipStatus_encode_uper;
+per_type_decoder_f S1ap_CSGMembershipStatus_decode_aper;
+per_type_encoder_f S1ap_CSGMembershipStatus_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_CSGMembershipStatus_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CancelledCellinEAI-Item.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CancelledCellinEAI-Item.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_CancelledCellinEAI_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CancelledCellinEAI_Item, eCGI),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_EUTRAN_CGI,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"eCGI"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CancelledCellinEAI_Item, numberOfBroadcasts),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_NumberOfBroadcasts,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"numberOfBroadcasts"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_CancelledCellinEAI_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P16,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_CancelledCellinEAI_Item_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_CancelledCellinEAI_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* eCGI */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* numberOfBroadcasts */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_CancelledCellinEAI_Item_specs_1 = {
+	sizeof(struct S1ap_CancelledCellinEAI_Item),
+	offsetof(struct S1ap_CancelledCellinEAI_Item, _asn_ctx),
+	asn_MAP_S1ap_CancelledCellinEAI_Item_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_S1ap_CancelledCellinEAI_Item_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinEAI_Item = {
+	"S1ap-CancelledCellinEAI-Item",
+	"S1ap-CancelledCellinEAI-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1,
+	sizeof(asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinEAI_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_CancelledCellinEAI_Item_1,
+	3,	/* Elements count */
+	&asn_SPC_S1ap_CancelledCellinEAI_Item_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CancelledCellinEAI-Item.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CancelledCellinEAI_Item_H_
+#define	_S1ap_CancelledCellinEAI_Item_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-EUTRAN-CGI.h"
+#include "S1ap-NumberOfBroadcasts.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-CancelledCellinEAI-Item */
+typedef struct S1ap_CancelledCellinEAI_Item {
+	S1ap_EUTRAN_CGI_t	 eCGI;
+	S1ap_NumberOfBroadcasts_t	 numberOfBroadcasts;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CancelledCellinEAI_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinEAI_Item;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_CancelledCellinEAI_Item_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CancelledCellinEAI.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CancelledCellinEAI.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_CancelledCellinEAI_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_CancelledCellinEAI_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_S1ap_CancelledCellinEAI_Item,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CancelledCellinEAI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_S1ap_CancelledCellinEAI_specs_1 = {
+	sizeof(struct S1ap_CancelledCellinEAI),
+	offsetof(struct S1ap_CancelledCellinEAI, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinEAI = {
+	"S1ap-CancelledCellinEAI",
+	"S1ap-CancelledCellinEAI",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CancelledCellinEAI_tags_1,
+	sizeof(asn_DEF_S1ap_CancelledCellinEAI_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinEAI_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CancelledCellinEAI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CancelledCellinEAI_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinEAI_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CancelledCellinEAI_constr_1,
+	asn_MBR_S1ap_CancelledCellinEAI_1,
+	1,	/* Single element */
+	&asn_SPC_S1ap_CancelledCellinEAI_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CancelledCellinEAI.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CancelledCellinEAI_H_
+#define	_S1ap_CancelledCellinEAI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct S1ap_CancelledCellinEAI_Item;
+
+/* S1ap-CancelledCellinEAI */
+typedef struct S1ap_CancelledCellinEAI {
+	A_SEQUENCE_OF(struct S1ap_CancelledCellinEAI_Item) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CancelledCellinEAI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinEAI;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "S1ap-CancelledCellinEAI-Item.h"
+
+#endif	/* _S1ap_CancelledCellinEAI_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CancelledCellinTAI-Item.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CancelledCellinTAI-Item.h"
+
+static asn_TYPE_member_t asn_MBR_S1ap_CancelledCellinTAI_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CancelledCellinTAI_Item, eCGI),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_EUTRAN_CGI,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"eCGI"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_CancelledCellinTAI_Item, numberOfBroadcasts),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_NumberOfBroadcasts,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"numberOfBroadcasts"
+		},
+	{ ATF_POINTER, 1, offsetof(struct S1ap_CancelledCellinTAI_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolExtensionContainer_5749P17,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_S1ap_CancelledCellinTAI_Item_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_CancelledCellinTAI_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* eCGI */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* numberOfBroadcasts */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_S1ap_CancelledCellinTAI_Item_specs_1 = {
+	sizeof(struct S1ap_CancelledCellinTAI_Item),
+	offsetof(struct S1ap_CancelledCellinTAI_Item, _asn_ctx),
+	asn_MAP_S1ap_CancelledCellinTAI_Item_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_S1ap_CancelledCellinTAI_Item_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinTAI_Item = {
+	"S1ap-CancelledCellinTAI-Item",
+	"S1ap-CancelledCellinTAI-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1,
+	sizeof(asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinTAI_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_S1ap_CancelledCellinTAI_Item_1,
+	3,	/* Elements count */
+	&asn_SPC_S1ap_CancelledCellinTAI_Item_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CancelledCellinTAI-Item.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CancelledCellinTAI_Item_H_
+#define	_S1ap_CancelledCellinTAI_Item_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-EUTRAN-CGI.h"
+#include "S1ap-NumberOfBroadcasts.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ProtocolExtensionContainer;
+
+/* S1ap-CancelledCellinTAI-Item */
+typedef struct S1ap_CancelledCellinTAI_Item {
+	S1ap_EUTRAN_CGI_t	 eCGI;
+	S1ap_NumberOfBroadcasts_t	 numberOfBroadcasts;
+	struct ProtocolExtensionContainer	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CancelledCellinTAI_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinTAI_Item;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ProtocolExtensionContainer.h"
+
+#endif	/* _S1ap_CancelledCellinTAI_Item_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CancelledCellinTAI.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CancelledCellinTAI.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_CancelledCellinTAI_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_CancelledCellinTAI_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_S1ap_CancelledCellinTAI_Item,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CancelledCellinTAI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_S1ap_CancelledCellinTAI_specs_1 = {
+	sizeof(struct S1ap_CancelledCellinTAI),
+	offsetof(struct S1ap_CancelledCellinTAI, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinTAI = {
+	"S1ap-CancelledCellinTAI",
+	"S1ap-CancelledCellinTAI",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CancelledCellinTAI_tags_1,
+	sizeof(asn_DEF_S1ap_CancelledCellinTAI_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinTAI_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CancelledCellinTAI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CancelledCellinTAI_tags_1)
+		/sizeof(asn_DEF_S1ap_CancelledCellinTAI_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CancelledCellinTAI_constr_1,
+	asn_MBR_S1ap_CancelledCellinTAI_1,
+	1,	/* Single element */
+	&asn_SPC_S1ap_CancelledCellinTAI_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-CancelledCellinTAI.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_CancelledCellinTAI_H_
+#define	_S1ap_CancelledCellinTAI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct S1ap_CancelledCellinTAI_Item;
+
+/* S1ap-CancelledCellinTAI */
+typedef struct S1ap_CancelledCellinTAI {
+	A_SEQUENCE_OF(struct S1ap_CancelledCellinTAI_Item) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_CancelledCellinTAI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_CancelledCellinTAI;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "S1ap-CancelledCellinTAI-Item.h"
+
+#endif	/* _S1ap_CancelledCellinTAI_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-Cause.c

@@ -0,0 +1,103 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-Cause.h"
+
+static asn_per_constraints_t asn_PER_type_S1ap_Cause_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0l,  4l }	/* (0..4,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_S1ap_Cause_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Cause, choice.radioNetwork),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CauseRadioNetwork,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"radioNetwork"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Cause, choice.transport),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CauseTransport,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"transport"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Cause, choice.nas),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CauseNas,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"nas"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Cause, choice.protocol),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CauseProtocol,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"protocol"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct S1ap_Cause, choice.misc),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_S1ap_CauseMisc,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"misc"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_S1ap_Cause_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* radioNetwork */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* transport */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* nas */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* misc */
+};
+static asn_CHOICE_specifics_t asn_SPC_S1ap_Cause_specs_1 = {
+	sizeof(struct S1ap_Cause),
+	offsetof(struct S1ap_Cause, _asn_ctx),
+	offsetof(struct S1ap_Cause, present),
+	sizeof(((struct S1ap_Cause *)0)->present),
+	asn_MAP_S1ap_Cause_tag2el_1,
+	5,	/* Count of tags in the map */
+	0,
+	5	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_Cause = {
+	"S1ap-Cause",
+	"S1ap-Cause",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_decode_aper,
+	CHOICE_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_S1ap_Cause_constr_1,
+	asn_MBR_S1ap_Cause_1,
+	5,	/* Elements count */
+	&asn_SPC_S1ap_Cause_specs_1	/* Additional specs */
+};
+

lib/asn/asn1c/S1ap-Cause.h

@@ -0,0 +1,65 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#ifndef	_S1ap_Cause_H_
+#define	_S1ap_Cause_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "S1ap-CauseRadioNetwork.h"
+#include "S1ap-CauseTransport.h"
+#include "S1ap-CauseNas.h"
+#include "S1ap-CauseProtocol.h"
+#include "S1ap-CauseMisc.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum S1ap_Cause_PR {
+	S1ap_Cause_PR_NOTHING,	/* No components present */
+	S1ap_Cause_PR_radioNetwork,
+	S1ap_Cause_PR_transport,
+	S1ap_Cause_PR_nas,
+	S1ap_Cause_PR_protocol,
+	S1ap_Cause_PR_misc,
+	/* Extensions may appear below */
+	
+} S1ap_Cause_PR;
+
+/* S1ap-Cause */
+typedef struct S1ap_Cause {
+	S1ap_Cause_PR present;
+	union S1ap_Cause_u {
+		S1ap_CauseRadioNetwork_t	 radioNetwork;
+		S1ap_CauseTransport_t	 transport;
+		S1ap_CauseNas_t	 nas;
+		S1ap_CauseProtocol_t	 protocol;
+		S1ap_CauseMisc_t	 misc;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} S1ap_Cause_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_S1ap_Cause;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _S1ap_Cause_H_ */
+#include <asn_internal.h>

lib/asn/asn1c/S1ap-CauseMisc.c

@@ -0,0 +1,176 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "S1AP-IEs"
+ * 	found in "../support/S1AP-PDU.asn"
+ * 	`asn1c -fcompound-names`
+ */
+
+#include "S1ap-CauseMisc.h"
+
+int
+S1ap_CauseMisc_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+S1ap_CauseMisc_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+S1ap_CauseMisc_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+S1ap_CauseMisc_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CauseMisc_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+S1ap_CauseMisc_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CauseMisc_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+S1ap_CauseMisc_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+S1ap_CauseMisc_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+S1ap_CauseMisc_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+S1ap_CauseMisc_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+S1ap_CauseMisc_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	S1ap_CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_S1ap_CauseMisc_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0l,  5l }	/* (0..5,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_S1ap_CauseMisc_value2enum_1[] = {
+	{ 0,	27,	"control-processing-overload" },
+	{ 1,	42,	"not-enough-user-plane-processing-resources" },
+	{ 2,	16,	"hardware-failure" },
+	{ 3,	15,	"om-intervention" },
+	{ 4,	11,	"unspecified" },
+	{ 5,	12,	"unknown-PLMN" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_S1ap_CauseMisc_enum2value_1[] = {
+	0,	/* control-processing-overload(0) */
+	2,	/* hardware-failure(2) */
+	1,	/* not-enough-user-plane-processing-resources(1) */
+	3,	/* om-intervention(3) */
+	5,	/* unknown-PLMN(5) */
+	4	/* unspecified(4) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_S1ap_CauseMisc_specs_1 = {
+	asn_MAP_S1ap_CauseMisc_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_S1ap_CauseMisc_enum2value_1,	/* N => "tag"; sorted by N */
+	6,	/* Number of elements in the maps */
+	7,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_S1ap_CauseMisc_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_S1ap_CauseMisc = {
+	"S1ap-CauseMisc",
+	"S1ap-CauseMisc",
+	S1ap_CauseMisc_free,
+	S1ap_CauseMisc_print,
+	S1ap_CauseMisc_constraint,
+	S1ap_CauseMisc_decode_ber,
+	S1ap_CauseMisc_encode_der,
+	S1ap_CauseMisc_decode_xer,
+	S1ap_CauseMisc_encode_xer,
+	S1ap_CauseMisc_decode_uper,
+	S1ap_CauseMisc_encode_uper,
+	S1ap_CauseMisc_decode_aper,
+	S1ap_CauseMisc_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_S1ap_CauseMisc_tags_1,
+	sizeof(asn_DEF_S1ap_CauseMisc_tags_1)
+		/sizeof(asn_DEF_S1ap_CauseMisc_tags_1[0]), /* 1 */
+	asn_DEF_S1ap_CauseMisc_tags_1,	/* Same as above */
+	sizeof(asn_DEF_S1ap_CauseMisc_tags_1)
+		/sizeof(asn_DEF_S1ap_CauseMisc_tags_1[0]), /* 1 */
+	&asn_PER_type_S1ap_CauseMisc_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_S1ap_CauseMisc_specs_1	/* Additional specs */
+};
+