xapp-bs-connector --> xapp-sm-connector

setup/xapp-sm-connector/asn1c_defs/ANY.c

@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) 2004-2017 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>
+
+asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs = {
+	sizeof(ANY_t),
+	offsetof(ANY_t, _asn_ctx),
+	ASN_OSUBV_ANY
+};
+asn_TYPE_operation_t asn_OP_ANY = {
+	OCTET_STRING_free,
+	OCTET_STRING_print,
+	OCTET_STRING_compare,
+	OCTET_STRING_decode_ber,
+	OCTET_STRING_encode_der,
+	OCTET_STRING_decode_xer_hex,
+	ANY_encode_xer,
+#ifdef	ASN_DISABLE_OER_SUPPORT
+	0,
+	0,
+#else
+	0,
+	0,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef	ASN_DISABLE_PER_SUPPORT
+	0, 0, 0, 0,
+#else
+	ANY_decode_uper,
+	ANY_encode_uper,
+	ANY_decode_aper,
+	ANY_encode_aper,
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+	0,	/* Random fill is not defined for ANY type */
+	0	/* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_ANY = {
+	"ANY",
+	"ANY",
+	&asn_OP_ANY,
+	0, 0, 0, 0,
+	{ 0, 0, asn_generic_no_constraint },	/* No constraints */
+	0, 0,	/* No members */
+	&asn_SPC_ANY_specs,
+};
+
+#undef RETURN
+#define RETURN(_code)                       \
+    do {                                    \
+        asn_dec_rval_t tmprval;             \
+        tmprval.code = _code;               \
+        tmprval.consumed = consumed_myself; \
+        return tmprval;                     \
+    } while(0)
+
+asn_enc_rval_t
+ANY_encode_xer(const asn_TYPE_descriptor_t *td, const 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 = {0,0,0};
+
+	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->encoding_constraints.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;
+}
+
+#ifndef ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+ANY_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                const asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, void **sptr,
+                asn_per_data_t *pd) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_ANY_specs;
+    size_t consumed_myself = 0;
+    int repeat;
+    ANY_t *st = (ANY_t *)*sptr;
+
+    (void)opt_codec_ctx;
+    (void)constraints;
+
+    /*
+     * Allocate the structure.
+     */
+    if(!st) {
+        st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) RETURN(RC_FAIL);
+    }
+
+    ASN_DEBUG("UPER Decoding ANY type");
+
+    st->size = 0;
+    do {
+        ssize_t raw_len;
+        ssize_t len_bytes;
+        ssize_t len_bits;
+        void *p;
+        int ret;
+
+        /* Get the PER length */
+        raw_len = uper_get_length(pd, -1, 0, &repeat);
+        if(raw_len < 0) RETURN(RC_WMORE);
+        if(raw_len == 0 && st->buf) break;
+
+        ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
+                  repeat ? "repeat" : "once", td->name);
+        len_bytes = raw_len;
+        len_bits = len_bytes * 8;
+
+        p = REALLOC(st->buf, st->size + len_bytes + 1);
+        if(!p) RETURN(RC_FAIL);
+        st->buf = (uint8_t *)p;
+
+        ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
+        if(ret < 0) RETURN(RC_WMORE);
+        consumed_myself += len_bits;
+        st->size += len_bytes;
+    } while(repeat);
+    st->buf[st->size] = 0; /* nul-terminate */
+
+    RETURN(RC_OK);
+}
+
+asn_enc_rval_t
+ANY_encode_uper(const asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, const void *sptr,
+                asn_per_outp_t *po) {
+    const ANY_t *st = (const ANY_t *)sptr;
+    asn_enc_rval_t er = {0, 0, 0};
+    const uint8_t *buf;
+    size_t size;
+    int ret;
+
+    (void)constraints;
+
+    if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
+
+    buf = st->buf;
+    size = st->size;
+    do {
+        int need_eom = 0;
+        ssize_t may_save = uper_put_length(po, size, &need_eom);
+        if(may_save < 0) ASN__ENCODE_FAILED;
+
+        ret = per_put_many_bits(po, buf, may_save * 8);
+        if(ret) ASN__ENCODE_FAILED;
+
+        buf += may_save;
+        size -= may_save;
+        assert(!(may_save & 0x07) || !size);
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+    } while(size);
+
+    ASN__ENCODED_OK(er);
+}
+
+asn_dec_rval_t
+ANY_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,
+                const asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, void **sptr,
+                asn_per_data_t *pd) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_ANY_specs;
+    size_t consumed_myself = 0;
+    int repeat;
+    ANY_t *st = (ANY_t *)*sptr;
+
+    (void)opt_codec_ctx;
+    (void)constraints;
+
+    /*
+     * Allocate the structure.
+     */
+    if(!st) {
+        st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) RETURN(RC_FAIL);
+    }
+
+    ASN_DEBUG("APER Decoding ANY type");
+
+    st->size = 0;
+    do {
+        ssize_t raw_len;
+        ssize_t len_bytes;
+        ssize_t len_bits;
+        void *p;
+        int ret;
+
+        /* Get the PER length */
+        raw_len = aper_get_length(pd, -1, 0, &repeat);
+        if(raw_len < 0) RETURN(RC_WMORE);
+        if(raw_len == 0 && st->buf) break;
+
+        ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
+                  repeat ? "repeat" : "once", td->name);
+        len_bytes = raw_len;
+        len_bits = len_bytes * 8;
+
+        p = REALLOC(st->buf, st->size + len_bytes + 1);
+        if(!p) RETURN(RC_FAIL);
+        st->buf = (uint8_t *)p;
+
+        ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
+        if(ret < 0) RETURN(RC_WMORE);
+        consumed_myself += len_bits;
+        st->size += len_bytes;
+    } while(repeat);
+    st->buf[st->size] = 0; /* nul-terminate */
+
+    RETURN(RC_OK);
+}
+
+asn_enc_rval_t
+ANY_encode_aper(const asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, const void *sptr,
+                asn_per_outp_t *po) {
+    const ANY_t *st = (const ANY_t *)sptr;
+    asn_enc_rval_t er = {0, 0, 0};
+    const uint8_t *buf;
+    size_t size;
+    int ret;
+
+    (void)constraints;
+
+    if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
+
+    buf = st->buf;
+    size = st->size;
+    do {
+        int need_eom = 0;
+        ssize_t may_save = uper_put_length(po, size, &need_eom);
+        if(may_save < 0) ASN__ENCODE_FAILED;
+
+        ret = per_put_many_bits(po, buf, may_save * 8);
+        if(ret) ASN__ENCODE_FAILED;
+
+        buf += may_save;
+        size -= may_save;
+        assert(!(may_save & 0x07) || !size);
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+    } while(size);
+
+    ASN__ENCODED_OK(er);
+}
+#endif /* ASN_DISABLE_PER_SUPPORT */
+

setup/xapp-sm-connector/asn1c_defs/ANY.h

@@ -0,0 +1,65 @@
+/*-
+ * Copyright (c) 2004-2017 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;
+extern asn_TYPE_operation_t asn_OP_ANY;
+extern asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs;
+
+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;
+per_type_decoder_f ANY_decode_uper;
+per_type_encoder_f ANY_encode_uper;
+per_type_decoder_f ANY_decode_aper;
+per_type_encoder_f ANY_encode_aper;
+
+#define ANY_free         OCTET_STRING_free
+#define ANY_print        OCTET_STRING_print
+#define ANY_compare      OCTET_STRING_compare
+#define ANY_constraint   asn_generic_no_constraint
+#define ANY_decode_ber   OCTET_STRING_decode_ber
+#define ANY_encode_der   OCTET_STRING_encode_der
+#define ANY_decode_xer   OCTET_STRING_decode_xer_hex
+
+/******************************
+ * 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 */

setup/xapp-sm-connector/asn1c_defs/BIT_STRING.c

