import ans1c generated C sources for HNBAP

TODO: split the HNBAP specific code from the core runtime code
and use libosmo-asn1c instead.  This is required as we will be
dealing with multiple ASN.1 data formats from within a single
executable.

src/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;
+}
+

src/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 */

src/asn1c/Access-stratum-release-indicator.c

@@ -0,0 +1,176 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "Access-stratum-release-indicator.h"
+
+int
+Access_stratum_release_indicator_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
+Access_stratum_release_indicator_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
+Access_stratum_release_indicator_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Access_stratum_release_indicator_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Access_stratum_release_indicator_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) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Access_stratum_release_indicator_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) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Access_stratum_release_indicator_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) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Access_stratum_release_indicator_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) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Access_stratum_release_indicator_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) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+Access_stratum_release_indicator_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+Access_stratum_release_indicator_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Access_stratum_release_indicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+Access_stratum_release_indicator_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) {
+	Access_stratum_release_indicator_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_Access_stratum_release_indicator_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_Access_stratum_release_indicator_value2enum_1[] = {
+	{ 0,	3,	"r99" },
+	{ 1,	5,	"rel-4" },
+	{ 2,	5,	"rel-5" },
+	{ 3,	5,	"rel-6" },
+	{ 4,	5,	"rel-7" },
+	{ 5,	16,	"rel-8-and-beyond" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_Access_stratum_release_indicator_enum2value_1[] = {
+	0,	/* r99(0) */
+	1,	/* rel-4(1) */
+	2,	/* rel-5(2) */
+	3,	/* rel-6(3) */
+	4,	/* rel-7(4) */
+	5	/* rel-8-and-beyond(5) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_Access_stratum_release_indicator_specs_1 = {
+	asn_MAP_Access_stratum_release_indicator_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Access_stratum_release_indicator_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_Access_stratum_release_indicator_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Access_stratum_release_indicator = {
+	"Access-stratum-release-indicator",
+	"Access-stratum-release-indicator",
+	Access_stratum_release_indicator_free,
+	Access_stratum_release_indicator_print,
+	Access_stratum_release_indicator_constraint,
+	Access_stratum_release_indicator_decode_ber,
+	Access_stratum_release_indicator_encode_der,
+	Access_stratum_release_indicator_decode_xer,
+	Access_stratum_release_indicator_encode_xer,
+	Access_stratum_release_indicator_decode_uper,
+	Access_stratum_release_indicator_encode_uper,
+	Access_stratum_release_indicator_decode_aper,
+	Access_stratum_release_indicator_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Access_stratum_release_indicator_tags_1,
+	sizeof(asn_DEF_Access_stratum_release_indicator_tags_1)
+		/sizeof(asn_DEF_Access_stratum_release_indicator_tags_1[0]), /* 1 */
+	asn_DEF_Access_stratum_release_indicator_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Access_stratum_release_indicator_tags_1)
+		/sizeof(asn_DEF_Access_stratum_release_indicator_tags_1[0]), /* 1 */
+	&asn_PER_type_Access_stratum_release_indicator_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Access_stratum_release_indicator_specs_1	/* Additional specs */
+};
+

src/asn1c/Access-stratum-release-indicator.h

@@ -0,0 +1,56 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_Access_stratum_release_indicator_H_
+#define	_Access_stratum_release_indicator_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Access_stratum_release_indicator {
+	Access_stratum_release_indicator_r99	= 0,
+	Access_stratum_release_indicator_rel_4	= 1,
+	Access_stratum_release_indicator_rel_5	= 2,
+	Access_stratum_release_indicator_rel_6	= 3,
+	Access_stratum_release_indicator_rel_7	= 4,
+	Access_stratum_release_indicator_rel_8_and_beyond	= 5
+	/*
+	 * Enumeration is extensible
+	 */
+} e_Access_stratum_release_indicator;
+
+/* Access-stratum-release-indicator */
+typedef long	 Access_stratum_release_indicator_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Access_stratum_release_indicator;
+asn_struct_free_f Access_stratum_release_indicator_free;
+asn_struct_print_f Access_stratum_release_indicator_print;
+asn_constr_check_f Access_stratum_release_indicator_constraint;
+ber_type_decoder_f Access_stratum_release_indicator_decode_ber;
+der_type_encoder_f Access_stratum_release_indicator_encode_der;
+xer_type_decoder_f Access_stratum_release_indicator_decode_xer;
+xer_type_encoder_f Access_stratum_release_indicator_encode_xer;
+per_type_decoder_f Access_stratum_release_indicator_decode_uper;
+per_type_encoder_f Access_stratum_release_indicator_encode_uper;
+per_type_decoder_f Access_stratum_release_indicator_decode_aper;
+per_type_encoder_f Access_stratum_release_indicator_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Access_stratum_release_indicator_H_ */
+#include <asn_internal.h>

src/asn1c/AccessResult.c

@@ -0,0 +1,168 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "AccessResult.h"
+
+int
+AccessResult_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
+AccessResult_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
+AccessResult_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AccessResult_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AccessResult_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) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AccessResult_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) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AccessResult_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) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AccessResult_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) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+AccessResult_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) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+AccessResult_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+AccessResult_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	AccessResult_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+AccessResult_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) {
+	AccessResult_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_AccessResult_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  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_AccessResult_value2enum_1[] = {
+	{ 0,	7,	"allowed" },
+	{ 1,	10,	"notAllowed" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_AccessResult_enum2value_1[] = {
+	0,	/* allowed(0) */
+	1	/* notAllowed(1) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_AccessResult_specs_1 = {
+	asn_MAP_AccessResult_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_AccessResult_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_AccessResult_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AccessResult = {
+	"AccessResult",
+	"AccessResult",
+	AccessResult_free,
+	AccessResult_print,
+	AccessResult_constraint,
+	AccessResult_decode_ber,
+	AccessResult_encode_der,
+	AccessResult_decode_xer,
+	AccessResult_encode_xer,
+	AccessResult_decode_uper,
+	AccessResult_encode_uper,
+	AccessResult_decode_aper,
+	AccessResult_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AccessResult_tags_1,
+	sizeof(asn_DEF_AccessResult_tags_1)
+		/sizeof(asn_DEF_AccessResult_tags_1[0]), /* 1 */
+	asn_DEF_AccessResult_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AccessResult_tags_1)
+		/sizeof(asn_DEF_AccessResult_tags_1[0]), /* 1 */
+	&asn_PER_type_AccessResult_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_AccessResult_specs_1	/* Additional specs */
+};
+

src/asn1c/AccessResult.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_AccessResult_H_
+#define	_AccessResult_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum AccessResult {
+	AccessResult_allowed	= 0,
+	AccessResult_notAllowed	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_AccessResult;
+
+/* AccessResult */
+typedef long	 AccessResult_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AccessResult;
+asn_struct_free_f AccessResult_free;
+asn_struct_print_f AccessResult_print;
+asn_constr_check_f AccessResult_constraint;
+ber_type_decoder_f AccessResult_decode_ber;
+der_type_encoder_f AccessResult_encode_der;
+xer_type_decoder_f AccessResult_decode_xer;
+xer_type_encoder_f AccessResult_encode_xer;
+per_type_decoder_f AccessResult_decode_uper;
+per_type_encoder_f AccessResult_encode_uper;
+per_type_decoder_f AccessResult_decode_aper;
+per_type_encoder_f AccessResult_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AccessResult_H_ */
+#include <asn_internal.h>

src/asn1c/AdditionalNeighbourInfoList.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "AdditionalNeighbourInfoList.h"
+
+static asn_per_constraints_t asn_PER_type_AdditionalNeighbourInfoList_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 7,  7,  1l,  128l }	/* (SIZE(1..128)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_AdditionalNeighbourInfoList_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_HNBConfigInfo,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_AdditionalNeighbourInfoList_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_AdditionalNeighbourInfoList_specs_1 = {
+	sizeof(struct AdditionalNeighbourInfoList),
+	offsetof(struct AdditionalNeighbourInfoList, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_AdditionalNeighbourInfoList = {
+	"AdditionalNeighbourInfoList",
+	"AdditionalNeighbourInfoList",
+	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_AdditionalNeighbourInfoList_tags_1,
+	sizeof(asn_DEF_AdditionalNeighbourInfoList_tags_1)
+		/sizeof(asn_DEF_AdditionalNeighbourInfoList_tags_1[0]), /* 1 */
+	asn_DEF_AdditionalNeighbourInfoList_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AdditionalNeighbourInfoList_tags_1)
+		/sizeof(asn_DEF_AdditionalNeighbourInfoList_tags_1[0]), /* 1 */
+	&asn_PER_type_AdditionalNeighbourInfoList_constr_1,
+	asn_MBR_AdditionalNeighbourInfoList_1,
+	1,	/* Single element */
+	&asn_SPC_AdditionalNeighbourInfoList_specs_1	/* Additional specs */
+};
+

src/asn1c/AdditionalNeighbourInfoList.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_AdditionalNeighbourInfoList_H_
+#define	_AdditionalNeighbourInfoList_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 HNBConfigInfo;
+
+/* AdditionalNeighbourInfoList */
+typedef struct AdditionalNeighbourInfoList {
+	A_SEQUENCE_OF(struct HNBConfigInfo) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AdditionalNeighbourInfoList_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AdditionalNeighbourInfoList;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "HNBConfigInfo.h"
+
+#endif	/* _AdditionalNeighbourInfoList_H_ */
+#include <asn_internal.h>

src/asn1c/AltitudeAndDirection.c

@@ -0,0 +1,261 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "AltitudeAndDirection.h"
+
+static int
+directionOfAltitude_2_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
+directionOfAltitude_2_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 */
+}
+
+static void
+directionOfAltitude_2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+directionOfAltitude_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+directionOfAltitude_2_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) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+directionOfAltitude_2_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) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+directionOfAltitude_2_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) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+directionOfAltitude_2_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) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_dec_rval_t
+directionOfAltitude_2_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) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_enc_rval_t
+directionOfAltitude_2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_enc_rval_t
+directionOfAltitude_2_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_dec_rval_t
+directionOfAltitude_2_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) {
+	directionOfAltitude_2_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static int
+memb_altitude_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	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 *)sptr;
+	
+	if((value >= 0l && value <= 32767l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_directionOfAltitude_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_altitude_constr_5 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 15,  15,  0l,  32767l }	/* (0..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_directionOfAltitude_value2enum_2[] = {
+	{ 0,	6,	"height" },
+	{ 1,	5,	"depth" }
+};
+static const unsigned int asn_MAP_directionOfAltitude_enum2value_2[] = {
+	1,	/* depth(1) */
+	0	/* height(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_directionOfAltitude_specs_2 = {
+	asn_MAP_directionOfAltitude_value2enum_2,	/* "tag" => N; sorted by tag */
+	asn_MAP_directionOfAltitude_enum2value_2,	/* 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_directionOfAltitude_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_directionOfAltitude_2 = {
+	"directionOfAltitude",
+	"directionOfAltitude",
+	directionOfAltitude_2_free,
+	directionOfAltitude_2_print,
+	directionOfAltitude_2_constraint,
+	directionOfAltitude_2_decode_ber,
+	directionOfAltitude_2_encode_der,
+	directionOfAltitude_2_decode_xer,
+	directionOfAltitude_2_encode_xer,
+	directionOfAltitude_2_decode_uper,
+	directionOfAltitude_2_encode_uper,
+	directionOfAltitude_2_decode_aper,
+	directionOfAltitude_2_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_directionOfAltitude_tags_2,
+	sizeof(asn_DEF_directionOfAltitude_tags_2)
+		/sizeof(asn_DEF_directionOfAltitude_tags_2[0]) - 1, /* 1 */
+	asn_DEF_directionOfAltitude_tags_2,	/* Same as above */
+	sizeof(asn_DEF_directionOfAltitude_tags_2)
+		/sizeof(asn_DEF_directionOfAltitude_tags_2[0]), /* 2 */
+	&asn_PER_type_directionOfAltitude_constr_2,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_directionOfAltitude_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_AltitudeAndDirection_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AltitudeAndDirection, directionOfAltitude),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_directionOfAltitude_2,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"directionOfAltitude"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AltitudeAndDirection, altitude),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_altitude_constraint_1,
+		&asn_PER_memb_altitude_constr_5,
+		0,
+		"altitude"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_AltitudeAndDirection_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_AltitudeAndDirection_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* directionOfAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* altitude */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AltitudeAndDirection_specs_1 = {
+	sizeof(struct AltitudeAndDirection),
+	offsetof(struct AltitudeAndDirection, _asn_ctx),
+	asn_MAP_AltitudeAndDirection_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* Start extensions */
+	3	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AltitudeAndDirection = {
+	"AltitudeAndDirection",
+	"AltitudeAndDirection",
+	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_AltitudeAndDirection_tags_1,
+	sizeof(asn_DEF_AltitudeAndDirection_tags_1)
+		/sizeof(asn_DEF_AltitudeAndDirection_tags_1[0]), /* 1 */
+	asn_DEF_AltitudeAndDirection_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AltitudeAndDirection_tags_1)
+		/sizeof(asn_DEF_AltitudeAndDirection_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AltitudeAndDirection_1,
+	2,	/* Elements count */
+	&asn_SPC_AltitudeAndDirection_specs_1	/* Additional specs */
+};
+

src/asn1c/AltitudeAndDirection.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_AltitudeAndDirection_H_
+#define	_AltitudeAndDirection_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum directionOfAltitude {
+	directionOfAltitude_height	= 0,
+	directionOfAltitude_depth	= 1
+} e_directionOfAltitude;
+
+/* AltitudeAndDirection */
+typedef struct AltitudeAndDirection {
+	long	 directionOfAltitude;
+	long	 altitude;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AltitudeAndDirection_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_directionOfAltitude_2;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_AltitudeAndDirection;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AltitudeAndDirection_H_ */
+#include <asn_internal.h>

src/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) _i_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)
+		_i_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) _i_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;
+}
+

src/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_ */

src/asn1c/BackoffTimer.c

@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "BackoffTimer.h"
+
+int
+BackoffTimer_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	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 *)sptr;
+	
+	if((value >= 0l && value <= 3600l)) {
+		/* 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 NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+BackoffTimer_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+BackoffTimer_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BackoffTimer_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BackoffTimer_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) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BackoffTimer_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) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BackoffTimer_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) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BackoffTimer_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) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+BackoffTimer_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) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+BackoffTimer_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+BackoffTimer_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BackoffTimer_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+BackoffTimer_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) {
+	BackoffTimer_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_BackoffTimer_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 12,  12,  0l,  3600l }	/* (0..3600) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_BackoffTimer_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BackoffTimer = {
+	"BackoffTimer",
+	"BackoffTimer",
+	BackoffTimer_free,
+	BackoffTimer_print,
+	BackoffTimer_constraint,
+	BackoffTimer_decode_ber,
+	BackoffTimer_encode_der,
+	BackoffTimer_decode_xer,
+	BackoffTimer_encode_xer,
+	BackoffTimer_decode_uper,
+	BackoffTimer_encode_uper,
+	BackoffTimer_decode_aper,
+	BackoffTimer_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BackoffTimer_tags_1,
+	sizeof(asn_DEF_BackoffTimer_tags_1)
+		/sizeof(asn_DEF_BackoffTimer_tags_1[0]), /* 1 */
+	asn_DEF_BackoffTimer_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BackoffTimer_tags_1)
+		/sizeof(asn_DEF_BackoffTimer_tags_1[0]), /* 1 */
+	&asn_PER_type_BackoffTimer_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/BackoffTimer.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_BackoffTimer_H_
+#define	_BackoffTimer_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BackoffTimer */
+typedef long	 BackoffTimer_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BackoffTimer;
+asn_struct_free_f BackoffTimer_free;
+asn_struct_print_f BackoffTimer_print;
+asn_constr_check_f BackoffTimer_constraint;
+ber_type_decoder_f BackoffTimer_decode_ber;
+der_type_encoder_f BackoffTimer_encode_der;
+xer_type_decoder_f BackoffTimer_decode_xer;
+xer_type_encoder_f BackoffTimer_encode_xer;
+per_type_decoder_f BackoffTimer_decode_uper;
+per_type_encoder_f BackoffTimer_encode_uper;
+per_type_decoder_f BackoffTimer_decode_aper;
+per_type_encoder_f BackoffTimer_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BackoffTimer_H_ */
+#include <asn_internal.h>

src/asn1c/BindingID.c

@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "BindingID.h"
+
+int
+BindingID_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 >= 1l && size <= 4l)) {
+		/* 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
+BindingID_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
+BindingID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BindingID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BindingID_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) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BindingID_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) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BindingID_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) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BindingID_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) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+BindingID_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) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+BindingID_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+BindingID_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BindingID_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+BindingID_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) {
+	BindingID_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_BindingID_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  1l,  4l }	/* (SIZE(1..4,...)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_BindingID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BindingID = {
+	"BindingID",
+	"BindingID",
+	BindingID_free,
+	BindingID_print,
+	BindingID_constraint,
+	BindingID_decode_ber,
+	BindingID_encode_der,
+	BindingID_decode_xer,
+	BindingID_encode_xer,
+	BindingID_decode_uper,
+	BindingID_encode_uper,
+	BindingID_decode_aper,
+	BindingID_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BindingID_tags_1,
+	sizeof(asn_DEF_BindingID_tags_1)
+		/sizeof(asn_DEF_BindingID_tags_1[0]), /* 1 */
+	asn_DEF_BindingID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BindingID_tags_1)
+		/sizeof(asn_DEF_BindingID_tags_1[0]), /* 1 */
+	&asn_PER_type_BindingID_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/BindingID.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_BindingID_H_
+#define	_BindingID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BindingID */
+typedef OCTET_STRING_t	 BindingID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BindingID;
+asn_struct_free_f BindingID_free;
+asn_struct_print_f BindingID_print;
+asn_constr_check_f BindingID_constraint;
+ber_type_decoder_f BindingID_decode_ber;
+der_type_encoder_f BindingID_encode_der;
+xer_type_decoder_f BindingID_decode_xer;
+xer_type_encoder_f BindingID_encode_xer;
+per_type_decoder_f BindingID_decode_uper;
+per_type_encoder_f BindingID_encode_uper;
+per_type_decoder_f BindingID_decode_aper;
+per_type_encoder_f BindingID_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BindingID_H_ */
+#include <asn_internal.h>

src/asn1c/CELL-FACHMobilitySupport.c

@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CELL-FACHMobilitySupport.h"
+
+int
+CELL_FACHMobilitySupport_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
+CELL_FACHMobilitySupport_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
+CELL_FACHMobilitySupport_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CELL_FACHMobilitySupport_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CELL_FACHMobilitySupport_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) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CELL_FACHMobilitySupport_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) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CELL_FACHMobilitySupport_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) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CELL_FACHMobilitySupport_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) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CELL_FACHMobilitySupport_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) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CELL_FACHMobilitySupport_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CELL_FACHMobilitySupport_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CELL_FACHMobilitySupport_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CELL_FACHMobilitySupport_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) {
+	CELL_FACHMobilitySupport_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_CELL_FACHMobilitySupport_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_CELL_FACHMobilitySupport_value2enum_1[] = {
+	{ 0,	9,	"supported" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CELL_FACHMobilitySupport_enum2value_1[] = {
+	0	/* supported(0) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CELL_FACHMobilitySupport_specs_1 = {
+	asn_MAP_CELL_FACHMobilitySupport_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CELL_FACHMobilitySupport_enum2value_1,	/* N => "tag"; sorted by N */
+	1,	/* 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_CELL_FACHMobilitySupport_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CELL_FACHMobilitySupport = {
+	"CELL-FACHMobilitySupport",
+	"CELL-FACHMobilitySupport",
+	CELL_FACHMobilitySupport_free,
+	CELL_FACHMobilitySupport_print,
+	CELL_FACHMobilitySupport_constraint,
+	CELL_FACHMobilitySupport_decode_ber,
+	CELL_FACHMobilitySupport_encode_der,
+	CELL_FACHMobilitySupport_decode_xer,
+	CELL_FACHMobilitySupport_encode_xer,
+	CELL_FACHMobilitySupport_decode_uper,
+	CELL_FACHMobilitySupport_encode_uper,
+	CELL_FACHMobilitySupport_decode_aper,
+	CELL_FACHMobilitySupport_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CELL_FACHMobilitySupport_tags_1,
+	sizeof(asn_DEF_CELL_FACHMobilitySupport_tags_1)
+		/sizeof(asn_DEF_CELL_FACHMobilitySupport_tags_1[0]), /* 1 */
+	asn_DEF_CELL_FACHMobilitySupport_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CELL_FACHMobilitySupport_tags_1)
+		/sizeof(asn_DEF_CELL_FACHMobilitySupport_tags_1[0]), /* 1 */
+	&asn_PER_type_CELL_FACHMobilitySupport_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CELL_FACHMobilitySupport_specs_1	/* Additional specs */
+};
+

src/asn1c/CELL-FACHMobilitySupport.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CELL_FACHMobilitySupport_H_
+#define	_CELL_FACHMobilitySupport_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CELL_FACHMobilitySupport {
+	CELL_FACHMobilitySupport_supported	= 0
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CELL_FACHMobilitySupport;
+
+/* CELL-FACHMobilitySupport */
+typedef long	 CELL_FACHMobilitySupport_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CELL_FACHMobilitySupport;
+asn_struct_free_f CELL_FACHMobilitySupport_free;
+asn_struct_print_f CELL_FACHMobilitySupport_print;
+asn_constr_check_f CELL_FACHMobilitySupport_constraint;
+ber_type_decoder_f CELL_FACHMobilitySupport_decode_ber;
+der_type_encoder_f CELL_FACHMobilitySupport_encode_der;
+xer_type_decoder_f CELL_FACHMobilitySupport_decode_xer;
+xer_type_encoder_f CELL_FACHMobilitySupport_encode_xer;
+per_type_decoder_f CELL_FACHMobilitySupport_decode_uper;
+per_type_encoder_f CELL_FACHMobilitySupport_encode_uper;
+per_type_decoder_f CELL_FACHMobilitySupport_decode_aper;
+per_type_encoder_f CELL_FACHMobilitySupport_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CELL_FACHMobilitySupport_H_ */
+#include <asn_internal.h>

src/asn1c/CGI.c

@@ -0,0 +1,94 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CGI.h"
+
+static asn_TYPE_member_t asn_MBR_CGI_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct CGI, pLMNidentity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMNidentity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pLMNidentity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CGI, lAC),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_LAC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"lAC"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CGI, cI),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CI,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cI"
+		},
+	{ ATF_POINTER, 1, offsetof(struct CGI, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_CGI_oms_1[] = { 3 };
+static const ber_tlv_tag_t asn_DEF_CGI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_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 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_CGI_specs_1 = {
+	sizeof(struct CGI),
+	offsetof(struct CGI, _asn_ctx),
+	asn_MAP_CGI_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_CGI_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_CGI = {
+	"CGI",
+	"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_CGI_tags_1,
+	sizeof(asn_DEF_CGI_tags_1)
+		/sizeof(asn_DEF_CGI_tags_1[0]), /* 1 */
+	asn_DEF_CGI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CGI_tags_1)
+		/sizeof(asn_DEF_CGI_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_CGI_1,
+	4,	/* Elements count */
+	&asn_SPC_CGI_specs_1	/* Additional specs */
+};
+

src/asn1c/CGI.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CGI_H_
+#define	_CGI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMNidentity.h"
+#include "LAC.h"
+#include "CI.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* CGI */
+typedef struct CGI {
+	PLMNidentity_t	 pLMNidentity;
+	LAC_t	 lAC;
+	CI_t	 cI;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CGI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CGI;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _CGI_H_ */
+#include <asn_internal.h>

src/asn1c/CI.c

@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CI.h"
+
+int
+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 == 2l)) {
+		/* 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
+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
+CI_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CI_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CI_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+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) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+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) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CI_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CI_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CI_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+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) {
+	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_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_CI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CI = {
+	"CI",
+	"CI",
+	CI_free,
+	CI_print,
+	CI_constraint,
+	CI_decode_ber,
+	CI_encode_der,
+	CI_decode_xer,
+	CI_encode_xer,
+	CI_decode_uper,
+	CI_encode_uper,
+	CI_decode_aper,
+	CI_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CI_tags_1,
+	sizeof(asn_DEF_CI_tags_1)
+		/sizeof(asn_DEF_CI_tags_1[0]), /* 1 */
+	asn_DEF_CI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CI_tags_1)
+		/sizeof(asn_DEF_CI_tags_1[0]), /* 1 */
+	&asn_PER_type_CI_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/CI.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CI_H_
+#define	_CI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CI */
+typedef OCTET_STRING_t	 CI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CI;
+asn_struct_free_f CI_free;
+asn_struct_print_f CI_print;
+asn_constr_check_f CI_constraint;
+ber_type_decoder_f CI_decode_ber;
+der_type_encoder_f CI_encode_der;
+xer_type_decoder_f CI_decode_xer;
+xer_type_encoder_f CI_encode_xer;
+per_type_decoder_f CI_decode_uper;
+per_type_encoder_f CI_encode_uper;
+per_type_decoder_f CI_decode_aper;
+per_type_encoder_f CI_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CI_H_ */
+#include <asn_internal.h>

src/asn1c/CN-DomainIndicator.c

@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CN-DomainIndicator.h"
+
+int
+CN_DomainIndicator_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
+CN_DomainIndicator_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
+CN_DomainIndicator_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CN_DomainIndicator_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_DomainIndicator_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) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CN_DomainIndicator_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) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_DomainIndicator_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) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CN_DomainIndicator_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) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_DomainIndicator_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) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CN_DomainIndicator_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CN_DomainIndicator_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CN_DomainIndicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CN_DomainIndicator_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) {
+	CN_DomainIndicator_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_CN_DomainIndicator_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_CN_DomainIndicator_value2enum_1[] = {
+	{ 0,	9,	"cs-domain" },
+	{ 1,	9,	"ps-domain" }
+};
+static const unsigned int asn_MAP_CN_DomainIndicator_enum2value_1[] = {
+	0,	/* cs-domain(0) */
+	1	/* ps-domain(1) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CN_DomainIndicator_specs_1 = {
+	asn_MAP_CN_DomainIndicator_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CN_DomainIndicator_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_CN_DomainIndicator_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CN_DomainIndicator = {
+	"CN-DomainIndicator",
+	"CN-DomainIndicator",
+	CN_DomainIndicator_free,
+	CN_DomainIndicator_print,
+	CN_DomainIndicator_constraint,
+	CN_DomainIndicator_decode_ber,
+	CN_DomainIndicator_encode_der,
+	CN_DomainIndicator_decode_xer,
+	CN_DomainIndicator_encode_xer,
+	CN_DomainIndicator_decode_uper,
+	CN_DomainIndicator_encode_uper,
+	CN_DomainIndicator_decode_aper,
+	CN_DomainIndicator_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CN_DomainIndicator_tags_1,
+	sizeof(asn_DEF_CN_DomainIndicator_tags_1)
+		/sizeof(asn_DEF_CN_DomainIndicator_tags_1[0]), /* 1 */
+	asn_DEF_CN_DomainIndicator_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_DomainIndicator_tags_1)
+		/sizeof(asn_DEF_CN_DomainIndicator_tags_1[0]), /* 1 */
+	&asn_PER_type_CN_DomainIndicator_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CN_DomainIndicator_specs_1	/* Additional specs */
+};
+

src/asn1c/CN-DomainIndicator.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CN_DomainIndicator_H_
+#define	_CN_DomainIndicator_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CN_DomainIndicator {
+	CN_DomainIndicator_cs_domain	= 0,
+	CN_DomainIndicator_ps_domain	= 1
+} e_CN_DomainIndicator;
+
+/* CN-DomainIndicator */
+typedef long	 CN_DomainIndicator_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CN_DomainIndicator;
+asn_struct_free_f CN_DomainIndicator_free;
+asn_struct_print_f CN_DomainIndicator_print;
+asn_constr_check_f CN_DomainIndicator_constraint;
+ber_type_decoder_f CN_DomainIndicator_decode_ber;
+der_type_encoder_f CN_DomainIndicator_encode_der;
+xer_type_decoder_f CN_DomainIndicator_decode_xer;
+xer_type_encoder_f CN_DomainIndicator_encode_xer;
+per_type_decoder_f CN_DomainIndicator_decode_uper;
+per_type_encoder_f CN_DomainIndicator_encode_uper;
+per_type_decoder_f CN_DomainIndicator_decode_aper;
+per_type_encoder_f CN_DomainIndicator_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CN_DomainIndicator_H_ */
+#include <asn_internal.h>

src/asn1c/CSG-Capability.c

@@ -0,0 +1,168 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CSG-Capability.h"
+
+int
+CSG_Capability_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
+CSG_Capability_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
+CSG_Capability_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CSG_Capability_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CSG_Capability_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) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CSG_Capability_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) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CSG_Capability_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) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CSG_Capability_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) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CSG_Capability_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) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CSG_Capability_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CSG_Capability_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CSG_Capability_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CSG_Capability_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) {
+	CSG_Capability_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_CSG_Capability_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  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_CSG_Capability_value2enum_1[] = {
+	{ 0,	11,	"csg-capable" },
+	{ 1,	15,	"not-csg-capable" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CSG_Capability_enum2value_1[] = {
+	0,	/* csg-capable(0) */
+	1	/* not-csg-capable(1) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CSG_Capability_specs_1 = {
+	asn_MAP_CSG_Capability_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CSG_Capability_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CSG_Capability_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CSG_Capability = {
+	"CSG-Capability",
+	"CSG-Capability",
+	CSG_Capability_free,
+	CSG_Capability_print,
+	CSG_Capability_constraint,
+	CSG_Capability_decode_ber,
+	CSG_Capability_encode_der,
+	CSG_Capability_decode_xer,
+	CSG_Capability_encode_xer,
+	CSG_Capability_decode_uper,
+	CSG_Capability_encode_uper,
+	CSG_Capability_decode_aper,
+	CSG_Capability_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CSG_Capability_tags_1,
+	sizeof(asn_DEF_CSG_Capability_tags_1)
+		/sizeof(asn_DEF_CSG_Capability_tags_1[0]), /* 1 */
+	asn_DEF_CSG_Capability_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CSG_Capability_tags_1)
+		/sizeof(asn_DEF_CSG_Capability_tags_1[0]), /* 1 */
+	&asn_PER_type_CSG_Capability_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CSG_Capability_specs_1	/* Additional specs */
+};
+

src/asn1c/CSG-Capability.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CSG_Capability_H_
+#define	_CSG_Capability_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CSG_Capability {
+	CSG_Capability_csg_capable	= 0,
+	CSG_Capability_not_csg_capable	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CSG_Capability;
+
+/* CSG-Capability */
+typedef long	 CSG_Capability_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CSG_Capability;
+asn_struct_free_f CSG_Capability_free;
+asn_struct_print_f CSG_Capability_print;
+asn_constr_check_f CSG_Capability_constraint;
+ber_type_decoder_f CSG_Capability_decode_ber;
+der_type_encoder_f CSG_Capability_encode_der;
+xer_type_decoder_f CSG_Capability_decode_xer;
+xer_type_encoder_f CSG_Capability_encode_xer;
+per_type_decoder_f CSG_Capability_decode_uper;
+per_type_encoder_f CSG_Capability_encode_uper;
+per_type_decoder_f CSG_Capability_decode_aper;
+per_type_encoder_f CSG_Capability_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CSG_Capability_H_ */
+#include <asn_internal.h>

src/asn1c/CSG-ID.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CSG-ID.h"
+
+int
+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 == 27l)) {
+		/* 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
+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
+CSG_ID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CSG_ID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+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) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+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) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CSG_ID_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CSG_ID_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CSG_ID_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+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) {
+	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_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_CSG_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CSG_ID = {
+	"CSG-ID",
+	"CSG-ID",
+	CSG_ID_free,
+	CSG_ID_print,
+	CSG_ID_constraint,
+	CSG_ID_decode_ber,
+	CSG_ID_encode_der,
+	CSG_ID_decode_xer,
+	CSG_ID_encode_xer,
+	CSG_ID_decode_uper,
+	CSG_ID_encode_uper,
+	CSG_ID_decode_aper,
+	CSG_ID_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CSG_ID_tags_1,
+	sizeof(asn_DEF_CSG_ID_tags_1)
+		/sizeof(asn_DEF_CSG_ID_tags_1[0]), /* 1 */
+	asn_DEF_CSG_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CSG_ID_tags_1)
+		/sizeof(asn_DEF_CSG_ID_tags_1[0]), /* 1 */
+	&asn_PER_type_CSG_ID_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/CSG-ID.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CSG_ID_H_
+#define	_CSG_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CSG-ID */
+typedef BIT_STRING_t	 CSG_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CSG_ID;
+asn_struct_free_f CSG_ID_free;
+asn_struct_print_f CSG_ID_print;
+asn_constr_check_f CSG_ID_constraint;
+ber_type_decoder_f CSG_ID_decode_ber;
+der_type_encoder_f CSG_ID_encode_der;
+xer_type_decoder_f CSG_ID_decode_xer;
+xer_type_encoder_f CSG_ID_encode_xer;
+per_type_decoder_f CSG_ID_decode_uper;
+per_type_encoder_f CSG_ID_encode_uper;
+per_type_decoder_f CSG_ID_decode_aper;
+per_type_encoder_f CSG_ID_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CSG_ID_H_ */
+#include <asn_internal.h>