@@ -0,0 +1,656 @@
+/*-
+ * 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))
+};
+asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs = {
+	sizeof(BIT_STRING_t),
+	offsetof(BIT_STRING_t, _asn_ctx),
+	ASN_OSUBV_BIT
+};
+asn_TYPE_operation_t asn_OP_BIT_STRING = {
+	OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+	BIT_STRING_print,
+	BIT_STRING_compare,
+	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,
+#ifdef	ASN_DISABLE_OER_SUPPORT
+	0,
+	0,
+#else
+	BIT_STRING_decode_oer,
+	BIT_STRING_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef	ASN_DISABLE_PER_SUPPORT
+	0,
+	0,
+	0,
+	0,
+#else
+	BIT_STRING_decode_uper,	/* Unaligned PER decoder */
+	BIT_STRING_encode_uper,	/* Unaligned PER encoder */
+	OCTET_STRING_decode_aper,	/* Aligned PER decoder */
+	OCTET_STRING_encode_aper,	/* Aligned PER encoder */
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+	BIT_STRING_random_fill,
+	0	/* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+	"BIT STRING",
+	"BIT_STRING",
+	&asn_OP_BIT_STRING,
+	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, 0, BIT_STRING_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(const 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 const 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(const asn_TYPE_descriptor_t *td, const void *sptr,
+                      int ilevel, enum xer_encoder_flags_e flags,
+                      asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t er = {0, 0, 0};
+	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) {
+			ASN__CALLBACK(scratch, p - scratch);
+			p = scratch;
+			if(nline) ASN__TEXT_INDENT(1, ilevel);
+		}
+		memcpy(p + 0, _bit_pattern[v >> 4], 4);
+		memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+		p += 8;
+	}
+
+	if(!xcan && ((buf - st->buf) % 8) == 0)
+		ASN__TEXT_INDENT(1, ilevel);
+	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;
+		ASN__CALLBACK(scratch, p - scratch);
+	}
+
+	if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+
+	ASN__ENCODED_OK(er);
+cb_failed:
+	ASN__ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(const 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;
+	}
+
+    if(st->bits_unused) {
+        int ret = snprintf(scratch, sizeof(scratch), " (%d bit%s unused)",
+                           st->bits_unused, st->bits_unused == 1 ? "" : "s");
+        assert(ret > 0 && ret < (ssize_t)sizeof(scratch));
+        if(ret > 0 && ret < (ssize_t)sizeof(scratch)
+           && cb(scratch, ret, app_key) < 0)
+            return -1;
+    }
+
+	return 0;
+}
+
+/*
+ * Non-destructively remove the trailing 0-bits from the given bit string.
+ */
+static const BIT_STRING_t *
+BIT_STRING__compactify(const BIT_STRING_t *st, BIT_STRING_t *tmp) {
+    const uint8_t *b;
+    union {
+        const uint8_t *c_buf;
+        uint8_t *nc_buf;
+    } unconst;
+
+    if(st->size == 0) {
+        assert(st->bits_unused == 0);
+        return st;
+    } else {
+        for(b = &st->buf[st->size - 1]; b > st->buf && *b == 0; b--) {
+            ;
+        }
+        /* b points to the last byte which may contain data */
+        if(*b) {
+            int unused = 7;
+            uint8_t v = *b;
+            v &= -(int8_t)v;
+            if(v & 0x0F) unused -= 4;
+            if(v & 0x33) unused -= 2;
+            if(v & 0x55) unused -= 1;
+            tmp->size = b-st->buf + 1;
+            tmp->bits_unused = unused;
+        } else {
+            tmp->size = b-st->buf;
+            tmp->bits_unused = 0;
+        }
+
+        assert(b >= st->buf);
+    }
+
+    unconst.c_buf = st->buf;
+    tmp->buf = unconst.nc_buf;
+    return tmp;
+}
+
+/*
+ * Lexicographically compare the common prefix of both strings,
+ * and if it is the same return -1 for the smallest string.
+ */
+int
+BIT_STRING_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+                   const void *bptr) {
+    /*
+     * Remove information about trailing bits, since
+     * X.680 (08/2015) #22.7 "ensure that different semantics are not"
+     * "associated with [values that differ only in] the trailing 0 bits."
+     */
+    BIT_STRING_t compact_a, compact_b;
+    const BIT_STRING_t *a = BIT_STRING__compactify(aptr, &compact_a);
+    const BIT_STRING_t *b = BIT_STRING__compactify(bptr, &compact_b);
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics;
+
+    assert(specs && specs->subvariant == ASN_OSUBV_BIT);
+
+    if(a && b) {
+        size_t common_prefix_size = a->size <= b->size ? a->size : b->size;
+        int ret = memcmp(a->buf, b->buf, common_prefix_size);
+        if(ret == 0) {
+            /* Figure out which string with equal prefixes is longer. */
+            if(a->size < b->size) {
+                return -1;
+            } else if(a->size > b->size) {
+                return 1;
+            } else {
+                /* Figure out how many unused bits */
+                if(a->bits_unused > b->bits_unused) {
+                    return -1;
+                } else if(a->bits_unused < b->bits_unused) {
+                    return 1;
+                } else {
+                    return 0;
+                }
+            }
+        } else {
+            return ret;
+        }
+    } else if(!a && !b) {
+        return 0;
+    } else if(!a) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+#ifndef  ASN_DISABLE_PER_SUPPORT
+
+#undef  RETURN
+#define RETURN(_code)                       \
+    do {                                    \
+        asn_dec_rval_t tmprval;             \
+        tmprval.code = _code;               \
+        tmprval.consumed = consumed_myself; \
+        return tmprval;                     \
+    } while(0)
+
+static asn_per_constraint_t asn_DEF_BIT_STRING_constraint_size = {
+    APC_SEMI_CONSTRAINED, -1, -1, 0, 0};
+
+asn_dec_rval_t
+BIT_STRING_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                       const asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints, void **sptr,
+                       asn_per_data_t *pd) {
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics
+		? (const asn_OCTET_STRING_specifics_t *)td->specifics
+		: &asn_SPC_BIT_STRING_specs;
+    const asn_per_constraints_t *pc =
+        constraints ? constraints : td->encoding_constraints.per_constraints;
+	const asn_per_constraint_t *csiz;
+	asn_dec_rval_t rval = { RC_OK, 0 };
+	BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
+	ssize_t consumed_myself = 0;
+	int repeat;
+
+	(void)opt_codec_ctx;
+
+	if(pc) {
+		csiz = &pc->size;
+	} else {
+		csiz = &asn_DEF_BIT_STRING_constraint_size;
+	}
+
+	if(specs->subvariant != ASN_OSUBV_BIT) {
+		ASN_DEBUG("Subvariant %d is not BIT OSUBV_BIT", specs->subvariant);
+		RETURN(RC_FAIL);
+    }
+
+	/*
+	 * Allocate the string.
+	 */
+	if(!st) {
+		st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+		if(!st) RETURN(RC_FAIL);
+	}
+
+	ASN_DEBUG("PER Decoding %s size %ld .. %ld bits %d",
+		csiz->flags & APC_EXTENSIBLE ? "extensible" : "non-extensible",
+		csiz->lower_bound, csiz->upper_bound, csiz->effective_bits);
+
+	if(csiz->flags & APC_EXTENSIBLE) {
+		int inext = per_get_few_bits(pd, 1);
+		if(inext < 0) RETURN(RC_WMORE);
+		if(inext) {
+			csiz = &asn_DEF_BIT_STRING_constraint_size;
+		}
+	}
+
+	if(csiz->effective_bits >= 0) {
+		FREEMEM(st->buf);
+        st->size = (csiz->upper_bound + 7) >> 3;
+        st->buf = (uint8_t *)MALLOC(st->size + 1);
+		if(!st->buf) { st->size = 0; RETURN(RC_FAIL); }
+	}
+
+	/* X.691, #16.5: zero-length encoding */
+	/* X.691, #16.6: short fixed length encoding (up to 2 octets) */
+	/* X.691, #16.7: long fixed length encoding (up to 64K octets) */
+	if(csiz->effective_bits == 0) {
+		int ret;
+        ASN_DEBUG("Encoding BIT STRING size %ld", csiz->upper_bound);
+        ret = per_get_many_bits(pd, st->buf, 0, csiz->upper_bound);
+		if(ret < 0) RETURN(RC_WMORE);
+		consumed_myself += csiz->upper_bound;
+		st->buf[st->size] = 0;
+        st->bits_unused = (8 - (csiz->upper_bound & 0x7)) & 0x7;
+        RETURN(RC_OK);
+	}
+
+	st->size = 0;
+	do {
+		ssize_t raw_len;
+		ssize_t len_bytes;
+		ssize_t len_bits;
+		void *p;
+		int ret;
+
+		/* Get the PER length */
+		raw_len = uper_get_length(pd, csiz->effective_bits, csiz->lower_bound,
+		                          &repeat);
+		if(raw_len < 0) RETURN(RC_WMORE);
+        if(raw_len == 0 && st->buf) break;
+
+		ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",
+			(long)csiz->effective_bits, (long)raw_len,
+			repeat ? "repeat" : "once", td->name);
+        len_bits = raw_len;
+        len_bytes = (len_bits + 7) >> 3;
+        if(len_bits & 0x7) st->bits_unused = 8 - (len_bits & 0x7);
+        /* len_bits be multiple of 16K if repeat is set */
+        p = REALLOC(st->buf, st->size + len_bytes + 1);
+		if(!p) RETURN(RC_FAIL);
+		st->buf = (uint8_t *)p;
+
+        ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
+        if(ret < 0) RETURN(RC_WMORE);
+		st->size += len_bytes;
+	} while(repeat);
+	st->buf[st->size] = 0;	/* nul-terminate */
+
+	return rval;
+}
+
+asn_enc_rval_t
+BIT_STRING_encode_uper(const asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints,
+                       const void *sptr, asn_per_outp_t *po) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_BIT_STRING_specs;
+    const asn_per_constraints_t *pc =
+        constraints ? constraints : td->encoding_constraints.per_constraints;
+	const asn_per_constraint_t *csiz;
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	BIT_STRING_t compact_bstr;  /* Do not modify this directly! */
+	asn_enc_rval_t er = { 0, 0, 0 };
+	int inext = 0;		/* Lies not within extension root */
+	size_t size_in_bits;
+	const uint8_t *buf;
+	int ret;
+	int ct_extensible;
+
+	if(!st || (!st->buf && st->size))
+		ASN__ENCODE_FAILED;
+
+	if(specs->subvariant == ASN_OSUBV_BIT) {
+        if((st->size == 0 && st->bits_unused) || (st->bits_unused & ~7))
+            ASN__ENCODE_FAILED;
+    } else {
+		ASN__ENCODE_FAILED;
+    }
+
+	if(pc) {
+        csiz = &pc->size;
+    } else {
+		csiz = &asn_DEF_BIT_STRING_constraint_size;
+	}
+	ct_extensible = csiz->flags & APC_EXTENSIBLE;
+
+    /* Figure out the size without the trailing bits */
+    st = BIT_STRING__compactify(st, &compact_bstr);
+    size_in_bits = 8 * st->size - st->bits_unused;
+
+    ASN_DEBUG(
+        "Encoding %s into %" ASN_PRI_SIZE " bits"
+        " (%ld..%ld, effective %d)%s",
+        td->name, size_in_bits, csiz->lower_bound, csiz->upper_bound,
+        csiz->effective_bits, ct_extensible ? " EXT" : "");
+
+    /* Figure out whether size lies within PER visible constraint */
+
+    if(csiz->effective_bits >= 0) {
+        if((ssize_t)size_in_bits > csiz->upper_bound) {
+            if(ct_extensible) {
+                csiz = &asn_DEF_BIT_STRING_constraint_size;
+                inext = 1;
+            } else {
+                ASN__ENCODE_FAILED;
+            }
+        }
+    } else {
+        inext = 0;
+    }
+
+    if(ct_extensible) {
+		/* Declare whether length is [not] within extension root */
+		if(per_put_few_bits(po, inext, 1))
+			ASN__ENCODE_FAILED;
+	}
+
+    if(csiz->effective_bits >= 0 && !inext) {
+        int add_trailer = (ssize_t)size_in_bits < csiz->lower_bound;
+        ASN_DEBUG(
+            "Encoding %" ASN_PRI_SIZE " bytes (%ld), length (in %d bits) trailer %d; actual "
+            "value %" ASN_PRI_SSIZE "",
+            st->size, size_in_bits - csiz->lower_bound, csiz->effective_bits,
+            add_trailer,
+            add_trailer ? 0 : (ssize_t)size_in_bits - csiz->lower_bound);
+        ret = per_put_few_bits(
+            po, add_trailer ? 0 : (ssize_t)size_in_bits - csiz->lower_bound,
+            csiz->effective_bits);
+        if(ret) ASN__ENCODE_FAILED;
+        ret = per_put_many_bits(po, st->buf, size_in_bits);
+        if(ret) ASN__ENCODE_FAILED;
+        if(add_trailer) {
+            static const uint8_t zeros[16];
+            size_t trailing_zero_bits = csiz->lower_bound - size_in_bits;
+            while(trailing_zero_bits > 0) {
+                if(trailing_zero_bits > 8 * sizeof(zeros)) {
+                    ret = per_put_many_bits(po, zeros, 8 * sizeof(zeros));
+                    trailing_zero_bits -= 8 * sizeof(zeros);
+                } else {
+                    ret = per_put_many_bits(po, zeros, trailing_zero_bits);
+                    trailing_zero_bits = 0;
+                }
+                if(ret) ASN__ENCODE_FAILED;
+            }
+        }
+        ASN__ENCODED_OK(er);
+    }
+
+    ASN_DEBUG("Encoding %" ASN_PRI_SIZE " bytes", st->size);
+
+    buf = st->buf;
+    do {
+        int need_eom = 0;
+        ssize_t maySave = uper_put_length(po, size_in_bits, &need_eom);
+        if(maySave < 0) ASN__ENCODE_FAILED;
+
+        ASN_DEBUG("Encoding %" ASN_PRI_SSIZE " of %" ASN_PRI_SIZE "", maySave, size_in_bits);
+
+        ret = per_put_many_bits(po, buf, maySave);
+        if(ret) ASN__ENCODE_FAILED;
+
+        buf += maySave >> 3;
+        size_in_bits -= maySave;
+        assert(!(maySave & 0x07) || !size_in_bits);
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+    } while(size_in_bits);
+
+    ASN__ENCODED_OK(er);
+}
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+asn_random_fill_result_t
+BIT_STRING_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                       const asn_encoding_constraints_t *constraints,
+                       size_t max_length) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_BIT_STRING_specs;
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    static unsigned lengths[] = {0,     1,     2,     3,     4,     8,
+                                 126,   127,   128,   16383, 16384, 16385,
+                                 65534, 65535, 65536, 65537};
+    uint8_t *buf;
+    uint8_t *bend;
+    uint8_t *b;
+    size_t rnd_bits, rnd_len;
+    BIT_STRING_t *st;
+
+    if(max_length == 0) return result_skipped;
+
+    switch(specs->subvariant) {
+    case ASN_OSUBV_ANY:
+        return result_failed;
+    case ASN_OSUBV_BIT:
+        break;
+    default:
+        break;
+    }
+
+    /* Figure out how far we should go */
+    rnd_bits = lengths[asn_random_between(
+        0, sizeof(lengths) / sizeof(lengths[0]) - 1)];
+    if(!constraints || !constraints->per_constraints)
+        constraints = &td->encoding_constraints;
+    if(constraints->per_constraints) {
+        const asn_per_constraint_t *pc = &constraints->per_constraints->size;
+        if(pc->flags & APC_CONSTRAINED) {
+            long suggested_upper_bound = pc->upper_bound < (ssize_t)max_length
+                                             ? pc->upper_bound
+                                             : (ssize_t)max_length;
+            if(max_length < (size_t)pc->lower_bound) {
+                return result_skipped;
+            }
+            if(pc->flags & APC_EXTENSIBLE) {
+                switch(asn_random_between(0, 5)) {
+                case 0:
+                    if(pc->lower_bound > 0) {
+                        rnd_bits = pc->lower_bound - 1;
+                        break;
+                    }
+                    /* Fall through */
+                case 1:
+                    rnd_bits = pc->upper_bound + 1;
+                    break;
+                case 2:
+                    /* Keep rnd_bits from the table */
+                    if(rnd_bits < max_length) {
+                        break;
+                    }
+                    /* Fall through */
+                default:
+                    rnd_bits = asn_random_between(pc->lower_bound,
+                                                  suggested_upper_bound);
+                }
+            } else {
+                rnd_bits =
+                    asn_random_between(pc->lower_bound, suggested_upper_bound);
+            }
+        } else {
+            rnd_bits = asn_random_between(0, max_length - 1);
+        }
+    } else if(rnd_bits >= max_length) {
+        rnd_bits = asn_random_between(0, max_length - 1);
+    }
+
+    rnd_len = (rnd_bits + 7) / 8;
+    buf = CALLOC(1, rnd_len + 1);
+    if(!buf) return result_failed;
+
+    bend = &buf[rnd_len];
+
+    for(b = buf; b < bend; b++) {
+        *(uint8_t *)b = asn_random_between(0, 255);
+    }
+    *b = 0; /* Zero-terminate just in case. */
+
+    if(*sptr) {
+        st = *sptr;
+        FREEMEM(st->buf);
+    } else {
+        st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) {
+            FREEMEM(buf);
+            return result_failed;
+        }
+    }
+
+    st->buf = buf;
+    st->size = rnd_len;
+    st->bits_unused = (8 - (rnd_bits & 0x7)) & 0x7;
+    if(st->bits_unused) {
+        assert(st->size > 0);
+        st->buf[st->size-1] &= 0xff << st->bits_unused;
+    }
+
+    result_ok.length = st->size;
+    return result_ok;
+}

setup/xapp-sm-connector/asn1c_defs/BIT_STRING.h

@@ -0,0 +1,48 @@
+/*-
+ * Copyright (c) 2003-2017 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 */
+	size_t 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;
+extern asn_TYPE_operation_t asn_OP_BIT_STRING;
+extern asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_struct_compare_f BIT_STRING_compare;
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+oer_type_decoder_f BIT_STRING_decode_oer;
+oer_type_encoder_f BIT_STRING_encode_oer;
+per_type_decoder_f BIT_STRING_decode_uper;
+per_type_encoder_f BIT_STRING_encode_uper;
+asn_random_fill_f  BIT_STRING_random_fill;
+
+#define BIT_STRING_free              OCTET_STRING_free
+#define BIT_STRING_decode_ber        OCTET_STRING_decode_ber
+#define BIT_STRING_encode_der        OCTET_STRING_encode_der
+#define BIT_STRING_decode_xer        OCTET_STRING_decode_xer_binary
+#define BIT_STRING_decode_aper       OCTET_STRING_decode_aper
+#define BIT_STRING_encode_aper       OCTET_STRING_encode_aper
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */

setup/xapp-sm-connector/asn1c_defs/BOOLEAN.c