src/asn1c/CSGMembershipStatus.c

@@ -0,0 +1,168 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CSGMembershipStatus.h"
+
+int
+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
+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
+CSGMembershipStatus_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CSGMembershipStatus_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+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) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+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) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CSGMembershipStatus_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CSGMembershipStatus_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CSGMembershipStatus_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+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) {
+	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_CSGMembershipStatus_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  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_CSGMembershipStatus_value2enum_1[] = {
+	{ 0,	6,	"member" },
+	{ 1,	10,	"non-member" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CSGMembershipStatus_enum2value_1[] = {
+	0,	/* member(0) */
+	1	/* non-member(1) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CSGMembershipStatus_specs_1 = {
+	asn_MAP_CSGMembershipStatus_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CSGMembershipStatus_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CSGMembershipStatus_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CSGMembershipStatus = {
+	"CSGMembershipStatus",
+	"CSGMembershipStatus",
+	CSGMembershipStatus_free,
+	CSGMembershipStatus_print,
+	CSGMembershipStatus_constraint,
+	CSGMembershipStatus_decode_ber,
+	CSGMembershipStatus_encode_der,
+	CSGMembershipStatus_decode_xer,
+	CSGMembershipStatus_encode_xer,
+	CSGMembershipStatus_decode_uper,
+	CSGMembershipStatus_encode_uper,
+	CSGMembershipStatus_decode_aper,
+	CSGMembershipStatus_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CSGMembershipStatus_tags_1,
+	sizeof(asn_DEF_CSGMembershipStatus_tags_1)
+		/sizeof(asn_DEF_CSGMembershipStatus_tags_1[0]), /* 1 */
+	asn_DEF_CSGMembershipStatus_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CSGMembershipStatus_tags_1)
+		/sizeof(asn_DEF_CSGMembershipStatus_tags_1[0]), /* 1 */
+	&asn_PER_type_CSGMembershipStatus_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CSGMembershipStatus_specs_1	/* Additional specs */
+};
+

src/asn1c/CSGMembershipStatus.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CSGMembershipStatus_H_
+#define	_CSGMembershipStatus_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CSGMembershipStatus {
+	CSGMembershipStatus_member	= 0,
+	CSGMembershipStatus_non_member	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CSGMembershipStatus;
+
+/* CSGMembershipStatus */
+typedef long	 CSGMembershipStatus_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CSGMembershipStatus;
+asn_struct_free_f CSGMembershipStatus_free;
+asn_struct_print_f CSGMembershipStatus_print;
+asn_constr_check_f CSGMembershipStatus_constraint;
+ber_type_decoder_f CSGMembershipStatus_decode_ber;
+der_type_encoder_f CSGMembershipStatus_encode_der;
+xer_type_decoder_f CSGMembershipStatus_decode_xer;
+xer_type_encoder_f CSGMembershipStatus_encode_xer;
+per_type_decoder_f CSGMembershipStatus_decode_uper;
+per_type_encoder_f CSGMembershipStatus_encode_uper;
+per_type_decoder_f CSGMembershipStatus_decode_aper;
+per_type_encoder_f CSGMembershipStatus_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CSGMembershipStatus_H_ */
+#include <asn_internal.h>

src/asn1c/CSGMembershipUpdate.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CSGMembershipUpdate.h"
+
+static int
+memb_csgMembershipUpdate_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_csgMembershipUpdate_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_csgMembershipUpdate_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_csgMembershipUpdate_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_csgMembershipUpdate_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_csgMembershipUpdate_ies_specs_2 = {
+	sizeof(struct csgMembershipUpdate_ies),
+	offsetof(struct csgMembershipUpdate_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_csgMembershipUpdate_ies_2 = {
+	"csgMembershipUpdate-ies",
+	"csgMembershipUpdate-ies",
+	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_csgMembershipUpdate_ies_tags_2,
+	sizeof(asn_DEF_csgMembershipUpdate_ies_tags_2)
+		/sizeof(asn_DEF_csgMembershipUpdate_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_csgMembershipUpdate_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_csgMembershipUpdate_ies_tags_2)
+		/sizeof(asn_DEF_csgMembershipUpdate_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_csgMembershipUpdate_ies_constr_2,
+	asn_MBR_csgMembershipUpdate_ies_2,
+	1,	/* Single element */
+	&asn_SPC_csgMembershipUpdate_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_CSGMembershipUpdate_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct CSGMembershipUpdate, csgMembershipUpdate_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_csgMembershipUpdate_ies_2,
+		memb_csgMembershipUpdate_ies_constraint_1,
+		&asn_PER_memb_csgMembershipUpdate_ies_constr_2,
+		0,
+		"csgMembershipUpdate-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_CSGMembershipUpdate_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_CSGMembershipUpdate_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* csgMembershipUpdate-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_CSGMembershipUpdate_specs_1 = {
+	sizeof(struct CSGMembershipUpdate),
+	offsetof(struct CSGMembershipUpdate, _asn_ctx),
+	asn_MAP_CSGMembershipUpdate_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_CSGMembershipUpdate = {
+	"CSGMembershipUpdate",
+	"CSGMembershipUpdate",
+	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_CSGMembershipUpdate_tags_1,
+	sizeof(asn_DEF_CSGMembershipUpdate_tags_1)
+		/sizeof(asn_DEF_CSGMembershipUpdate_tags_1[0]), /* 1 */
+	asn_DEF_CSGMembershipUpdate_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CSGMembershipUpdate_tags_1)
+		/sizeof(asn_DEF_CSGMembershipUpdate_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_CSGMembershipUpdate_1,
+	1,	/* Elements count */
+	&asn_SPC_CSGMembershipUpdate_specs_1	/* Additional specs */
+};
+

src/asn1c/CSGMembershipUpdate.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CSGMembershipUpdate_H_
+#define	_CSGMembershipUpdate_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* CSGMembershipUpdate */
+typedef struct CSGMembershipUpdate {
+	struct csgMembershipUpdate_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} csgMembershipUpdate_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CSGMembershipUpdate_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CSGMembershipUpdate;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _CSGMembershipUpdate_H_ */
+#include <asn_internal.h>

src/asn1c/Cause.c

@@ -0,0 +1,93 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "Cause.h"
+
+static asn_per_constraints_t asn_PER_type_Cause_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  3l }	/* (0..3,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_Cause_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.radioNetwork),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseRadioNetwork,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"radioNetwork"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.transport),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseTransport,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"transport"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.protocol),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseProtocol,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"protocol"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.misc),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseMisc,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"misc"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_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 }, /* protocol */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* misc */
+};
+static asn_CHOICE_specifics_t asn_SPC_Cause_specs_1 = {
+	sizeof(struct Cause),
+	offsetof(struct Cause, _asn_ctx),
+	offsetof(struct Cause, present),
+	sizeof(((struct Cause *)0)->present),
+	asn_MAP_Cause_tag2el_1,
+	4,	/* Count of tags in the map */
+	0,
+	4	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Cause = {
+	"Cause",
+	"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_Cause_constr_1,
+	asn_MBR_Cause_1,
+	4,	/* Elements count */
+	&asn_SPC_Cause_specs_1	/* Additional specs */
+};
+

src/asn1c/Cause.h

@@ -0,0 +1,62 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_Cause_H_
+#define	_Cause_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "CauseRadioNetwork.h"
+#include "CauseTransport.h"
+#include "CauseProtocol.h"
+#include "CauseMisc.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Cause_PR {
+	Cause_PR_NOTHING,	/* No components present */
+	Cause_PR_radioNetwork,
+	Cause_PR_transport,
+	Cause_PR_protocol,
+	Cause_PR_misc,
+	/* Extensions may appear below */
+	
+} Cause_PR;
+
+/* Cause */
+typedef struct Cause {
+	Cause_PR present;
+	union Cause_u {
+		CauseRadioNetwork_t	 radioNetwork;
+		CauseTransport_t	 transport;
+		CauseProtocol_t	 protocol;
+		CauseMisc_t	 misc;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Cause_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Cause;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Cause_H_ */
+#include <asn_internal.h>

src/asn1c/CauseMisc.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CauseMisc.h"
+
+int
+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
+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
+CauseMisc_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CauseMisc_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+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) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+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) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+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) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CauseMisc_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CauseMisc_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseMisc_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+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) {
+	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_CauseMisc_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  3l }	/* (0..3,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_CauseMisc_value2enum_1[] = {
+	{ 0,	19,	"processing-overload" },
+	{ 1,	16,	"hardware-failure" },
+	{ 2,	20,	"o-and-m-intervention" },
+	{ 3,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseMisc_enum2value_1[] = {
+	1,	/* hardware-failure(1) */
+	2,	/* o-and-m-intervention(2) */
+	0,	/* processing-overload(0) */
+	3	/* unspecified(3) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CauseMisc_specs_1 = {
+	asn_MAP_CauseMisc_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CauseMisc_enum2value_1,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	5,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CauseMisc_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CauseMisc = {
+	"CauseMisc",
+	"CauseMisc",
+	CauseMisc_free,
+	CauseMisc_print,
+	CauseMisc_constraint,
+	CauseMisc_decode_ber,
+	CauseMisc_encode_der,
+	CauseMisc_decode_xer,
+	CauseMisc_encode_xer,
+	CauseMisc_decode_uper,
+	CauseMisc_encode_uper,
+	CauseMisc_decode_aper,
+	CauseMisc_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CauseMisc_tags_1,
+	sizeof(asn_DEF_CauseMisc_tags_1)
+		/sizeof(asn_DEF_CauseMisc_tags_1[0]), /* 1 */
+	asn_DEF_CauseMisc_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CauseMisc_tags_1)
+		/sizeof(asn_DEF_CauseMisc_tags_1[0]), /* 1 */
+	&asn_PER_type_CauseMisc_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseMisc_specs_1	/* Additional specs */
+};
+

src/asn1c/CauseMisc.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CauseMisc_H_
+#define	_CauseMisc_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CauseMisc {
+	CauseMisc_processing_overload	= 0,
+	CauseMisc_hardware_failure	= 1,
+	CauseMisc_o_and_m_intervention	= 2,
+	CauseMisc_unspecified	= 3
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseMisc;
+
+/* CauseMisc */
+typedef long	 CauseMisc_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CauseMisc;
+asn_struct_free_f CauseMisc_free;
+asn_struct_print_f CauseMisc_print;
+asn_constr_check_f CauseMisc_constraint;
+ber_type_decoder_f CauseMisc_decode_ber;
+der_type_encoder_f CauseMisc_encode_der;
+xer_type_decoder_f CauseMisc_decode_xer;
+xer_type_encoder_f CauseMisc_encode_xer;
+per_type_decoder_f CauseMisc_decode_uper;
+per_type_encoder_f CauseMisc_encode_uper;
+per_type_decoder_f CauseMisc_decode_aper;
+per_type_encoder_f CauseMisc_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CauseMisc_H_ */
+#include <asn_internal.h>

src/asn1c/CauseProtocol.c

@@ -0,0 +1,178 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CauseProtocol.h"
+
+int
+CauseProtocol_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
+CauseProtocol_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
+CauseProtocol_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CauseProtocol_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseProtocol_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) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CauseProtocol_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) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseProtocol_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) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CauseProtocol_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) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseProtocol_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) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CauseProtocol_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CauseProtocol_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseProtocol_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CauseProtocol_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) {
+	CauseProtocol_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_CauseProtocol_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0l,  6l }	/* (0..6,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_CauseProtocol_value2enum_1[] = {
+	{ 0,	21,	"transfer-syntax-error" },
+	{ 1,	28,	"abstract-syntax-error-reject" },
+	{ 2,	39,	"abstract-syntax-error-ignore-and-notify" },
+	{ 3,	42,	"message-not-compatible-with-receiver-state" },
+	{ 4,	14,	"semantic-error" },
+	{ 5,	11,	"unspecified" },
+	{ 6,	49,	"abstract-syntax-error-falsely-constructed-message" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseProtocol_enum2value_1[] = {
+	6,	/* abstract-syntax-error-falsely-constructed-message(6) */
+	2,	/* abstract-syntax-error-ignore-and-notify(2) */
+	1,	/* abstract-syntax-error-reject(1) */
+	3,	/* message-not-compatible-with-receiver-state(3) */
+	4,	/* semantic-error(4) */
+	0,	/* transfer-syntax-error(0) */
+	5	/* unspecified(5) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CauseProtocol_specs_1 = {
+	asn_MAP_CauseProtocol_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CauseProtocol_enum2value_1,	/* N => "tag"; sorted by N */
+	7,	/* Number of elements in the maps */
+	8,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CauseProtocol_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CauseProtocol = {
+	"CauseProtocol",
+	"CauseProtocol",
+	CauseProtocol_free,
+	CauseProtocol_print,
+	CauseProtocol_constraint,
+	CauseProtocol_decode_ber,
+	CauseProtocol_encode_der,
+	CauseProtocol_decode_xer,
+	CauseProtocol_encode_xer,
+	CauseProtocol_decode_uper,
+	CauseProtocol_encode_uper,
+	CauseProtocol_decode_aper,
+	CauseProtocol_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CauseProtocol_tags_1,
+	sizeof(asn_DEF_CauseProtocol_tags_1)
+		/sizeof(asn_DEF_CauseProtocol_tags_1[0]), /* 1 */
+	asn_DEF_CauseProtocol_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CauseProtocol_tags_1)
+		/sizeof(asn_DEF_CauseProtocol_tags_1[0]), /* 1 */
+	&asn_PER_type_CauseProtocol_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseProtocol_specs_1	/* Additional specs */
+};
+

src/asn1c/CauseProtocol.h

@@ -0,0 +1,57 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CauseProtocol_H_
+#define	_CauseProtocol_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CauseProtocol {
+	CauseProtocol_transfer_syntax_error	= 0,
+	CauseProtocol_abstract_syntax_error_reject	= 1,
+	CauseProtocol_abstract_syntax_error_ignore_and_notify	= 2,
+	CauseProtocol_message_not_compatible_with_receiver_state	= 3,
+	CauseProtocol_semantic_error	= 4,
+	CauseProtocol_unspecified	= 5,
+	CauseProtocol_abstract_syntax_error_falsely_constructed_message	= 6
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseProtocol;
+
+/* CauseProtocol */
+typedef long	 CauseProtocol_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CauseProtocol;
+asn_struct_free_f CauseProtocol_free;
+asn_struct_print_f CauseProtocol_print;
+asn_constr_check_f CauseProtocol_constraint;
+ber_type_decoder_f CauseProtocol_decode_ber;
+der_type_encoder_f CauseProtocol_encode_der;
+xer_type_decoder_f CauseProtocol_decode_xer;
+xer_type_encoder_f CauseProtocol_encode_xer;
+per_type_decoder_f CauseProtocol_decode_uper;
+per_type_encoder_f CauseProtocol_encode_uper;
+per_type_decoder_f CauseProtocol_decode_aper;
+per_type_encoder_f CauseProtocol_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CauseProtocol_H_ */
+#include <asn_internal.h>

src/asn1c/CauseRadioNetwork.c

@@ -0,0 +1,196 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CauseRadioNetwork.h"
+
+int
+CauseRadioNetwork_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
+CauseRadioNetwork_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
+CauseRadioNetwork_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CauseRadioNetwork_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseRadioNetwork_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) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CauseRadioNetwork_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) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseRadioNetwork_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) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CauseRadioNetwork_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) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseRadioNetwork_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) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CauseRadioNetwork_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CauseRadioNetwork_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseRadioNetwork_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CauseRadioNetwork_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) {
+	CauseRadioNetwork_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_CauseRadioNetwork_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  4,  4,  0l,  13l }	/* (0..13,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_CauseRadioNetwork_value2enum_1[] = {
+	{ 0,	8,	"overload" },
+	{ 1,	21,	"unauthorised-Location" },
+	{ 2,	16,	"unauthorised-HNB" },
+	{ 3,	22,	"hNB-parameter-mismatch" },
+	{ 4,	19,	"invalid-UE-identity" },
+	{ 5,	26,	"uE-not-allowed-on-this-HNB" },
+	{ 6,	15,	"uE-unauthorised" },
+	{ 7,	23,	"connection-with-UE-lost" },
+	{ 8,	14,	"ue-RRC-release" },
+	{ 9,	18,	"hNB-not-registered" },
+	{ 10,	11,	"unspecified" },
+	{ 11,	6,	"normal" },
+	{ 12,	12,	"uE-relocated" },
+	{ 13,	28,	"ue-registered-in-another-HNB" },
+	{ 14,	34,	"no-neighbour-information-available" },
+	{ 15,	45,	"iurh-connection-to-that-neighbour-not-Allowed" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseRadioNetwork_enum2value_1[] = {
+	7,	/* connection-with-UE-lost(7) */
+	9,	/* hNB-not-registered(9) */
+	3,	/* hNB-parameter-mismatch(3) */
+	4,	/* invalid-UE-identity(4) */
+	15,	/* iurh-connection-to-that-neighbour-not-Allowed(15) */
+	14,	/* no-neighbour-information-available(14) */
+	11,	/* normal(11) */
+	0,	/* overload(0) */
+	5,	/* uE-not-allowed-on-this-HNB(5) */
+	12,	/* uE-relocated(12) */
+	6,	/* uE-unauthorised(6) */
+	8,	/* ue-RRC-release(8) */
+	13,	/* ue-registered-in-another-HNB(13) */
+	2,	/* unauthorised-HNB(2) */
+	1,	/* unauthorised-Location(1) */
+	10	/* unspecified(10) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CauseRadioNetwork_specs_1 = {
+	asn_MAP_CauseRadioNetwork_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CauseRadioNetwork_enum2value_1,	/* N => "tag"; sorted by N */
+	16,	/* Number of elements in the maps */
+	15,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CauseRadioNetwork_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CauseRadioNetwork = {
+	"CauseRadioNetwork",
+	"CauseRadioNetwork",
+	CauseRadioNetwork_free,
+	CauseRadioNetwork_print,
+	CauseRadioNetwork_constraint,
+	CauseRadioNetwork_decode_ber,
+	CauseRadioNetwork_encode_der,
+	CauseRadioNetwork_decode_xer,
+	CauseRadioNetwork_encode_xer,
+	CauseRadioNetwork_decode_uper,
+	CauseRadioNetwork_encode_uper,
+	CauseRadioNetwork_decode_aper,
+	CauseRadioNetwork_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CauseRadioNetwork_tags_1,
+	sizeof(asn_DEF_CauseRadioNetwork_tags_1)
+		/sizeof(asn_DEF_CauseRadioNetwork_tags_1[0]), /* 1 */
+	asn_DEF_CauseRadioNetwork_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CauseRadioNetwork_tags_1)
+		/sizeof(asn_DEF_CauseRadioNetwork_tags_1[0]), /* 1 */
+	&asn_PER_type_CauseRadioNetwork_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseRadioNetwork_specs_1	/* Additional specs */
+};
+

src/asn1c/CauseRadioNetwork.h

@@ -0,0 +1,66 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CauseRadioNetwork_H_
+#define	_CauseRadioNetwork_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CauseRadioNetwork {
+	CauseRadioNetwork_overload	= 0,
+	CauseRadioNetwork_unauthorised_Location	= 1,
+	CauseRadioNetwork_unauthorised_HNB	= 2,
+	CauseRadioNetwork_hNB_parameter_mismatch	= 3,
+	CauseRadioNetwork_invalid_UE_identity	= 4,
+	CauseRadioNetwork_uE_not_allowed_on_this_HNB	= 5,
+	CauseRadioNetwork_uE_unauthorised	= 6,
+	CauseRadioNetwork_connection_with_UE_lost	= 7,
+	CauseRadioNetwork_ue_RRC_release	= 8,
+	CauseRadioNetwork_hNB_not_registered	= 9,
+	CauseRadioNetwork_unspecified	= 10,
+	CauseRadioNetwork_normal	= 11,
+	CauseRadioNetwork_uE_relocated	= 12,
+	CauseRadioNetwork_ue_registered_in_another_HNB	= 13,
+	/*
+	 * Enumeration is extensible
+	 */
+	CauseRadioNetwork_no_neighbour_information_available	= 14,
+	CauseRadioNetwork_iurh_connection_to_that_neighbour_not_Allowed	= 15
+} e_CauseRadioNetwork;
+
+/* CauseRadioNetwork */
+typedef long	 CauseRadioNetwork_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CauseRadioNetwork;
+asn_struct_free_f CauseRadioNetwork_free;
+asn_struct_print_f CauseRadioNetwork_print;
+asn_constr_check_f CauseRadioNetwork_constraint;
+ber_type_decoder_f CauseRadioNetwork_decode_ber;
+der_type_encoder_f CauseRadioNetwork_encode_der;
+xer_type_decoder_f CauseRadioNetwork_decode_xer;
+xer_type_encoder_f CauseRadioNetwork_encode_xer;
+per_type_decoder_f CauseRadioNetwork_decode_uper;
+per_type_encoder_f CauseRadioNetwork_encode_uper;
+per_type_decoder_f CauseRadioNetwork_decode_aper;
+per_type_encoder_f CauseRadioNetwork_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CauseRadioNetwork_H_ */
+#include <asn_internal.h>

src/asn1c/CauseTransport.c

@@ -0,0 +1,168 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CauseTransport.h"
+
+int
+CauseTransport_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
+CauseTransport_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
+CauseTransport_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CauseTransport_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseTransport_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) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CauseTransport_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) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseTransport_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) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CauseTransport_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) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CauseTransport_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) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CauseTransport_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CauseTransport_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CauseTransport_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CauseTransport_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) {
+	CauseTransport_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_CauseTransport_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  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_CauseTransport_value2enum_1[] = {
+	{ 0,	30,	"transport-resource-unavailable" },
+	{ 1,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseTransport_enum2value_1[] = {
+	0,	/* transport-resource-unavailable(0) */
+	1	/* unspecified(1) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_CauseTransport_specs_1 = {
+	asn_MAP_CauseTransport_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CauseTransport_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CauseTransport_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CauseTransport = {
+	"CauseTransport",
+	"CauseTransport",
+	CauseTransport_free,
+	CauseTransport_print,
+	CauseTransport_constraint,
+	CauseTransport_decode_ber,
+	CauseTransport_encode_der,
+	CauseTransport_decode_xer,
+	CauseTransport_encode_xer,
+	CauseTransport_decode_uper,
+	CauseTransport_encode_uper,
+	CauseTransport_decode_aper,
+	CauseTransport_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CauseTransport_tags_1,
+	sizeof(asn_DEF_CauseTransport_tags_1)
+		/sizeof(asn_DEF_CauseTransport_tags_1[0]), /* 1 */
+	asn_DEF_CauseTransport_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CauseTransport_tags_1)
+		/sizeof(asn_DEF_CauseTransport_tags_1[0]), /* 1 */
+	&asn_PER_type_CauseTransport_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseTransport_specs_1	/* Additional specs */
+};
+

src/asn1c/CauseTransport.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CauseTransport_H_
+#define	_CauseTransport_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CauseTransport {
+	CauseTransport_transport_resource_unavailable	= 0,
+	CauseTransport_unspecified	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseTransport;
+
+/* CauseTransport */
+typedef long	 CauseTransport_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CauseTransport;
+asn_struct_free_f CauseTransport_free;
+asn_struct_print_f CauseTransport_print;
+asn_constr_check_f CauseTransport_constraint;
+ber_type_decoder_f CauseTransport_decode_ber;
+der_type_encoder_f CauseTransport_encode_der;
+xer_type_decoder_f CauseTransport_decode_xer;
+xer_type_encoder_f CauseTransport_encode_xer;
+per_type_decoder_f CauseTransport_decode_uper;
+per_type_encoder_f CauseTransport_encode_uper;
+per_type_decoder_f CauseTransport_decode_aper;
+per_type_encoder_f CauseTransport_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CauseTransport_H_ */
+#include <asn_internal.h>

src/asn1c/CellIdentity.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CellIdentity.h"
+
+int
+CellIdentity_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 == 28l)) {
+		/* 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
+CellIdentity_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
+CellIdentity_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CellIdentity_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CellIdentity_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) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CellIdentity_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) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CellIdentity_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) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CellIdentity_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) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CellIdentity_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) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CellIdentity_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+CellIdentity_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CellIdentity_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+CellIdentity_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) {
+	CellIdentity_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_CellIdentity_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  28l,  28l }	/* (SIZE(28..28)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_CellIdentity_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CellIdentity = {
+	"CellIdentity",
+	"CellIdentity",
+	CellIdentity_free,
+	CellIdentity_print,
+	CellIdentity_constraint,
+	CellIdentity_decode_ber,
+	CellIdentity_encode_der,
+	CellIdentity_decode_xer,
+	CellIdentity_encode_xer,
+	CellIdentity_decode_uper,
+	CellIdentity_encode_uper,
+	CellIdentity_decode_aper,
+	CellIdentity_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CellIdentity_tags_1,
+	sizeof(asn_DEF_CellIdentity_tags_1)
+		/sizeof(asn_DEF_CellIdentity_tags_1[0]), /* 1 */
+	asn_DEF_CellIdentity_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CellIdentity_tags_1)
+		/sizeof(asn_DEF_CellIdentity_tags_1[0]), /* 1 */
+	&asn_PER_type_CellIdentity_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/CellIdentity.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CellIdentity_H_
+#define	_CellIdentity_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CellIdentity */
+typedef BIT_STRING_t	 CellIdentity_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CellIdentity;
+asn_struct_free_f CellIdentity_free;
+asn_struct_print_f CellIdentity_print;
+asn_constr_check_f CellIdentity_constraint;
+ber_type_decoder_f CellIdentity_decode_ber;
+der_type_encoder_f CellIdentity_encode_der;
+xer_type_decoder_f CellIdentity_decode_xer;
+xer_type_encoder_f CellIdentity_encode_xer;
+per_type_decoder_f CellIdentity_decode_uper;
+per_type_encoder_f CellIdentity_encode_uper;
+per_type_decoder_f CellIdentity_decode_aper;
+per_type_encoder_f CellIdentity_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CellIdentity_H_ */
+#include <asn_internal.h>

src/asn1c/ConfigurationInformation.c

@@ -0,0 +1,73 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "ConfigurationInformation.h"
+
+static asn_per_constraints_t asn_PER_type_ConfigurationInformation_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0l,  1l }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_ConfigurationInformation_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ConfigurationInformation, choice.provided),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HNBConfigurationInformationProvided,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"provided"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ConfigurationInformation, choice.missing),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HNBConfigurationInformationMissing,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"missing"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_ConfigurationInformation_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* provided */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* missing */
+};
+static asn_CHOICE_specifics_t asn_SPC_ConfigurationInformation_specs_1 = {
+	sizeof(struct ConfigurationInformation),
+	offsetof(struct ConfigurationInformation, _asn_ctx),
+	offsetof(struct ConfigurationInformation, present),
+	sizeof(((struct ConfigurationInformation *)0)->present),
+	asn_MAP_ConfigurationInformation_tag2el_1,
+	2,	/* Count of tags in the map */
+	0,
+	2	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_ConfigurationInformation = {
+	"ConfigurationInformation",
+	"ConfigurationInformation",
+	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_ConfigurationInformation_constr_1,
+	asn_MBR_ConfigurationInformation_1,
+	2,	/* Elements count */
+	&asn_SPC_ConfigurationInformation_specs_1	/* Additional specs */
+};
+

src/asn1c/ConfigurationInformation.h

@@ -0,0 +1,56 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_ConfigurationInformation_H_
+#define	_ConfigurationInformation_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HNBConfigurationInformationProvided.h"
+#include "HNBConfigurationInformationMissing.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ConfigurationInformation_PR {
+	ConfigurationInformation_PR_NOTHING,	/* No components present */
+	ConfigurationInformation_PR_provided,
+	ConfigurationInformation_PR_missing,
+	/* Extensions may appear below */
+	
+} ConfigurationInformation_PR;
+
+/* ConfigurationInformation */
+typedef struct ConfigurationInformation {
+	ConfigurationInformation_PR present;
+	union ConfigurationInformation_u {
+		HNBConfigurationInformationProvided_t	 provided;
+		HNBConfigurationInformationMissing_t	 missing;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ConfigurationInformation_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ConfigurationInformation;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ConfigurationInformation_H_ */
+#include <asn_internal.h>

src/asn1c/Context-ID.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "Context-ID.h"
+
+int
+Context_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 == 24l)) {
+		/* 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
+Context_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
+Context_ID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Context_ID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Context_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) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Context_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) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Context_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) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Context_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) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Context_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) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+Context_ID_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+Context_ID_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Context_ID_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+Context_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) {
+	Context_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_Context_ID_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  24l,  24l }	/* (SIZE(24..24)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_Context_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Context_ID = {
+	"Context-ID",
+	"Context-ID",
+	Context_ID_free,
+	Context_ID_print,
+	Context_ID_constraint,
+	Context_ID_decode_ber,
+	Context_ID_encode_der,
+	Context_ID_decode_xer,
+	Context_ID_encode_xer,
+	Context_ID_decode_uper,
+	Context_ID_encode_uper,
+	Context_ID_decode_aper,
+	Context_ID_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Context_ID_tags_1,
+	sizeof(asn_DEF_Context_ID_tags_1)
+		/sizeof(asn_DEF_Context_ID_tags_1[0]), /* 1 */
+	asn_DEF_Context_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Context_ID_tags_1)
+		/sizeof(asn_DEF_Context_ID_tags_1[0]), /* 1 */
+	&asn_PER_type_Context_ID_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/Context-ID.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_Context_ID_H_
+#define	_Context_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Context-ID */
+typedef BIT_STRING_t	 Context_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Context_ID;
+asn_struct_free_f Context_ID_free;
+asn_struct_print_f Context_ID_print;
+asn_constr_check_f Context_ID_constraint;
+ber_type_decoder_f Context_ID_decode_ber;
+der_type_encoder_f Context_ID_encode_der;
+xer_type_decoder_f Context_ID_decode_xer;
+xer_type_encoder_f Context_ID_encode_xer;
+per_type_decoder_f Context_ID_decode_uper;
+per_type_encoder_f Context_ID_encode_uper;
+per_type_decoder_f Context_ID_decode_aper;
+per_type_encoder_f Context_ID_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Context_ID_H_ */
+#include <asn_internal.h>

src/asn1c/Criticality.c

@@ -0,0 +1,168 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-CommonDataTypes"
+ * 	found in "../../asn1/hnbap/HNBAP-CommonDataTypes.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "Criticality.h"
+
+int
+Criticality_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
+Criticality_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
+Criticality_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Criticality_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Criticality_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) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Criticality_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) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Criticality_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) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Criticality_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) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Criticality_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) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+Criticality_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+Criticality_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Criticality_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+Criticality_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) {
+	Criticality_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_Criticality_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0l,  2l }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_Criticality_value2enum_1[] = {
+	{ 0,	6,	"reject" },
+	{ 1,	6,	"ignore" },
+	{ 2,	6,	"notify" }
+};
+static const unsigned int asn_MAP_Criticality_enum2value_1[] = {
+	1,	/* ignore(1) */
+	2,	/* notify(2) */
+	0	/* reject(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_Criticality_specs_1 = {
+	asn_MAP_Criticality_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Criticality_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* 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_Criticality_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Criticality = {
+	"Criticality",
+	"Criticality",
+	Criticality_free,
+	Criticality_print,
+	Criticality_constraint,
+	Criticality_decode_ber,
+	Criticality_encode_der,
+	Criticality_decode_xer,
+	Criticality_encode_xer,
+	Criticality_decode_uper,
+	Criticality_encode_uper,
+	Criticality_decode_aper,
+	Criticality_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Criticality_tags_1,
+	sizeof(asn_DEF_Criticality_tags_1)
+		/sizeof(asn_DEF_Criticality_tags_1[0]), /* 1 */
+	asn_DEF_Criticality_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Criticality_tags_1)
+		/sizeof(asn_DEF_Criticality_tags_1[0]), /* 1 */
+	&asn_PER_type_Criticality_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Criticality_specs_1	/* Additional specs */
+};
+