@@ -0,0 +1,492 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <BOOLEAN.h>
+
+/*
+ * BOOLEAN basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
+};
+asn_TYPE_operation_t asn_OP_BOOLEAN = {
+	BOOLEAN_free,
+	BOOLEAN_print,
+	BOOLEAN_compare,
+	BOOLEAN_decode_ber,
+	BOOLEAN_encode_der,
+	BOOLEAN_decode_xer,
+	BOOLEAN_encode_xer,
+#ifdef	ASN_DISABLE_OER_SUPPORT
+	0,
+	0,
+#else
+	BOOLEAN_decode_oer,
+	BOOLEAN_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef	ASN_DISABLE_PER_SUPPORT
+	0,
+	0,
+	0,
+	0,
+#else
+	BOOLEAN_decode_uper,	/* Unaligned PER decoder */
+	BOOLEAN_encode_uper,	/* Unaligned PER encoder */
+	BOOLEAN_decode_aper,	/* Aligned PER decoder */
+	BOOLEAN_encode_aper,	/* Aligned PER encoder */
+#endif	/* ASN_DISABLE_PER_SUPPORT */
+	BOOLEAN_random_fill,
+	0	/* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {
+	"BOOLEAN",
+	"BOOLEAN",
+	&asn_OP_BOOLEAN,
+	asn_DEF_BOOLEAN_tags,
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	asn_DEF_BOOLEAN_tags,	/* Same as above */
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	{ 0, 0, asn_generic_no_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode BOOLEAN type.
+ */
+asn_dec_rval_t
+BOOLEAN_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td, void **bool_value,
+                   const void *buf_ptr, size_t size, int tag_mode) {
+    BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+	ber_tlv_len_t lidx;
+
+	if(st == NULL) {
+		st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
+		if(st == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+		tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("Boolean length is %d bytes", (int)length);
+
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * Compute boolean value.
+	 */
+	for(*st = 0, lidx = 0;
+		(lidx < length) && *st == 0; lidx++) {
+		/*
+		 * Very simple approach: read bytes until the end or
+		 * value is already TRUE.
+		 * BOOLEAN is not supposed to contain meaningful data anyway.
+		 */
+		*st |= ((const uint8_t *)buf_ptr)[lidx];
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
+		(long)rval.consumed, (long)length,
+		td->name, *st);
+	
+	return rval;
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
+                   int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
+                   void *app_key) {
+	asn_enc_rval_t erval = {0,0,0};
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+
+	erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		erval.failed_type = td;
+		erval.structure_ptr = sptr;
+		return erval;
+	}
+
+	if(cb) {
+		uint8_t bool_value;
+
+		bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
+
+		if(cb(&bool_value, 1, app_key) < 0) {
+			erval.encoded = -1;
+			erval.failed_type = td;
+			erval.structure_ptr = sptr;
+			return erval;
+		}
+	}
+
+	erval.encoded += 1;
+
+	ASN__ENCODED_OK(erval);
+}
+
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+static enum xer_pbd_rval
+BOOLEAN__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                         const void *chunk_buf, size_t chunk_size) {
+    BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+	const char *p = (const char *)chunk_buf;
+
+	(void)td;
+
+	if(chunk_size && p[0] == 0x3c /* '<' */) {
+		switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
+		case XCT_BOTH:
+			/* "<false/>" */
+			*st = 0;
+			break;
+		case XCT_UNKNOWN_BO:
+			if(xer_check_tag(chunk_buf, chunk_size, "true")
+					!= XCT_BOTH)
+				return XPBD_BROKEN_ENCODING;
+			/* "<true/>" */
+			*st = 1;	/* Or 0xff as in DER?.. */
+			break;
+		default:
+			return XPBD_BROKEN_ENCODING;
+		}
+		return XPBD_BODY_CONSUMED;
+	} else {
+		return XPBD_BROKEN_ENCODING;
+	}
+}
+
+
+asn_dec_rval_t
+BOOLEAN_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td, void **sptr,
+                   const char *opt_mname, const void *buf_ptr, size_t size) {
+    return xer_decode_primitive(opt_codec_ctx, td,
+		sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,
+		BOOLEAN__xer_body_decode);
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er = {0, 0, 0};
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!st) ASN__ENCODE_FAILED;
+
+	if(*st) {
+		ASN__CALLBACK("<true/>", 7);
+	} else {
+		ASN__CALLBACK("<false/>", 8);
+	}
+
+	ASN__ENCODED_OK(er);
+cb_failed:
+	ASN__ENCODE_FAILED;
+}
+
+int
+BOOLEAN_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+              asn_app_consume_bytes_f *cb, void *app_key) {
+    const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	const char *buf;
+	size_t buflen;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(st) {
+		if(*st) {
+			buf = "TRUE";
+			buflen = 4;
+		} else {
+			buf = "FALSE";
+			buflen = 5;
+		}
+	} else {
+		buf = "<absent>";
+		buflen = 8;
+	}
+
+	return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
+}
+
+void
+BOOLEAN_free(const asn_TYPE_descriptor_t *td, void *ptr,
+             enum asn_struct_free_method method) {
+    if(td && ptr) {
+        switch(method) {
+        case ASFM_FREE_EVERYTHING:
+            FREEMEM(ptr);
+            break;
+        case ASFM_FREE_UNDERLYING:
+            break;
+        case ASFM_FREE_UNDERLYING_AND_RESET:
+            memset(ptr, 0, sizeof(BOOLEAN_t));
+            break;
+        }
+    }
+}
+
+#ifndef ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+BOOLEAN_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                    const asn_TYPE_descriptor_t *td,
+                    const asn_per_constraints_t *constraints, void **sptr,
+                    asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
+	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
+
+	(void)opt_codec_ctx;
+    (void)td;
+	(void)constraints;
+
+	if(!st) {
+		st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
+		if(!st) ASN__DECODE_FAILED;
+	}
+
+	/*
+	 * Extract a single bit
+	 */
+	switch(per_get_few_bits(pd, 1)) {
+	case 1: *st = 1; break;
+	case 0: *st = 0; break;
+	case -1: default: ASN__DECODE_STARVED;
+	}
+
+	ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
+
+	rv.code = RC_OK;
+	rv.consumed = 1;
+	return rv;
+}
+
+
+asn_enc_rval_t
+BOOLEAN_encode_uper(const asn_TYPE_descriptor_t *td,
+                    const asn_per_constraints_t *constraints, const void *sptr,
+                    asn_per_outp_t *po) {
+    const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er = { 0, 0, 0 };
+
+	(void)constraints;
+
+	if(!st) ASN__ENCODE_FAILED;
+
+	if(per_put_few_bits(po, *st ? 1 : 0, 1))
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+asn_dec_rval_t
+BOOLEAN_decode_aper(const asn_codec_ctx_t *opt_codec_ctx, const asn_TYPE_descriptor_t *td,
+                    const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
+
+	(void)opt_codec_ctx;
+	(void)constraints;
+	(void)td;
+
+	if(!st) {
+		st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
+		if(!st) ASN__DECODE_FAILED;
+	}
+
+	/*
+	 * Extract a single bit
+	 */
+	switch(per_get_few_bits(pd, 1)) {
+	case 1:
+		*st = 1;
+		break;
+	case 0:
+		*st = 0;
+		break;
+	case -1:
+	default:
+		ASN__DECODE_STARVED;
+	}
+
+	ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
+
+	rv.code = RC_OK;
+	rv.consumed = 1;
+	return rv;
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_aper(const asn_TYPE_descriptor_t *td,
+                    const asn_per_constraints_t *constraints,
+                    const void *sptr, asn_per_outp_t *po) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er = { 0, 0, 0 };
+
+	(void)constraints;
+
+	if(!st) ASN__ENCODE_FAILED;
+
+	if(per_put_few_bits(po, *st ? 1 : 0, 1))
+        	ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+#endif /* ASN_DISABLE_PER_SUPPORT */
+
+#ifndef  ASN_DISABLE_OER_SUPPORT
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+BOOLEAN_encode_oer(const asn_TYPE_descriptor_t *td,
+                   const asn_oer_constraints_t *constraints, const void *sptr,
+                   asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t er = { 1, 0, 0 };
+    const BOOLEAN_t *st = sptr;
+    uint8_t bool_value = *st ? 0xff : 0; /* 0xff mandated by OER */
+
+    (void)td;
+    (void)constraints;  /* Constraints are unused in OER */
+
+    if(cb(&bool_value, 1, app_key) < 0) {
+        ASN__ENCODE_FAILED;
+    } else {
+        ASN__ENCODED_OK(er);
+    }
+}
+
+asn_dec_rval_t
+BOOLEAN_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td,
+                   const asn_oer_constraints_t *constraints, void **sptr,
+                   const void *ptr, size_t size) {
+    asn_dec_rval_t ok = {RC_OK, 1};
+    BOOLEAN_t *st;
+
+    (void)opt_codec_ctx;
+    (void)td;
+    (void)constraints; /* Constraints are unused in OER */
+
+    if(size < 1) {
+        ASN__DECODE_STARVED;
+    }
+
+    if(!(st = *sptr)) {
+        st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));
+        if(!st) ASN__DECODE_FAILED;
+    }
+
+    *st = *(const uint8_t *)ptr;
+
+    return ok;
+}
+
+
+
+#endif
+
+int
+BOOLEAN_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+                const void *bptr) {
+    const BOOLEAN_t *a = aptr;
+    const BOOLEAN_t *b = bptr;
+
+    (void)td;
+
+    if(a && b) {
+        if(!*a == !*b) {    /* TRUE can be encoded by any non-zero byte. */
+            return 0;
+        } else if(!*a) {
+            return -1;
+        } else {
+            return 1;
+        }
+    } else if(!a) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+asn_random_fill_result_t
+BOOLEAN_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                    const asn_encoding_constraints_t *constraints,
+                    size_t max_length) {
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    BOOLEAN_t *st = *sptr;
+
+    if(max_length == 0) return result_skipped;
+
+    if(st == NULL) {
+        st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    if(!constraints || !constraints->per_constraints)
+        constraints = &td->encoding_constraints;
+    if(constraints->per_constraints) {
+        const asn_per_constraint_t *pc = &constraints->per_constraints->value;
+        if(pc->flags & APC_CONSTRAINED) {
+            *st = asn_random_between(pc->lower_bound, pc->upper_bound);
+            return result_ok;
+        }
+    }
+
+    /* Simulate booleans that are sloppily set and biased. */
+    switch(asn_random_between(0, 7)) {
+    case 0:
+    case 1:
+    case 2:
+        *st = 0; break;
+    case 3: *st = -1; break;
+    case 4: *st = 1; break;
+    case 5: *st = INT_MIN; break;
+    case 6: *st = INT_MAX; break;
+    default:
+        *st = asn_random_between(INT_MIN, INT_MAX);
+        break;
+    }
+    return result_ok;
+}

setup/xapp-sm-connector/asn1c_defs/BOOLEAN.h

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

setup/xapp-sm-connector/asn1c_defs/Cause.c

@@ -0,0 +1,92 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "Cause.h"
+
+asn_per_constraints_t asn_PER_type_Cause_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  4 }	/* (0..4,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_Cause_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.ricRequest),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseRIC,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ricRequest"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.ricService),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseRICservice,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ricService"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.transport),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseTransport,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"transport"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.protocol),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseProtocol,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"protocol"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Cause, choice.misc),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CauseMisc,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"misc"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_Cause_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ricRequest */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ricService */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* transport */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* misc */
+};
+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,
+	5,	/* Count of tags in the map */
+	0, 0,
+	5	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Cause = {
+	"Cause",
+	"Cause",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_Cause_constr_1, CHOICE_constraint },
+	asn_MBR_Cause_1,
+	5,	/* Elements count */
+	&asn_SPC_Cause_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/Cause.h