src/asn1c/Criticality.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-CommonDataTypes"
+ * 	found in "../../asn1/hnbap/HNBAP-CommonDataTypes.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_Criticality_H_
+#define	_Criticality_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Criticality {
+	Criticality_reject	= 0,
+	Criticality_ignore	= 1,
+	Criticality_notify	= 2
+} e_Criticality;
+
+/* Criticality */
+typedef long	 Criticality_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Criticality;
+asn_struct_free_f Criticality_free;
+asn_struct_print_f Criticality_print;
+asn_constr_check_f Criticality_constraint;
+ber_type_decoder_f Criticality_decode_ber;
+der_type_encoder_f Criticality_encode_der;
+xer_type_decoder_f Criticality_decode_xer;
+xer_type_encoder_f Criticality_encode_xer;
+per_type_decoder_f Criticality_decode_uper;
+per_type_encoder_f Criticality_encode_uper;
+per_type_decoder_f Criticality_decode_aper;
+per_type_encoder_f Criticality_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Criticality_H_ */
+#include <asn_internal.h>

src/asn1c/CriticalityDiagnostics-IE-List.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CriticalityDiagnostics-IE-List.h"
+
+static asn_per_constraints_t asn_PER_type_CriticalityDiagnostics_IE_List_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_Member_2[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Member, iECriticality),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iECriticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Member, iE_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolIE_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Member, typeOfError),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_TypeOfError,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"typeOfError"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Member, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_Member_oms_2[] = { 3 };
+static const ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* iECriticality */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* iE-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* typeOfError */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
+	sizeof(struct Member),
+	offsetof(struct Member, _asn_ctx),
+	asn_MAP_Member_tag2el_2,
+	4,	/* Count of tags in the map */
+	asn_MAP_Member_oms_2,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	3,	/* Start extensions */
+	5	/* Stop extensions */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_Member_2 = {
+	"SEQUENCE",
+	"SEQUENCE",
+	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_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Member_2,
+	4,	/* Elements count */
+	&asn_SPC_Member_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_CriticalityDiagnostics_IE_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_Member_2,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_CriticalityDiagnostics_IE_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_CriticalityDiagnostics_IE_List_specs_1 = {
+	sizeof(struct CriticalityDiagnostics_IE_List),
+	offsetof(struct CriticalityDiagnostics_IE_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics_IE_List = {
+	"CriticalityDiagnostics-IE-List",
+	"CriticalityDiagnostics-IE-List",
+	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_CriticalityDiagnostics_IE_List_tags_1,
+	sizeof(asn_DEF_CriticalityDiagnostics_IE_List_tags_1)
+		/sizeof(asn_DEF_CriticalityDiagnostics_IE_List_tags_1[0]), /* 1 */
+	asn_DEF_CriticalityDiagnostics_IE_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CriticalityDiagnostics_IE_List_tags_1)
+		/sizeof(asn_DEF_CriticalityDiagnostics_IE_List_tags_1[0]), /* 1 */
+	&asn_PER_type_CriticalityDiagnostics_IE_List_constr_1,
+	asn_MBR_CriticalityDiagnostics_IE_List_1,
+	1,	/* Single element */
+	&asn_SPC_CriticalityDiagnostics_IE_List_specs_1	/* Additional specs */
+};
+

src/asn1c/CriticalityDiagnostics-IE-List.h

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CriticalityDiagnostics_IE_List_H_
+#define	_CriticalityDiagnostics_IE_List_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include "Criticality.h"
+#include "ProtocolIE-ID.h"
+#include "TypeOfError.h"
+#include <constr_SEQUENCE.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* CriticalityDiagnostics-IE-List */
+typedef struct CriticalityDiagnostics_IE_List {
+	A_SEQUENCE_OF(struct Member {
+		Criticality_t	 iECriticality;
+		ProtocolIE_ID_t	 iE_ID;
+		TypeOfError_t	 typeOfError;
+		struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} ) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CriticalityDiagnostics_IE_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics_IE_List;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _CriticalityDiagnostics_IE_List_H_ */
+#include <asn_internal.h>

src/asn1c/CriticalityDiagnostics.c

@@ -0,0 +1,104 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "CriticalityDiagnostics.h"
+
+static asn_TYPE_member_t asn_MBR_CriticalityDiagnostics_1[] = {
+	{ ATF_POINTER, 5, offsetof(struct CriticalityDiagnostics, procedureCode),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProcedureCode,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCode"
+		},
+	{ ATF_POINTER, 4, offsetof(struct CriticalityDiagnostics, triggeringMessage),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_TriggeringMessage,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"triggeringMessage"
+		},
+	{ ATF_POINTER, 3, offsetof(struct CriticalityDiagnostics, procedureCriticality),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCriticality"
+		},
+	{ ATF_POINTER, 2, offsetof(struct CriticalityDiagnostics, iEsCriticalityDiagnostics),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CriticalityDiagnostics_IE_List,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iEsCriticalityDiagnostics"
+		},
+	{ ATF_POINTER, 1, offsetof(struct CriticalityDiagnostics, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_CriticalityDiagnostics_oms_1[] = { 0, 1, 2, 3, 4 };
+static const ber_tlv_tag_t asn_DEF_CriticalityDiagnostics_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_CriticalityDiagnostics_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* procedureCode */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* triggeringMessage */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* procedureCriticality */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* iEsCriticalityDiagnostics */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_CriticalityDiagnostics_specs_1 = {
+	sizeof(struct CriticalityDiagnostics),
+	offsetof(struct CriticalityDiagnostics, _asn_ctx),
+	asn_MAP_CriticalityDiagnostics_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_CriticalityDiagnostics_oms_1,	/* Optional members */
+	5, 0,	/* Root/Additions */
+	4,	/* Start extensions */
+	6	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics = {
+	"CriticalityDiagnostics",
+	"CriticalityDiagnostics",
+	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_CriticalityDiagnostics_tags_1,
+	sizeof(asn_DEF_CriticalityDiagnostics_tags_1)
+		/sizeof(asn_DEF_CriticalityDiagnostics_tags_1[0]), /* 1 */
+	asn_DEF_CriticalityDiagnostics_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CriticalityDiagnostics_tags_1)
+		/sizeof(asn_DEF_CriticalityDiagnostics_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_CriticalityDiagnostics_1,
+	5,	/* Elements count */
+	&asn_SPC_CriticalityDiagnostics_specs_1	/* Additional specs */
+};
+

src/asn1c/CriticalityDiagnostics.h

@@ -0,0 +1,56 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_CriticalityDiagnostics_H_
+#define	_CriticalityDiagnostics_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProcedureCode.h"
+#include "TriggeringMessage.h"
+#include "Criticality.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct CriticalityDiagnostics_IE_List;
+struct IE_Extensions;
+
+/* CriticalityDiagnostics */
+typedef struct CriticalityDiagnostics {
+	ProcedureCode_t	*procedureCode	/* OPTIONAL */;
+	TriggeringMessage_t	*triggeringMessage	/* OPTIONAL */;
+	Criticality_t	*procedureCriticality	/* OPTIONAL */;
+	struct CriticalityDiagnostics_IE_List	*iEsCriticalityDiagnostics	/* OPTIONAL */;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CriticalityDiagnostics_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "CriticalityDiagnostics-IE-List.h"
+#include "IE-Extensions.h"
+
+#endif	/* _CriticalityDiagnostics_H_ */
+#include <asn_internal.h>

src/asn1c/ESN.c

@@ -0,0 +1,172 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "ESN.h"
+
+int
+ESN_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 == 32l)) {
+		/* 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
+ESN_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
+ESN_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ESN_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ESN_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) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ESN_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) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ESN_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) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ESN_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) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+ESN_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) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+ESN_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+ESN_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ESN_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+ESN_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) {
+	ESN_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_ESN_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  32l,  32l }	/* (SIZE(32..32)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_ESN_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ESN = {
+	"ESN",
+	"ESN",
+	ESN_free,
+	ESN_print,
+	ESN_constraint,
+	ESN_decode_ber,
+	ESN_encode_der,
+	ESN_decode_xer,
+	ESN_encode_xer,
+	ESN_decode_uper,
+	ESN_encode_uper,
+	ESN_decode_aper,
+	ESN_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ESN_tags_1,
+	sizeof(asn_DEF_ESN_tags_1)
+		/sizeof(asn_DEF_ESN_tags_1[0]), /* 1 */
+	asn_DEF_ESN_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ESN_tags_1)
+		/sizeof(asn_DEF_ESN_tags_1[0]), /* 1 */
+	&asn_PER_type_ESN_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/ESN.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_ESN_H_
+#define	_ESN_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ESN */
+typedef BIT_STRING_t	 ESN_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ESN;
+asn_struct_free_f ESN_free;
+asn_struct_print_f ESN_print;
+asn_constr_check_f ESN_constraint;
+ber_type_decoder_f ESN_decode_ber;
+der_type_encoder_f ESN_encode_der;
+xer_type_decoder_f ESN_decode_xer;
+xer_type_encoder_f ESN_encode_xer;
+per_type_decoder_f ESN_decode_uper;
+per_type_encoder_f ESN_encode_uper;
+per_type_decoder_f ESN_decode_aper;
+per_type_encoder_f ESN_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ESN_H_ */
+#include <asn_internal.h>

src/asn1c/ErrorIndication.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "ErrorIndication.h"
+
+static int
+memb_errorIndication_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_errorIndication_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_errorIndication_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_errorIndication_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_errorIndication_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_errorIndication_ies_specs_2 = {
+	sizeof(struct errorIndication_ies),
+	offsetof(struct errorIndication_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_errorIndication_ies_2 = {
+	"errorIndication-ies",
+	"errorIndication-ies",
+	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_errorIndication_ies_tags_2,
+	sizeof(asn_DEF_errorIndication_ies_tags_2)
+		/sizeof(asn_DEF_errorIndication_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_errorIndication_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_errorIndication_ies_tags_2)
+		/sizeof(asn_DEF_errorIndication_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_errorIndication_ies_constr_2,
+	asn_MBR_errorIndication_ies_2,
+	1,	/* Single element */
+	&asn_SPC_errorIndication_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_ErrorIndication_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ErrorIndication, errorIndication_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_errorIndication_ies_2,
+		memb_errorIndication_ies_constraint_1,
+		&asn_PER_memb_errorIndication_ies_constr_2,
+		0,
+		"errorIndication-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ErrorIndication_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_ErrorIndication_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* errorIndication-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_ErrorIndication_specs_1 = {
+	sizeof(struct ErrorIndication),
+	offsetof(struct ErrorIndication, _asn_ctx),
+	asn_MAP_ErrorIndication_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_ErrorIndication = {
+	"ErrorIndication",
+	"ErrorIndication",
+	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_ErrorIndication_tags_1,
+	sizeof(asn_DEF_ErrorIndication_tags_1)
+		/sizeof(asn_DEF_ErrorIndication_tags_1[0]), /* 1 */
+	asn_DEF_ErrorIndication_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ErrorIndication_tags_1)
+		/sizeof(asn_DEF_ErrorIndication_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_ErrorIndication_1,
+	1,	/* Elements count */
+	&asn_SPC_ErrorIndication_specs_1	/* Additional specs */
+};
+

src/asn1c/ErrorIndication.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_ErrorIndication_H_
+#define	_ErrorIndication_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* ErrorIndication */
+typedef struct ErrorIndication {
+	struct errorIndication_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} errorIndication_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ErrorIndication_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ErrorIndication;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _ErrorIndication_H_ */
+#include <asn_internal.h>

src/asn1c/GTP-TEI.c

@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "GTP-TEI.h"
+
+int
+GTP_TEI_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 == 4l)) {
+		/* 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
+GTP_TEI_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
+GTP_TEI_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+GTP_TEI_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+GTP_TEI_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) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+GTP_TEI_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) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+GTP_TEI_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) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+GTP_TEI_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) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+GTP_TEI_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) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+GTP_TEI_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+GTP_TEI_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	GTP_TEI_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+GTP_TEI_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) {
+	GTP_TEI_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_GTP_TEI_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  4l,  4l }	/* (SIZE(4..4)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_GTP_TEI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_GTP_TEI = {
+	"GTP-TEI",
+	"GTP-TEI",
+	GTP_TEI_free,
+	GTP_TEI_print,
+	GTP_TEI_constraint,
+	GTP_TEI_decode_ber,
+	GTP_TEI_encode_der,
+	GTP_TEI_decode_xer,
+	GTP_TEI_encode_xer,
+	GTP_TEI_decode_uper,
+	GTP_TEI_encode_uper,
+	GTP_TEI_decode_aper,
+	GTP_TEI_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_GTP_TEI_tags_1,
+	sizeof(asn_DEF_GTP_TEI_tags_1)
+		/sizeof(asn_DEF_GTP_TEI_tags_1[0]), /* 1 */
+	asn_DEF_GTP_TEI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GTP_TEI_tags_1)
+		/sizeof(asn_DEF_GTP_TEI_tags_1[0]), /* 1 */
+	&asn_PER_type_GTP_TEI_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/GTP-TEI.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_GTP_TEI_H_
+#define	_GTP_TEI_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GTP-TEI */
+typedef OCTET_STRING_t	 GTP_TEI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GTP_TEI;
+asn_struct_free_f GTP_TEI_free;
+asn_struct_print_f GTP_TEI_print;
+asn_constr_check_f GTP_TEI_constraint;
+ber_type_decoder_f GTP_TEI_decode_ber;
+der_type_encoder_f GTP_TEI_encode_der;
+xer_type_decoder_f GTP_TEI_decode_xer;
+xer_type_encoder_f GTP_TEI_encode_xer;
+per_type_decoder_f GTP_TEI_decode_uper;
+per_type_encoder_f GTP_TEI_encode_uper;
+per_type_decoder_f GTP_TEI_decode_aper;
+per_type_encoder_f GTP_TEI_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GTP_TEI_H_ */
+#include <asn_internal.h>

src/asn1c/GeographicalCoordinates.c

@@ -0,0 +1,313 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "GeographicalCoordinates.h"
+
+static int
+latitudeSign_2_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
+latitudeSign_2_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 */
+}
+
+static void
+latitudeSign_2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+latitudeSign_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+latitudeSign_2_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) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+latitudeSign_2_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) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+latitudeSign_2_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) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+latitudeSign_2_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) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_dec_rval_t
+latitudeSign_2_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) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_enc_rval_t
+latitudeSign_2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_enc_rval_t
+latitudeSign_2_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_dec_rval_t
+latitudeSign_2_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) {
+	latitudeSign_2_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static int
+memb_latitude_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	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 *)sptr;
+	
+	if((value >= 0l && value <= 8388607l)) {
+		/* 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_longitude_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	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 *)sptr;
+	
+	if((value >= -8388608ull && value <= 8388607l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_latitudeSign_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_latitude_constr_5 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 23, -1,  0l,  8388607l }	/* (0..8388607) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_longitude_constr_6 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 24, -1, -8388608ull,  8388607l }	/* (-8388608..8388607) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_latitudeSign_value2enum_2[] = {
+	{ 0,	5,	"north" },
+	{ 1,	5,	"south" }
+};
+static const unsigned int asn_MAP_latitudeSign_enum2value_2[] = {
+	0,	/* north(0) */
+	1	/* south(1) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_latitudeSign_specs_2 = {
+	asn_MAP_latitudeSign_value2enum_2,	/* "tag" => N; sorted by tag */
+	asn_MAP_latitudeSign_enum2value_2,	/* 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_latitudeSign_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_latitudeSign_2 = {
+	"latitudeSign",
+	"latitudeSign",
+	latitudeSign_2_free,
+	latitudeSign_2_print,
+	latitudeSign_2_constraint,
+	latitudeSign_2_decode_ber,
+	latitudeSign_2_encode_der,
+	latitudeSign_2_decode_xer,
+	latitudeSign_2_encode_xer,
+	latitudeSign_2_decode_uper,
+	latitudeSign_2_encode_uper,
+	latitudeSign_2_decode_aper,
+	latitudeSign_2_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_latitudeSign_tags_2,
+	sizeof(asn_DEF_latitudeSign_tags_2)
+		/sizeof(asn_DEF_latitudeSign_tags_2[0]) - 1, /* 1 */
+	asn_DEF_latitudeSign_tags_2,	/* Same as above */
+	sizeof(asn_DEF_latitudeSign_tags_2)
+		/sizeof(asn_DEF_latitudeSign_tags_2[0]), /* 2 */
+	&asn_PER_type_latitudeSign_constr_2,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_latitudeSign_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_GeographicalCoordinates_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GeographicalCoordinates, latitudeSign),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_latitudeSign_2,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"latitudeSign"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GeographicalCoordinates, latitude),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_latitude_constraint_1,
+		&asn_PER_memb_latitude_constr_5,
+		0,
+		"latitude"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GeographicalCoordinates, longitude),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_longitude_constraint_1,
+		&asn_PER_memb_longitude_constr_6,
+		0,
+		"longitude"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GeographicalCoordinates, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_GeographicalCoordinates_oms_1[] = { 3 };
+static const ber_tlv_tag_t asn_DEF_GeographicalCoordinates_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GeographicalCoordinates_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* latitudeSign */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* latitude */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* longitude */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GeographicalCoordinates_specs_1 = {
+	sizeof(struct GeographicalCoordinates),
+	offsetof(struct GeographicalCoordinates, _asn_ctx),
+	asn_MAP_GeographicalCoordinates_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_GeographicalCoordinates_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	3,	/* Start extensions */
+	5	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GeographicalCoordinates = {
+	"GeographicalCoordinates",
+	"GeographicalCoordinates",
+	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_GeographicalCoordinates_tags_1,
+	sizeof(asn_DEF_GeographicalCoordinates_tags_1)
+		/sizeof(asn_DEF_GeographicalCoordinates_tags_1[0]), /* 1 */
+	asn_DEF_GeographicalCoordinates_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GeographicalCoordinates_tags_1)
+		/sizeof(asn_DEF_GeographicalCoordinates_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_GeographicalCoordinates_1,
+	4,	/* Elements count */
+	&asn_SPC_GeographicalCoordinates_specs_1	/* Additional specs */
+};
+

src/asn1c/GeographicalCoordinates.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_GeographicalCoordinates_H_
+#define	_GeographicalCoordinates_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum latitudeSign {
+	latitudeSign_north	= 0,
+	latitudeSign_south	= 1
+} e_latitudeSign;
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* GeographicalCoordinates */
+typedef struct GeographicalCoordinates {
+	long	 latitudeSign;
+	long	 latitude;
+	long	 longitude;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GeographicalCoordinates_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_latitudeSign_2;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_GeographicalCoordinates;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _GeographicalCoordinates_H_ */
+#include <asn_internal.h>

src/asn1c/GeographicalLocation.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "GeographicalLocation.h"
+
+static asn_TYPE_member_t asn_MBR_GeographicalLocation_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GeographicalLocation, geographicalCoordinates),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GeographicalCoordinates,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"geographicalCoordinates"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GeographicalLocation, altitudeAndDirection),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_AltitudeAndDirection,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeAndDirection"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GeographicalLocation, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_GeographicalLocation_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_GeographicalLocation_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GeographicalLocation_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* geographicalCoordinates */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* altitudeAndDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GeographicalLocation_specs_1 = {
+	sizeof(struct GeographicalLocation),
+	offsetof(struct GeographicalLocation, _asn_ctx),
+	asn_MAP_GeographicalLocation_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_GeographicalLocation_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GeographicalLocation = {
+	"GeographicalLocation",
+	"GeographicalLocation",
+	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_GeographicalLocation_tags_1,
+	sizeof(asn_DEF_GeographicalLocation_tags_1)
+		/sizeof(asn_DEF_GeographicalLocation_tags_1[0]), /* 1 */
+	asn_DEF_GeographicalLocation_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GeographicalLocation_tags_1)
+		/sizeof(asn_DEF_GeographicalLocation_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_GeographicalLocation_1,
+	3,	/* Elements count */
+	&asn_SPC_GeographicalLocation_specs_1	/* Additional specs */
+};
+