@@ -0,0 +1,68 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_Cause_H_
+#define	_Cause_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "CauseRIC.h"
+#include "CauseRICservice.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_ricRequest,
+	Cause_PR_ricService,
+	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 {
+		CauseRIC_t	 ricRequest;
+		CauseRICservice_t	 ricService;
+		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;
+extern asn_CHOICE_specifics_t asn_SPC_Cause_specs_1;
+extern asn_TYPE_member_t asn_MBR_Cause_1[5];
+extern asn_per_constraints_t asn_PER_type_Cause_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Cause_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/CauseMisc.c

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CauseMisc.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_CauseMisc_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  3 }	/* (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,	27,	"control-processing-overload" },
+	{ 1,	16,	"hardware-failure" },
+	{ 2,	15,	"om-intervention" },
+	{ 3,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseMisc_enum2value_1[] = {
+	0,	/* control-processing-overload(0) */
+	1,	/* hardware-failure(1) */
+	2,	/* om-intervention(2) */
+	3	/* unspecified(3) */
+	/* This list is extensible */
+};
+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",
+	&asn_OP_NativeEnumerated,
+	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 */
+	{ 0, &asn_PER_type_CauseMisc_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseMisc_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CauseMisc.h

@@ -0,0 +1,56 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#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_control_processing_overload	= 0,
+	CauseMisc_hardware_failure	= 1,
+	CauseMisc_om_intervention	= 2,
+	CauseMisc_unspecified	= 3
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseMisc;
+
+/* CauseMisc */
+typedef long	 CauseMisc_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_CauseMisc_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_CauseMisc;
+extern const asn_INTEGER_specifics_t asn_SPC_CauseMisc_specs_1;
+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>

setup/xapp-sm-connector/asn1c_defs/CauseProtocol.c

@@ -0,0 +1,65 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CauseProtocol.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_CauseProtocol_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  6 }	/* (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,	49,	"abstract-syntax-error-falsely-constructed-message" },
+	{ 6,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseProtocol_enum2value_1[] = {
+	5,	/* abstract-syntax-error-falsely-constructed-message(5) */
+	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) */
+	6	/* unspecified(6) */
+	/* This list is extensible */
+};
+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",
+	&asn_OP_NativeEnumerated,
+	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 */
+	{ 0, &asn_PER_type_CauseProtocol_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseProtocol_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CauseProtocol.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#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_abstract_syntax_error_falsely_constructed_message	= 5,
+	CauseProtocol_unspecified	= 6
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseProtocol;
+
+/* CauseProtocol */
+typedef long	 CauseProtocol_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_CauseProtocol_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_CauseProtocol;
+extern const asn_INTEGER_specifics_t asn_SPC_CauseProtocol_specs_1;
+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>

setup/xapp-sm-connector/asn1c_defs/CauseRIC.c

@@ -0,0 +1,73 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CauseRIC.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_CauseRIC_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  4,  4,  0,  10 }	/* (0..10,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_CauseRIC_value2enum_1[] = {
+	{ 0,	23,	"ran-function-id-Invalid" },
+	{ 1,	20,	"action-not-supported" },
+	{ 2,	17,	"excessive-actions" },
+	{ 3,	16,	"duplicate-action" },
+	{ 4,	15,	"duplicate-event" },
+	{ 5,	23,	"function-resource-limit" },
+	{ 6,	18,	"request-id-unknown" },
+	{ 7,	46,	"inconsistent-action-subsequent-action-sequence" },
+	{ 8,	23,	"control-message-invalid" },
+	{ 9,	23,	"call-process-id-invalid" },
+	{ 10,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseRIC_enum2value_1[] = {
+	1,	/* action-not-supported(1) */
+	9,	/* call-process-id-invalid(9) */
+	8,	/* control-message-invalid(8) */
+	3,	/* duplicate-action(3) */
+	4,	/* duplicate-event(4) */
+	2,	/* excessive-actions(2) */
+	5,	/* function-resource-limit(5) */
+	7,	/* inconsistent-action-subsequent-action-sequence(7) */
+	0,	/* ran-function-id-Invalid(0) */
+	6,	/* request-id-unknown(6) */
+	10	/* unspecified(10) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_CauseRIC_specs_1 = {
+	asn_MAP_CauseRIC_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CauseRIC_enum2value_1,	/* N => "tag"; sorted by N */
+	11,	/* Number of elements in the maps */
+	12,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_CauseRIC_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CauseRIC = {
+	"CauseRIC",
+	"CauseRIC",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_CauseRIC_tags_1,
+	sizeof(asn_DEF_CauseRIC_tags_1)
+		/sizeof(asn_DEF_CauseRIC_tags_1[0]), /* 1 */
+	asn_DEF_CauseRIC_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CauseRIC_tags_1)
+		/sizeof(asn_DEF_CauseRIC_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_CauseRIC_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseRIC_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CauseRIC.h

@@ -0,0 +1,63 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_CauseRIC_H_
+#define	_CauseRIC_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CauseRIC {
+	CauseRIC_ran_function_id_Invalid	= 0,
+	CauseRIC_action_not_supported	= 1,
+	CauseRIC_excessive_actions	= 2,
+	CauseRIC_duplicate_action	= 3,
+	CauseRIC_duplicate_event	= 4,
+	CauseRIC_function_resource_limit	= 5,
+	CauseRIC_request_id_unknown	= 6,
+	CauseRIC_inconsistent_action_subsequent_action_sequence	= 7,
+	CauseRIC_control_message_invalid	= 8,
+	CauseRIC_call_process_id_invalid	= 9,
+	CauseRIC_unspecified	= 10
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseRIC;
+
+/* CauseRIC */
+typedef long	 CauseRIC_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_CauseRIC_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_CauseRIC;
+extern const asn_INTEGER_specifics_t asn_SPC_CauseRIC_specs_1;
+asn_struct_free_f CauseRIC_free;
+asn_struct_print_f CauseRIC_print;
+asn_constr_check_f CauseRIC_constraint;
+ber_type_decoder_f CauseRIC_decode_ber;
+der_type_encoder_f CauseRIC_encode_der;
+xer_type_decoder_f CauseRIC_decode_xer;
+xer_type_encoder_f CauseRIC_encode_xer;
+per_type_decoder_f CauseRIC_decode_uper;
+per_type_encoder_f CauseRIC_encode_uper;
+per_type_decoder_f CauseRIC_decode_aper;
+per_type_encoder_f CauseRIC_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CauseRIC_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/CauseRICservice.c

@@ -0,0 +1,57 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CauseRICservice.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_CauseRICservice_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  2 }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_CauseRICservice_value2enum_1[] = {
+	{ 0,	21,	"function-not-required" },
+	{ 1,	19,	"excessive-functions" },
+	{ 2,	18,	"ric-resource-limit" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseRICservice_enum2value_1[] = {
+	1,	/* excessive-functions(1) */
+	0,	/* function-not-required(0) */
+	2	/* ric-resource-limit(2) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_CauseRICservice_specs_1 = {
+	asn_MAP_CauseRICservice_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CauseRICservice_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_CauseRICservice_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CauseRICservice = {
+	"CauseRICservice",
+	"CauseRICservice",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_CauseRICservice_tags_1,
+	sizeof(asn_DEF_CauseRICservice_tags_1)
+		/sizeof(asn_DEF_CauseRICservice_tags_1[0]), /* 1 */
+	asn_DEF_CauseRICservice_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CauseRICservice_tags_1)
+		/sizeof(asn_DEF_CauseRICservice_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_CauseRICservice_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseRICservice_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CauseRICservice.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_CauseRICservice_H_
+#define	_CauseRICservice_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CauseRICservice {
+	CauseRICservice_function_not_required	= 0,
+	CauseRICservice_excessive_functions	= 1,
+	CauseRICservice_ric_resource_limit	= 2
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseRICservice;
+
+/* CauseRICservice */
+typedef long	 CauseRICservice_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_CauseRICservice_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_CauseRICservice;
+extern const asn_INTEGER_specifics_t asn_SPC_CauseRICservice_specs_1;
+asn_struct_free_f CauseRICservice_free;
+asn_struct_print_f CauseRICservice_print;
+asn_constr_check_f CauseRICservice_constraint;
+ber_type_decoder_f CauseRICservice_decode_ber;
+der_type_encoder_f CauseRICservice_encode_der;
+xer_type_decoder_f CauseRICservice_decode_xer;
+xer_type_encoder_f CauseRICservice_encode_xer;
+per_type_decoder_f CauseRICservice_decode_uper;
+per_type_encoder_f CauseRICservice_encode_uper;
+per_type_decoder_f CauseRICservice_decode_aper;
+per_type_encoder_f CauseRICservice_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CauseRICservice_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/CauseTransport.c

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CauseTransport.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_CauseTransport_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (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,	11,	"unspecified" },
+	{ 1,	30,	"transport-resource-unavailable" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_CauseTransport_enum2value_1[] = {
+	1,	/* transport-resource-unavailable(1) */
+	0	/* unspecified(0) */
+	/* This list is extensible */
+};
+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",
+	&asn_OP_NativeEnumerated,
+	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 */
+	{ 0, &asn_PER_type_CauseTransport_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CauseTransport_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CauseTransport.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#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_unspecified	= 0,
+	CauseTransport_transport_resource_unavailable	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_CauseTransport;
+
+/* CauseTransport */
+typedef long	 CauseTransport_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_CauseTransport_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_CauseTransport;
+extern const asn_INTEGER_specifics_t asn_SPC_CauseTransport_specs_1;
+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>

setup/xapp-sm-connector/asn1c_defs/Criticality.c

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-CommonDataTypes"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "Criticality.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_Criticality_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  2 }	/* (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) */
+};
+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",
+	&asn_OP_NativeEnumerated,
+	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 */
+	{ 0, &asn_PER_type_Criticality_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Criticality_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/Criticality.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-CommonDataTypes"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#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_per_constraints_t asn_PER_type_Criticality_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_Criticality;
+extern const asn_INTEGER_specifics_t asn_SPC_Criticality_specs_1;
+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>

setup/xapp-sm-connector/asn1c_defs/CriticalityDiagnostics-IE-Item.c

@@ -0,0 +1,70 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CriticalityDiagnostics-IE-Item.h"
+
+asn_TYPE_member_t asn_MBR_CriticalityDiagnostics_IE_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct CriticalityDiagnostics_IE_Item, iECriticality),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Criticality,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"iECriticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CriticalityDiagnostics_IE_Item, iE_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolIE_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"iE-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CriticalityDiagnostics_IE_Item, typeOfError),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_TypeOfError,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"typeOfError"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_CriticalityDiagnostics_IE_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_CriticalityDiagnostics_IE_Item_tag2el_1[] = {
+    { (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_SEQUENCE_specifics_t asn_SPC_CriticalityDiagnostics_IE_Item_specs_1 = {
+	sizeof(struct CriticalityDiagnostics_IE_Item),
+	offsetof(struct CriticalityDiagnostics_IE_Item, _asn_ctx),
+	asn_MAP_CriticalityDiagnostics_IE_Item_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	3,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics_IE_Item = {
+	"CriticalityDiagnostics-IE-Item",
+	"CriticalityDiagnostics-IE-Item",
+	&asn_OP_SEQUENCE,
+	asn_DEF_CriticalityDiagnostics_IE_Item_tags_1,
+	sizeof(asn_DEF_CriticalityDiagnostics_IE_Item_tags_1)
+		/sizeof(asn_DEF_CriticalityDiagnostics_IE_Item_tags_1[0]), /* 1 */
+	asn_DEF_CriticalityDiagnostics_IE_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CriticalityDiagnostics_IE_Item_tags_1)
+		/sizeof(asn_DEF_CriticalityDiagnostics_IE_Item_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_CriticalityDiagnostics_IE_Item_1,
+	3,	/* Elements count */
+	&asn_SPC_CriticalityDiagnostics_IE_Item_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CriticalityDiagnostics-IE-Item.h

@@ -0,0 +1,48 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_CriticalityDiagnostics_IE_Item_H_
+#define	_CriticalityDiagnostics_IE_Item_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Criticality.h"
+#include "ProtocolIE-ID.h"
+#include "TypeOfError.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CriticalityDiagnostics-IE-Item */
+typedef struct CriticalityDiagnostics_IE_Item {
+	Criticality_t	 iECriticality;
+	ProtocolIE_ID_t	 iE_ID;
+	TypeOfError_t	 typeOfError;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CriticalityDiagnostics_IE_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics_IE_Item;
+extern asn_SEQUENCE_specifics_t asn_SPC_CriticalityDiagnostics_IE_Item_specs_1;
+extern asn_TYPE_member_t asn_MBR_CriticalityDiagnostics_IE_Item_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CriticalityDiagnostics_IE_Item_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/CriticalityDiagnostics-IE-List.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CriticalityDiagnostics-IE-List.h"
+
+#include "CriticalityDiagnostics-IE-Item.h"
+asn_per_constraints_t asn_PER_type_CriticalityDiagnostics_IE_List_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1,  256 }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_CriticalityDiagnostics_IE_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_CriticalityDiagnostics_IE_Item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_CriticalityDiagnostics_IE_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+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",
+	&asn_OP_SEQUENCE_OF,
+	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 */
+	{ 0, &asn_PER_type_CriticalityDiagnostics_IE_List_constr_1, SEQUENCE_OF_constraint },
+	asn_MBR_CriticalityDiagnostics_IE_List_1,
+	1,	/* Single element */
+	&asn_SPC_CriticalityDiagnostics_IE_List_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CriticalityDiagnostics-IE-List.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_CriticalityDiagnostics_IE_List_H_
+#define	_CriticalityDiagnostics_IE_List_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 CriticalityDiagnostics_IE_Item;
+
+/* CriticalityDiagnostics-IE-List */
+typedef struct CriticalityDiagnostics_IE_List {
+	A_SEQUENCE_OF(struct CriticalityDiagnostics_IE_Item) 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;
+extern asn_SET_OF_specifics_t asn_SPC_CriticalityDiagnostics_IE_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_CriticalityDiagnostics_IE_List_1[1];
+extern asn_per_constraints_t asn_PER_type_CriticalityDiagnostics_IE_List_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CriticalityDiagnostics_IE_List_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/CriticalityDiagnostics.c

@@ -0,0 +1,94 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "CriticalityDiagnostics.h"
+
+#include "RICrequestID.h"
+#include "CriticalityDiagnostics-IE-List.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,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"procedureCode"
+		},
+	{ ATF_POINTER, 4, offsetof(struct CriticalityDiagnostics, triggeringMessage),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_TriggeringMessage,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"triggeringMessage"
+		},
+	{ ATF_POINTER, 3, offsetof(struct CriticalityDiagnostics, procedureCriticality),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Criticality,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"procedureCriticality"
+		},
+	{ ATF_POINTER, 2, offsetof(struct CriticalityDiagnostics, ricRequestorID),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RICrequestID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ricRequestorID"
+		},
+	{ ATF_POINTER, 1, offsetof(struct CriticalityDiagnostics, iEsCriticalityDiagnostics),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CriticalityDiagnostics_IE_List,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"iEsCriticalityDiagnostics"
+		},
+};
+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 }, /* ricRequestorID */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* iEsCriticalityDiagnostics */
+};
+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 */
+	5,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_CriticalityDiagnostics = {
+	"CriticalityDiagnostics",
+	"CriticalityDiagnostics",
+	&asn_OP_SEQUENCE,
+	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, 0, SEQUENCE_constraint },
+	asn_MBR_CriticalityDiagnostics_1,
+	5,	/* Elements count */
+	&asn_SPC_CriticalityDiagnostics_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/CriticalityDiagnostics.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#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 RICrequestID;
+struct CriticalityDiagnostics_IE_List;
+
+/* CriticalityDiagnostics */
+typedef struct CriticalityDiagnostics {
+	ProcedureCode_t	*procedureCode;	/* OPTIONAL */
+	TriggeringMessage_t	*triggeringMessage;	/* OPTIONAL */
+	Criticality_t	*procedureCriticality;	/* OPTIONAL */
+	struct RICrequestID	*ricRequestorID;	/* OPTIONAL */
+	struct CriticalityDiagnostics_IE_List	*iEsCriticalityDiagnostics;	/* 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
+
+#endif	/* _CriticalityDiagnostics_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2AP-PDU.c

@@ -0,0 +1,75 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Descriptions"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2AP-PDU.h"
+
+#include "InitiatingMessage.h"
+#include "SuccessfulOutcome.h"
+#include "UnsuccessfulOutcome.h"
+static asn_per_constraints_t asn_PER_type_E2AP_PDU_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  2 }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2AP_PDU_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2AP_PDU, choice.initiatingMessage),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_InitiatingMessage,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"initiatingMessage"
+		},
+	{ ATF_POINTER, 0, offsetof(struct E2AP_PDU, choice.successfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SuccessfulOutcome,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"successfulOutcome"
+		},
+	{ ATF_POINTER, 0, offsetof(struct E2AP_PDU, choice.unsuccessfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_UnsuccessfulOutcome,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"unsuccessfulOutcome"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2AP_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_E2AP_PDU_specs_1 = {
+	sizeof(struct E2AP_PDU),
+	offsetof(struct E2AP_PDU, _asn_ctx),
+	offsetof(struct E2AP_PDU, present),
+	sizeof(((struct E2AP_PDU *)0)->present),
+	asn_MAP_E2AP_PDU_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2AP_PDU = {
+	"E2AP-PDU",
+	"E2AP-PDU",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2AP_PDU_constr_1, CHOICE_constraint },
+	asn_MBR_E2AP_PDU_1,
+	3,	/* Elements count */
+	&asn_SPC_E2AP_PDU_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2AP-PDU.h

@@ -0,0 +1,61 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Descriptions"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2AP_PDU_H_
+#define	_E2AP_PDU_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2AP_PDU_PR {
+	E2AP_PDU_PR_NOTHING,	/* No components present */
+	E2AP_PDU_PR_initiatingMessage,
+	E2AP_PDU_PR_successfulOutcome,
+	E2AP_PDU_PR_unsuccessfulOutcome
+	/* Extensions may appear below */
+	
+} E2AP_PDU_PR;
+
+/* Forward declarations */
+struct InitiatingMessage;
+struct SuccessfulOutcome;
+struct UnsuccessfulOutcome;
+
+/* E2AP-PDU */
+typedef struct E2AP_PDU {
+	E2AP_PDU_PR present;
+	union E2AP_PDU_u {
+		struct InitiatingMessage	*initiatingMessage;
+		struct SuccessfulOutcome	*successfulOutcome;
+		struct UnsuccessfulOutcome	*unsuccessfulOutcome;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2AP_PDU_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2AP_PDU;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2AP_PDU_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ActionDefinition-Format1.c

@@ -0,0 +1,126 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-ActionDefinition-Format1.h"
+
+#include "RANparameter-Item.h"
+static int
+memb_ranParameter_List_constraint_1(const 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 >= 1 && size <= 255)) {
+		/* Perform validation of the inner elements */
+		return td->encoding_constraints.general_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_ranParameter_List_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1,  255 }	/* (SIZE(1..255)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_ranParameter_List_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1,  255 }	/* (SIZE(1..255)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_ranParameter_List_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RANparameter_Item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ranParameter_List_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ranParameter_List_specs_2 = {
+	sizeof(struct E2SM_HelloWorld_ActionDefinition_Format1__ranParameter_List),
+	offsetof(struct E2SM_HelloWorld_ActionDefinition_Format1__ranParameter_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ranParameter_List_2 = {
+	"ranParameter-List",
+	"ranParameter-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ranParameter_List_tags_2,
+	sizeof(asn_DEF_ranParameter_List_tags_2)
+		/sizeof(asn_DEF_ranParameter_List_tags_2[0]) - 1, /* 1 */
+	asn_DEF_ranParameter_List_tags_2,	/* Same as above */
+	sizeof(asn_DEF_ranParameter_List_tags_2)
+		/sizeof(asn_DEF_ranParameter_List_tags_2[0]), /* 2 */
+	{ 0, &asn_PER_type_ranParameter_List_constr_2, SEQUENCE_OF_constraint },
+	asn_MBR_ranParameter_List_2,
+	1,	/* Single element */
+	&asn_SPC_ranParameter_List_specs_2	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ActionDefinition_Format1_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct E2SM_HelloWorld_ActionDefinition_Format1, ranParameter_List),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_ranParameter_List_2,
+		0,
+		{ 0, &asn_PER_memb_ranParameter_List_constr_2,  memb_ranParameter_List_constraint_1 },
+		0, 0, /* No default value */
+		"ranParameter-List"
+		},
+};
+static const int asn_MAP_E2SM_HelloWorld_ActionDefinition_Format1_oms_1[] = { 0 };
+static const ber_tlv_tag_t asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_ActionDefinition_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* ranParameter-List */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_ActionDefinition_Format1_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_ActionDefinition_Format1),
+	offsetof(struct E2SM_HelloWorld_ActionDefinition_Format1, _asn_ctx),
+	asn_MAP_E2SM_HelloWorld_ActionDefinition_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	asn_MAP_E2SM_HelloWorld_ActionDefinition_Format1_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1 = {
+	"E2SM-HelloWorld-ActionDefinition-Format1",
+	"E2SM-HelloWorld-ActionDefinition-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_HelloWorld_ActionDefinition_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_ActionDefinition_Format1_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ActionDefinition-Format1.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_ActionDefinition_Format1_H_
+#define	_E2SM_HelloWorld_ActionDefinition_Format1_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 RANparameter_Item;
+
+/* E2SM-HelloWorld-ActionDefinition-Format1 */
+typedef struct E2SM_HelloWorld_ActionDefinition_Format1 {
+	struct E2SM_HelloWorld_ActionDefinition_Format1__ranParameter_List {
+		A_SEQUENCE_OF(struct RANparameter_Item) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ranParameter_List;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_ActionDefinition_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_ActionDefinition_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ActionDefinition_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_ActionDefinition_Format1_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ActionDefinition.c

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-ActionDefinition.h"
+
+#include "E2SM-HelloWorld-ActionDefinition-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_HelloWorld_ActionDefinition_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ActionDefinition_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_HelloWorld_ActionDefinition, choice.actionDefinition_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_HelloWorld_ActionDefinition_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"actionDefinition-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_ActionDefinition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* actionDefinition-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_HelloWorld_ActionDefinition_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_ActionDefinition),
+	offsetof(struct E2SM_HelloWorld_ActionDefinition, _asn_ctx),
+	offsetof(struct E2SM_HelloWorld_ActionDefinition, present),
+	sizeof(((struct E2SM_HelloWorld_ActionDefinition *)0)->present),
+	asn_MAP_E2SM_HelloWorld_ActionDefinition_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ActionDefinition = {
+	"E2SM-HelloWorld-ActionDefinition",
+	"E2SM-HelloWorld-ActionDefinition",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2SM_HelloWorld_ActionDefinition_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_HelloWorld_ActionDefinition_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_ActionDefinition_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ActionDefinition.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_ActionDefinition_H_
+#define	_E2SM_HelloWorld_ActionDefinition_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_HelloWorld_ActionDefinition_PR {
+	E2SM_HelloWorld_ActionDefinition_PR_NOTHING,	/* No components present */
+	E2SM_HelloWorld_ActionDefinition_PR_actionDefinition_Format1
+	/* Extensions may appear below */
+	
+} E2SM_HelloWorld_ActionDefinition_PR;
+
+/* Forward declarations */
+struct E2SM_HelloWorld_ActionDefinition_Format1;
+
+/* E2SM-HelloWorld-ActionDefinition */
+typedef struct E2SM_HelloWorld_ActionDefinition {
+	E2SM_HelloWorld_ActionDefinition_PR present;
+	union E2SM_HelloWorld_ActionDefinition_u {
+		struct E2SM_HelloWorld_ActionDefinition_Format1	*actionDefinition_Format1;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_ActionDefinition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ActionDefinition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_ActionDefinition_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlHeader-Format1.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-ControlHeader-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ControlHeader_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_HelloWorld_ControlHeader_Format1, controlHeaderParam),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HW_Header,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"controlHeaderParam"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_ControlHeader_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* controlHeaderParam */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_ControlHeader_Format1_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_ControlHeader_Format1),
+	offsetof(struct E2SM_HelloWorld_ControlHeader_Format1, _asn_ctx),
+	asn_MAP_E2SM_HelloWorld_ControlHeader_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlHeader_Format1 = {
+	"E2SM-HelloWorld-ControlHeader-Format1",
+	"E2SM-HelloWorld-ControlHeader-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_ControlHeader_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_HelloWorld_ControlHeader_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_ControlHeader_Format1_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlHeader-Format1.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_ControlHeader_Format1_H_
+#define	_E2SM_HelloWorld_ControlHeader_Format1_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HW-Header.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-HelloWorld-ControlHeader-Format1 */
+typedef struct E2SM_HelloWorld_ControlHeader_Format1 {
+	HW_Header_t	 controlHeaderParam;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_ControlHeader_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlHeader_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_ControlHeader_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ControlHeader_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_ControlHeader_Format1_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlHeader.c

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-ControlHeader.h"
+
+#include "E2SM-HelloWorld-ControlHeader-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_HelloWorld_ControlHeader_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ControlHeader_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_HelloWorld_ControlHeader, choice.controlHeader_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_HelloWorld_ControlHeader_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"controlHeader-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_ControlHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* controlHeader-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_HelloWorld_ControlHeader_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_ControlHeader),
+	offsetof(struct E2SM_HelloWorld_ControlHeader, _asn_ctx),
+	offsetof(struct E2SM_HelloWorld_ControlHeader, present),
+	sizeof(((struct E2SM_HelloWorld_ControlHeader *)0)->present),
+	asn_MAP_E2SM_HelloWorld_ControlHeader_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlHeader = {
+	"E2SM-HelloWorld-ControlHeader",
+	"E2SM-HelloWorld-ControlHeader",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2SM_HelloWorld_ControlHeader_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_HelloWorld_ControlHeader_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_ControlHeader_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlHeader.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_ControlHeader_H_
+#define	_E2SM_HelloWorld_ControlHeader_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_HelloWorld_ControlHeader_PR {
+	E2SM_HelloWorld_ControlHeader_PR_NOTHING,	/* No components present */
+	E2SM_HelloWorld_ControlHeader_PR_controlHeader_Format1
+	/* Extensions may appear below */
+	
+} E2SM_HelloWorld_ControlHeader_PR;
+
+/* Forward declarations */
+struct E2SM_HelloWorld_ControlHeader_Format1;
+
+/* E2SM-HelloWorld-ControlHeader */
+typedef struct E2SM_HelloWorld_ControlHeader {
+	E2SM_HelloWorld_ControlHeader_PR present;
+	union E2SM_HelloWorld_ControlHeader_u {
+		struct E2SM_HelloWorld_ControlHeader_Format1	*controlHeader_Format1;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_ControlHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_ControlHeader_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlMessage-Format1.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-ControlMessage-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ControlMessage_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_HelloWorld_ControlMessage_Format1, controlMsgParam),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HW_Message,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"controlMsgParam"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_ControlMessage_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* controlMsgParam */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_ControlMessage_Format1_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_ControlMessage_Format1),
+	offsetof(struct E2SM_HelloWorld_ControlMessage_Format1, _asn_ctx),
+	asn_MAP_E2SM_HelloWorld_ControlMessage_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlMessage_Format1 = {
+	"E2SM-HelloWorld-ControlMessage-Format1",
+	"E2SM-HelloWorld-ControlMessage-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_ControlMessage_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_HelloWorld_ControlMessage_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_ControlMessage_Format1_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlMessage-Format1.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_ControlMessage_Format1_H_
+#define	_E2SM_HelloWorld_ControlMessage_Format1_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HW-Message.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-HelloWorld-ControlMessage-Format1 */
+typedef struct E2SM_HelloWorld_ControlMessage_Format1 {
+	HW_Message_t	 controlMsgParam;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_ControlMessage_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlMessage_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_ControlMessage_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ControlMessage_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_ControlMessage_Format1_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlMessage.c

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-ControlMessage.h"
+
+#include "E2SM-HelloWorld-ControlMessage-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_HelloWorld_ControlMessage_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_ControlMessage_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_HelloWorld_ControlMessage, choice.controlMessage_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_HelloWorld_ControlMessage_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"controlMessage-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_ControlMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* controlMessage-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_HelloWorld_ControlMessage_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_ControlMessage),
+	offsetof(struct E2SM_HelloWorld_ControlMessage, _asn_ctx),
+	offsetof(struct E2SM_HelloWorld_ControlMessage, present),
+	sizeof(((struct E2SM_HelloWorld_ControlMessage *)0)->present),
+	asn_MAP_E2SM_HelloWorld_ControlMessage_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlMessage = {
+	"E2SM-HelloWorld-ControlMessage",
+	"E2SM-HelloWorld-ControlMessage",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2SM_HelloWorld_ControlMessage_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_HelloWorld_ControlMessage_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_ControlMessage_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-ControlMessage.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_ControlMessage_H_
+#define	_E2SM_HelloWorld_ControlMessage_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_HelloWorld_ControlMessage_PR {
+	E2SM_HelloWorld_ControlMessage_PR_NOTHING,	/* No components present */
+	E2SM_HelloWorld_ControlMessage_PR_controlMessage_Format1
+	/* Extensions may appear below */
+	
+} E2SM_HelloWorld_ControlMessage_PR;
+
+/* Forward declarations */
+struct E2SM_HelloWorld_ControlMessage_Format1;
+
+/* E2SM-HelloWorld-ControlMessage */
+typedef struct E2SM_HelloWorld_ControlMessage {
+	E2SM_HelloWorld_ControlMessage_PR present;
+	union E2SM_HelloWorld_ControlMessage_u {
+		struct E2SM_HelloWorld_ControlMessage_Format1	*controlMessage_Format1;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_ControlMessage_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_ControlMessage;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_ControlMessage_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-EventTriggerDefinition-Format1.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-EventTriggerDefinition-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_EventTriggerDefinition_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_HelloWorld_EventTriggerDefinition_Format1, triggerNature),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HW_TriggerNature,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"triggerNature"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_EventTriggerDefinition_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* triggerNature */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_EventTriggerDefinition_Format1_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_EventTriggerDefinition_Format1),
+	offsetof(struct E2SM_HelloWorld_EventTriggerDefinition_Format1, _asn_ctx),
+	asn_MAP_E2SM_HelloWorld_EventTriggerDefinition_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1 = {
+	"E2SM-HelloWorld-EventTriggerDefinition-Format1",
+	"E2SM-HelloWorld-EventTriggerDefinition-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_HelloWorld_EventTriggerDefinition_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_EventTriggerDefinition_Format1_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-EventTriggerDefinition-Format1.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_EventTriggerDefinition_Format1_H_
+#define	_E2SM_HelloWorld_EventTriggerDefinition_Format1_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HW-TriggerNature.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-HelloWorld-EventTriggerDefinition-Format1 */
+typedef struct E2SM_HelloWorld_EventTriggerDefinition_Format1 {
+	HW_TriggerNature_t	 triggerNature;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_EventTriggerDefinition_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_EventTriggerDefinition_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_EventTriggerDefinition_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_EventTriggerDefinition_Format1_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-EventTriggerDefinition.c

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-EventTriggerDefinition.h"
+
+#include "E2SM-HelloWorld-EventTriggerDefinition-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_HelloWorld_EventTriggerDefinition_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_EventTriggerDefinition_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_HelloWorld_EventTriggerDefinition, choice.eventDefinition_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_HelloWorld_EventTriggerDefinition_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"eventDefinition-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_EventTriggerDefinition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* eventDefinition-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_HelloWorld_EventTriggerDefinition_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_EventTriggerDefinition),
+	offsetof(struct E2SM_HelloWorld_EventTriggerDefinition, _asn_ctx),
+	offsetof(struct E2SM_HelloWorld_EventTriggerDefinition, present),
+	sizeof(((struct E2SM_HelloWorld_EventTriggerDefinition *)0)->present),
+	asn_MAP_E2SM_HelloWorld_EventTriggerDefinition_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_EventTriggerDefinition = {
+	"E2SM-HelloWorld-EventTriggerDefinition",
+	"E2SM-HelloWorld-EventTriggerDefinition",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2SM_HelloWorld_EventTriggerDefinition_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_HelloWorld_EventTriggerDefinition_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_EventTriggerDefinition_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-EventTriggerDefinition.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_EventTriggerDefinition_H_
+#define	_E2SM_HelloWorld_EventTriggerDefinition_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_HelloWorld_EventTriggerDefinition_PR {
+	E2SM_HelloWorld_EventTriggerDefinition_PR_NOTHING,	/* No components present */
+	E2SM_HelloWorld_EventTriggerDefinition_PR_eventDefinition_Format1
+	/* Extensions may appear below */
+	
+} E2SM_HelloWorld_EventTriggerDefinition_PR;
+
+/* Forward declarations */
+struct E2SM_HelloWorld_EventTriggerDefinition_Format1;
+
+/* E2SM-HelloWorld-EventTriggerDefinition */
+typedef struct E2SM_HelloWorld_EventTriggerDefinition {
+	E2SM_HelloWorld_EventTriggerDefinition_PR present;
+	union E2SM_HelloWorld_EventTriggerDefinition_u {
+		struct E2SM_HelloWorld_EventTriggerDefinition_Format1	*eventDefinition_Format1;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_EventTriggerDefinition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_EventTriggerDefinition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_EventTriggerDefinition_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationHeader-Format1.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-IndicationHeader-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_IndicationHeader_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_HelloWorld_IndicationHeader_Format1, indicationHeaderParam),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HW_Header,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"indicationHeaderParam"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_IndicationHeader_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* indicationHeaderParam */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_IndicationHeader_Format1_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_IndicationHeader_Format1),
+	offsetof(struct E2SM_HelloWorld_IndicationHeader_Format1, _asn_ctx),
+	asn_MAP_E2SM_HelloWorld_IndicationHeader_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1 = {
+	"E2SM-HelloWorld-IndicationHeader-Format1",
+	"E2SM-HelloWorld-IndicationHeader-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_HelloWorld_IndicationHeader_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_IndicationHeader_Format1_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationHeader-Format1.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_IndicationHeader_Format1_H_
+#define	_E2SM_HelloWorld_IndicationHeader_Format1_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HW-Header.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-HelloWorld-IndicationHeader-Format1 */
+typedef struct E2SM_HelloWorld_IndicationHeader_Format1 {
+	HW_Header_t	 indicationHeaderParam;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_IndicationHeader_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_IndicationHeader_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_IndicationHeader_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_IndicationHeader_Format1_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationHeader.c

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-IndicationHeader.h"
+
+#include "E2SM-HelloWorld-IndicationHeader-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_HelloWorld_IndicationHeader_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_IndicationHeader_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_HelloWorld_IndicationHeader, choice.indicationHeader_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_HelloWorld_IndicationHeader_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"indicationHeader-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_IndicationHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* indicationHeader-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_HelloWorld_IndicationHeader_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_IndicationHeader),
+	offsetof(struct E2SM_HelloWorld_IndicationHeader, _asn_ctx),
+	offsetof(struct E2SM_HelloWorld_IndicationHeader, present),
+	sizeof(((struct E2SM_HelloWorld_IndicationHeader *)0)->present),
+	asn_MAP_E2SM_HelloWorld_IndicationHeader_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationHeader = {
+	"E2SM-HelloWorld-IndicationHeader",
+	"E2SM-HelloWorld-IndicationHeader",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2SM_HelloWorld_IndicationHeader_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_HelloWorld_IndicationHeader_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_IndicationHeader_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationHeader.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_IndicationHeader_H_
+#define	_E2SM_HelloWorld_IndicationHeader_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_HelloWorld_IndicationHeader_PR {
+	E2SM_HelloWorld_IndicationHeader_PR_NOTHING,	/* No components present */
+	E2SM_HelloWorld_IndicationHeader_PR_indicationHeader_Format1
+	/* Extensions may appear below */
+	
+} E2SM_HelloWorld_IndicationHeader_PR;
+
+/* Forward declarations */
+struct E2SM_HelloWorld_IndicationHeader_Format1;
+
+/* E2SM-HelloWorld-IndicationHeader */
+typedef struct E2SM_HelloWorld_IndicationHeader {
+	E2SM_HelloWorld_IndicationHeader_PR present;
+	union E2SM_HelloWorld_IndicationHeader_u {
+		struct E2SM_HelloWorld_IndicationHeader_Format1	*indicationHeader_Format1;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_IndicationHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_IndicationHeader_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationMessage-Format1.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-IndicationMessage-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_IndicationMessage_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_HelloWorld_IndicationMessage_Format1, indicationMsgParam),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_HW_Message,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"indicationMsgParam"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_IndicationMessage_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* indicationMsgParam */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_IndicationMessage_Format1_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_IndicationMessage_Format1),
+	offsetof(struct E2SM_HelloWorld_IndicationMessage_Format1, _asn_ctx),
+	asn_MAP_E2SM_HelloWorld_IndicationMessage_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1 = {
+	"E2SM-HelloWorld-IndicationMessage-Format1",
+	"E2SM-HelloWorld-IndicationMessage-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_HelloWorld_IndicationMessage_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_IndicationMessage_Format1_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationMessage-Format1.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_IndicationMessage_Format1_H_
+#define	_E2SM_HelloWorld_IndicationMessage_Format1_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "HW-Message.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-HelloWorld-IndicationMessage-Format1 */
+typedef struct E2SM_HelloWorld_IndicationMessage_Format1 {
+	HW_Message_t	 indicationMsgParam;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_IndicationMessage_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_HelloWorld_IndicationMessage_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_IndicationMessage_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_IndicationMessage_Format1_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationMessage.c

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2SM-HelloWorld-IndicationMessage.h"
+
+#include "E2SM-HelloWorld-IndicationMessage-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_HelloWorld_IndicationMessage_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_E2SM_HelloWorld_IndicationMessage_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_HelloWorld_IndicationMessage, choice.indicationMessage_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_HelloWorld_IndicationMessage_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"indicationMessage-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_HelloWorld_IndicationMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* indicationMessage-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_HelloWorld_IndicationMessage_specs_1 = {
+	sizeof(struct E2SM_HelloWorld_IndicationMessage),
+	offsetof(struct E2SM_HelloWorld_IndicationMessage, _asn_ctx),
+	offsetof(struct E2SM_HelloWorld_IndicationMessage, present),
+	sizeof(((struct E2SM_HelloWorld_IndicationMessage *)0)->present),
+	asn_MAP_E2SM_HelloWorld_IndicationMessage_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationMessage = {
+	"E2SM-HelloWorld-IndicationMessage",
+	"E2SM-HelloWorld-IndicationMessage",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_E2SM_HelloWorld_IndicationMessage_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_HelloWorld_IndicationMessage_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_HelloWorld_IndicationMessage_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2SM-HelloWorld-IndicationMessage.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2SM_HelloWorld_IndicationMessage_H_
+#define	_E2SM_HelloWorld_IndicationMessage_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_HelloWorld_IndicationMessage_PR {
+	E2SM_HelloWorld_IndicationMessage_PR_NOTHING,	/* No components present */
+	E2SM_HelloWorld_IndicationMessage_PR_indicationMessage_Format1
+	/* Extensions may appear below */
+	
+} E2SM_HelloWorld_IndicationMessage_PR;
+
+/* Forward declarations */
+struct E2SM_HelloWorld_IndicationMessage_Format1;
+
+/* E2SM-HelloWorld-IndicationMessage */
+typedef struct E2SM_HelloWorld_IndicationMessage {
+	E2SM_HelloWorld_IndicationMessage_PR present;
+	union E2SM_HelloWorld_IndicationMessage_u {
+		struct E2SM_HelloWorld_IndicationMessage_Format1	*indicationMessage_Format1;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_HelloWorld_IndicationMessage_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_HelloWorld_IndicationMessage;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_HelloWorld_IndicationMessage_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2setupFailure.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2setupFailure.h"
+
+asn_TYPE_member_t asn_MBR_E2setupFailure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2setupFailure, protocolIEs),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolIE_Container_1412P13,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"protocolIEs"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2setupFailure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2setupFailure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* protocolIEs */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2setupFailure_specs_1 = {
+	sizeof(struct E2setupFailure),
+	offsetof(struct E2setupFailure, _asn_ctx),
+	asn_MAP_E2setupFailure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2setupFailure = {
+	"E2setupFailure",
+	"E2setupFailure",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2setupFailure_tags_1,
+	sizeof(asn_DEF_E2setupFailure_tags_1)
+		/sizeof(asn_DEF_E2setupFailure_tags_1[0]), /* 1 */
+	asn_DEF_E2setupFailure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2setupFailure_tags_1)
+		/sizeof(asn_DEF_E2setupFailure_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2setupFailure_1,
+	1,	/* Elements count */
+	&asn_SPC_E2setupFailure_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2setupFailure.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2setupFailure_H_
+#define	_E2setupFailure_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProtocolIE-Container.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2setupFailure */
+typedef struct E2setupFailure {
+	ProtocolIE_Container_1412P13_t	 protocolIEs;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2setupFailure_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2setupFailure;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2setupFailure_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2setupFailure_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2setupFailure_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2setupRequest.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2setupRequest.h"
+
+asn_TYPE_member_t asn_MBR_E2setupRequest_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2setupRequest, protocolIEs),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolIE_Container_1412P11,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"protocolIEs"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2setupRequest_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2setupRequest_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* protocolIEs */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2setupRequest_specs_1 = {
+	sizeof(struct E2setupRequest),
+	offsetof(struct E2setupRequest, _asn_ctx),
+	asn_MAP_E2setupRequest_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2setupRequest = {
+	"E2setupRequest",
+	"E2setupRequest",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2setupRequest_tags_1,
+	sizeof(asn_DEF_E2setupRequest_tags_1)
+		/sizeof(asn_DEF_E2setupRequest_tags_1[0]), /* 1 */
+	asn_DEF_E2setupRequest_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2setupRequest_tags_1)
+		/sizeof(asn_DEF_E2setupRequest_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2setupRequest_1,
+	1,	/* Elements count */
+	&asn_SPC_E2setupRequest_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2setupRequest.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2setupRequest_H_
+#define	_E2setupRequest_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProtocolIE-Container.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2setupRequest */
+typedef struct E2setupRequest {
+	ProtocolIE_Container_1412P11_t	 protocolIEs;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2setupRequest_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2setupRequest;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2setupRequest_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2setupRequest_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2setupRequest_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/E2setupResponse.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "E2setupResponse.h"
+
+asn_TYPE_member_t asn_MBR_E2setupResponse_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2setupResponse, protocolIEs),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolIE_Container_1412P12,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"protocolIEs"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2setupResponse_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2setupResponse_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* protocolIEs */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2setupResponse_specs_1 = {
+	sizeof(struct E2setupResponse),
+	offsetof(struct E2setupResponse, _asn_ctx),
+	asn_MAP_E2setupResponse_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2setupResponse = {
+	"E2setupResponse",
+	"E2setupResponse",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2setupResponse_tags_1,
+	sizeof(asn_DEF_E2setupResponse_tags_1)
+		/sizeof(asn_DEF_E2setupResponse_tags_1[0]), /* 1 */
+	asn_DEF_E2setupResponse_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2setupResponse_tags_1)
+		/sizeof(asn_DEF_E2setupResponse_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2setupResponse_1,
+	1,	/* Elements count */
+	&asn_SPC_E2setupResponse_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/E2setupResponse.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_E2setupResponse_H_
+#define	_E2setupResponse_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProtocolIE-Container.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2setupResponse */
+typedef struct E2setupResponse {
+	ProtocolIE_Container_1412P12_t	 protocolIEs;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2setupResponse_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2setupResponse;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2setupResponse_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2setupResponse_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2setupResponse_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/ENB-ID-Choice.c

@@ -0,0 +1,180 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "ENB-ID-Choice.h"
+
+static int
+memb_enb_ID_macro_constraint_1(const 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 == 20)) {
+		/* 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_enb_ID_shortmacro_constraint_1(const 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 == 18)) {
+		/* 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_enb_ID_longmacro_constraint_1(const 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 == 21)) {
+		/* 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_memb_enb_ID_macro_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  20,  20 }	/* (SIZE(20..20)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_enb_ID_shortmacro_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  18,  18 }	/* (SIZE(18..18)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_enb_ID_longmacro_constr_4 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  21,  21 }	/* (SIZE(21..21)) */,
+	0, 0	/* No PER value map */
+};
+asn_per_constraints_t asn_PER_type_ENB_ID_Choice_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  2 }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_ENB_ID_Choice_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID_Choice, choice.enb_ID_macro),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_enb_ID_macro_constr_2,  memb_enb_ID_macro_constraint_1 },
+		0, 0, /* No default value */
+		"enb-ID-macro"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID_Choice, choice.enb_ID_shortmacro),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_enb_ID_shortmacro_constr_3,  memb_enb_ID_shortmacro_constraint_1 },
+		0, 0, /* No default value */
+		"enb-ID-shortmacro"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID_Choice, choice.enb_ID_longmacro),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_enb_ID_longmacro_constr_4,  memb_enb_ID_longmacro_constraint_1 },
+		0, 0, /* No default value */
+		"enb-ID-longmacro"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_ENB_ID_Choice_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* enb-ID-macro */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* enb-ID-shortmacro */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* enb-ID-longmacro */
+};
+asn_CHOICE_specifics_t asn_SPC_ENB_ID_Choice_specs_1 = {
+	sizeof(struct ENB_ID_Choice),
+	offsetof(struct ENB_ID_Choice, _asn_ctx),
+	offsetof(struct ENB_ID_Choice, present),
+	sizeof(((struct ENB_ID_Choice *)0)->present),
+	asn_MAP_ENB_ID_Choice_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_ENB_ID_Choice = {
+	"ENB-ID-Choice",
+	"ENB-ID-Choice",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_ENB_ID_Choice_constr_1, CHOICE_constraint },
+	asn_MBR_ENB_ID_Choice_1,
+	3,	/* Elements count */
+	&asn_SPC_ENB_ID_Choice_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/ENB-ID-Choice.h

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_ENB_ID_Choice_H_
+#define	_ENB_ID_Choice_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ENB_ID_Choice_PR {
+	ENB_ID_Choice_PR_NOTHING,	/* No components present */
+	ENB_ID_Choice_PR_enb_ID_macro,
+	ENB_ID_Choice_PR_enb_ID_shortmacro,
+	ENB_ID_Choice_PR_enb_ID_longmacro
+	/* Extensions may appear below */
+	
+} ENB_ID_Choice_PR;
+
+/* ENB-ID-Choice */
+typedef struct ENB_ID_Choice {
+	ENB_ID_Choice_PR present;
+	union ENB_ID_Choice_u {
+		BIT_STRING_t	 enb_ID_macro;
+		BIT_STRING_t	 enb_ID_shortmacro;
+		BIT_STRING_t	 enb_ID_longmacro;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ENB_ID_Choice_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ENB_ID_Choice;
+extern asn_CHOICE_specifics_t asn_SPC_ENB_ID_Choice_specs_1;
+extern asn_TYPE_member_t asn_MBR_ENB_ID_Choice_1[3];
+extern asn_per_constraints_t asn_PER_type_ENB_ID_Choice_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ENB_ID_Choice_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/ENB-ID.c

@@ -0,0 +1,226 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "ENB-ID.h"
+
+static int
+memb_macro_eNB_ID_constraint_1(const 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 == 20)) {
+		/* 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_home_eNB_ID_constraint_1(const 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 == 28)) {
+		/* 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_short_Macro_eNB_ID_constraint_1(const 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 == 18)) {
+		/* 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_long_Macro_eNB_ID_constraint_1(const 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 == 21)) {
+		/* 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_memb_macro_eNB_ID_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  20,  20 }	/* (SIZE(20..20)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_home_eNB_ID_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  28,  28 }	/* (SIZE(28..28)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_short_Macro_eNB_ID_constr_5 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  18,  18 }	/* (SIZE(18..18)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_long_Macro_eNB_ID_constr_6 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  21,  21 }	/* (SIZE(21..21)) */,
+	0, 0	/* No PER value map */
+};
+asn_per_constraints_t asn_PER_type_ENB_ID_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_ENB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID, choice.macro_eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_macro_eNB_ID_constr_2,  memb_macro_eNB_ID_constraint_1 },
+		0, 0, /* No default value */
+		"macro-eNB-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID, choice.home_eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_home_eNB_ID_constr_3,  memb_home_eNB_ID_constraint_1 },
+		0, 0, /* No default value */
+		"home-eNB-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID, choice.short_Macro_eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_short_Macro_eNB_ID_constr_5,  memb_short_Macro_eNB_ID_constraint_1 },
+		0, 0, /* No default value */
+		"short-Macro-eNB-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ENB_ID, choice.long_Macro_eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_long_Macro_eNB_ID_constr_6,  memb_long_Macro_eNB_ID_constraint_1 },
+		0, 0, /* No default value */
+		"long-Macro-eNB-ID"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_ENB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* macro-eNB-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* home-eNB-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* short-Macro-eNB-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* long-Macro-eNB-ID */
+};
+asn_CHOICE_specifics_t asn_SPC_ENB_ID_specs_1 = {
+	sizeof(struct ENB_ID),
+	offsetof(struct ENB_ID, _asn_ctx),
+	offsetof(struct ENB_ID, present),
+	sizeof(((struct ENB_ID *)0)->present),
+	asn_MAP_ENB_ID_tag2el_1,
+	4,	/* Count of tags in the map */
+	0, 0,
+	2	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_ENB_ID = {
+	"ENB-ID",
+	"ENB-ID",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_ENB_ID_constr_1, CHOICE_constraint },
+	asn_MBR_ENB_ID_1,
+	4,	/* Elements count */
+	&asn_SPC_ENB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/ENB-ID.h

@@ -0,0 +1,61 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_ENB_ID_H_
+#define	_ENB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ENB_ID_PR {
+	ENB_ID_PR_NOTHING,	/* No components present */
+	ENB_ID_PR_macro_eNB_ID,
+	ENB_ID_PR_home_eNB_ID,
+	/* Extensions may appear below */
+	ENB_ID_PR_short_Macro_eNB_ID,
+	ENB_ID_PR_long_Macro_eNB_ID
+} ENB_ID_PR;
+
+/* ENB-ID */
+typedef struct ENB_ID {
+	ENB_ID_PR present;
+	union ENB_ID_u {
+		BIT_STRING_t	 macro_eNB_ID;
+		BIT_STRING_t	 home_eNB_ID;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+		BIT_STRING_t	 short_Macro_eNB_ID;
+		BIT_STRING_t	 long_Macro_eNB_ID;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ENB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ENB_ID;
+extern asn_CHOICE_specifics_t asn_SPC_ENB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_ENB_ID_1[4];
+extern asn_per_constraints_t asn_PER_type_ENB_ID_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ENB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/ENGNB-ID.c

@@ -0,0 +1,88 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "ENGNB-ID.h"
+
+static int
+memb_gNB_ID_constraint_1(const 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 >= 22 && size <= 32)) {
+		/* 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_memb_gNB_ID_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 4,  4,  22,  32 }	/* (SIZE(22..32)) */,
+	0, 0	/* No PER value map */
+};
+asn_per_constraints_t asn_PER_type_ENGNB_ID_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_ENGNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ENGNB_ID, choice.gNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_gNB_ID_constr_2,  memb_gNB_ID_constraint_1 },
+		0, 0, /* No default value */
+		"gNB-ID"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_ENGNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* gNB-ID */
+};
+asn_CHOICE_specifics_t asn_SPC_ENGNB_ID_specs_1 = {
+	sizeof(struct ENGNB_ID),
+	offsetof(struct ENGNB_ID, _asn_ctx),
+	offsetof(struct ENGNB_ID, present),
+	sizeof(((struct ENGNB_ID *)0)->present),
+	asn_MAP_ENGNB_ID_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_ENGNB_ID = {
+	"ENGNB-ID",
+	"ENGNB-ID",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_ENGNB_ID_constr_1, CHOICE_constraint },
+	asn_MBR_ENGNB_ID_1,
+	1,	/* Elements count */
+	&asn_SPC_ENGNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/ENGNB-ID.h

@@ -0,0 +1,56 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_ENGNB_ID_H_
+#define	_ENGNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ENGNB_ID_PR {
+	ENGNB_ID_PR_NOTHING,	/* No components present */
+	ENGNB_ID_PR_gNB_ID
+	/* Extensions may appear below */
+	
+} ENGNB_ID_PR;
+
+/* ENGNB-ID */
+typedef struct ENGNB_ID {
+	ENGNB_ID_PR present;
+	union ENGNB_ID_u {
+		BIT_STRING_t	 gNB_ID;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ENGNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ENGNB_ID;
+extern asn_CHOICE_specifics_t asn_SPC_ENGNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_ENGNB_ID_1[1];
+extern asn_per_constraints_t asn_PER_type_ENGNB_ID_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ENGNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/ErrorIndication.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "ErrorIndication.h"
+
+asn_TYPE_member_t asn_MBR_ErrorIndication_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ErrorIndication, protocolIEs),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ProtocolIE_Container_1412P10,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"protocolIEs"
+		},
+};
+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 } /* protocolIEs */
+};
+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) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_ErrorIndication = {
+	"ErrorIndication",
+	"ErrorIndication",
+	&asn_OP_SEQUENCE,
+	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, 0, SEQUENCE_constraint },
+	asn_MBR_ErrorIndication_1,
+	1,	/* Elements count */
+	&asn_SPC_ErrorIndication_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/ErrorIndication.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-PDU-Contents"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_ErrorIndication_H_
+#define	_ErrorIndication_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ProtocolIE-Container.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ErrorIndication */
+typedef struct ErrorIndication {
+	ProtocolIE_Container_1412P10_t	 protocolIEs;
+	/*
+	 * 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;
+extern asn_SEQUENCE_specifics_t asn_SPC_ErrorIndication_specs_1;
+extern asn_TYPE_member_t asn_MBR_ErrorIndication_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ErrorIndication_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GNB-CU-UP-ID.c

@@ -0,0 +1,67 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GNB-CU-UP-ID.h"
+
+int
+GNB_CU_UP_ID_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 0 && value <= 68719476735)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_GNB_CU_UP_ID_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 36, -1,  0,  68719476735 }	/* (0..68719476735) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_GNB_CU_UP_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_GNB_CU_UP_ID = {
+	"GNB-CU-UP-ID",
+	"GNB-CU-UP-ID",
+	&asn_OP_INTEGER,
+	asn_DEF_GNB_CU_UP_ID_tags_1,
+	sizeof(asn_DEF_GNB_CU_UP_ID_tags_1)
+		/sizeof(asn_DEF_GNB_CU_UP_ID_tags_1[0]), /* 1 */
+	asn_DEF_GNB_CU_UP_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GNB_CU_UP_ID_tags_1)
+		/sizeof(asn_DEF_GNB_CU_UP_ID_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_GNB_CU_UP_ID_constr_1, GNB_CU_UP_ID_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/xapp-sm-connector/asn1c_defs/GNB-CU-UP-ID.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GNB_CU_UP_ID_H_
+#define	_GNB_CU_UP_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GNB-CU-UP-ID */
+typedef INTEGER_t	 GNB_CU_UP_ID_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_GNB_CU_UP_ID_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_GNB_CU_UP_ID;
+asn_struct_free_f GNB_CU_UP_ID_free;
+asn_struct_print_f GNB_CU_UP_ID_print;
+asn_constr_check_f GNB_CU_UP_ID_constraint;
+ber_type_decoder_f GNB_CU_UP_ID_decode_ber;
+der_type_encoder_f GNB_CU_UP_ID_encode_der;
+xer_type_decoder_f GNB_CU_UP_ID_decode_xer;
+xer_type_encoder_f GNB_CU_UP_ID_encode_xer;
+per_type_decoder_f GNB_CU_UP_ID_decode_uper;
+per_type_encoder_f GNB_CU_UP_ID_encode_uper;
+per_type_decoder_f GNB_CU_UP_ID_decode_aper;
+per_type_encoder_f GNB_CU_UP_ID_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GNB_CU_UP_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GNB-DU-ID.c

@@ -0,0 +1,67 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GNB-DU-ID.h"
+
+int
+GNB_DU_ID_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 0 && value <= 68719476735)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_GNB_DU_ID_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 36, -1,  0,  68719476735 }	/* (0..68719476735) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_GNB_DU_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_GNB_DU_ID = {
+	"GNB-DU-ID",
+	"GNB-DU-ID",
+	&asn_OP_INTEGER,
+	asn_DEF_GNB_DU_ID_tags_1,
+	sizeof(asn_DEF_GNB_DU_ID_tags_1)
+		/sizeof(asn_DEF_GNB_DU_ID_tags_1[0]), /* 1 */
+	asn_DEF_GNB_DU_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GNB_DU_ID_tags_1)
+		/sizeof(asn_DEF_GNB_DU_ID_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_GNB_DU_ID_constr_1, GNB_DU_ID_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/xapp-sm-connector/asn1c_defs/GNB-DU-ID.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GNB_DU_ID_H_
+#define	_GNB_DU_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GNB-DU-ID */
+typedef INTEGER_t	 GNB_DU_ID_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_GNB_DU_ID_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_GNB_DU_ID;
+asn_struct_free_f GNB_DU_ID_free;
+asn_struct_print_f GNB_DU_ID_print;
+asn_constr_check_f GNB_DU_ID_constraint;
+ber_type_decoder_f GNB_DU_ID_decode_ber;
+der_type_encoder_f GNB_DU_ID_encode_der;
+xer_type_decoder_f GNB_DU_ID_decode_xer;
+xer_type_encoder_f GNB_DU_ID_encode_xer;
+per_type_decoder_f GNB_DU_ID_decode_uper;
+per_type_encoder_f GNB_DU_ID_encode_uper;
+per_type_decoder_f GNB_DU_ID_decode_aper;
+per_type_encoder_f GNB_DU_ID_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GNB_DU_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GNB-ID-Choice.c

@@ -0,0 +1,88 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GNB-ID-Choice.h"
+
+static int
+memb_gnb_ID_constraint_1(const 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 >= 22 && size <= 32)) {
+		/* 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_memb_gnb_ID_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 4,  4,  22,  32 }	/* (SIZE(22..32)) */,
+	0, 0	/* No PER value map */
+};
+asn_per_constraints_t asn_PER_type_GNB_ID_Choice_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_GNB_ID_Choice_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GNB_ID_Choice, choice.gnb_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_gnb_ID_constr_2,  memb_gnb_ID_constraint_1 },
+		0, 0, /* No default value */
+		"gnb-ID"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_GNB_ID_Choice_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* gnb-ID */
+};
+asn_CHOICE_specifics_t asn_SPC_GNB_ID_Choice_specs_1 = {
+	sizeof(struct GNB_ID_Choice),
+	offsetof(struct GNB_ID_Choice, _asn_ctx),
+	offsetof(struct GNB_ID_Choice, present),
+	sizeof(((struct GNB_ID_Choice *)0)->present),
+	asn_MAP_GNB_ID_Choice_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_GNB_ID_Choice = {
+	"GNB-ID-Choice",
+	"GNB-ID-Choice",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_GNB_ID_Choice_constr_1, CHOICE_constraint },
+	asn_MBR_GNB_ID_Choice_1,
+	1,	/* Elements count */
+	&asn_SPC_GNB_ID_Choice_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GNB-ID-Choice.h

@@ -0,0 +1,56 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GNB_ID_Choice_H_
+#define	_GNB_ID_Choice_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum GNB_ID_Choice_PR {
+	GNB_ID_Choice_PR_NOTHING,	/* No components present */
+	GNB_ID_Choice_PR_gnb_ID
+	/* Extensions may appear below */
+	
+} GNB_ID_Choice_PR;
+
+/* GNB-ID-Choice */
+typedef struct GNB_ID_Choice {
+	GNB_ID_Choice_PR present;
+	union GNB_ID_Choice_u {
+		BIT_STRING_t	 gnb_ID;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GNB_ID_Choice_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GNB_ID_Choice;
+extern asn_CHOICE_specifics_t asn_SPC_GNB_ID_Choice_specs_1;
+extern asn_TYPE_member_t asn_MBR_GNB_ID_Choice_1[1];
+extern asn_per_constraints_t asn_PER_type_GNB_ID_Choice_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GNB_ID_Choice_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-ID.c

@@ -0,0 +1,86 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalE2node-ID.h"
+
+#include "GlobalE2node-gNB-ID.h"
+#include "GlobalE2node-en-gNB-ID.h"
+#include "GlobalE2node-ng-eNB-ID.h"
+#include "GlobalE2node-eNB-ID.h"
+static asn_per_constraints_t asn_PER_type_GlobalE2node_ID_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  3 }	/* (0..3,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_GlobalE2node_ID_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct GlobalE2node_ID, choice.gNB),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalE2node_gNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"gNB"
+		},
+	{ ATF_POINTER, 0, offsetof(struct GlobalE2node_ID, choice.en_gNB),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalE2node_en_gNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"en-gNB"
+		},
+	{ ATF_POINTER, 0, offsetof(struct GlobalE2node_ID, choice.ng_eNB),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalE2node_ng_eNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ng-eNB"
+		},
+	{ ATF_POINTER, 0, offsetof(struct GlobalE2node_ID, choice.eNB),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalE2node_eNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"eNB"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalE2node_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gNB */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* en-gNB */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ng-eNB */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* eNB */
+};
+static asn_CHOICE_specifics_t asn_SPC_GlobalE2node_ID_specs_1 = {
+	sizeof(struct GlobalE2node_ID),
+	offsetof(struct GlobalE2node_ID, _asn_ctx),
+	offsetof(struct GlobalE2node_ID, present),
+	sizeof(((struct GlobalE2node_ID *)0)->present),
+	asn_MAP_GlobalE2node_ID_tag2el_1,
+	4,	/* Count of tags in the map */
+	0, 0,
+	4	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalE2node_ID = {
+	"GlobalE2node-ID",
+	"GlobalE2node-ID",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_GlobalE2node_ID_constr_1, CHOICE_constraint },
+	asn_MBR_GlobalE2node_ID_1,
+	4,	/* Elements count */
+	&asn_SPC_GlobalE2node_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-ID.h

@@ -0,0 +1,64 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalE2node_ID_H_
+#define	_GlobalE2node_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum GlobalE2node_ID_PR {
+	GlobalE2node_ID_PR_NOTHING,	/* No components present */
+	GlobalE2node_ID_PR_gNB,
+	GlobalE2node_ID_PR_en_gNB,
+	GlobalE2node_ID_PR_ng_eNB,
+	GlobalE2node_ID_PR_eNB
+	/* Extensions may appear below */
+	
+} GlobalE2node_ID_PR;
+
+/* Forward declarations */
+struct GlobalE2node_gNB_ID;
+struct GlobalE2node_en_gNB_ID;
+struct GlobalE2node_ng_eNB_ID;
+struct GlobalE2node_eNB_ID;
+
+/* GlobalE2node-ID */
+typedef struct GlobalE2node_ID {
+	GlobalE2node_ID_PR present;
+	union GlobalE2node_ID_u {
+		struct GlobalE2node_gNB_ID	*gNB;
+		struct GlobalE2node_en_gNB_ID	*en_gNB;
+		struct GlobalE2node_ng_eNB_ID	*ng_eNB;
+		struct GlobalE2node_eNB_ID	*eNB;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalE2node_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalE2node_ID;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalE2node_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-eNB-ID.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalE2node-eNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalE2node_eNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalE2node_eNB_ID, global_eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalENB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"global-eNB-ID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalE2node_eNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalE2node_eNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* global-eNB-ID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_eNB_ID_specs_1 = {
+	sizeof(struct GlobalE2node_eNB_ID),
+	offsetof(struct GlobalE2node_eNB_ID, _asn_ctx),
+	asn_MAP_GlobalE2node_eNB_ID_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalE2node_eNB_ID = {
+	"GlobalE2node-eNB-ID",
+	"GlobalE2node-eNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalE2node_eNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalE2node_eNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_eNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalE2node_eNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalE2node_eNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_eNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalE2node_eNB_ID_1,
+	1,	/* Elements count */
+	&asn_SPC_GlobalE2node_eNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-eNB-ID.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalE2node_eNB_ID_H_
+#define	_GlobalE2node_eNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GlobalENB-ID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalE2node-eNB-ID */
+typedef struct GlobalE2node_eNB_ID {
+	GlobalENB_ID_t	 global_eNB_ID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalE2node_eNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalE2node_eNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_eNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalE2node_eNB_ID_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalE2node_eNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-en-gNB-ID.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalE2node-en-gNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalE2node_en_gNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalE2node_en_gNB_ID, global_gNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalenGNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"global-gNB-ID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalE2node_en_gNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalE2node_en_gNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* global-gNB-ID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_en_gNB_ID_specs_1 = {
+	sizeof(struct GlobalE2node_en_gNB_ID),
+	offsetof(struct GlobalE2node_en_gNB_ID, _asn_ctx),
+	asn_MAP_GlobalE2node_en_gNB_ID_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalE2node_en_gNB_ID = {
+	"GlobalE2node-en-gNB-ID",
+	"GlobalE2node-en-gNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalE2node_en_gNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalE2node_en_gNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_en_gNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalE2node_en_gNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalE2node_en_gNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_en_gNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalE2node_en_gNB_ID_1,
+	1,	/* Elements count */
+	&asn_SPC_GlobalE2node_en_gNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-en-gNB-ID.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalE2node_en_gNB_ID_H_
+#define	_GlobalE2node_en_gNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GlobalenGNB-ID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalE2node-en-gNB-ID */
+typedef struct GlobalE2node_en_gNB_ID {
+	GlobalenGNB_ID_t	 global_gNB_ID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalE2node_en_gNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalE2node_en_gNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_en_gNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalE2node_en_gNB_ID_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalE2node_en_gNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-gNB-ID.c

@@ -0,0 +1,72 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalE2node-gNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalE2node_gNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalE2node_gNB_ID, global_gNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalgNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"global-gNB-ID"
+		},
+	{ ATF_POINTER, 2, offsetof(struct GlobalE2node_gNB_ID, gNB_CU_UP_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GNB_CU_UP_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"gNB-CU-UP-ID"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GlobalE2node_gNB_ID, gNB_DU_ID),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GNB_DU_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"gNB-DU-ID"
+		},
+};
+static const int asn_MAP_GlobalE2node_gNB_ID_oms_1[] = { 1, 2 };
+static const ber_tlv_tag_t asn_DEF_GlobalE2node_gNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalE2node_gNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* global-gNB-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* gNB-CU-UP-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* gNB-DU-ID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_gNB_ID_specs_1 = {
+	sizeof(struct GlobalE2node_gNB_ID),
+	offsetof(struct GlobalE2node_gNB_ID, _asn_ctx),
+	asn_MAP_GlobalE2node_gNB_ID_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_GlobalE2node_gNB_ID_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	3,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalE2node_gNB_ID = {
+	"GlobalE2node-gNB-ID",
+	"GlobalE2node-gNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalE2node_gNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalE2node_gNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_gNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalE2node_gNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalE2node_gNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_gNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalE2node_gNB_ID_1,
+	3,	/* Elements count */
+	&asn_SPC_GlobalE2node_gNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-gNB-ID.h

@@ -0,0 +1,48 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalE2node_gNB_ID_H_
+#define	_GlobalE2node_gNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GlobalgNB-ID.h"
+#include "GNB-CU-UP-ID.h"
+#include "GNB-DU-ID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalE2node-gNB-ID */
+typedef struct GlobalE2node_gNB_ID {
+	GlobalgNB_ID_t	 global_gNB_ID;
+	GNB_CU_UP_ID_t	*gNB_CU_UP_ID;	/* OPTIONAL */
+	GNB_DU_ID_t	*gNB_DU_ID;	/* OPTIONAL */
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalE2node_gNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalE2node_gNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_gNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalE2node_gNB_ID_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalE2node_gNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-ng-eNB-ID.c

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalE2node-ng-eNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalE2node_ng_eNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalE2node_ng_eNB_ID, global_ng_eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GlobalngeNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"global-ng-eNB-ID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalE2node_ng_eNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalE2node_ng_eNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* global-ng-eNB-ID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_ng_eNB_ID_specs_1 = {
+	sizeof(struct GlobalE2node_ng_eNB_ID),
+	offsetof(struct GlobalE2node_ng_eNB_ID, _asn_ctx),
+	asn_MAP_GlobalE2node_ng_eNB_ID_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalE2node_ng_eNB_ID = {
+	"GlobalE2node-ng-eNB-ID",
+	"GlobalE2node-ng-eNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalE2node_ng_eNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalE2node_ng_eNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_ng_eNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalE2node_ng_eNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalE2node_ng_eNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalE2node_ng_eNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalE2node_ng_eNB_ID_1,
+	1,	/* Elements count */
+	&asn_SPC_GlobalE2node_ng_eNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalE2node-ng-eNB-ID.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalE2node_ng_eNB_ID_H_
+#define	_GlobalE2node_ng_eNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GlobalngeNB-ID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalE2node-ng-eNB-ID */
+typedef struct GlobalE2node_ng_eNB_ID {
+	GlobalngeNB_ID_t	 global_ng_eNB_ID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalE2node_ng_eNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalE2node_ng_eNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalE2node_ng_eNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalE2node_ng_eNB_ID_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalE2node_ng_eNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalENB-ID.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalENB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalENB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalENB_ID, pLMN_Identity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMN_Identity,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"pLMN-Identity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalENB_ID, eNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ENB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"eNB-ID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalENB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalENB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMN-Identity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* eNB-ID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalENB_ID_specs_1 = {
+	sizeof(struct GlobalENB_ID),
+	offsetof(struct GlobalENB_ID, _asn_ctx),
+	asn_MAP_GlobalENB_ID_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	2,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalENB_ID = {
+	"GlobalENB-ID",
+	"GlobalENB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalENB_ID_tags_1,
+	sizeof(asn_DEF_GlobalENB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalENB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalENB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalENB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalENB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalENB_ID_1,
+	2,	/* Elements count */
+	&asn_SPC_GlobalENB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalENB-ID.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalENB_ID_H_
+#define	_GlobalENB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include "ENB-ID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalENB-ID */
+typedef struct GlobalENB_ID {
+	PLMN_Identity_t	 pLMN_Identity;
+	ENB_ID_t	 eNB_ID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalENB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalENB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalENB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalENB_ID_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalENB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalRIC-ID.c

@@ -0,0 +1,96 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalRIC-ID.h"
+
+static int
+memb_ric_ID_constraint_1(const 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 == 20)) {
+		/* 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_memb_ric_ID_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  20,  20 }	/* (SIZE(20..20)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_GlobalRIC_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalRIC_ID, pLMN_Identity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMN_Identity,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"pLMN-Identity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalRIC_ID, ric_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, &asn_PER_memb_ric_ID_constr_3,  memb_ric_ID_constraint_1 },
+		0, 0, /* No default value */
+		"ric-ID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalRIC_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalRIC_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMN-Identity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* ric-ID */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GlobalRIC_ID_specs_1 = {
+	sizeof(struct GlobalRIC_ID),
+	offsetof(struct GlobalRIC_ID, _asn_ctx),
+	asn_MAP_GlobalRIC_ID_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	2,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalRIC_ID = {
+	"GlobalRIC-ID",
+	"GlobalRIC-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalRIC_ID_tags_1,
+	sizeof(asn_DEF_GlobalRIC_ID_tags_1)
+		/sizeof(asn_DEF_GlobalRIC_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalRIC_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalRIC_ID_tags_1)
+		/sizeof(asn_DEF_GlobalRIC_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalRIC_ID_1,
+	2,	/* Elements count */
+	&asn_SPC_GlobalRIC_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalRIC-ID.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalRIC_ID_H_
+#define	_GlobalRIC_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include <BIT_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalRIC-ID */
+typedef struct GlobalRIC_ID {
+	PLMN_Identity_t	 pLMN_Identity;
+	BIT_STRING_t	 ric_ID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalRIC_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalRIC_ID;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalRIC_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalenGNB-ID.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalenGNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalenGNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalenGNB_ID, pLMN_Identity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMN_Identity,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"pLMN-Identity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalenGNB_ID, gNB_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ENGNB_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"gNB-ID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalenGNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalenGNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMN-Identity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* gNB-ID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalenGNB_ID_specs_1 = {
+	sizeof(struct GlobalenGNB_ID),
+	offsetof(struct GlobalenGNB_ID, _asn_ctx),
+	asn_MAP_GlobalenGNB_ID_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	2,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalenGNB_ID = {
+	"GlobalenGNB-ID",
+	"GlobalenGNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalenGNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalenGNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalenGNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalenGNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalenGNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalenGNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalenGNB_ID_1,
+	2,	/* Elements count */
+	&asn_SPC_GlobalenGNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalenGNB-ID.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalenGNB_ID_H_
+#define	_GlobalenGNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include "ENGNB-ID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalenGNB-ID */
+typedef struct GlobalenGNB_ID {
+	PLMN_Identity_t	 pLMN_Identity;
+	ENGNB_ID_t	 gNB_ID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalenGNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalenGNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalenGNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalenGNB_ID_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalenGNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalgNB-ID.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalgNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalgNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalgNB_ID, plmn_id),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMN_Identity,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"plmn-id"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalgNB_ID, gnb_id),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_GNB_ID_Choice,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"gnb-id"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalgNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalgNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* plmn-id */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* gnb-id */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalgNB_ID_specs_1 = {
+	sizeof(struct GlobalgNB_ID),
+	offsetof(struct GlobalgNB_ID, _asn_ctx),
+	asn_MAP_GlobalgNB_ID_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	2,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalgNB_ID = {
+	"GlobalgNB-ID",
+	"GlobalgNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalgNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalgNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalgNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalgNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalgNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalgNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalgNB_ID_1,
+	2,	/* Elements count */
+	&asn_SPC_GlobalgNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalgNB-ID.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalgNB_ID_H_
+#define	_GlobalgNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include "GNB-ID-Choice.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalgNB-ID */
+typedef struct GlobalgNB_ID {
+	PLMN_Identity_t	 plmn_id;
+	GNB_ID_Choice_t	 gnb_id;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalgNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalgNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalgNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalgNB_ID_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalgNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/GlobalngeNB-ID.c

@@ -0,0 +1,60 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "GlobalngeNB-ID.h"
+
+asn_TYPE_member_t asn_MBR_GlobalngeNB_ID_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalngeNB_ID, plmn_id),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PLMN_Identity,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"plmn-id"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GlobalngeNB_ID, enb_id),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ENB_ID_Choice,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"enb-id"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_GlobalngeNB_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_GlobalngeNB_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* plmn-id */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* enb-id */
+};
+asn_SEQUENCE_specifics_t asn_SPC_GlobalngeNB_ID_specs_1 = {
+	sizeof(struct GlobalngeNB_ID),
+	offsetof(struct GlobalngeNB_ID, _asn_ctx),
+	asn_MAP_GlobalngeNB_ID_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	2,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_GlobalngeNB_ID = {
+	"GlobalngeNB-ID",
+	"GlobalngeNB-ID",
+	&asn_OP_SEQUENCE,
+	asn_DEF_GlobalngeNB_ID_tags_1,
+	sizeof(asn_DEF_GlobalngeNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalngeNB_ID_tags_1[0]), /* 1 */
+	asn_DEF_GlobalngeNB_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GlobalngeNB_ID_tags_1)
+		/sizeof(asn_DEF_GlobalngeNB_ID_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_GlobalngeNB_ID_1,
+	2,	/* Elements count */
+	&asn_SPC_GlobalngeNB_ID_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/GlobalngeNB-ID.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2AP-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2ap-oran-wg3-v01.00.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_GlobalngeNB_ID_H_
+#define	_GlobalngeNB_ID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include "ENB-ID-Choice.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GlobalngeNB-ID */
+typedef struct GlobalngeNB_ID {
+	PLMN_Identity_t	 plmn_id;
+	ENB_ID_Choice_t	 enb_id;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GlobalngeNB_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GlobalngeNB_ID;
+extern asn_SEQUENCE_specifics_t asn_SPC_GlobalngeNB_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_GlobalngeNB_ID_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GlobalngeNB_ID_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/HW-ControlCommand.c

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "HW-ControlCommand.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static asn_per_constraints_t asn_PER_type_HW_ControlCommand_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_HW_ControlCommand_value2enum_1[] = {
+	{ 0,	8,	"addition" },
+	{ 1,	8,	"deletion" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_HW_ControlCommand_enum2value_1[] = {
+	0,	/* addition(0) */
+	1	/* deletion(1) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_HW_ControlCommand_specs_1 = {
+	asn_MAP_HW_ControlCommand_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_HW_ControlCommand_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_HW_ControlCommand_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HW_ControlCommand = {
+	"HW-ControlCommand",
+	"HW-ControlCommand",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_HW_ControlCommand_tags_1,
+	sizeof(asn_DEF_HW_ControlCommand_tags_1)
+		/sizeof(asn_DEF_HW_ControlCommand_tags_1[0]), /* 1 */
+	asn_DEF_HW_ControlCommand_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HW_ControlCommand_tags_1)
+		/sizeof(asn_DEF_HW_ControlCommand_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_HW_ControlCommand_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_HW_ControlCommand_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/HW-ControlCommand.h

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_HW_ControlCommand_H_
+#define	_HW_ControlCommand_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum HW_ControlCommand {
+	HW_ControlCommand_addition	= 0,
+	HW_ControlCommand_deletion	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_HW_ControlCommand;
+
+/* HW-ControlCommand */
+typedef long	 HW_ControlCommand_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HW_ControlCommand;
+asn_struct_free_f HW_ControlCommand_free;
+asn_struct_print_f HW_ControlCommand_print;
+asn_constr_check_f HW_ControlCommand_constraint;
+ber_type_decoder_f HW_ControlCommand_decode_ber;
+der_type_encoder_f HW_ControlCommand_encode_der;
+xer_type_decoder_f HW_ControlCommand_decode_xer;
+xer_type_encoder_f HW_ControlCommand_encode_xer;
+per_type_decoder_f HW_ControlCommand_decode_uper;
+per_type_encoder_f HW_ControlCommand_encode_uper;
+per_type_decoder_f HW_ControlCommand_decode_aper;
+per_type_encoder_f HW_ControlCommand_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HW_ControlCommand_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/HW-Header.c

@@ -0,0 +1,31 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "HW-Header.h"
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static const ber_tlv_tag_t asn_DEF_HW_Header_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HW_Header = {
+	"HW-Header",
+	"HW-Header",
+	&asn_OP_NativeInteger,
+	asn_DEF_HW_Header_tags_1,
+	sizeof(asn_DEF_HW_Header_tags_1)
+		/sizeof(asn_DEF_HW_Header_tags_1[0]), /* 1 */
+	asn_DEF_HW_Header_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HW_Header_tags_1)
+		/sizeof(asn_DEF_HW_Header_tags_1[0]), /* 1 */
+	{ 0, 0, NativeInteger_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/xapp-sm-connector/asn1c_defs/HW-Header.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_HW_Header_H_
+#define	_HW_Header_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* HW-Header */
+typedef long	 HW_Header_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HW_Header;
+asn_struct_free_f HW_Header_free;
+asn_struct_print_f HW_Header_print;
+asn_constr_check_f HW_Header_constraint;
+ber_type_decoder_f HW_Header_decode_ber;
+der_type_encoder_f HW_Header_encode_der;
+xer_type_decoder_f HW_Header_decode_xer;
+xer_type_encoder_f HW_Header_encode_xer;
+per_type_decoder_f HW_Header_decode_uper;
+per_type_encoder_f HW_Header_encode_uper;
+per_type_decoder_f HW_Header_decode_aper;
+per_type_encoder_f HW_Header_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HW_Header_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/HW-Message.c

@@ -0,0 +1,31 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "HW-Message.h"
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static const ber_tlv_tag_t asn_DEF_HW_Message_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HW_Message = {
+	"HW-Message",
+	"HW-Message",
+	&asn_OP_OCTET_STRING,
+	asn_DEF_HW_Message_tags_1,
+	sizeof(asn_DEF_HW_Message_tags_1)
+		/sizeof(asn_DEF_HW_Message_tags_1[0]), /* 1 */
+	asn_DEF_HW_Message_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HW_Message_tags_1)
+		/sizeof(asn_DEF_HW_Message_tags_1[0]), /* 1 */
+	{ 0, 0, OCTET_STRING_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_OCTET_STRING_specs	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/HW-Message.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_HW_Message_H_
+#define	_HW_Message_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* HW-Message */
+typedef OCTET_STRING_t	 HW_Message_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_HW_Message;
+asn_struct_free_f HW_Message_free;
+asn_struct_print_f HW_Message_print;
+asn_constr_check_f HW_Message_constraint;
+ber_type_decoder_f HW_Message_decode_ber;
+der_type_encoder_f HW_Message_encode_der;
+xer_type_decoder_f HW_Message_decode_xer;
+xer_type_encoder_f HW_Message_encode_xer;
+per_type_decoder_f HW_Message_decode_uper;
+per_type_encoder_f HW_Message_encode_uper;
+per_type_decoder_f HW_Message_decode_aper;
+per_type_encoder_f HW_Message_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HW_Message_H_ */
+#include <asn_internal.h>

setup/xapp-sm-connector/asn1c_defs/HW-TriggerNature.c

@@ -0,0 +1,55 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#include "HW-TriggerNature.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_HW_TriggerNature_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_HW_TriggerNature_value2enum_1[] = {
+	{ 0,	3,	"now" },
+	{ 1,	8,	"onchange" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_HW_TriggerNature_enum2value_1[] = {
+	0,	/* now(0) */
+	1	/* onchange(1) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_HW_TriggerNature_specs_1 = {
+	asn_MAP_HW_TriggerNature_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_HW_TriggerNature_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_HW_TriggerNature_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_HW_TriggerNature = {
+	"HW-TriggerNature",
+	"HW-TriggerNature",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_HW_TriggerNature_tags_1,
+	sizeof(asn_DEF_HW_TriggerNature_tags_1)
+		/sizeof(asn_DEF_HW_TriggerNature_tags_1[0]), /* 1 */
+	asn_DEF_HW_TriggerNature_tags_1,	/* Same as above */
+	sizeof(asn_DEF_HW_TriggerNature_tags_1)
+		/sizeof(asn_DEF_HW_TriggerNature_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_HW_TriggerNature_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_HW_TriggerNature_specs_1	/* Additional specs */
+};
+

setup/xapp-sm-connector/asn1c_defs/HW-TriggerNature.h

@@ -0,0 +1,54 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-HelloWorld-IEs"
+ * 	found in "/home/sjana/ASN-Defns/e2sm-HelloWorld-v002.asn"
+ * 	`asn1c -fno-include-deps -fcompound-names -findirect-choice -gen-PER -no-gen-OER`
+ */
+
+#ifndef	_HW_TriggerNature_H_
+#define	_HW_TriggerNature_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum HW_TriggerNature {
+	HW_TriggerNature_now	= 0,
+	HW_TriggerNature_onchange	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_HW_TriggerNature;
+
+/* HW-TriggerNature */
+typedef long	 HW_TriggerNature_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_HW_TriggerNature_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_HW_TriggerNature;
+extern const asn_INTEGER_specifics_t asn_SPC_HW_TriggerNature_specs_1;
+asn_struct_free_f HW_TriggerNature_free;
+asn_struct_print_f HW_TriggerNature_print;
+asn_constr_check_f HW_TriggerNature_constraint;
+ber_type_decoder_f HW_TriggerNature_decode_ber;
+der_type_encoder_f HW_TriggerNature_encode_der;
+xer_type_decoder_f HW_TriggerNature_decode_xer;
+xer_type_encoder_f HW_TriggerNature_encode_xer;
+per_type_decoder_f HW_TriggerNature_decode_uper;
+per_type_encoder_f HW_TriggerNature_encode_uper;
+per_type_decoder_f HW_TriggerNature_decode_aper;
+per_type_encoder_f HW_TriggerNature_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _HW_TriggerNature_H_ */
+#include <asn_internal.h>