src/asn1c/GeographicalLocation.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_GeographicalLocation_H_
+#define	_GeographicalLocation_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GeographicalCoordinates.h"
+#include "AltitudeAndDirection.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* GeographicalLocation */
+typedef struct GeographicalLocation {
+	GeographicalCoordinates_t	 geographicalCoordinates;
+	AltitudeAndDirection_t	 altitudeAndDirection;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GeographicalLocation_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GeographicalLocation;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _GeographicalLocation_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-Cell-Access-Mode.c

@@ -0,0 +1,170 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-Cell-Access-Mode.h"
+
+int
+HNB_Cell_Access_Mode_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
+HNB_Cell_Access_Mode_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
+HNB_Cell_Access_Mode_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+HNB_Cell_Access_Mode_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+HNB_Cell_Access_Mode_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) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+HNB_Cell_Access_Mode_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) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+HNB_Cell_Access_Mode_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) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+HNB_Cell_Access_Mode_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) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+HNB_Cell_Access_Mode_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) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+HNB_Cell_Access_Mode_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+HNB_Cell_Access_Mode_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	HNB_Cell_Access_Mode_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+HNB_Cell_Access_Mode_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) {
+	HNB_Cell_Access_Mode_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_HNB_Cell_Access_Mode_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 const asn_INTEGER_enum_map_t asn_MAP_HNB_Cell_Access_Mode_value2enum_1[] = {
+	{ 0,	6,	"closed" },
+	{ 1,	6,	"hybrid" },
+	{ 2,	4,	"open" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_HNB_Cell_Access_Mode_enum2value_1[] = {
+	0,	/* closed(0) */
+	1,	/* hybrid(1) */
+	2	/* open(2) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_HNB_Cell_Access_Mode_specs_1 = {
+	asn_MAP_HNB_Cell_Access_Mode_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_HNB_Cell_Access_Mode_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	4,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_HNB_Cell_Access_Mode_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_Cell_Access_Mode = {
+	"HNB-Cell-Access-Mode",
+	"HNB-Cell-Access-Mode",
+	HNB_Cell_Access_Mode_free,
+	HNB_Cell_Access_Mode_print,
+	HNB_Cell_Access_Mode_constraint,
+	HNB_Cell_Access_Mode_decode_ber,
+	HNB_Cell_Access_Mode_encode_der,
+	HNB_Cell_Access_Mode_decode_xer,
+	HNB_Cell_Access_Mode_encode_xer,
+	HNB_Cell_Access_Mode_decode_uper,
+	HNB_Cell_Access_Mode_encode_uper,
+	HNB_Cell_Access_Mode_decode_aper,
+	HNB_Cell_Access_Mode_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_HNB_Cell_Access_Mode_tags_1,
+	sizeof(asn_DEF_HNB_Cell_Access_Mode_tags_1)
+		/sizeof(asn_DEF_HNB_Cell_Access_Mode_tags_1[0]), /* 1 */
+	asn_DEF_HNB_Cell_Access_Mode_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNB_Cell_Access_Mode_tags_1)
+		/sizeof(asn_DEF_HNB_Cell_Access_Mode_tags_1[0]), /* 1 */
+	&asn_PER_type_HNB_Cell_Access_Mode_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_HNB_Cell_Access_Mode_specs_1	/* Additional specs */
+};
+

src/asn1c/HNB-Cell-Access-Mode.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_Cell_Access_Mode_H_
+#define	_HNB_Cell_Access_Mode_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum HNB_Cell_Access_Mode {
+	HNB_Cell_Access_Mode_closed	= 0,
+	HNB_Cell_Access_Mode_hybrid	= 1,
+	HNB_Cell_Access_Mode_open	= 2
+	/*
+	 * Enumeration is extensible
+	 */
+} e_HNB_Cell_Access_Mode;
+
+/* HNB-Cell-Access-Mode */
+typedef long	 HNB_Cell_Access_Mode_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_Cell_Access_Mode;
+asn_struct_free_f HNB_Cell_Access_Mode_free;
+asn_struct_print_f HNB_Cell_Access_Mode_print;
+asn_constr_check_f HNB_Cell_Access_Mode_constraint;
+ber_type_decoder_f HNB_Cell_Access_Mode_decode_ber;
+der_type_encoder_f HNB_Cell_Access_Mode_encode_der;
+xer_type_decoder_f HNB_Cell_Access_Mode_decode_xer;
+xer_type_encoder_f HNB_Cell_Access_Mode_encode_xer;
+per_type_decoder_f HNB_Cell_Access_Mode_decode_uper;
+per_type_encoder_f HNB_Cell_Access_Mode_encode_uper;
+per_type_decoder_f HNB_Cell_Access_Mode_decode_aper;
+per_type_encoder_f HNB_Cell_Access_Mode_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HNB_Cell_Access_Mode_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-Cell-Identifier.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-Cell-Identifier.h"
+
+static asn_TYPE_member_t asn_MBR_HNB_Cell_Identifier_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_Cell_Identifier, pLMNidentity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMNidentity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"pLMNidentity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_Cell_Identifier, cellIdentity),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CellIdentity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cellIdentity"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNB_Cell_Identifier, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_HNB_Cell_Identifier_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_HNB_Cell_Identifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNB_Cell_Identifier_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMNidentity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* cellIdentity */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNB_Cell_Identifier_specs_1 = {
+	sizeof(struct HNB_Cell_Identifier),
+	offsetof(struct HNB_Cell_Identifier, _asn_ctx),
+	asn_MAP_HNB_Cell_Identifier_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_HNB_Cell_Identifier_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_Cell_Identifier = {
+	"HNB-Cell-Identifier",
+	"HNB-Cell-Identifier",
+	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_HNB_Cell_Identifier_tags_1,
+	sizeof(asn_DEF_HNB_Cell_Identifier_tags_1)
+		/sizeof(asn_DEF_HNB_Cell_Identifier_tags_1[0]), /* 1 */
+	asn_DEF_HNB_Cell_Identifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNB_Cell_Identifier_tags_1)
+		/sizeof(asn_DEF_HNB_Cell_Identifier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNB_Cell_Identifier_1,
+	3,	/* Elements count */
+	&asn_SPC_HNB_Cell_Identifier_specs_1	/* Additional specs */
+};
+

src/asn1c/HNB-Cell-Identifier.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_Cell_Identifier_H_
+#define	_HNB_Cell_Identifier_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMNidentity.h"
+#include "CellIdentity.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* HNB-Cell-Identifier */
+typedef struct HNB_Cell_Identifier {
+	PLMNidentity_t	 pLMNidentity;
+	CellIdentity_t	 cellIdentity;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNB_Cell_Identifier_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_Cell_Identifier;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _HNB_Cell_Identifier_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-GWResponse.c

@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-GWResponse.h"
+
+static asn_per_constraints_t asn_PER_type_HNB_GWResponse_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_HNB_GWResponse_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_GWResponse, choice.hNB),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HNBConfigInfo,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"hNB"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_GWResponse, choice.macroRNC),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RNC_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"macroRNC"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_GWResponse, choice.unknownU_RNTIIndication),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_UnknownU_RNTIIndication,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"unknownU-RNTIIndication"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNB_GWResponse_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* hNB */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* macroRNC */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* unknownU-RNTIIndication */
+};
+static asn_CHOICE_specifics_t asn_SPC_HNB_GWResponse_specs_1 = {
+	sizeof(struct HNB_GWResponse),
+	offsetof(struct HNB_GWResponse, _asn_ctx),
+	offsetof(struct HNB_GWResponse, present),
+	sizeof(((struct HNB_GWResponse *)0)->present),
+	asn_MAP_HNB_GWResponse_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_GWResponse = {
+	"HNB-GWResponse",
+	"HNB-GWResponse",
+	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_HNB_GWResponse_constr_1,
+	asn_MBR_HNB_GWResponse_1,
+	3,	/* Elements count */
+	&asn_SPC_HNB_GWResponse_specs_1	/* Additional specs */
+};
+

src/asn1c/HNB-GWResponse.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_GWResponse_H_
+#define	_HNB_GWResponse_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HNBConfigInfo.h"
+#include "RNC-ID.h"
+#include "UnknownU-RNTIIndication.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum HNB_GWResponse_PR {
+	HNB_GWResponse_PR_NOTHING,	/* No components present */
+	HNB_GWResponse_PR_hNB,
+	HNB_GWResponse_PR_macroRNC,
+	HNB_GWResponse_PR_unknownU_RNTIIndication,
+	/* Extensions may appear below */
+	
+} HNB_GWResponse_PR;
+
+/* HNB-GWResponse */
+typedef struct HNB_GWResponse {
+	HNB_GWResponse_PR present;
+	union HNB_GWResponse_u {
+		HNBConfigInfo_t	 hNB;
+		RNC_ID_t	 macroRNC;
+		UnknownU_RNTIIndication_t	 unknownU_RNTIIndication;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNB_GWResponse_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_GWResponse;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HNB_GWResponse_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-Identity-Info.c

@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-Identity-Info.h"
+
+int
+HNB_Identity_Info_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 >= 1l && size <= 255l)) {
+		/* 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
+HNB_Identity_Info_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
+HNB_Identity_Info_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+HNB_Identity_Info_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+HNB_Identity_Info_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) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+HNB_Identity_Info_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) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+HNB_Identity_Info_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) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+HNB_Identity_Info_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) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+HNB_Identity_Info_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) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+HNB_Identity_Info_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+HNB_Identity_Info_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	HNB_Identity_Info_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+HNB_Identity_Info_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) {
+	HNB_Identity_Info_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_HNB_Identity_Info_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1l,  255l }	/* (SIZE(1..255)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_HNB_Identity_Info_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_Identity_Info = {
+	"HNB-Identity-Info",
+	"HNB-Identity-Info",
+	HNB_Identity_Info_free,
+	HNB_Identity_Info_print,
+	HNB_Identity_Info_constraint,
+	HNB_Identity_Info_decode_ber,
+	HNB_Identity_Info_encode_der,
+	HNB_Identity_Info_decode_xer,
+	HNB_Identity_Info_encode_xer,
+	HNB_Identity_Info_decode_uper,
+	HNB_Identity_Info_encode_uper,
+	HNB_Identity_Info_decode_aper,
+	HNB_Identity_Info_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_HNB_Identity_Info_tags_1,
+	sizeof(asn_DEF_HNB_Identity_Info_tags_1)
+		/sizeof(asn_DEF_HNB_Identity_Info_tags_1[0]), /* 1 */
+	asn_DEF_HNB_Identity_Info_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNB_Identity_Info_tags_1)
+		/sizeof(asn_DEF_HNB_Identity_Info_tags_1[0]), /* 1 */
+	&asn_PER_type_HNB_Identity_Info_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/HNB-Identity-Info.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_Identity_Info_H_
+#define	_HNB_Identity_Info_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* HNB-Identity-Info */
+typedef OCTET_STRING_t	 HNB_Identity_Info_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_Identity_Info;
+asn_struct_free_f HNB_Identity_Info_free;
+asn_struct_print_f HNB_Identity_Info_print;
+asn_constr_check_f HNB_Identity_Info_constraint;
+ber_type_decoder_f HNB_Identity_Info_decode_ber;
+der_type_encoder_f HNB_Identity_Info_encode_der;
+xer_type_decoder_f HNB_Identity_Info_decode_xer;
+xer_type_encoder_f HNB_Identity_Info_encode_xer;
+per_type_decoder_f HNB_Identity_Info_decode_uper;
+per_type_encoder_f HNB_Identity_Info_encode_uper;
+per_type_decoder_f HNB_Identity_Info_decode_aper;
+per_type_encoder_f HNB_Identity_Info_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HNB_Identity_Info_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-Identity.c

@@ -0,0 +1,74 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-Identity.h"
+
+static asn_TYPE_member_t asn_MBR_HNB_Identity_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_Identity, hNB_Identity_Info),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HNB_Identity_Info,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"hNB-Identity-Info"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNB_Identity, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_HNB_Identity_oms_1[] = { 1 };
+static const ber_tlv_tag_t asn_DEF_HNB_Identity_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNB_Identity_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* hNB-Identity-Info */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNB_Identity_specs_1 = {
+	sizeof(struct HNB_Identity),
+	offsetof(struct HNB_Identity, _asn_ctx),
+	asn_MAP_HNB_Identity_tag2el_1,
+	2,	/* Count of tags in the map */
+	asn_MAP_HNB_Identity_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	1,	/* Start extensions */
+	3	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_Identity = {
+	"HNB-Identity",
+	"HNB-Identity",
+	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_HNB_Identity_tags_1,
+	sizeof(asn_DEF_HNB_Identity_tags_1)
+		/sizeof(asn_DEF_HNB_Identity_tags_1[0]), /* 1 */
+	asn_DEF_HNB_Identity_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNB_Identity_tags_1)
+		/sizeof(asn_DEF_HNB_Identity_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNB_Identity_1,
+	2,	/* Elements count */
+	&asn_SPC_HNB_Identity_specs_1	/* Additional specs */
+};
+

src/asn1c/HNB-Identity.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_Identity_H_
+#define	_HNB_Identity_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HNB-Identity-Info.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* HNB-Identity */
+typedef struct HNB_Identity {
+	HNB_Identity_Info_t	 hNB_Identity_Info;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNB_Identity_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_Identity;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _HNB_Identity_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-Location-Information.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-Location-Information.h"
+
+static asn_TYPE_member_t asn_MBR_HNB_Location_Information_1[] = {
+	{ ATF_POINTER, 3, offsetof(struct HNB_Location_Information, macroCoverageInfo),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_MacroCoverageInformation,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"macroCoverageInfo"
+		},
+	{ ATF_POINTER, 2, offsetof(struct HNB_Location_Information, geographicalCoordinates),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GeographicalLocation,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"geographicalCoordinates"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNB_Location_Information, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_HNB_Location_Information_oms_1[] = { 0, 1, 2 };
+static const ber_tlv_tag_t asn_DEF_HNB_Location_Information_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNB_Location_Information_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* macroCoverageInfo */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* geographicalCoordinates */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNB_Location_Information_specs_1 = {
+	sizeof(struct HNB_Location_Information),
+	offsetof(struct HNB_Location_Information, _asn_ctx),
+	asn_MAP_HNB_Location_Information_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_HNB_Location_Information_oms_1,	/* Optional members */
+	3, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_Location_Information = {
+	"HNB-Location-Information",
+	"HNB-Location-Information",
+	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_HNB_Location_Information_tags_1,
+	sizeof(asn_DEF_HNB_Location_Information_tags_1)
+		/sizeof(asn_DEF_HNB_Location_Information_tags_1[0]), /* 1 */
+	asn_DEF_HNB_Location_Information_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNB_Location_Information_tags_1)
+		/sizeof(asn_DEF_HNB_Location_Information_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNB_Location_Information_1,
+	3,	/* Elements count */
+	&asn_SPC_HNB_Location_Information_specs_1	/* Additional specs */
+};
+

src/asn1c/HNB-Location-Information.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_Location_Information_H_
+#define	_HNB_Location_Information_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct MacroCoverageInformation;
+struct GeographicalLocation;
+struct IE_Extensions;
+
+/* HNB-Location-Information */
+typedef struct HNB_Location_Information {
+	struct MacroCoverageInformation	*macroCoverageInfo	/* OPTIONAL */;
+	struct GeographicalLocation	*geographicalCoordinates	/* OPTIONAL */;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNB_Location_Information_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_Location_Information;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "MacroCoverageInformation.h"
+#include "GeographicalLocation.h"
+#include "IE-Extensions.h"
+
+#endif	/* _HNB_Location_Information_H_ */
+#include <asn_internal.h>

src/asn1c/HNB-RNL-Identity.c

@@ -0,0 +1,63 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNB-RNL-Identity.h"
+
+static asn_per_constraints_t asn_PER_type_HNB_RNL_Identity_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 asn_TYPE_member_t asn_MBR_HNB_RNL_Identity_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNB_RNL_Identity, choice.hNB_Identity_as_Cell_Identifier),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HNB_Cell_Identifier,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"hNB-Identity-as-Cell-Identifier"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNB_RNL_Identity_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hNB-Identity-as-Cell-Identifier */
+};
+static asn_CHOICE_specifics_t asn_SPC_HNB_RNL_Identity_specs_1 = {
+	sizeof(struct HNB_RNL_Identity),
+	offsetof(struct HNB_RNL_Identity, _asn_ctx),
+	offsetof(struct HNB_RNL_Identity, present),
+	sizeof(((struct HNB_RNL_Identity *)0)->present),
+	asn_MAP_HNB_RNL_Identity_tag2el_1,
+	1,	/* Count of tags in the map */
+	0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_HNB_RNL_Identity = {
+	"HNB-RNL-Identity",
+	"HNB-RNL-Identity",
+	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_HNB_RNL_Identity_constr_1,
+	asn_MBR_HNB_RNL_Identity_1,
+	1,	/* Elements count */
+	&asn_SPC_HNB_RNL_Identity_specs_1	/* Additional specs */
+};
+

src/asn1c/HNB-RNL-Identity.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNB_RNL_Identity_H_
+#define	_HNB_RNL_Identity_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HNB-Cell-Identifier.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum HNB_RNL_Identity_PR {
+	HNB_RNL_Identity_PR_NOTHING,	/* No components present */
+	HNB_RNL_Identity_PR_hNB_Identity_as_Cell_Identifier,
+	/* Extensions may appear below */
+	
+} HNB_RNL_Identity_PR;
+
+/* HNB-RNL-Identity */
+typedef struct HNB_RNL_Identity {
+	HNB_RNL_Identity_PR present;
+	union HNB_RNL_Identity_u {
+		HNB_Cell_Identifier_t	 hNB_Identity_as_Cell_Identifier;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNB_RNL_Identity_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNB_RNL_Identity;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HNB_RNL_Identity_H_ */
+#include <asn_internal.h>

src/asn1c/HNBAP-PDU.c

@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBAP-PDU.h"
+
+static asn_per_constraints_t asn_PER_type_HNBAP_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_HNBAP_PDU_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBAP_PDU, choice.initiatingMessage),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_InitiatingMessage,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"initiatingMessage"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBAP_PDU, choice.successfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SuccessfulOutcome,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"successfulOutcome"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBAP_PDU, choice.unsuccessfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_UnsuccessfulOutcome,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"unsuccessfulOutcome"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBAP_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_HNBAP_PDU_specs_1 = {
+	sizeof(struct HNBAP_PDU),
+	offsetof(struct HNBAP_PDU, _asn_ctx),
+	offsetof(struct HNBAP_PDU, present),
+	sizeof(((struct HNBAP_PDU *)0)->present),
+	asn_MAP_HNBAP_PDU_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBAP_PDU = {
+	"HNBAP-PDU",
+	"HNBAP-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_HNBAP_PDU_constr_1,
+	asn_MBR_HNBAP_PDU_1,
+	3,	/* Elements count */
+	&asn_SPC_HNBAP_PDU_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBAP-PDU.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBAP_PDU_H_
+#define	_HNBAP_PDU_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "InitiatingMessage.h"
+#include "SuccessfulOutcome.h"
+#include "UnsuccessfulOutcome.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum HNBAP_PDU_PR {
+	HNBAP_PDU_PR_NOTHING,	/* No components present */
+	HNBAP_PDU_PR_initiatingMessage,
+	HNBAP_PDU_PR_successfulOutcome,
+	HNBAP_PDU_PR_unsuccessfulOutcome,
+	/* Extensions may appear below */
+	
+} HNBAP_PDU_PR;
+
+/* HNBAP-PDU */
+typedef struct HNBAP_PDU {
+	HNBAP_PDU_PR present;
+	union HNBAP_PDU_u {
+		InitiatingMessage_t	 initiatingMessage;
+		SuccessfulOutcome_t	 successfulOutcome;
+		UnsuccessfulOutcome_t	 unsuccessfulOutcome;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBAP_PDU_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBAP_PDU;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HNBAP_PDU_H_ */
+#include <asn_internal.h>

src/asn1c/HNBCapacity.c

@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBCapacity.h"
+
+int
+HNBCapacity_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	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 *)sptr;
+	
+	if((value >= 0l && value <= 1000l)) {
+		/* 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 NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+HNBCapacity_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+HNBCapacity_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+HNBCapacity_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+HNBCapacity_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) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+HNBCapacity_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) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+HNBCapacity_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) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+HNBCapacity_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) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+HNBCapacity_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) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+HNBCapacity_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+HNBCapacity_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	HNBCapacity_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+HNBCapacity_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) {
+	HNBCapacity_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_HNBCapacity_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 10,  10,  0l,  1000l }	/* (0..1000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_HNBCapacity_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HNBCapacity = {
+	"HNBCapacity",
+	"HNBCapacity",
+	HNBCapacity_free,
+	HNBCapacity_print,
+	HNBCapacity_constraint,
+	HNBCapacity_decode_ber,
+	HNBCapacity_encode_der,
+	HNBCapacity_decode_xer,
+	HNBCapacity_encode_xer,
+	HNBCapacity_decode_uper,
+	HNBCapacity_encode_uper,
+	HNBCapacity_decode_aper,
+	HNBCapacity_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_HNBCapacity_tags_1,
+	sizeof(asn_DEF_HNBCapacity_tags_1)
+		/sizeof(asn_DEF_HNBCapacity_tags_1[0]), /* 1 */
+	asn_DEF_HNBCapacity_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBCapacity_tags_1)
+		/sizeof(asn_DEF_HNBCapacity_tags_1[0]), /* 1 */
+	&asn_PER_type_HNBCapacity_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/asn1c/HNBCapacity.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBCapacity_H_
+#define	_HNBCapacity_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* HNBCapacity */
+typedef long	 HNBCapacity_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBCapacity;
+asn_struct_free_f HNBCapacity_free;
+asn_struct_print_f HNBCapacity_print;
+asn_constr_check_f HNBCapacity_constraint;
+ber_type_decoder_f HNBCapacity_decode_ber;
+der_type_encoder_f HNBCapacity_encode_der;
+xer_type_decoder_f HNBCapacity_decode_xer;
+xer_type_encoder_f HNBCapacity_encode_xer;
+per_type_decoder_f HNBCapacity_decode_uper;
+per_type_encoder_f HNBCapacity_encode_uper;
+per_type_decoder_f HNBCapacity_decode_aper;
+per_type_encoder_f HNBCapacity_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HNBCapacity_H_ */
+#include <asn_internal.h>

src/asn1c/HNBConfigInfo.c

@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBConfigInfo.h"
+
+static asn_TYPE_member_t asn_MBR_HNBConfigInfo_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigInfo, hnb_RNL_Identity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_HNB_RNL_Identity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"hnb-RNL-Identity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigInfo, configurationInformation),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ConfigurationInformation,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"configurationInformation"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNBConfigInfo, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_HNBConfigInfo_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_HNBConfigInfo_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBConfigInfo_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* hnb-RNL-Identity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* configurationInformation */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBConfigInfo_specs_1 = {
+	sizeof(struct HNBConfigInfo),
+	offsetof(struct HNBConfigInfo, _asn_ctx),
+	asn_MAP_HNBConfigInfo_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_HNBConfigInfo_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBConfigInfo = {
+	"HNBConfigInfo",
+	"HNBConfigInfo",
+	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_HNBConfigInfo_tags_1,
+	sizeof(asn_DEF_HNBConfigInfo_tags_1)
+		/sizeof(asn_DEF_HNBConfigInfo_tags_1[0]), /* 1 */
+	asn_DEF_HNBConfigInfo_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBConfigInfo_tags_1)
+		/sizeof(asn_DEF_HNBConfigInfo_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBConfigInfo_1,
+	3,	/* Elements count */
+	&asn_SPC_HNBConfigInfo_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBConfigInfo.h

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBConfigInfo_H_
+#define	_HNBConfigInfo_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HNB-RNL-Identity.h"
+#include "ConfigurationInformation.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* HNBConfigInfo */
+typedef struct HNBConfigInfo {
+	HNB_RNL_Identity_t	 hnb_RNL_Identity;
+	ConfigurationInformation_t	 configurationInformation;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBConfigInfo_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBConfigInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _HNBConfigInfo_H_ */
+#include <asn_internal.h>

src/asn1c/HNBConfigTransferRequest.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBConfigTransferRequest.h"
+
+static int
+memb_hnbConfigTransferRequest_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_hnbConfigTransferRequest_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_hnbConfigTransferRequest_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_hnbConfigTransferRequest_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_hnbConfigTransferRequest_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_hnbConfigTransferRequest_ies_specs_2 = {
+	sizeof(struct hnbConfigTransferRequest_ies),
+	offsetof(struct hnbConfigTransferRequest_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_hnbConfigTransferRequest_ies_2 = {
+	"hnbConfigTransferRequest-ies",
+	"hnbConfigTransferRequest-ies",
+	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_hnbConfigTransferRequest_ies_tags_2,
+	sizeof(asn_DEF_hnbConfigTransferRequest_ies_tags_2)
+		/sizeof(asn_DEF_hnbConfigTransferRequest_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_hnbConfigTransferRequest_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_hnbConfigTransferRequest_ies_tags_2)
+		/sizeof(asn_DEF_hnbConfigTransferRequest_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_hnbConfigTransferRequest_ies_constr_2,
+	asn_MBR_hnbConfigTransferRequest_ies_2,
+	1,	/* Single element */
+	&asn_SPC_hnbConfigTransferRequest_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_HNBConfigTransferRequest_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigTransferRequest, hnbConfigTransferRequest_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_hnbConfigTransferRequest_ies_2,
+		memb_hnbConfigTransferRequest_ies_constraint_1,
+		&asn_PER_memb_hnbConfigTransferRequest_ies_constr_2,
+		0,
+		"hnbConfigTransferRequest-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_HNBConfigTransferRequest_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBConfigTransferRequest_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hnbConfigTransferRequest-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBConfigTransferRequest_specs_1 = {
+	sizeof(struct HNBConfigTransferRequest),
+	offsetof(struct HNBConfigTransferRequest, _asn_ctx),
+	asn_MAP_HNBConfigTransferRequest_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBConfigTransferRequest = {
+	"HNBConfigTransferRequest",
+	"HNBConfigTransferRequest",
+	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_HNBConfigTransferRequest_tags_1,
+	sizeof(asn_DEF_HNBConfigTransferRequest_tags_1)
+		/sizeof(asn_DEF_HNBConfigTransferRequest_tags_1[0]), /* 1 */
+	asn_DEF_HNBConfigTransferRequest_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBConfigTransferRequest_tags_1)
+		/sizeof(asn_DEF_HNBConfigTransferRequest_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBConfigTransferRequest_1,
+	1,	/* Elements count */
+	&asn_SPC_HNBConfigTransferRequest_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBConfigTransferRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBConfigTransferRequest_H_
+#define	_HNBConfigTransferRequest_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* HNBConfigTransferRequest */
+typedef struct HNBConfigTransferRequest {
+	struct hnbConfigTransferRequest_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} hnbConfigTransferRequest_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBConfigTransferRequest_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBConfigTransferRequest;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _HNBConfigTransferRequest_H_ */
+#include <asn_internal.h>

src/asn1c/HNBConfigTransferResponse.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBConfigTransferResponse.h"
+
+static int
+memb_hnbConfigTransferResponse_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_hnbConfigTransferResponse_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_hnbConfigTransferResponse_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_hnbConfigTransferResponse_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_hnbConfigTransferResponse_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_hnbConfigTransferResponse_ies_specs_2 = {
+	sizeof(struct hnbConfigTransferResponse_ies),
+	offsetof(struct hnbConfigTransferResponse_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_hnbConfigTransferResponse_ies_2 = {
+	"hnbConfigTransferResponse-ies",
+	"hnbConfigTransferResponse-ies",
+	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_hnbConfigTransferResponse_ies_tags_2,
+	sizeof(asn_DEF_hnbConfigTransferResponse_ies_tags_2)
+		/sizeof(asn_DEF_hnbConfigTransferResponse_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_hnbConfigTransferResponse_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_hnbConfigTransferResponse_ies_tags_2)
+		/sizeof(asn_DEF_hnbConfigTransferResponse_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_hnbConfigTransferResponse_ies_constr_2,
+	asn_MBR_hnbConfigTransferResponse_ies_2,
+	1,	/* Single element */
+	&asn_SPC_hnbConfigTransferResponse_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_HNBConfigTransferResponse_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigTransferResponse, hnbConfigTransferResponse_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_hnbConfigTransferResponse_ies_2,
+		memb_hnbConfigTransferResponse_ies_constraint_1,
+		&asn_PER_memb_hnbConfigTransferResponse_ies_constr_2,
+		0,
+		"hnbConfigTransferResponse-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_HNBConfigTransferResponse_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBConfigTransferResponse_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hnbConfigTransferResponse-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBConfigTransferResponse_specs_1 = {
+	sizeof(struct HNBConfigTransferResponse),
+	offsetof(struct HNBConfigTransferResponse, _asn_ctx),
+	asn_MAP_HNBConfigTransferResponse_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBConfigTransferResponse = {
+	"HNBConfigTransferResponse",
+	"HNBConfigTransferResponse",
+	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_HNBConfigTransferResponse_tags_1,
+	sizeof(asn_DEF_HNBConfigTransferResponse_tags_1)
+		/sizeof(asn_DEF_HNBConfigTransferResponse_tags_1[0]), /* 1 */
+	asn_DEF_HNBConfigTransferResponse_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBConfigTransferResponse_tags_1)
+		/sizeof(asn_DEF_HNBConfigTransferResponse_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBConfigTransferResponse_1,
+	1,	/* Elements count */
+	&asn_SPC_HNBConfigTransferResponse_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBConfigTransferResponse.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBConfigTransferResponse_H_
+#define	_HNBConfigTransferResponse_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* HNBConfigTransferResponse */
+typedef struct HNBConfigTransferResponse {
+	struct hnbConfigTransferResponse_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} hnbConfigTransferResponse_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBConfigTransferResponse_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBConfigTransferResponse;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _HNBConfigTransferResponse_H_ */
+#include <asn_internal.h>

src/asn1c/HNBConfigurationInformationMissing.c

@@ -0,0 +1,74 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBConfigurationInformationMissing.h"
+
+static asn_TYPE_member_t asn_MBR_HNBConfigurationInformationMissing_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigurationInformationMissing, cause),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_Cause,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cause"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNBConfigurationInformationMissing, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_HNBConfigurationInformationMissing_oms_1[] = { 1 };
+static const ber_tlv_tag_t asn_DEF_HNBConfigurationInformationMissing_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBConfigurationInformationMissing_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* cause */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBConfigurationInformationMissing_specs_1 = {
+	sizeof(struct HNBConfigurationInformationMissing),
+	offsetof(struct HNBConfigurationInformationMissing, _asn_ctx),
+	asn_MAP_HNBConfigurationInformationMissing_tag2el_1,
+	2,	/* Count of tags in the map */
+	asn_MAP_HNBConfigurationInformationMissing_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	1,	/* Start extensions */
+	3	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBConfigurationInformationMissing = {
+	"HNBConfigurationInformationMissing",
+	"HNBConfigurationInformationMissing",
+	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_HNBConfigurationInformationMissing_tags_1,
+	sizeof(asn_DEF_HNBConfigurationInformationMissing_tags_1)
+		/sizeof(asn_DEF_HNBConfigurationInformationMissing_tags_1[0]), /* 1 */
+	asn_DEF_HNBConfigurationInformationMissing_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBConfigurationInformationMissing_tags_1)
+		/sizeof(asn_DEF_HNBConfigurationInformationMissing_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBConfigurationInformationMissing_1,
+	2,	/* Elements count */
+	&asn_SPC_HNBConfigurationInformationMissing_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBConfigurationInformationMissing.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBConfigurationInformationMissing_H_
+#define	_HNBConfigurationInformationMissing_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Cause.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* HNBConfigurationInformationMissing */
+typedef struct HNBConfigurationInformationMissing {
+	Cause_t	 cause;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBConfigurationInformationMissing_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBConfigurationInformationMissing;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _HNBConfigurationInformationMissing_H_ */
+#include <asn_internal.h>

src/asn1c/HNBConfigurationInformationProvided.c

@@ -0,0 +1,104 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBConfigurationInformationProvided.h"
+
+static asn_TYPE_member_t asn_MBR_HNBConfigurationInformationProvided_1[] = {
+	{ ATF_POINTER, 2, offsetof(struct HNBConfigurationInformationProvided, psc),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PSC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"psc"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNBConfigurationInformationProvided, cSG_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CSG_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cSG-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigurationInformationProvided, hNB_Cell_Access_Mode),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HNB_Cell_Access_Mode,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"hNB-Cell-Access-Mode"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBConfigurationInformationProvided, iurh_Signalling_TNL_AddressList),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Iurh_Signalling_TNL_AddressList,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iurh-Signalling-TNL-AddressList"
+		},
+	{ ATF_POINTER, 1, offsetof(struct HNBConfigurationInformationProvided, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_HNBConfigurationInformationProvided_oms_1[] = { 0, 1, 4 };
+static const ber_tlv_tag_t asn_DEF_HNBConfigurationInformationProvided_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBConfigurationInformationProvided_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* psc */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* cSG-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* hNB-Cell-Access-Mode */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* iurh-Signalling-TNL-AddressList */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBConfigurationInformationProvided_specs_1 = {
+	sizeof(struct HNBConfigurationInformationProvided),
+	offsetof(struct HNBConfigurationInformationProvided, _asn_ctx),
+	asn_MAP_HNBConfigurationInformationProvided_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_HNBConfigurationInformationProvided_oms_1,	/* Optional members */
+	3, 0,	/* Root/Additions */
+	4,	/* Start extensions */
+	6	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBConfigurationInformationProvided = {
+	"HNBConfigurationInformationProvided",
+	"HNBConfigurationInformationProvided",
+	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_HNBConfigurationInformationProvided_tags_1,
+	sizeof(asn_DEF_HNBConfigurationInformationProvided_tags_1)
+		/sizeof(asn_DEF_HNBConfigurationInformationProvided_tags_1[0]), /* 1 */
+	asn_DEF_HNBConfigurationInformationProvided_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBConfigurationInformationProvided_tags_1)
+		/sizeof(asn_DEF_HNBConfigurationInformationProvided_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBConfigurationInformationProvided_1,
+	5,	/* Elements count */
+	&asn_SPC_HNBConfigurationInformationProvided_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBConfigurationInformationProvided.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-IEs"
+ * 	found in "../../asn1/hnbap/HNBAP-IEs.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBConfigurationInformationProvided_H_
+#define	_HNBConfigurationInformationProvided_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PSC.h"
+#include "CSG-ID.h"
+#include "HNB-Cell-Access-Mode.h"
+#include "Iurh-Signalling-TNL-AddressList.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE_Extensions;
+
+/* HNBConfigurationInformationProvided */
+typedef struct HNBConfigurationInformationProvided {
+	PSC_t	*psc	/* OPTIONAL */;
+	CSG_ID_t	*cSG_ID	/* OPTIONAL */;
+	HNB_Cell_Access_Mode_t	 hNB_Cell_Access_Mode;
+	Iurh_Signalling_TNL_AddressList_t	 iurh_Signalling_TNL_AddressList;
+	struct IE_Extensions	*iE_Extensions	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBConfigurationInformationProvided_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBConfigurationInformationProvided;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE-Extensions.h"
+
+#endif	/* _HNBConfigurationInformationProvided_H_ */
+#include <asn_internal.h>

src/asn1c/HNBDe-Register.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBDe-Register.h"
+
+static int
+memb_hnbDe_Register_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_hnbDe_Register_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_hnbDe_Register_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_hnbDe_Register_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_hnbDe_Register_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_hnbDe_Register_ies_specs_2 = {
+	sizeof(struct hnbDe_Register_ies),
+	offsetof(struct hnbDe_Register_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_hnbDe_Register_ies_2 = {
+	"hnbDe-Register-ies",
+	"hnbDe-Register-ies",
+	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_hnbDe_Register_ies_tags_2,
+	sizeof(asn_DEF_hnbDe_Register_ies_tags_2)
+		/sizeof(asn_DEF_hnbDe_Register_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_hnbDe_Register_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_hnbDe_Register_ies_tags_2)
+		/sizeof(asn_DEF_hnbDe_Register_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_hnbDe_Register_ies_constr_2,
+	asn_MBR_hnbDe_Register_ies_2,
+	1,	/* Single element */
+	&asn_SPC_hnbDe_Register_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_HNBDe_Register_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBDe_Register, hnbDe_Register_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_hnbDe_Register_ies_2,
+		memb_hnbDe_Register_ies_constraint_1,
+		&asn_PER_memb_hnbDe_Register_ies_constr_2,
+		0,
+		"hnbDe-Register-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_HNBDe_Register_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBDe_Register_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hnbDe-Register-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBDe_Register_specs_1 = {
+	sizeof(struct HNBDe_Register),
+	offsetof(struct HNBDe_Register, _asn_ctx),
+	asn_MAP_HNBDe_Register_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBDe_Register = {
+	"HNBDe-Register",
+	"HNBDe-Register",
+	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_HNBDe_Register_tags_1,
+	sizeof(asn_DEF_HNBDe_Register_tags_1)
+		/sizeof(asn_DEF_HNBDe_Register_tags_1[0]), /* 1 */
+	asn_DEF_HNBDe_Register_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBDe_Register_tags_1)
+		/sizeof(asn_DEF_HNBDe_Register_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBDe_Register_1,
+	1,	/* Elements count */
+	&asn_SPC_HNBDe_Register_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBDe-Register.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBDe_Register_H_
+#define	_HNBDe_Register_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* HNBDe-Register */
+typedef struct HNBDe_Register {
+	struct hnbDe_Register_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} hnbDe_Register_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBDe_Register_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBDe_Register;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _HNBDe_Register_H_ */
+#include <asn_internal.h>

src/asn1c/HNBRegisterAccept.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBRegisterAccept.h"
+
+static int
+memb_hnbRegisterAccept_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_hnbRegisterAccept_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_hnbRegisterAccept_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_hnbRegisterAccept_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_hnbRegisterAccept_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_hnbRegisterAccept_ies_specs_2 = {
+	sizeof(struct hnbRegisterAccept_ies),
+	offsetof(struct hnbRegisterAccept_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_hnbRegisterAccept_ies_2 = {
+	"hnbRegisterAccept-ies",
+	"hnbRegisterAccept-ies",
+	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_hnbRegisterAccept_ies_tags_2,
+	sizeof(asn_DEF_hnbRegisterAccept_ies_tags_2)
+		/sizeof(asn_DEF_hnbRegisterAccept_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_hnbRegisterAccept_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_hnbRegisterAccept_ies_tags_2)
+		/sizeof(asn_DEF_hnbRegisterAccept_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_hnbRegisterAccept_ies_constr_2,
+	asn_MBR_hnbRegisterAccept_ies_2,
+	1,	/* Single element */
+	&asn_SPC_hnbRegisterAccept_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_HNBRegisterAccept_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBRegisterAccept, hnbRegisterAccept_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_hnbRegisterAccept_ies_2,
+		memb_hnbRegisterAccept_ies_constraint_1,
+		&asn_PER_memb_hnbRegisterAccept_ies_constr_2,
+		0,
+		"hnbRegisterAccept-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_HNBRegisterAccept_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBRegisterAccept_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hnbRegisterAccept-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBRegisterAccept_specs_1 = {
+	sizeof(struct HNBRegisterAccept),
+	offsetof(struct HNBRegisterAccept, _asn_ctx),
+	asn_MAP_HNBRegisterAccept_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBRegisterAccept = {
+	"HNBRegisterAccept",
+	"HNBRegisterAccept",
+	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_HNBRegisterAccept_tags_1,
+	sizeof(asn_DEF_HNBRegisterAccept_tags_1)
+		/sizeof(asn_DEF_HNBRegisterAccept_tags_1[0]), /* 1 */
+	asn_DEF_HNBRegisterAccept_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBRegisterAccept_tags_1)
+		/sizeof(asn_DEF_HNBRegisterAccept_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBRegisterAccept_1,
+	1,	/* Elements count */
+	&asn_SPC_HNBRegisterAccept_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBRegisterAccept.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBRegisterAccept_H_
+#define	_HNBRegisterAccept_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* HNBRegisterAccept */
+typedef struct HNBRegisterAccept {
+	struct hnbRegisterAccept_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} hnbRegisterAccept_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBRegisterAccept_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBRegisterAccept;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _HNBRegisterAccept_H_ */
+#include <asn_internal.h>

src/asn1c/HNBRegisterReject.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBRegisterReject.h"
+
+static int
+memb_hnbRegisterReject_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_hnbRegisterReject_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_hnbRegisterReject_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_hnbRegisterReject_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_hnbRegisterReject_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_hnbRegisterReject_ies_specs_2 = {
+	sizeof(struct hnbRegisterReject_ies),
+	offsetof(struct hnbRegisterReject_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_hnbRegisterReject_ies_2 = {
+	"hnbRegisterReject-ies",
+	"hnbRegisterReject-ies",
+	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_hnbRegisterReject_ies_tags_2,
+	sizeof(asn_DEF_hnbRegisterReject_ies_tags_2)
+		/sizeof(asn_DEF_hnbRegisterReject_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_hnbRegisterReject_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_hnbRegisterReject_ies_tags_2)
+		/sizeof(asn_DEF_hnbRegisterReject_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_hnbRegisterReject_ies_constr_2,
+	asn_MBR_hnbRegisterReject_ies_2,
+	1,	/* Single element */
+	&asn_SPC_hnbRegisterReject_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_HNBRegisterReject_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBRegisterReject, hnbRegisterReject_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_hnbRegisterReject_ies_2,
+		memb_hnbRegisterReject_ies_constraint_1,
+		&asn_PER_memb_hnbRegisterReject_ies_constr_2,
+		0,
+		"hnbRegisterReject-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_HNBRegisterReject_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBRegisterReject_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hnbRegisterReject-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBRegisterReject_specs_1 = {
+	sizeof(struct HNBRegisterReject),
+	offsetof(struct HNBRegisterReject, _asn_ctx),
+	asn_MAP_HNBRegisterReject_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBRegisterReject = {
+	"HNBRegisterReject",
+	"HNBRegisterReject",
+	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_HNBRegisterReject_tags_1,
+	sizeof(asn_DEF_HNBRegisterReject_tags_1)
+		/sizeof(asn_DEF_HNBRegisterReject_tags_1[0]), /* 1 */
+	asn_DEF_HNBRegisterReject_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBRegisterReject_tags_1)
+		/sizeof(asn_DEF_HNBRegisterReject_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBRegisterReject_1,
+	1,	/* Elements count */
+	&asn_SPC_HNBRegisterReject_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBRegisterReject.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBRegisterReject_H_
+#define	_HNBRegisterReject_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* HNBRegisterReject */
+typedef struct HNBRegisterReject {
+	struct hnbRegisterReject_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} hnbRegisterReject_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBRegisterReject_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBRegisterReject;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _HNBRegisterReject_H_ */
+#include <asn_internal.h>

src/asn1c/HNBRegisterRequest.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#include "HNBRegisterRequest.h"
+
+static int
+memb_hnbRegisterRequest_ies_constraint_1(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 <= 65535l)) {
+		/* 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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_hnbRegisterRequest_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_hnbRegisterRequest_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_hnbRegisterRequest_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_hnbRegisterRequest_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_hnbRegisterRequest_ies_specs_2 = {
+	sizeof(struct hnbRegisterRequest_ies),
+	offsetof(struct hnbRegisterRequest_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_hnbRegisterRequest_ies_2 = {
+	"hnbRegisterRequest-ies",
+	"hnbRegisterRequest-ies",
+	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_hnbRegisterRequest_ies_tags_2,
+	sizeof(asn_DEF_hnbRegisterRequest_ies_tags_2)
+		/sizeof(asn_DEF_hnbRegisterRequest_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_hnbRegisterRequest_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_hnbRegisterRequest_ies_tags_2)
+		/sizeof(asn_DEF_hnbRegisterRequest_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_hnbRegisterRequest_ies_constr_2,
+	asn_MBR_hnbRegisterRequest_ies_2,
+	1,	/* Single element */
+	&asn_SPC_hnbRegisterRequest_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_HNBRegisterRequest_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct HNBRegisterRequest, hnbRegisterRequest_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_hnbRegisterRequest_ies_2,
+		memb_hnbRegisterRequest_ies_constraint_1,
+		&asn_PER_memb_hnbRegisterRequest_ies_constr_2,
+		0,
+		"hnbRegisterRequest-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_HNBRegisterRequest_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_HNBRegisterRequest_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* hnbRegisterRequest-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_HNBRegisterRequest_specs_1 = {
+	sizeof(struct HNBRegisterRequest),
+	offsetof(struct HNBRegisterRequest, _asn_ctx),
+	asn_MAP_HNBRegisterRequest_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_HNBRegisterRequest = {
+	"HNBRegisterRequest",
+	"HNBRegisterRequest",
+	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_HNBRegisterRequest_tags_1,
+	sizeof(asn_DEF_HNBRegisterRequest_tags_1)
+		/sizeof(asn_DEF_HNBRegisterRequest_tags_1[0]), /* 1 */
+	asn_DEF_HNBRegisterRequest_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HNBRegisterRequest_tags_1)
+		/sizeof(asn_DEF_HNBRegisterRequest_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_HNBRegisterRequest_1,
+	1,	/* Elements count */
+	&asn_SPC_HNBRegisterRequest_specs_1	/* Additional specs */
+};
+

src/asn1c/HNBRegisterRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "HNBAP-PDU"
+ * 	found in "../../asn1/hnbap/HNBAP-PDU.asn"
+ * 	`asn1c -gen-PER -fnative-types`
+ */
+
+#ifndef	_HNBRegisterRequest_H_
+#define	_HNBRegisterRequest_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct IE;
+
+/* HNBRegisterRequest */
+typedef struct HNBRegisterRequest {
+	struct hnbRegisterRequest_ies {
+		A_SEQUENCE_OF(struct IE) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} hnbRegisterRequest_ies;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} HNBRegisterRequest_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HNBRegisterRequest;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "IE.h"
+
+#endif	/* _HNBRegisterRequest_H_ */
+#include <asn_internal.h>