First commit

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/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/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/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/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/BOOLEAN.c

@@ -0,0 +1,510 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*-
+ * 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/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/BOOLEAN.h

@@ -0,0 +1,63 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*-
+ * 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/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ActionDefinition-Format1.c

@@ -0,0 +1,144 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-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_gNB_NRT_ActionDefinition_Format1__ranParameter_List),
+	offsetof(struct E2SM_gNB_NRT_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_gNB_NRT_ActionDefinition_Format1_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct E2SM_gNB_NRT_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_gNB_NRT_ActionDefinition_Format1_oms_1[] = { 0 };
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_ActionDefinition_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* ranParameter-List */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_ActionDefinition_Format1_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_ActionDefinition_Format1),
+	offsetof(struct E2SM_gNB_NRT_ActionDefinition_Format1, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_ActionDefinition_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	asn_MAP_E2SM_gNB_NRT_ActionDefinition_Format1_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1 = {
+	"E2SM-gNB-NRT-ActionDefinition-Format1",
+	"E2SM-gNB-NRT-ActionDefinition-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_ActionDefinition_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_ActionDefinition_Format1_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ActionDefinition-Format1.h

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_ActionDefinition_Format1_H_
+#define	_E2SM_gNB_NRT_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-gNB-NRT-ActionDefinition-Format1 */
+typedef struct E2SM_gNB_NRT_ActionDefinition_Format1 {
+	struct E2SM_gNB_NRT_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_gNB_NRT_ActionDefinition_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_ActionDefinition_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_ActionDefinition_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_ActionDefinition_Format1_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ActionDefinition.c

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-ActionDefinition.h"
+
+#include "E2SM-gNB-NRT-ActionDefinition-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_gNB_NRT_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_gNB_NRT_ActionDefinition_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_gNB_NRT_ActionDefinition, choice.actionDefinition_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_gNB_NRT_ActionDefinition_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"actionDefinition-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_ActionDefinition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* actionDefinition-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_gNB_NRT_ActionDefinition_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_ActionDefinition),
+	offsetof(struct E2SM_gNB_NRT_ActionDefinition, _asn_ctx),
+	offsetof(struct E2SM_gNB_NRT_ActionDefinition, present),
+	sizeof(((struct E2SM_gNB_NRT_ActionDefinition *)0)->present),
+	asn_MAP_E2SM_gNB_NRT_ActionDefinition_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ActionDefinition = {
+	"E2SM-gNB-NRT-ActionDefinition",
+	"E2SM-gNB-NRT-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_gNB_NRT_ActionDefinition_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_gNB_NRT_ActionDefinition_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_ActionDefinition_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ActionDefinition.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_ActionDefinition_H_
+#define	_E2SM_gNB_NRT_ActionDefinition_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_gNB_NRT_ActionDefinition_PR {
+	E2SM_gNB_NRT_ActionDefinition_PR_NOTHING,	/* No components present */
+	E2SM_gNB_NRT_ActionDefinition_PR_actionDefinition_Format1
+	/* Extensions may appear below */
+	
+} E2SM_gNB_NRT_ActionDefinition_PR;
+
+/* Forward declarations */
+struct E2SM_gNB_NRT_ActionDefinition_Format1;
+
+/* E2SM-gNB-NRT-ActionDefinition */
+typedef struct E2SM_gNB_NRT_ActionDefinition {
+	E2SM_gNB_NRT_ActionDefinition_PR present;
+	union E2SM_gNB_NRT_ActionDefinition_u {
+		struct E2SM_gNB_NRT_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_gNB_NRT_ActionDefinition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ActionDefinition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_ActionDefinition_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlHeader-Format1.c

@@ -0,0 +1,88 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-ControlHeader-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_ControlHeader_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_ControlHeader_Format1, command),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRT_ControlCommand,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"command"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_ControlHeader_Format1, servedCellID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_NRT_Cell_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"servedCellID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_ControlHeader_Format1, neighbourCellID),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_NRT_Cell_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"neighbourCellID"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_ControlHeader_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* command */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* servedCellID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* neighbourCellID */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_ControlHeader_Format1_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_ControlHeader_Format1),
+	offsetof(struct E2SM_gNB_NRT_ControlHeader_Format1, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_ControlHeader_Format1_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_E2SM_gNB_NRT_ControlHeader_Format1 = {
+	"E2SM-gNB-NRT-ControlHeader-Format1",
+	"E2SM-gNB-NRT-ControlHeader-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_ControlHeader_Format1_1,
+	3,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_ControlHeader_Format1_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlHeader-Format1.h

@@ -0,0 +1,65 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_ControlHeader_Format1_H_
+#define	_E2SM_gNB_NRT_ControlHeader_Format1_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NRT-ControlCommand.h"
+#include "NRT-Cell-ID.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-gNB-NRT-ControlHeader-Format1 */
+typedef struct E2SM_gNB_NRT_ControlHeader_Format1 {
+	NRT_ControlCommand_t	 command;
+	NRT_Cell_ID_t	 servedCellID;
+	NRT_Cell_ID_t	 neighbourCellID;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_gNB_NRT_ControlHeader_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_ControlHeader_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_ControlHeader_Format1_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_ControlHeader_Format1_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlHeader.c

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-ControlHeader.h"
+
+#include "E2SM-gNB-NRT-ControlHeader-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_gNB_NRT_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_gNB_NRT_ControlHeader_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_gNB_NRT_ControlHeader, choice.controlHeader_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_gNB_NRT_ControlHeader_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"controlHeader-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_ControlHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* controlHeader-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_gNB_NRT_ControlHeader_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_ControlHeader),
+	offsetof(struct E2SM_gNB_NRT_ControlHeader, _asn_ctx),
+	offsetof(struct E2SM_gNB_NRT_ControlHeader, present),
+	sizeof(((struct E2SM_gNB_NRT_ControlHeader *)0)->present),
+	asn_MAP_E2SM_gNB_NRT_ControlHeader_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ControlHeader = {
+	"E2SM-gNB-NRT-ControlHeader",
+	"E2SM-gNB-NRT-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_gNB_NRT_ControlHeader_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_gNB_NRT_ControlHeader_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_ControlHeader_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlHeader.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_ControlHeader_H_
+#define	_E2SM_gNB_NRT_ControlHeader_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_gNB_NRT_ControlHeader_PR {
+	E2SM_gNB_NRT_ControlHeader_PR_NOTHING,	/* No components present */
+	E2SM_gNB_NRT_ControlHeader_PR_controlHeader_Format1
+	/* Extensions may appear below */
+	
+} E2SM_gNB_NRT_ControlHeader_PR;
+
+/* Forward declarations */
+struct E2SM_gNB_NRT_ControlHeader_Format1;
+
+/* E2SM-gNB-NRT-ControlHeader */
+typedef struct E2SM_gNB_NRT_ControlHeader {
+	E2SM_gNB_NRT_ControlHeader_PR present;
+	union E2SM_gNB_NRT_ControlHeader_u {
+		struct E2SM_gNB_NRT_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_gNB_NRT_ControlHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ControlHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_ControlHeader_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlMessage-Format1.c

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-ControlMessage-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_ControlMessage_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_ControlMessage_Format1, tablerecord),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRT_TableRecord,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"tablerecord"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_ControlMessage_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* tablerecord */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_ControlMessage_Format1_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_ControlMessage_Format1),
+	offsetof(struct E2SM_gNB_NRT_ControlMessage_Format1, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_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_gNB_NRT_ControlMessage_Format1 = {
+	"E2SM-gNB-NRT-ControlMessage-Format1",
+	"E2SM-gNB-NRT-ControlMessage-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_ControlMessage_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_ControlMessage_Format1_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlMessage-Format1.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_ControlMessage_Format1_H_
+#define	_E2SM_gNB_NRT_ControlMessage_Format1_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NRT-TableRecord.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-gNB-NRT-ControlMessage-Format1 */
+typedef struct E2SM_gNB_NRT_ControlMessage_Format1 {
+	NRT_TableRecord_t	 tablerecord;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_gNB_NRT_ControlMessage_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_ControlMessage_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_ControlMessage_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_ControlMessage_Format1_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlMessage.c

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-ControlMessage.h"
+
+#include "E2SM-gNB-NRT-ControlMessage-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_gNB_NRT_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_gNB_NRT_ControlMessage_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_gNB_NRT_ControlMessage, choice.controlMessage_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_gNB_NRT_ControlMessage_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"controlMessage-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_ControlMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* controlMessage-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_gNB_NRT_ControlMessage_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_ControlMessage),
+	offsetof(struct E2SM_gNB_NRT_ControlMessage, _asn_ctx),
+	offsetof(struct E2SM_gNB_NRT_ControlMessage, present),
+	sizeof(((struct E2SM_gNB_NRT_ControlMessage *)0)->present),
+	asn_MAP_E2SM_gNB_NRT_ControlMessage_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ControlMessage = {
+	"E2SM-gNB-NRT-ControlMessage",
+	"E2SM-gNB-NRT-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_gNB_NRT_ControlMessage_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_gNB_NRT_ControlMessage_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_ControlMessage_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-ControlMessage.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_ControlMessage_H_
+#define	_E2SM_gNB_NRT_ControlMessage_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_gNB_NRT_ControlMessage_PR {
+	E2SM_gNB_NRT_ControlMessage_PR_NOTHING,	/* No components present */
+	E2SM_gNB_NRT_ControlMessage_PR_controlMessage_Format1
+	/* Extensions may appear below */
+	
+} E2SM_gNB_NRT_ControlMessage_PR;
+
+/* Forward declarations */
+struct E2SM_gNB_NRT_ControlMessage_Format1;
+
+/* E2SM-gNB-NRT-ControlMessage */
+typedef struct E2SM_gNB_NRT_ControlMessage {
+	E2SM_gNB_NRT_ControlMessage_PR present;
+	union E2SM_gNB_NRT_ControlMessage_u {
+		struct E2SM_gNB_NRT_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_gNB_NRT_ControlMessage_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_ControlMessage;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_ControlMessage_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-EventTriggerDefinition-Format1.c

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-EventTriggerDefinition-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_EventTriggerDefinition_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_EventTriggerDefinition_Format1, triggerNature),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRT_TriggerNature,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"triggerNature"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* triggerNature */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_EventTriggerDefinition_Format1_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_EventTriggerDefinition_Format1),
+	offsetof(struct E2SM_gNB_NRT_EventTriggerDefinition_Format1, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_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_gNB_NRT_EventTriggerDefinition_Format1 = {
+	"E2SM-gNB-NRT-EventTriggerDefinition-Format1",
+	"E2SM-gNB-NRT-EventTriggerDefinition-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_EventTriggerDefinition_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_EventTriggerDefinition_Format1_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-EventTriggerDefinition-Format1.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_EventTriggerDefinition_Format1_H_
+#define	_E2SM_gNB_NRT_EventTriggerDefinition_Format1_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NRT-TriggerNature.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-gNB-NRT-EventTriggerDefinition-Format1 */
+typedef struct E2SM_gNB_NRT_EventTriggerDefinition_Format1 {
+	NRT_TriggerNature_t	 triggerNature;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_gNB_NRT_EventTriggerDefinition_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_EventTriggerDefinition_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_EventTriggerDefinition_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_EventTriggerDefinition_Format1_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-EventTriggerDefinition.c

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-EventTriggerDefinition.h"
+
+#include "E2SM-gNB-NRT-EventTriggerDefinition-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_gNB_NRT_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_gNB_NRT_EventTriggerDefinition_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_gNB_NRT_EventTriggerDefinition, choice.eventDefinition_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"eventDefinition-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_EventTriggerDefinition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* eventDefinition-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_gNB_NRT_EventTriggerDefinition_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_EventTriggerDefinition),
+	offsetof(struct E2SM_gNB_NRT_EventTriggerDefinition, _asn_ctx),
+	offsetof(struct E2SM_gNB_NRT_EventTriggerDefinition, present),
+	sizeof(((struct E2SM_gNB_NRT_EventTriggerDefinition *)0)->present),
+	asn_MAP_E2SM_gNB_NRT_EventTriggerDefinition_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition = {
+	"E2SM-gNB-NRT-EventTriggerDefinition",
+	"E2SM-gNB-NRT-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_gNB_NRT_EventTriggerDefinition_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_gNB_NRT_EventTriggerDefinition_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_EventTriggerDefinition_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-EventTriggerDefinition.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_EventTriggerDefinition_H_
+#define	_E2SM_gNB_NRT_EventTriggerDefinition_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_gNB_NRT_EventTriggerDefinition_PR {
+	E2SM_gNB_NRT_EventTriggerDefinition_PR_NOTHING,	/* No components present */
+	E2SM_gNB_NRT_EventTriggerDefinition_PR_eventDefinition_Format1
+	/* Extensions may appear below */
+	
+} E2SM_gNB_NRT_EventTriggerDefinition_PR;
+
+/* Forward declarations */
+struct E2SM_gNB_NRT_EventTriggerDefinition_Format1;
+
+/* E2SM-gNB-NRT-EventTriggerDefinition */
+typedef struct E2SM_gNB_NRT_EventTriggerDefinition {
+	E2SM_gNB_NRT_EventTriggerDefinition_PR present;
+	union E2SM_gNB_NRT_EventTriggerDefinition_u {
+		struct E2SM_gNB_NRT_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_gNB_NRT_EventTriggerDefinition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_EventTriggerDefinition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_EventTriggerDefinition_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationHeader-Format1.c

@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-IndicationHeader-Format1.h"
+
+asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_IndicationHeader_Format1_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct E2SM_gNB_NRT_IndicationHeader_Format1, timestamp),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRT_TimeStamp,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"timestamp"
+		},
+};
+static const int asn_MAP_E2SM_gNB_NRT_IndicationHeader_Format1_oms_1[] = { 0 };
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_IndicationHeader_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* timestamp */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_IndicationHeader_Format1_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_IndicationHeader_Format1),
+	offsetof(struct E2SM_gNB_NRT_IndicationHeader_Format1, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_IndicationHeader_Format1_tag2el_1,
+	1,	/* Count of tags in the map */
+	asn_MAP_E2SM_gNB_NRT_IndicationHeader_Format1_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1 = {
+	"E2SM-gNB-NRT-IndicationHeader-Format1",
+	"E2SM-gNB-NRT-IndicationHeader-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_IndicationHeader_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_IndicationHeader_Format1_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationHeader-Format1.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_IndicationHeader_Format1_H_
+#define	_E2SM_gNB_NRT_IndicationHeader_Format1_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NRT-TimeStamp.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* E2SM-gNB-NRT-IndicationHeader-Format1 */
+typedef struct E2SM_gNB_NRT_IndicationHeader_Format1 {
+	NRT_TimeStamp_t	*timestamp;	/* OPTIONAL */
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_gNB_NRT_IndicationHeader_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_IndicationHeader_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_IndicationHeader_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_IndicationHeader_Format1_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationHeader.c

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-IndicationHeader.h"
+
+#include "E2SM-gNB-NRT-IndicationHeader-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_gNB_NRT_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_gNB_NRT_IndicationHeader_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_gNB_NRT_IndicationHeader, choice.indicationHeader_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_gNB_NRT_IndicationHeader_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"indicationHeader-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_IndicationHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* indicationHeader-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_gNB_NRT_IndicationHeader_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_IndicationHeader),
+	offsetof(struct E2SM_gNB_NRT_IndicationHeader, _asn_ctx),
+	offsetof(struct E2SM_gNB_NRT_IndicationHeader, present),
+	sizeof(((struct E2SM_gNB_NRT_IndicationHeader *)0)->present),
+	asn_MAP_E2SM_gNB_NRT_IndicationHeader_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationHeader = {
+	"E2SM-gNB-NRT-IndicationHeader",
+	"E2SM-gNB-NRT-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_gNB_NRT_IndicationHeader_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_gNB_NRT_IndicationHeader_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_IndicationHeader_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationHeader.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_IndicationHeader_H_
+#define	_E2SM_gNB_NRT_IndicationHeader_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_gNB_NRT_IndicationHeader_PR {
+	E2SM_gNB_NRT_IndicationHeader_PR_NOTHING,	/* No components present */
+	E2SM_gNB_NRT_IndicationHeader_PR_indicationHeader_Format1
+	/* Extensions may appear below */
+	
+} E2SM_gNB_NRT_IndicationHeader_PR;
+
+/* Forward declarations */
+struct E2SM_gNB_NRT_IndicationHeader_Format1;
+
+/* E2SM-gNB-NRT-IndicationHeader */
+typedef struct E2SM_gNB_NRT_IndicationHeader {
+	E2SM_gNB_NRT_IndicationHeader_PR present;
+	union E2SM_gNB_NRT_IndicationHeader_u {
+		struct E2SM_gNB_NRT_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_gNB_NRT_IndicationHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_IndicationHeader_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationMessage-Format1.c

@@ -0,0 +1,142 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-IndicationMessage-Format1.h"
+
+#include "NRT-Record-List-item.h"
+static int
+memb_nrt_Record_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 <= 16384)) {
+		/* 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_nrt_Record_List_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 14,  14,  1,  16384 }	/* (SIZE(1..16384)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_nrt_Record_List_constr_2 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 14,  14,  1,  16384 }	/* (SIZE(1..16384)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_nrt_Record_List_2[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_NRT_Record_List_item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_nrt_Record_List_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_nrt_Record_List_specs_2 = {
+	sizeof(struct E2SM_gNB_NRT_IndicationMessage_Format1__nrt_Record_List),
+	offsetof(struct E2SM_gNB_NRT_IndicationMessage_Format1__nrt_Record_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_nrt_Record_List_2 = {
+	"nrt-Record-List",
+	"nrt-Record-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_nrt_Record_List_tags_2,
+	sizeof(asn_DEF_nrt_Record_List_tags_2)
+		/sizeof(asn_DEF_nrt_Record_List_tags_2[0]) - 1, /* 1 */
+	asn_DEF_nrt_Record_List_tags_2,	/* Same as above */
+	sizeof(asn_DEF_nrt_Record_List_tags_2)
+		/sizeof(asn_DEF_nrt_Record_List_tags_2[0]), /* 2 */
+	{ 0, &asn_PER_type_nrt_Record_List_constr_2, SEQUENCE_OF_constraint },
+	asn_MBR_nrt_Record_List_2,
+	1,	/* Single element */
+	&asn_SPC_nrt_Record_List_specs_2	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_IndicationMessage_Format1_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_IndicationMessage_Format1, nrt_Record_List),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_nrt_Record_List_2,
+		0,
+		{ 0, &asn_PER_memb_nrt_Record_List_constr_2,  memb_nrt_Record_List_constraint_1 },
+		0, 0, /* No default value */
+		"nrt-Record-List"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_IndicationMessage_Format1_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* nrt-Record-List */
+};
+asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_IndicationMessage_Format1_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_IndicationMessage_Format1),
+	offsetof(struct E2SM_gNB_NRT_IndicationMessage_Format1, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_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_gNB_NRT_IndicationMessage_Format1 = {
+	"E2SM-gNB-NRT-IndicationMessage-Format1",
+	"E2SM-gNB-NRT-IndicationMessage-Format1",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_IndicationMessage_Format1_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_IndicationMessage_Format1_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationMessage-Format1.h

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_IndicationMessage_Format1_H_
+#define	_E2SM_gNB_NRT_IndicationMessage_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 NRT_Record_List_item;
+
+/* E2SM-gNB-NRT-IndicationMessage-Format1 */
+typedef struct E2SM_gNB_NRT_IndicationMessage_Format1 {
+	struct E2SM_gNB_NRT_IndicationMessage_Format1__nrt_Record_List {
+		A_SEQUENCE_OF(struct NRT_Record_List_item) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} nrt_Record_List;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_gNB_NRT_IndicationMessage_Format1_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1;
+extern asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_IndicationMessage_Format1_specs_1;
+extern asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_IndicationMessage_Format1_1[1];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_IndicationMessage_Format1_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationMessage.c

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-IndicationMessage.h"
+
+#include "E2SM-gNB-NRT-IndicationMessage-Format1.h"
+static asn_per_constraints_t asn_PER_type_E2SM_gNB_NRT_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_gNB_NRT_IndicationMessage_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct E2SM_gNB_NRT_IndicationMessage, choice.indicationMessage_Format1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_E2SM_gNB_NRT_IndicationMessage_Format1,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"indicationMessage-Format1"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_IndicationMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* indicationMessage-Format1 */
+};
+static asn_CHOICE_specifics_t asn_SPC_E2SM_gNB_NRT_IndicationMessage_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_IndicationMessage),
+	offsetof(struct E2SM_gNB_NRT_IndicationMessage, _asn_ctx),
+	offsetof(struct E2SM_gNB_NRT_IndicationMessage, present),
+	sizeof(((struct E2SM_gNB_NRT_IndicationMessage *)0)->present),
+	asn_MAP_E2SM_gNB_NRT_IndicationMessage_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0,
+	1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationMessage = {
+	"E2SM-gNB-NRT-IndicationMessage",
+	"E2SM-gNB-NRT-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_gNB_NRT_IndicationMessage_constr_1, CHOICE_constraint },
+	asn_MBR_E2SM_gNB_NRT_IndicationMessage_1,
+	1,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_IndicationMessage_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-IndicationMessage.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_IndicationMessage_H_
+#define	_E2SM_gNB_NRT_IndicationMessage_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum E2SM_gNB_NRT_IndicationMessage_PR {
+	E2SM_gNB_NRT_IndicationMessage_PR_NOTHING,	/* No components present */
+	E2SM_gNB_NRT_IndicationMessage_PR_indicationMessage_Format1
+	/* Extensions may appear below */
+	
+} E2SM_gNB_NRT_IndicationMessage_PR;
+
+/* Forward declarations */
+struct E2SM_gNB_NRT_IndicationMessage_Format1;
+
+/* E2SM-gNB-NRT-IndicationMessage */
+typedef struct E2SM_gNB_NRT_IndicationMessage {
+	E2SM_gNB_NRT_IndicationMessage_PR present;
+	union E2SM_gNB_NRT_IndicationMessage_u {
+		struct E2SM_gNB_NRT_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_gNB_NRT_IndicationMessage_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_IndicationMessage;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_IndicationMessage_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.c

@@ -0,0 +1,490 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "E2SM-gNB-NRT-RANfunction-Definition.h"
+
+#include "RIC-EventTriggerStyle-List.h"
+#include "RIC-ReportStyle-List.h"
+#include "RIC-InsertStyle-List.h"
+#include "RIC-ControlStyle-List.h"
+#include "RIC-PolicyStyle-List.h"
+static int
+memb_ric_EventTriggerStyle_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 <= 63)) {
+		/* 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 int
+memb_ric_ReportStyle_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 <= 63)) {
+		/* 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 int
+memb_ric_InsertStyle_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 <= 63)) {
+		/* 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 int
+memb_ric_ControlStyle_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 <= 63)) {
+		/* 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 int
+memb_ric_PolicyStyle_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 <= 63)) {
+		/* 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_ric_EventTriggerStyle_List_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_type_ric_ReportStyle_List_constr_5 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_type_ric_InsertStyle_List_constr_7 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_type_ric_ControlStyle_List_constr_9 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_type_ric_PolicyStyle_List_constr_11 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_ric_EventTriggerStyle_List_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_ric_ReportStyle_List_constr_5 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_ric_InsertStyle_List_constr_7 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_ric_ControlStyle_List_constr_9 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_ric_PolicyStyle_List_constr_11 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 6,  6,  1,  63 }	/* (SIZE(1..63)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_ric_EventTriggerStyle_List_3[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RIC_EventTriggerStyle_List,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_EventTriggerStyle_List_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_EventTriggerStyle_List_specs_3 = {
+	sizeof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_EventTriggerStyle_List),
+	offsetof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_EventTriggerStyle_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_EventTriggerStyle_List_3 = {
+	"ric-EventTriggerStyle-List",
+	"ric-EventTriggerStyle-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_EventTriggerStyle_List_tags_3,
+	sizeof(asn_DEF_ric_EventTriggerStyle_List_tags_3)
+		/sizeof(asn_DEF_ric_EventTriggerStyle_List_tags_3[0]) - 1, /* 1 */
+	asn_DEF_ric_EventTriggerStyle_List_tags_3,	/* Same as above */
+	sizeof(asn_DEF_ric_EventTriggerStyle_List_tags_3)
+		/sizeof(asn_DEF_ric_EventTriggerStyle_List_tags_3[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_EventTriggerStyle_List_constr_3, SEQUENCE_OF_constraint },
+	asn_MBR_ric_EventTriggerStyle_List_3,
+	1,	/* Single element */
+	&asn_SPC_ric_EventTriggerStyle_List_specs_3	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_ric_ReportStyle_List_5[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RIC_ReportStyle_List,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_ReportStyle_List_tags_5[] = {
+	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_ReportStyle_List_specs_5 = {
+	sizeof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_ReportStyle_List),
+	offsetof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_ReportStyle_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_ReportStyle_List_5 = {
+	"ric-ReportStyle-List",
+	"ric-ReportStyle-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_ReportStyle_List_tags_5,
+	sizeof(asn_DEF_ric_ReportStyle_List_tags_5)
+		/sizeof(asn_DEF_ric_ReportStyle_List_tags_5[0]) - 1, /* 1 */
+	asn_DEF_ric_ReportStyle_List_tags_5,	/* Same as above */
+	sizeof(asn_DEF_ric_ReportStyle_List_tags_5)
+		/sizeof(asn_DEF_ric_ReportStyle_List_tags_5[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_ReportStyle_List_constr_5, SEQUENCE_OF_constraint },
+	asn_MBR_ric_ReportStyle_List_5,
+	1,	/* Single element */
+	&asn_SPC_ric_ReportStyle_List_specs_5	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_ric_InsertStyle_List_7[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RIC_InsertStyle_List,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_InsertStyle_List_tags_7[] = {
+	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_InsertStyle_List_specs_7 = {
+	sizeof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_InsertStyle_List),
+	offsetof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_InsertStyle_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_InsertStyle_List_7 = {
+	"ric-InsertStyle-List",
+	"ric-InsertStyle-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_InsertStyle_List_tags_7,
+	sizeof(asn_DEF_ric_InsertStyle_List_tags_7)
+		/sizeof(asn_DEF_ric_InsertStyle_List_tags_7[0]) - 1, /* 1 */
+	asn_DEF_ric_InsertStyle_List_tags_7,	/* Same as above */
+	sizeof(asn_DEF_ric_InsertStyle_List_tags_7)
+		/sizeof(asn_DEF_ric_InsertStyle_List_tags_7[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_InsertStyle_List_constr_7, SEQUENCE_OF_constraint },
+	asn_MBR_ric_InsertStyle_List_7,
+	1,	/* Single element */
+	&asn_SPC_ric_InsertStyle_List_specs_7	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_ric_ControlStyle_List_9[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RIC_ControlStyle_List,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_ControlStyle_List_tags_9[] = {
+	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_ControlStyle_List_specs_9 = {
+	sizeof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_ControlStyle_List),
+	offsetof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_ControlStyle_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_ControlStyle_List_9 = {
+	"ric-ControlStyle-List",
+	"ric-ControlStyle-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_ControlStyle_List_tags_9,
+	sizeof(asn_DEF_ric_ControlStyle_List_tags_9)
+		/sizeof(asn_DEF_ric_ControlStyle_List_tags_9[0]) - 1, /* 1 */
+	asn_DEF_ric_ControlStyle_List_tags_9,	/* Same as above */
+	sizeof(asn_DEF_ric_ControlStyle_List_tags_9)
+		/sizeof(asn_DEF_ric_ControlStyle_List_tags_9[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_ControlStyle_List_constr_9, SEQUENCE_OF_constraint },
+	asn_MBR_ric_ControlStyle_List_9,
+	1,	/* Single element */
+	&asn_SPC_ric_ControlStyle_List_specs_9	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_ric_PolicyStyle_List_11[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RIC_PolicyStyle_List,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_PolicyStyle_List_tags_11[] = {
+	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_PolicyStyle_List_specs_11 = {
+	sizeof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_PolicyStyle_List),
+	offsetof(struct E2SM_gNB_NRT_RANfunction_Definition__ric_PolicyStyle_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_PolicyStyle_List_11 = {
+	"ric-PolicyStyle-List",
+	"ric-PolicyStyle-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_PolicyStyle_List_tags_11,
+	sizeof(asn_DEF_ric_PolicyStyle_List_tags_11)
+		/sizeof(asn_DEF_ric_PolicyStyle_List_tags_11[0]) - 1, /* 1 */
+	asn_DEF_ric_PolicyStyle_List_tags_11,	/* Same as above */
+	sizeof(asn_DEF_ric_PolicyStyle_List_tags_11)
+		/sizeof(asn_DEF_ric_PolicyStyle_List_tags_11[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_PolicyStyle_List_constr_11, SEQUENCE_OF_constraint },
+	asn_MBR_ric_PolicyStyle_List_11,
+	1,	/* Single element */
+	&asn_SPC_ric_PolicyStyle_List_specs_11	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_E2SM_gNB_NRT_RANfunction_Definition_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, ranFunction_Name),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RANfunction_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranFunction-Name"
+		},
+	{ ATF_POINTER, 5, offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, ric_EventTriggerStyle_List),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		0,
+		&asn_DEF_ric_EventTriggerStyle_List_3,
+		0,
+		{ 0, &asn_PER_memb_ric_EventTriggerStyle_List_constr_3,  memb_ric_EventTriggerStyle_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-EventTriggerStyle-List"
+		},
+	{ ATF_POINTER, 4, offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, ric_ReportStyle_List),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		0,
+		&asn_DEF_ric_ReportStyle_List_5,
+		0,
+		{ 0, &asn_PER_memb_ric_ReportStyle_List_constr_5,  memb_ric_ReportStyle_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-ReportStyle-List"
+		},
+	{ ATF_POINTER, 3, offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, ric_InsertStyle_List),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		0,
+		&asn_DEF_ric_InsertStyle_List_7,
+		0,
+		{ 0, &asn_PER_memb_ric_InsertStyle_List_constr_7,  memb_ric_InsertStyle_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-InsertStyle-List"
+		},
+	{ ATF_POINTER, 2, offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, ric_ControlStyle_List),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		0,
+		&asn_DEF_ric_ControlStyle_List_9,
+		0,
+		{ 0, &asn_PER_memb_ric_ControlStyle_List_constr_9,  memb_ric_ControlStyle_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-ControlStyle-List"
+		},
+	{ ATF_POINTER, 1, offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, ric_PolicyStyle_List),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		0,
+		&asn_DEF_ric_PolicyStyle_List_11,
+		0,
+		{ 0, &asn_PER_memb_ric_PolicyStyle_List_constr_11,  memb_ric_PolicyStyle_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-PolicyStyle-List"
+		},
+};
+static const int asn_MAP_E2SM_gNB_NRT_RANfunction_Definition_oms_1[] = { 1, 2, 3, 4, 5 };
+static const ber_tlv_tag_t asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_E2SM_gNB_NRT_RANfunction_Definition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ranFunction-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ric-EventTriggerStyle-List */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ric-ReportStyle-List */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* ric-InsertStyle-List */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ric-ControlStyle-List */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 } /* ric-PolicyStyle-List */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_E2SM_gNB_NRT_RANfunction_Definition_specs_1 = {
+	sizeof(struct E2SM_gNB_NRT_RANfunction_Definition),
+	offsetof(struct E2SM_gNB_NRT_RANfunction_Definition, _asn_ctx),
+	asn_MAP_E2SM_gNB_NRT_RANfunction_Definition_tag2el_1,
+	6,	/* Count of tags in the map */
+	asn_MAP_E2SM_gNB_NRT_RANfunction_Definition_oms_1,	/* Optional members */
+	5, 0,	/* Root/Additions */
+	6,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_RANfunction_Definition = {
+	"E2SM-gNB-NRT-RANfunction-Definition",
+	"E2SM-gNB-NRT-RANfunction-Definition",
+	&asn_OP_SEQUENCE,
+	asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1,
+	sizeof(asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1[0]), /* 1 */
+	asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1)
+		/sizeof(asn_DEF_E2SM_gNB_NRT_RANfunction_Definition_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_E2SM_gNB_NRT_RANfunction_Definition_1,
+	6,	/* Elements count */
+	&asn_SPC_E2SM_gNB_NRT_RANfunction_Definition_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h

@@ -0,0 +1,99 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_E2SM_gNB_NRT_RANfunction_Definition_H_
+#define	_E2SM_gNB_NRT_RANfunction_Definition_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RANfunction-Name.h"
+#include "asn_SEQUENCE_OF.h"
+#include "constr_SEQUENCE_OF.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct RIC_EventTriggerStyle_List;
+struct RIC_ReportStyle_List;
+struct RIC_InsertStyle_List;
+struct RIC_ControlStyle_List;
+struct RIC_PolicyStyle_List;
+
+/* E2SM-gNB-NRT-RANfunction-Definition */
+typedef struct E2SM_gNB_NRT_RANfunction_Definition {
+	RANfunction_Name_t	 ranFunction_Name;
+	struct E2SM_gNB_NRT_RANfunction_Definition__ric_EventTriggerStyle_List {
+		A_SEQUENCE_OF(struct RIC_EventTriggerStyle_List) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ric_EventTriggerStyle_List;
+	struct E2SM_gNB_NRT_RANfunction_Definition__ric_ReportStyle_List {
+		A_SEQUENCE_OF(struct RIC_ReportStyle_List) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ric_ReportStyle_List;
+	struct E2SM_gNB_NRT_RANfunction_Definition__ric_InsertStyle_List {
+		A_SEQUENCE_OF(struct RIC_InsertStyle_List) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ric_InsertStyle_List;
+	struct E2SM_gNB_NRT_RANfunction_Definition__ric_ControlStyle_List {
+		A_SEQUENCE_OF(struct RIC_ControlStyle_List) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ric_ControlStyle_List;
+	struct E2SM_gNB_NRT_RANfunction_Definition__ric_PolicyStyle_List {
+		A_SEQUENCE_OF(struct RIC_PolicyStyle_List) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ric_PolicyStyle_List;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} E2SM_gNB_NRT_RANfunction_Definition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_E2SM_gNB_NRT_RANfunction_Definition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _E2SM_gNB_NRT_RANfunction_Definition_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/ECGI.c

@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "ECGI.h"
+
+asn_TYPE_member_t asn_MBR_ECGI_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ECGI, 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 ECGI, eUTRANcellIdentifier),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_EUTRANCellIdentifier,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"eUTRANcellIdentifier"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ECGI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_ECGI_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMN-Identity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* eUTRANcellIdentifier */
+};
+asn_SEQUENCE_specifics_t asn_SPC_ECGI_specs_1 = {
+	sizeof(struct ECGI),
+	offsetof(struct ECGI, _asn_ctx),
+	asn_MAP_ECGI_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_ECGI = {
+	"ECGI",
+	"ECGI",
+	&asn_OP_SEQUENCE,
+	asn_DEF_ECGI_tags_1,
+	sizeof(asn_DEF_ECGI_tags_1)
+		/sizeof(asn_DEF_ECGI_tags_1[0]), /* 1 */
+	asn_DEF_ECGI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ECGI_tags_1)
+		/sizeof(asn_DEF_ECGI_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_ECGI_1,
+	2,	/* Elements count */
+	&asn_SPC_ECGI_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/ECGI.h

@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_ECGI_H_
+#define	_ECGI_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include "EUTRANCellIdentifier.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ECGI */
+typedef struct ECGI {
+	PLMN_Identity_t	 pLMN_Identity;
+	EUTRANCellIdentifier_t	 eUTRANcellIdentifier;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ECGI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ECGI;
+extern asn_SEQUENCE_specifics_t asn_SPC_ECGI_specs_1;
+extern asn_TYPE_member_t asn_MBR_ECGI_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ECGI_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/EUTRANCellIdentifier.c

@@ -0,0 +1,85 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "EUTRANCellIdentifier.h"
+
+int
+EUTRANCellIdentifier_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;
+	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;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_EUTRANCellIdentifier_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  28,  28 }	/* (SIZE(28..28)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_EUTRANCellIdentifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_EUTRANCellIdentifier = {
+	"EUTRANCellIdentifier",
+	"EUTRANCellIdentifier",
+	&asn_OP_BIT_STRING,
+	asn_DEF_EUTRANCellIdentifier_tags_1,
+	sizeof(asn_DEF_EUTRANCellIdentifier_tags_1)
+		/sizeof(asn_DEF_EUTRANCellIdentifier_tags_1[0]), /* 1 */
+	asn_DEF_EUTRANCellIdentifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EUTRANCellIdentifier_tags_1)
+		/sizeof(asn_DEF_EUTRANCellIdentifier_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_EUTRANCellIdentifier_constr_1, EUTRANCellIdentifier_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_BIT_STRING_specs	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/EUTRANCellIdentifier.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_EUTRANCellIdentifier_H_
+#define	_EUTRANCellIdentifier_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "BIT_STRING.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* EUTRANCellIdentifier */
+typedef BIT_STRING_t	 EUTRANCellIdentifier_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_EUTRANCellIdentifier_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_EUTRANCellIdentifier;
+asn_struct_free_f EUTRANCellIdentifier_free;
+asn_struct_print_f EUTRANCellIdentifier_print;
+asn_constr_check_f EUTRANCellIdentifier_constraint;
+ber_type_decoder_f EUTRANCellIdentifier_decode_ber;
+der_type_encoder_f EUTRANCellIdentifier_encode_der;
+xer_type_decoder_f EUTRANCellIdentifier_decode_xer;
+xer_type_encoder_f EUTRANCellIdentifier_encode_xer;
+per_type_decoder_f EUTRANCellIdentifier_decode_uper;
+per_type_encoder_f EUTRANCellIdentifier_encode_uper;
+per_type_decoder_f EUTRANCellIdentifier_decode_aper;
+per_type_encoder_f EUTRANCellIdentifier_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _EUTRANCellIdentifier_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/INTEGER.h

@@ -0,0 +1,108 @@
+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_INTEGER_H_
+#define	_INTEGER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+extern asn_TYPE_operation_t asn_OP_INTEGER;
+
+/* Map with <tag> to integer value association */
+typedef struct asn_INTEGER_enum_map_s {
+	long		 nat_value;	/* associated native integer value */
+	size_t		 enum_len;	/* strlen("tag") */
+	const char	*enum_name;	/* "tag" */
+} asn_INTEGER_enum_map_t;
+
+/* This type describes an enumeration for INTEGER and ENUMERATED types */
+typedef struct asn_INTEGER_specifics_s {
+	const asn_INTEGER_enum_map_t *value2enum;	/* N -> "tag"; sorted by N */
+	const unsigned int *enum2value;		/* "tag" => N; sorted by tag */
+	int map_count;				/* Elements in either map */
+	int extension;				/* This map is extensible */
+	int strict_enumeration;			/* Enumeration set is fixed */
+	int field_width;			/* Size of native integer */
+	int field_unsigned;			/* Signed=0, unsigned=1 */
+} asn_INTEGER_specifics_t;
+
+#define INTEGER_free    ASN__PRIMITIVE_TYPE_free
+#define INTEGER_decode_ber	ber_decode_primitive
+#define INTEGER_constraint	asn_generic_no_constraint
+asn_struct_print_f INTEGER_print;
+asn_struct_compare_f INTEGER_compare;
+der_type_encoder_f INTEGER_encode_der;
+xer_type_decoder_f INTEGER_decode_xer;
+xer_type_encoder_f INTEGER_encode_xer;
+oer_type_decoder_f INTEGER_decode_oer;
+oer_type_encoder_f INTEGER_encode_oer;
+per_type_decoder_f INTEGER_decode_uper;
+per_type_encoder_f INTEGER_encode_uper;
+per_type_decoder_f INTEGER_decode_aper;
+per_type_encoder_f INTEGER_encode_aper;
+asn_random_fill_f  INTEGER_random_fill;
+
+/***********************************
+ * Some handy conversion routines. *
+ ***********************************/
+
+/*
+ * Natiwe size-independent conversion of native integers to/from INTEGER.
+ * (l_size) is in bytes.
+ * Returns 0 if it was possible to convert, -1 otherwise.
+ * -1/EINVAL: Mandatory argument missing
+ * -1/ERANGE: Value encoded is out of range for long representation
+ * -1/ENOMEM: Memory allocation failed (in asn_*2INTEGER()).
+ */
+int asn_INTEGER2imax(const INTEGER_t *i, intmax_t *l);
+int asn_INTEGER2umax(const INTEGER_t *i, uintmax_t *l);
+int asn_imax2INTEGER(INTEGER_t *i, intmax_t l);
+int asn_umax2INTEGER(INTEGER_t *i, uintmax_t l);
+
+/*
+ * Size-specific conversion helpers.
+ */
+int asn_INTEGER2long(const INTEGER_t *i, long *l);
+int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long *l);
+int asn_long2INTEGER(INTEGER_t *i, long l);
+int asn_ulong2INTEGER(INTEGER_t *i, unsigned long l);
+int asn_int642INTEGER(INTEGER_t *i, int64_t l);
+int asn_uint642INTEGER(INTEGER_t *i, uint64_t l);
+
+/* A version of strtol/strtoimax(3) with nicer error reporting. */
+enum asn_strtox_result_e {
+    ASN_STRTOX_ERROR_RANGE = -3,  /* Input outside of supported numeric range */
+    ASN_STRTOX_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOX_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOX_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOX_EXTRA_DATA  =  1   /* Conversion succeded, but the string has extra stuff */
+};
+enum asn_strtox_result_e asn_strtol_lim(const char *str, const char **end,
+                                        long *l);
+enum asn_strtox_result_e asn_strtoul_lim(const char *str, const char **end,
+                                         unsigned long *l);
+enum asn_strtox_result_e asn_strtoimax_lim(const char *str, const char **end,
+                                           intmax_t *l);
+enum asn_strtox_result_e asn_strtoumax_lim(const char *str, const char **end,
+                                           uintmax_t *l);
+
+/*
+ * Convert the integer value into the corresponding enumeration map entry.
+ */
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(
+    const asn_INTEGER_specifics_t *specs, long value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _INTEGER_H_ */

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/Makefile.am.asn1convert

@@ -0,0 +1,14 @@
+include ./Makefile.am.libasncodec
+
+bin_PROGRAMS += asn1convert
+asn1convert_CFLAGS = $(ASN_MODULE_CFLAGS) -DASN_PDU_COLLECTION 
+asn1convert_CPPFLAGS = -I$(top_srcdir)/./
+asn1convert_LDADD = libasncodec.la
+asn1convert_SOURCES = \
+	./converter-example.c\
+	./pdu_collection.c
+regen: regenerate-from-asn1-source
+
+regenerate-from-asn1-source:
+	asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D. ../asnTextFiles/e2sm-gNB-NRT-v401.asn
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/Makefile.am.libasncodec

@@ -0,0 +1,161 @@
+ASN_MODULE_SRCS=	\
+	./ECGI.c	\
+	./EUTRANCellIdentifier.c	\
+	./NRCellIdentifier.c	\
+	./NRCGI.c	\
+	./PLMN-Identity.c	\
+	./E2SM-gNB-NRT-EventTriggerDefinition.c	\
+	./E2SM-gNB-NRT-EventTriggerDefinition-Format1.c	\
+	./E2SM-gNB-NRT-ActionDefinition.c	\
+	./E2SM-gNB-NRT-ActionDefinition-Format1.c	\
+	./E2SM-gNB-NRT-IndicationHeader.c	\
+	./E2SM-gNB-NRT-IndicationHeader-Format1.c	\
+	./E2SM-gNB-NRT-IndicationMessage.c	\
+	./NRT-Record-row-item.c	\
+	./NRT-Record-List-item.c	\
+	./E2SM-gNB-NRT-IndicationMessage-Format1.c	\
+	./E2SM-gNB-NRT-ControlHeader.c	\
+	./E2SM-gNB-NRT-ControlHeader-Format1.c	\
+	./E2SM-gNB-NRT-ControlMessage.c	\
+	./E2SM-gNB-NRT-ControlMessage-Format1.c	\
+	./E2SM-gNB-NRT-RANfunction-Definition.c	\
+	./NRT-Cell-ID.c	\
+	./NRT-ControlCommand.c	\
+	./NRT-TableRecord.c	\
+	./NRT-TimeStamp.c	\
+	./NRT-TriggerNature.c	\
+	./RANfunction-Name.c	\
+	./RANparameter-Item.c	\
+	./RANparameterDef-Item.c	\
+	./RANparameter-ID.c	\
+	./RANparameter-Name.c	\
+	./RANparameter-Test.c	\
+	./RANparameter-Type.c	\
+	./RANparameter-Value.c	\
+	./RIC-ControlStyle-List.c	\
+	./RIC-EventTriggerStyle-List.c	\
+	./RIC-InsertStyle-List.c	\
+	./RIC-PolicyStyle-List.c	\
+	./RIC-ReportStyle-List.c	\
+	./RIC-Format-Type.c	\
+	./RIC-Style-Type.c	\
+	./RIC-Style-Name.c
+
+ASN_MODULE_HDRS=	\
+	./ECGI.h	\
+	./EUTRANCellIdentifier.h	\
+	./NRCellIdentifier.h	\
+	./NRCGI.h	\
+	./PLMN-Identity.h	\
+	./E2SM-gNB-NRT-EventTriggerDefinition.h	\
+	./E2SM-gNB-NRT-EventTriggerDefinition-Format1.h	\
+	./E2SM-gNB-NRT-ActionDefinition.h	\
+	./E2SM-gNB-NRT-ActionDefinition-Format1.h	\
+	./E2SM-gNB-NRT-IndicationHeader.h	\
+	./E2SM-gNB-NRT-IndicationHeader-Format1.h	\
+	./E2SM-gNB-NRT-IndicationMessage.h	\
+	./NRT-Record-row-item.h	\
+	./NRT-Record-List-item.h	\
+	./E2SM-gNB-NRT-IndicationMessage-Format1.h	\
+	./E2SM-gNB-NRT-ControlHeader.h	\
+	./E2SM-gNB-NRT-ControlHeader-Format1.h	\
+	./E2SM-gNB-NRT-ControlMessage.h	\
+	./E2SM-gNB-NRT-ControlMessage-Format1.h	\
+	./E2SM-gNB-NRT-RANfunction-Definition.h	\
+	./NRT-Cell-ID.h	\
+	./NRT-ControlCommand.h	\
+	./NRT-TableRecord.h	\
+	./NRT-TimeStamp.h	\
+	./NRT-TriggerNature.h	\
+	./RANfunction-Name.h	\
+	./RANparameter-Item.h	\
+	./RANparameterDef-Item.h	\
+	./RANparameter-ID.h	\
+	./RANparameter-Name.h	\
+	./RANparameter-Test.h	\
+	./RANparameter-Type.h	\
+	./RANparameter-Value.h	\
+	./RIC-ControlStyle-List.h	\
+	./RIC-EventTriggerStyle-List.h	\
+	./RIC-InsertStyle-List.h	\
+	./RIC-PolicyStyle-List.h	\
+	./RIC-ReportStyle-List.h	\
+	./RIC-Format-Type.h	\
+	./RIC-Style-Type.h	\
+	./RIC-Style-Name.h
+
+ASN_MODULE_HDRS+=./OPEN_TYPE.h
+ASN_MODULE_SRCS+=./OPEN_TYPE.c
+ASN_MODULE_HDRS+=./constr_CHOICE.h
+ASN_MODULE_HDRS+=./BOOLEAN.h
+ASN_MODULE_SRCS+=./BOOLEAN.c
+ASN_MODULE_HDRS+=./INTEGER.h
+ASN_MODULE_SRCS+=./INTEGER.c
+ASN_MODULE_HDRS+=./NativeEnumerated.h
+ASN_MODULE_SRCS+=./NativeEnumerated.c
+ASN_MODULE_HDRS+=./NativeInteger.h
+ASN_MODULE_SRCS+=./NativeInteger.c
+ASN_MODULE_HDRS+=./PrintableString.h
+ASN_MODULE_SRCS+=./PrintableString.c
+ASN_MODULE_HDRS+=./OCTET_STRING.h
+ASN_MODULE_HDRS+=./asn_SEQUENCE_OF.h
+ASN_MODULE_SRCS+=./asn_SEQUENCE_OF.c
+ASN_MODULE_HDRS+=./asn_SET_OF.h
+ASN_MODULE_SRCS+=./asn_SET_OF.c
+ASN_MODULE_SRCS+=./constr_CHOICE.c
+ASN_MODULE_HDRS+=./constr_SEQUENCE.h
+ASN_MODULE_SRCS+=./constr_SEQUENCE.c
+ASN_MODULE_HDRS+=./constr_SEQUENCE_OF.h
+ASN_MODULE_SRCS+=./constr_SEQUENCE_OF.c
+ASN_MODULE_HDRS+=./constr_SET_OF.h
+ASN_MODULE_SRCS+=./constr_SET_OF.c
+ASN_MODULE_HDRS+=./asn_application.h
+ASN_MODULE_SRCS+=./asn_application.c
+ASN_MODULE_HDRS+=./asn_ioc.h
+ASN_MODULE_HDRS+=./asn_system.h
+ASN_MODULE_HDRS+=./asn_codecs.h
+ASN_MODULE_HDRS+=./asn_internal.h
+ASN_MODULE_SRCS+=./asn_internal.c
+ASN_MODULE_HDRS+=./asn_random_fill.h
+ASN_MODULE_SRCS+=./asn_random_fill.c
+ASN_MODULE_HDRS+=./asn_bit_data.h
+ASN_MODULE_SRCS+=./asn_bit_data.c
+ASN_MODULE_SRCS+=./OCTET_STRING.c
+ASN_MODULE_HDRS+=./BIT_STRING.h
+ASN_MODULE_SRCS+=./BIT_STRING.c
+ASN_MODULE_SRCS+=./asn_codecs_prim.c
+ASN_MODULE_HDRS+=./asn_codecs_prim.h
+ASN_MODULE_HDRS+=./ber_tlv_length.h
+ASN_MODULE_SRCS+=./ber_tlv_length.c
+ASN_MODULE_HDRS+=./ber_tlv_tag.h
+ASN_MODULE_SRCS+=./ber_tlv_tag.c
+ASN_MODULE_HDRS+=./ber_decoder.h
+ASN_MODULE_SRCS+=./ber_decoder.c
+ASN_MODULE_HDRS+=./der_encoder.h
+ASN_MODULE_SRCS+=./der_encoder.c
+ASN_MODULE_HDRS+=./constr_TYPE.h
+ASN_MODULE_SRCS+=./constr_TYPE.c
+ASN_MODULE_HDRS+=./constraints.h
+ASN_MODULE_SRCS+=./constraints.c
+ASN_MODULE_HDRS+=./xer_support.h
+ASN_MODULE_SRCS+=./xer_support.c
+ASN_MODULE_HDRS+=./xer_decoder.h
+ASN_MODULE_SRCS+=./xer_decoder.c
+ASN_MODULE_HDRS+=./xer_encoder.h
+ASN_MODULE_SRCS+=./xer_encoder.c
+ASN_MODULE_HDRS+=./per_support.h
+ASN_MODULE_SRCS+=./per_support.c
+ASN_MODULE_HDRS+=./per_decoder.h
+ASN_MODULE_SRCS+=./per_decoder.c
+ASN_MODULE_HDRS+=./per_encoder.h
+ASN_MODULE_SRCS+=./per_encoder.c
+ASN_MODULE_HDRS+=./per_opentype.h
+ASN_MODULE_SRCS+=./per_opentype.c
+
+ASN_MODULE_CFLAGS=-DASN_DISABLE_OER_SUPPORT 
+
+lib_LTLIBRARIES+=libasncodec.la
+libasncodec_la_SOURCES=$(ASN_MODULE_SRCS) $(ASN_MODULE_HDRS)
+libasncodec_la_CPPFLAGS=-I$(top_srcdir)/./
+libasncodec_la_CFLAGS=$(ASN_MODULE_CFLAGS)
+libasncodec_la_LDFLAGS=-lm

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRCGI.c

@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRCGI.h"
+
+asn_TYPE_member_t asn_MBR_NRCGI_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct NRCGI, 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 NRCGI, nRcellIdentifier),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRCellIdentifier,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"nRcellIdentifier"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_NRCGI_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_NRCGI_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMN-Identity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* nRcellIdentifier */
+};
+asn_SEQUENCE_specifics_t asn_SPC_NRCGI_specs_1 = {
+	sizeof(struct NRCGI),
+	offsetof(struct NRCGI, _asn_ctx),
+	asn_MAP_NRCGI_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_NRCGI = {
+	"NRCGI",
+	"NRCGI",
+	&asn_OP_SEQUENCE,
+	asn_DEF_NRCGI_tags_1,
+	sizeof(asn_DEF_NRCGI_tags_1)
+		/sizeof(asn_DEF_NRCGI_tags_1[0]), /* 1 */
+	asn_DEF_NRCGI_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRCGI_tags_1)
+		/sizeof(asn_DEF_NRCGI_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_NRCGI_1,
+	2,	/* Elements count */
+	&asn_SPC_NRCGI_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRCGI.h

@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRCGI_H_
+#define	_NRCGI_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "PLMN-Identity.h"
+#include "NRCellIdentifier.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NRCGI */
+typedef struct NRCGI {
+	PLMN_Identity_t	 pLMN_Identity;
+	NRCellIdentifier_t	 nRcellIdentifier;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NRCGI_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_NRCGI;
+extern asn_SEQUENCE_specifics_t asn_SPC_NRCGI_specs_1;
+extern asn_TYPE_member_t asn_MBR_NRCGI_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRCGI_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRCellIdentifier.c

@@ -0,0 +1,85 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRCellIdentifier.h"
+
+int
+NRCellIdentifier_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;
+	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 == 36)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NRCellIdentifier_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  36,  36 }	/* (SIZE(36..36)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NRCellIdentifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NRCellIdentifier = {
+	"NRCellIdentifier",
+	"NRCellIdentifier",
+	&asn_OP_BIT_STRING,
+	asn_DEF_NRCellIdentifier_tags_1,
+	sizeof(asn_DEF_NRCellIdentifier_tags_1)
+		/sizeof(asn_DEF_NRCellIdentifier_tags_1[0]), /* 1 */
+	asn_DEF_NRCellIdentifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRCellIdentifier_tags_1)
+		/sizeof(asn_DEF_NRCellIdentifier_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NRCellIdentifier_constr_1, NRCellIdentifier_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_BIT_STRING_specs	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRCellIdentifier.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRCellIdentifier_H_
+#define	_NRCellIdentifier_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "BIT_STRING.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NRCellIdentifier */
+typedef BIT_STRING_t	 NRCellIdentifier_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NRCellIdentifier_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NRCellIdentifier;
+asn_struct_free_f NRCellIdentifier_free;
+asn_struct_print_f NRCellIdentifier_print;
+asn_constr_check_f NRCellIdentifier_constraint;
+ber_type_decoder_f NRCellIdentifier_decode_ber;
+der_type_encoder_f NRCellIdentifier_encode_der;
+xer_type_decoder_f NRCellIdentifier_decode_xer;
+xer_type_encoder_f NRCellIdentifier_encode_xer;
+per_type_decoder_f NRCellIdentifier_decode_uper;
+per_type_encoder_f NRCellIdentifier_encode_uper;
+per_type_decoder_f NRCellIdentifier_decode_aper;
+per_type_encoder_f NRCellIdentifier_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRCellIdentifier_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-Cell-ID.c

@@ -0,0 +1,82 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-Cell-ID.h"
+
+#include "ECGI.h"
+#include "NRCGI.h"
+asn_per_constraints_t asn_PER_type_NRT_Cell_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_NRT_Cell_ID_1[] = {
+	{ ATF_POINTER, 0, offsetof(struct NRT_Cell_ID, choice.ecgi),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ECGI,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ecgi"
+		},
+	{ ATF_POINTER, 0, offsetof(struct NRT_Cell_ID, choice.nrcgi),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRCGI,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"nrcgi"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_NRT_Cell_ID_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ecgi */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* nrcgi */
+};
+asn_CHOICE_specifics_t asn_SPC_NRT_Cell_ID_specs_1 = {
+	sizeof(struct NRT_Cell_ID),
+	offsetof(struct NRT_Cell_ID, _asn_ctx),
+	offsetof(struct NRT_Cell_ID, present),
+	sizeof(((struct NRT_Cell_ID *)0)->present),
+	asn_MAP_NRT_Cell_ID_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0,
+	2	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_Cell_ID = {
+	"NRT-Cell-ID",
+	"NRT-Cell-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_NRT_Cell_ID_constr_1, CHOICE_constraint },
+	asn_MBR_NRT_Cell_ID_1,
+	2,	/* Elements count */
+	&asn_SPC_NRT_Cell_ID_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-Cell-ID.h

@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_Cell_ID_H_
+#define	_NRT_Cell_ID_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum NRT_Cell_ID_PR {
+	NRT_Cell_ID_PR_NOTHING,	/* No components present */
+	NRT_Cell_ID_PR_ecgi,
+	NRT_Cell_ID_PR_nrcgi
+	/* Extensions may appear below */
+	
+} NRT_Cell_ID_PR;
+
+/* Forward declarations */
+struct ECGI;
+struct NRCGI;
+
+/* NRT-Cell-ID */
+typedef struct NRT_Cell_ID {
+	NRT_Cell_ID_PR present;
+	union NRT_Cell_ID_u {
+		struct ECGI	*ecgi;
+		struct NRCGI	*nrcgi;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NRT_Cell_ID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_NRT_Cell_ID;
+extern asn_CHOICE_specifics_t asn_SPC_NRT_Cell_ID_specs_1;
+extern asn_TYPE_member_t asn_MBR_NRT_Cell_ID_1[2];
+extern asn_per_constraints_t asn_PER_type_NRT_Cell_ID_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_Cell_ID_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-ControlCommand.c

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-ControlCommand.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NRT_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_NRT_ControlCommand_value2enum_1[] = {
+	{ 0,	8,	"addition" },
+	{ 1,	8,	"deletion" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_NRT_ControlCommand_enum2value_1[] = {
+	0,	/* addition(0) */
+	1	/* deletion(1) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_NRT_ControlCommand_specs_1 = {
+	asn_MAP_NRT_ControlCommand_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_NRT_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_NRT_ControlCommand_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_ControlCommand = {
+	"NRT-ControlCommand",
+	"NRT-ControlCommand",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_NRT_ControlCommand_tags_1,
+	sizeof(asn_DEF_NRT_ControlCommand_tags_1)
+		/sizeof(asn_DEF_NRT_ControlCommand_tags_1[0]), /* 1 */
+	asn_DEF_NRT_ControlCommand_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRT_ControlCommand_tags_1)
+		/sizeof(asn_DEF_NRT_ControlCommand_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NRT_ControlCommand_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_NRT_ControlCommand_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-ControlCommand.h

@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_ControlCommand_H_
+#define	_NRT_ControlCommand_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeEnumerated.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum NRT_ControlCommand {
+	NRT_ControlCommand_addition	= 0,
+	NRT_ControlCommand_deletion	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_NRT_ControlCommand;
+
+/* NRT-ControlCommand */
+typedef long	 NRT_ControlCommand_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NRT_ControlCommand_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NRT_ControlCommand;
+extern const asn_INTEGER_specifics_t asn_SPC_NRT_ControlCommand_specs_1;
+asn_struct_free_f NRT_ControlCommand_free;
+asn_struct_print_f NRT_ControlCommand_print;
+asn_constr_check_f NRT_ControlCommand_constraint;
+ber_type_decoder_f NRT_ControlCommand_decode_ber;
+der_type_encoder_f NRT_ControlCommand_encode_der;
+xer_type_decoder_f NRT_ControlCommand_decode_xer;
+xer_type_encoder_f NRT_ControlCommand_encode_xer;
+per_type_decoder_f NRT_ControlCommand_decode_uper;
+per_type_encoder_f NRT_ControlCommand_encode_uper;
+per_type_decoder_f NRT_ControlCommand_decode_aper;
+per_type_encoder_f NRT_ControlCommand_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_ControlCommand_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-Record-List-item.c

@@ -0,0 +1,152 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-Record-List-item.h"
+
+#include "NRT-Record-row-item.h"
+static int
+memb_nrt_Record_row_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 <= 1024)) {
+		/* 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_nrt_Record_row_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 10,  10,  1,  1024 }	/* (SIZE(1..1024)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_nrt_Record_row_constr_3 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 10,  10,  1,  1024 }	/* (SIZE(1..1024)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_nrt_Record_row_3[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_NRT_Record_row_item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_nrt_Record_row_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_nrt_Record_row_specs_3 = {
+	sizeof(struct NRT_Record_List_item__nrt_Record_row),
+	offsetof(struct NRT_Record_List_item__nrt_Record_row, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_nrt_Record_row_3 = {
+	"nrt-Record-row",
+	"nrt-Record-row",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_nrt_Record_row_tags_3,
+	sizeof(asn_DEF_nrt_Record_row_tags_3)
+		/sizeof(asn_DEF_nrt_Record_row_tags_3[0]) - 1, /* 1 */
+	asn_DEF_nrt_Record_row_tags_3,	/* Same as above */
+	sizeof(asn_DEF_nrt_Record_row_tags_3)
+		/sizeof(asn_DEF_nrt_Record_row_tags_3[0]), /* 2 */
+	{ 0, &asn_PER_type_nrt_Record_row_constr_3, SEQUENCE_OF_constraint },
+	asn_MBR_nrt_Record_row_3,
+	1,	/* Single element */
+	&asn_SPC_nrt_Record_row_specs_3	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_NRT_Record_List_item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct NRT_Record_List_item, servedCellID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_NRT_Cell_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"servedCellID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct NRT_Record_List_item, nrt_Record_row),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		0,
+		&asn_DEF_nrt_Record_row_3,
+		0,
+		{ 0, &asn_PER_memb_nrt_Record_row_constr_3,  memb_nrt_Record_row_constraint_1 },
+		0, 0, /* No default value */
+		"nrt-Record-row"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_NRT_Record_List_item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_NRT_Record_List_item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* servedCellID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* nrt-Record-row */
+};
+asn_SEQUENCE_specifics_t asn_SPC_NRT_Record_List_item_specs_1 = {
+	sizeof(struct NRT_Record_List_item),
+	offsetof(struct NRT_Record_List_item, _asn_ctx),
+	asn_MAP_NRT_Record_List_item_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_Record_List_item = {
+	"NRT-Record-List-item",
+	"NRT-Record-List-item",
+	&asn_OP_SEQUENCE,
+	asn_DEF_NRT_Record_List_item_tags_1,
+	sizeof(asn_DEF_NRT_Record_List_item_tags_1)
+		/sizeof(asn_DEF_NRT_Record_List_item_tags_1[0]), /* 1 */
+	asn_DEF_NRT_Record_List_item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRT_Record_List_item_tags_1)
+		/sizeof(asn_DEF_NRT_Record_List_item_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_NRT_Record_List_item_1,
+	2,	/* Elements count */
+	&asn_SPC_NRT_Record_List_item_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-Record-List-item.h

@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_Record_List_item_H_
+#define	_NRT_Record_List_item_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NRT-Cell-ID.h"
+#include "asn_SEQUENCE_OF.h"
+#include "constr_SEQUENCE_OF.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct NRT_Record_row_item;
+
+/* NRT-Record-List-item */
+typedef struct NRT_Record_List_item {
+	NRT_Cell_ID_t	 servedCellID;
+	struct NRT_Record_List_item__nrt_Record_row {
+		A_SEQUENCE_OF(struct NRT_Record_row_item) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} nrt_Record_row;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NRT_Record_List_item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_NRT_Record_List_item;
+extern asn_SEQUENCE_specifics_t asn_SPC_NRT_Record_List_item_specs_1;
+extern asn_TYPE_member_t asn_MBR_NRT_Record_List_item_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_Record_List_item_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-Record-row-item.c

@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-Record-row-item.h"
+
+asn_TYPE_member_t asn_MBR_NRT_Record_row_item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct NRT_Record_row_item, neighbourCellID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_NRT_Cell_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"neighbourCellID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct NRT_Record_row_item, nrt_Record),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NRT_TableRecord,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"nrt-Record"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_NRT_Record_row_item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_NRT_Record_row_item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* neighbourCellID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* nrt-Record */
+};
+asn_SEQUENCE_specifics_t asn_SPC_NRT_Record_row_item_specs_1 = {
+	sizeof(struct NRT_Record_row_item),
+	offsetof(struct NRT_Record_row_item, _asn_ctx),
+	asn_MAP_NRT_Record_row_item_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_Record_row_item = {
+	"NRT-Record-row-item",
+	"NRT-Record-row-item",
+	&asn_OP_SEQUENCE,
+	asn_DEF_NRT_Record_row_item_tags_1,
+	sizeof(asn_DEF_NRT_Record_row_item_tags_1)
+		/sizeof(asn_DEF_NRT_Record_row_item_tags_1[0]), /* 1 */
+	asn_DEF_NRT_Record_row_item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRT_Record_row_item_tags_1)
+		/sizeof(asn_DEF_NRT_Record_row_item_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_NRT_Record_row_item_1,
+	2,	/* Elements count */
+	&asn_SPC_NRT_Record_row_item_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-Record-row-item.h

@@ -0,0 +1,60 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_Record_row_item_H_
+#define	_NRT_Record_row_item_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NRT-Cell-ID.h"
+#include "NRT-TableRecord.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NRT-Record-row-item */
+typedef struct NRT_Record_row_item {
+	NRT_Cell_ID_t	 neighbourCellID;
+	NRT_TableRecord_t	 nrt_Record;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NRT_Record_row_item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_NRT_Record_row_item;
+extern asn_SEQUENCE_specifics_t asn_SPC_NRT_Record_row_item_specs_1;
+extern asn_TYPE_member_t asn_MBR_NRT_Record_row_item_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_Record_row_item_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-TableRecord.c

@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-TableRecord.h"
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static const ber_tlv_tag_t asn_DEF_NRT_TableRecord_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_TableRecord = {
+	"NRT-TableRecord",
+	"NRT-TableRecord",
+	&asn_OP_OCTET_STRING,
+	asn_DEF_NRT_TableRecord_tags_1,
+	sizeof(asn_DEF_NRT_TableRecord_tags_1)
+		/sizeof(asn_DEF_NRT_TableRecord_tags_1[0]), /* 1 */
+	asn_DEF_NRT_TableRecord_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRT_TableRecord_tags_1)
+		/sizeof(asn_DEF_NRT_TableRecord_tags_1[0]), /* 1 */
+	{ 0, 0, OCTET_STRING_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_OCTET_STRING_specs	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-TableRecord.h

@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_TableRecord_H_
+#define	_NRT_TableRecord_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "OCTET_STRING.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NRT-TableRecord */
+typedef OCTET_STRING_t	 NRT_TableRecord_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_NRT_TableRecord;
+asn_struct_free_f NRT_TableRecord_free;
+asn_struct_print_f NRT_TableRecord_print;
+asn_constr_check_f NRT_TableRecord_constraint;
+ber_type_decoder_f NRT_TableRecord_decode_ber;
+der_type_encoder_f NRT_TableRecord_encode_der;
+xer_type_decoder_f NRT_TableRecord_decode_xer;
+xer_type_encoder_f NRT_TableRecord_encode_xer;
+per_type_decoder_f NRT_TableRecord_decode_uper;
+per_type_encoder_f NRT_TableRecord_encode_uper;
+per_type_decoder_f NRT_TableRecord_decode_aper;
+per_type_encoder_f NRT_TableRecord_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_TableRecord_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-TimeStamp.c

@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-TimeStamp.h"
+
+int
+NRT_TimeStamp_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 8)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NRT_TimeStamp_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  8,  8 }	/* (SIZE(8..8)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NRT_TimeStamp_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_TimeStamp = {
+	"NRT-TimeStamp",
+	"NRT-TimeStamp",
+	&asn_OP_OCTET_STRING,
+	asn_DEF_NRT_TimeStamp_tags_1,
+	sizeof(asn_DEF_NRT_TimeStamp_tags_1)
+		/sizeof(asn_DEF_NRT_TimeStamp_tags_1[0]), /* 1 */
+	asn_DEF_NRT_TimeStamp_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRT_TimeStamp_tags_1)
+		/sizeof(asn_DEF_NRT_TimeStamp_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NRT_TimeStamp_constr_1, NRT_TimeStamp_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_OCTET_STRING_specs	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-TimeStamp.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_TimeStamp_H_
+#define	_NRT_TimeStamp_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "OCTET_STRING.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NRT-TimeStamp */
+typedef OCTET_STRING_t	 NRT_TimeStamp_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NRT_TimeStamp_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NRT_TimeStamp;
+asn_struct_free_f NRT_TimeStamp_free;
+asn_struct_print_f NRT_TimeStamp_print;
+asn_constr_check_f NRT_TimeStamp_constraint;
+ber_type_decoder_f NRT_TimeStamp_decode_ber;
+der_type_encoder_f NRT_TimeStamp_encode_der;
+xer_type_decoder_f NRT_TimeStamp_decode_xer;
+xer_type_encoder_f NRT_TimeStamp_encode_xer;
+per_type_decoder_f NRT_TimeStamp_decode_uper;
+per_type_encoder_f NRT_TimeStamp_encode_uper;
+per_type_decoder_f NRT_TimeStamp_decode_aper;
+per_type_encoder_f NRT_TimeStamp_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_TimeStamp_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-TriggerNature.c

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "NRT-TriggerNature.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NRT_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_NRT_TriggerNature_value2enum_1[] = {
+	{ 0,	3,	"now" },
+	{ 1,	8,	"onchange" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_NRT_TriggerNature_enum2value_1[] = {
+	0,	/* now(0) */
+	1	/* onchange(1) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_NRT_TriggerNature_specs_1 = {
+	asn_MAP_NRT_TriggerNature_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_NRT_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_NRT_TriggerNature_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NRT_TriggerNature = {
+	"NRT-TriggerNature",
+	"NRT-TriggerNature",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_NRT_TriggerNature_tags_1,
+	sizeof(asn_DEF_NRT_TriggerNature_tags_1)
+		/sizeof(asn_DEF_NRT_TriggerNature_tags_1[0]), /* 1 */
+	asn_DEF_NRT_TriggerNature_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NRT_TriggerNature_tags_1)
+		/sizeof(asn_DEF_NRT_TriggerNature_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NRT_TriggerNature_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_NRT_TriggerNature_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NRT-TriggerNature.h

@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_NRT_TriggerNature_H_
+#define	_NRT_TriggerNature_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeEnumerated.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum NRT_TriggerNature {
+	NRT_TriggerNature_now	= 0,
+	NRT_TriggerNature_onchange	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_NRT_TriggerNature;
+
+/* NRT-TriggerNature */
+typedef long	 NRT_TriggerNature_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NRT_TriggerNature_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NRT_TriggerNature;
+extern const asn_INTEGER_specifics_t asn_SPC_NRT_TriggerNature_specs_1;
+asn_struct_free_f NRT_TriggerNature_free;
+asn_struct_print_f NRT_TriggerNature_print;
+asn_constr_check_f NRT_TriggerNature_constraint;
+ber_type_decoder_f NRT_TriggerNature_decode_ber;
+der_type_encoder_f NRT_TriggerNature_encode_der;
+xer_type_decoder_f NRT_TriggerNature_decode_xer;
+xer_type_encoder_f NRT_TriggerNature_encode_xer;
+per_type_decoder_f NRT_TriggerNature_decode_uper;
+per_type_encoder_f NRT_TriggerNature_encode_uper;
+per_type_decoder_f NRT_TriggerNature_decode_aper;
+per_type_encoder_f NRT_TriggerNature_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NRT_TriggerNature_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NativeEnumerated.c

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

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NativeEnumerated.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard ENUMERATED in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeEnumerated_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef	_NativeEnumerated_H_
+#define	_NativeEnumerated_H_
+
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeEnumerated;
+extern asn_TYPE_operation_t asn_OP_NativeEnumerated;
+
+xer_type_encoder_f NativeEnumerated_encode_xer;
+oer_type_decoder_f NativeEnumerated_decode_oer;
+oer_type_encoder_f NativeEnumerated_encode_oer;
+per_type_decoder_f NativeEnumerated_decode_uper;
+per_type_encoder_f NativeEnumerated_encode_uper;
+per_type_decoder_f NativeEnumerated_decode_aper;
+per_type_encoder_f NativeEnumerated_encode_aper;
+
+#define NativeEnumerated_free       NativeInteger_free
+#define NativeEnumerated_print      NativeInteger_print
+#define NativeEnumerated_compare    NativeInteger_compare
+#define NativeEnumerated_random_fill NativeInteger_random_fill
+#define NativeEnumerated_constraint asn_generic_no_constraint
+#define NativeEnumerated_decode_ber NativeInteger_decode_ber
+#define NativeEnumerated_encode_der NativeInteger_encode_der
+#define NativeEnumerated_decode_xer NativeInteger_decode_xer
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NativeEnumerated_H_ */

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NativeInteger.c

@@ -0,0 +1,550 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeInteger.h>
+
+/*
+ * NativeInteger basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_operation_t asn_OP_NativeInteger = {
+	NativeInteger_free,
+	NativeInteger_print,
+	NativeInteger_compare,
+	NativeInteger_decode_ber,
+	NativeInteger_encode_der,
+	NativeInteger_decode_xer,
+	NativeInteger_encode_xer,
+#ifdef	ASN_DISABLE_OER_SUPPORT
+	0,
+	0,
+#else
+	NativeInteger_decode_oer,	/* OER decoder */
+	NativeInteger_encode_oer,	/* Canonical OER encoder */
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef	ASN_DISABLE_PER_SUPPORT
+	0,
+	0,
+	0,
+	0,
+#else
+	NativeInteger_decode_uper,	/* Unaligned PER decoder */
+	NativeInteger_encode_uper,	/* Unaligned PER encoder */
+	NativeInteger_decode_aper,	/* Aligned PER decoder */
+	NativeInteger_encode_aper,	/* Aligned PER encoder */
+#endif	/* ASN_DISABLE_PER_SUPPORT */
+	NativeInteger_random_fill,
+	0	/* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
+	"INTEGER",			/* The ASN.1 type is still INTEGER */
+	"INTEGER",
+	&asn_OP_NativeInteger,
+	asn_DEF_NativeInteger_tags,
+	sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+	asn_DEF_NativeInteger_tags,	/* Same as above */
+	sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+	{ 0, 0, asn_generic_no_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode INTEGER type.
+ */
+asn_dec_rval_t
+NativeInteger_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                         const asn_TYPE_descriptor_t *td, void **nint_ptr,
+                         const void *buf_ptr, size_t size, int tag_mode) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    long *native = (long *)*nint_ptr;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+
+	/*
+	 * If the structure is not there, allocate it.
+	 */
+	if(native == NULL) {
+		native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
+		if(native == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+			tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
+
+	/*
+	 * Make sure we have this length.
+	 */
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * ASN.1 encoded INTEGER: buf_ptr, length
+	 * Fill the native, at the same time checking for overflow.
+	 * If overflow occured, return with RC_FAIL.
+	 */
+	{
+		INTEGER_t tmp;
+		union {
+			const void *constbuf;
+			void *nonconstbuf;
+		} unconst_buf;
+		long l;
+
+		unconst_buf.constbuf = buf_ptr;
+		tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
+		tmp.size = length;
+
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmp, (unsigned long *)&l) /* sic */
+			: asn_INTEGER2long(&tmp, &l)) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+
+		*native = l;
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",
+		(long)rval.consumed, (long)length, td->name, (long)*native);
+
+	return rval;
+}
+
+/*
+ * Encode the NativeInteger using the standard INTEGER type DER encoder.
+ */
+asn_enc_rval_t
+NativeInteger_encode_der(const asn_TYPE_descriptor_t *sd, const void *ptr,
+                         int tag_mode, ber_tlv_tag_t tag,
+                         asn_app_consume_bytes_f *cb, void *app_key) {
+	unsigned long native = *(const unsigned long *)ptr; /* Disable sign ext. */
+	asn_enc_rval_t erval = {0,0,0};
+	INTEGER_t tmp;
+
+#ifdef	WORDS_BIGENDIAN		/* Opportunistic optimization */
+
+	tmp.buf = (uint8_t *)&native;
+	tmp.size = sizeof(native);
+
+#else	/* Works even if WORDS_BIGENDIAN is not set where should've been */
+	uint8_t buf[sizeof(native)];
+	uint8_t *p;
+
+	/* Prepare a fake INTEGER */
+	for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
+		*p = (uint8_t)native;
+
+	tmp.buf = buf;
+	tmp.size = sizeof(buf);
+#endif	/* WORDS_BIGENDIAN */
+	
+	/* Encode fake INTEGER */
+	erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
+    if(erval.structure_ptr == &tmp) {
+        erval.structure_ptr = ptr;
+    }
+	return erval;
+}
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+asn_dec_rval_t
+NativeInteger_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) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval;
+	INTEGER_t st;
+	void *st_ptr = (void *)&st;
+	long *native = (long *)*sptr;
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&st, 0, sizeof(st));
+	rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, 
+		opt_mname, buf_ptr, size);
+	if(rval.code == RC_OK) {
+		long l;
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&st, (unsigned long *)&l) /* sic */
+			: asn_INTEGER2long(&st, &l)) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+		} else {
+			*native = l;
+		}
+	} else {
+		/*
+		 * Cannot restart from the middle;
+		 * there is no place to save state in the native type.
+		 * Request a continuation from the very beginning.
+		 */
+		rval.consumed = 0;
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
+	return rval;
+}
+
+
+asn_enc_rval_t
+NativeInteger_encode_xer(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 asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    char scratch[32];	/* Enough for 64-bit int */
+	asn_enc_rval_t er = {0,0,0};
+	const long *native = (const long *)sptr;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!native) ASN__ENCODE_FAILED;
+
+	er.encoded = snprintf(scratch, sizeof(scratch),
+			(specs && specs->field_unsigned)
+			? "%lu" : "%ld", *native);
+	if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
+		|| cb(scratch, er.encoded, app_key) < 0)
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+#ifndef  ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+NativeInteger_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_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval;
+	long *native = (long *)*sptr;
+	INTEGER_t tmpint;
+	void *tmpintptr = &tmpint;
+
+	(void)opt_codec_ctx;
+	ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&tmpint, 0, sizeof tmpint);
+	rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
+				   &tmpintptr, pd);
+	if(rval.code == RC_OK) {
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)
+			: asn_INTEGER2long(&tmpint, native))
+			rval.code = RC_FAIL;
+		else
+			ASN_DEBUG("NativeInteger %s got value %ld",
+				td->name, *native);
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+
+	return rval;
+}
+
+asn_enc_rval_t
+NativeInteger_encode_uper(const asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints,
+                          const void *sptr, asn_per_outp_t *po) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_enc_rval_t er = {0,0,0};
+	long native;
+	INTEGER_t tmpint;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+
+    native = *(const long *)sptr;
+
+    ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
+
+	memset(&tmpint, 0, sizeof(tmpint));
+	if((specs&&specs->field_unsigned)
+		? asn_ulong2INTEGER(&tmpint, native)
+		: asn_long2INTEGER(&tmpint, native))
+		ASN__ENCODE_FAILED;
+	er = INTEGER_encode_uper(td, constraints, &tmpint, po);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+	return er;
+}
+
+asn_dec_rval_t
+NativeInteger_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_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval;
+	long *native = (long *)*sptr;
+	INTEGER_t tmpint;
+	void *tmpintptr = &tmpint;
+
+	(void)opt_codec_ctx;
+	ASN_DEBUG("Decoding NativeInteger %s (APER)", td->name);
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&tmpint, 0, sizeof tmpint);
+	rval = INTEGER_decode_aper(opt_codec_ctx, td, constraints,
+	                           &tmpintptr, pd);
+	if(rval.code == RC_OK) {
+		if((specs&&specs->field_unsigned)
+		        ? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)
+		        : asn_INTEGER2long(&tmpint, native))
+			rval.code = RC_FAIL;
+		else
+			ASN_DEBUG("NativeInteger %s got value %ld",
+			          td->name, *native);
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+
+	return rval;
+}
+
+asn_enc_rval_t
+NativeInteger_encode_aper(const asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints,
+                          const void *sptr, asn_per_outp_t *po) {
+
+	const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics;
+	asn_enc_rval_t er = {0,0,0};
+	long native;
+	INTEGER_t tmpint;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+
+	native = *(const long *)sptr;
+
+	ASN_DEBUG("Encoding NativeInteger %s %ld (APER)", td->name, native);
+
+	memset(&tmpint, 0, sizeof(tmpint));
+	if((specs&&specs->field_unsigned)
+	        ? asn_ulong2INTEGER(&tmpint, (unsigned long)native)
+	        : asn_long2INTEGER(&tmpint, native))
+		ASN__ENCODE_FAILED;
+	er = INTEGER_encode_aper(td, constraints, &tmpint, po);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+	return er;
+}
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+/*
+ * INTEGER specific human-readable output.
+ */
+int
+NativeInteger_print(const asn_TYPE_descriptor_t *td, const void *sptr,
+                    int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    const long *native = (const long *)sptr;
+    char scratch[32]; /* Enough for 64-bit int */
+    int ret;
+
+    (void)td;       /* Unused argument */
+    (void)ilevel;   /* Unused argument */
+
+    if(native) {
+        long value = *native;
+        ret = snprintf(scratch, sizeof(scratch),
+                       (specs && specs->field_unsigned) ? "%lu" : "%ld", value);
+        assert(ret > 0 && (size_t)ret < sizeof(scratch));
+        if(cb(scratch, ret, app_key) < 0) return -1;
+        if(specs && (value >= 0 || !specs->field_unsigned)) {
+            const asn_INTEGER_enum_map_t *el =
+                INTEGER_map_value2enum(specs, value);
+            if(el) {
+                if(cb(" (", 2, app_key) < 0) return -1;
+                if(cb(el->enum_name, el->enum_len, app_key) < 0) return -1;
+                if(cb(")", 1, app_key) < 0) return -1;
+            }
+        }
+        return 0;
+	} else {
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+	}
+}
+
+void
+NativeInteger_free(const asn_TYPE_descriptor_t *td, void *ptr,
+                   enum asn_struct_free_method method) {
+    if(!td || !ptr)
+		return;
+
+	ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
+		td->name, method, 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(long));
+        break;
+    }
+}
+
+int
+NativeInteger_compare(const asn_TYPE_descriptor_t *td, const void *aptr, const void *bptr) {
+    (void)td;
+
+    if(aptr && bptr) {
+        const asn_INTEGER_specifics_t *specs =
+            (const asn_INTEGER_specifics_t *)td->specifics;
+        if(specs && specs->field_unsigned) {
+            const unsigned long *a = aptr;
+            const unsigned long *b = bptr;
+            if(*a < *b) {
+                return -1;
+            } else if(*a > *b) {
+                return 1;
+            } else {
+                return 0;
+            }
+        } else {
+            const long *a = aptr;
+            const long *b = bptr;
+            if(*a < *b) {
+                return -1;
+            } else if(*a > *b) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+    } else if(!aptr) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+asn_random_fill_result_t
+NativeInteger_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                          const asn_encoding_constraints_t *constraints,
+                          size_t max_length) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    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};
+    long *st = *sptr;
+    const asn_INTEGER_enum_map_t *emap;
+    size_t emap_len;
+    intmax_t value;
+    int find_inside_map;
+
+    if(max_length == 0) return result_skipped;
+
+    if(st == NULL) {
+        st = (long *)CALLOC(1, sizeof(*st));
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    if(specs) {
+        emap = specs->value2enum;
+        emap_len = specs->map_count;
+        if(specs->strict_enumeration) {
+            find_inside_map = emap_len > 0;
+        } else {
+            find_inside_map = emap_len ? asn_random_between(0, 1) : 0;
+        }
+    } else {
+        emap = 0;
+        emap_len = 0;
+        find_inside_map = 0;
+    }
+
+    if(find_inside_map) {
+        assert(emap_len > 0);
+        value = emap[asn_random_between(0, emap_len - 1)].nat_value;
+    } else {
+        const asn_per_constraints_t *ct;
+
+        static const long variants[] = {
+            -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384,
+            -16383, -257,   -256,   -255,   -254,   -129,   -128,   -127,
+            -126,   -1,     0,      1,      126,    127,    128,    129,
+            254,    255,    256,    257,    16383,  16384,  16385,  32767,
+            32768,  32769,  65534,  65535,  65536,  65537};
+        if(specs && specs->field_unsigned) {
+            assert(variants[18] == 0);
+            value = variants[asn_random_between(
+                18, sizeof(variants) / sizeof(variants[0]) - 1)];
+        } else {
+            value = variants[asn_random_between(
+                0, sizeof(variants) / sizeof(variants[0]) - 1)];
+        }
+
+        if(!constraints) constraints = &td->encoding_constraints;
+        ct = constraints ? constraints->per_constraints : 0;
+        if(ct && (ct->value.flags & APC_CONSTRAINED)) {
+            if(value < ct->value.lower_bound || value > ct->value.upper_bound) {
+                value = asn_random_between(ct->value.lower_bound,
+                                           ct->value.upper_bound);
+            }
+        }
+    }
+
+    *sptr = st;
+    *st = value;
+    return result_ok;
+}

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/NativeInteger.h

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

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/OCTET_STRING.h

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

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/OPEN_TYPE.c

@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OPEN_TYPE.h>
+#include <constr_CHOICE.h>
+#include <per_opentype.h>
+#include <errno.h>
+
+asn_TYPE_operation_t asn_OP_OPEN_TYPE = {
+	OPEN_TYPE_free,
+	OPEN_TYPE_print,
+	OPEN_TYPE_compare,
+	OPEN_TYPE_decode_ber,
+	OPEN_TYPE_encode_der,
+	OPEN_TYPE_decode_xer,
+	OPEN_TYPE_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+ 	0, 0,	/* No OER support, use "-gen-OER" to enable */
+#else
+	OPEN_TYPE_decode_oer,
+	OPEN_TYPE_encode_oer,
+#endif
+#ifdef ASN_DISABLE_PER_SUPPORT
+	0, 0, 0, 0,
+#else
+	OPEN_TYPE_decode_uper,
+	OPEN_TYPE_encode_uper,
+	OPEN_TYPE_decode_aper,
+	OPEN_TYPE_encode_aper,
+#endif
+	0,  /* Random fill is not supported for open type */
+	0	/* Use generic outmost tag fetcher */
+};
+
+#undef  ADVANCE
+#define ADVANCE(num_bytes)               \
+    do {                                 \
+        size_t num = num_bytes;          \
+        ptr = ((const char *)ptr) + num; \
+        size -= num;                     \
+        consumed_myself += num;          \
+    } while(0)
+
+asn_dec_rval_t
+OPEN_TYPE_ber_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void *sptr,
+                  const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
+    size_t consumed_myself = 0;
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0) != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    ASN_DEBUG("presence %d\n", selected.presence_index);
+
+    rv = selected.type_descriptor->op->ber_decoder(
+        opt_codec_ctx, selected.type_descriptor, &inner_value, ptr, size,
+        elm->tag_mode);
+    ADVANCE(rv.consumed);
+    rv.consumed = 0;
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            rv.code = RC_OK;
+            rv.consumed = consumed_myself;
+            return rv;
+        } else {
+            /* Oh, now a full-blown failure failure */
+        }
+        /* Fall through */
+    case RC_FAIL:
+        rv.consumed = consumed_myself;
+        /* Fall through */
+    case RC_WMORE:
+        break;
+    }
+
+    if(*memb_ptr2) {
+        if(elm->flags & ATF_POINTER) {
+            ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+            *memb_ptr2 = NULL;
+        } else {
+            ASN_STRUCT_RESET(*selected.type_descriptor,
+                                          inner_value);
+        }
+    }
+    return rv;
+}
+
+asn_dec_rval_t
+OPEN_TYPE_xer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void *sptr,
+                  const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
+    size_t consumed_myself = 0;
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    int xer_context = 0;
+    ssize_t ch_size;
+    pxer_chunk_type_e ch_type;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    assert(elm->flags == ATF_OPEN_TYPE);
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+           != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    /*
+     * Confirm wrapper.
+     */
+    for(;;) {
+        ch_size = xer_next_token(&xer_context, ptr, size, &ch_type);
+        if(ch_size < 0) {
+            ASN__DECODE_FAILED;
+        } else {
+            switch(ch_type) {
+            case PXER_WMORE:
+                ASN__DECODE_STARVED;
+            case PXER_COMMENT:
+            case PXER_TEXT:
+                ADVANCE(ch_size);
+                continue;
+            case PXER_TAG:
+                break;
+            }
+            break;
+        }
+    }
+
+    /*
+     * Wrapper value confirmed.
+     */
+    switch(xer_check_tag(ptr, ch_size, elm->name)) {
+    case XCT_OPENING:
+        ADVANCE(ch_size);
+        break;
+    case XCT_BROKEN:
+    default:
+        ASN__DECODE_FAILED;
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    rv = selected.type_descriptor->op->xer_decoder(
+        opt_codec_ctx, selected.type_descriptor, &inner_value, NULL, ptr, size);
+    ADVANCE(rv.consumed);
+    rv.consumed = 0;
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            break;
+        } else {
+            rv.code = RC_FAIL;
+        }
+        /* Fall through */
+    case RC_FAIL:
+        /* Point to a best position where failure occurred */
+        rv.consumed = consumed_myself;
+        /* Fall through */
+    case RC_WMORE:
+        /* Wrt. rv.consumed==0:
+         * In case a genuine RC_WMORE, the whole Open Type decoding
+         * will have to be restarted.
+         */
+        if(*memb_ptr2) {
+            if(elm->flags & ATF_POINTER) {
+                ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+                *memb_ptr2 = NULL;
+            } else {
+                ASN_STRUCT_RESET(*selected.type_descriptor,
+                                              inner_value);
+            }
+        }
+        return rv;
+    }
+
+    /*
+     * Finalize wrapper.
+     */
+    for(;;) {
+        ch_size = xer_next_token(&xer_context, ptr, size, &ch_type);
+        if(ch_size < 0) {
+            ASN__DECODE_FAILED;
+        } else {
+            switch(ch_type) {
+            case PXER_WMORE:
+                ASN__DECODE_STARVED;
+            case PXER_COMMENT:
+            case PXER_TEXT:
+                ADVANCE(ch_size);
+                continue;
+            case PXER_TAG:
+                break;
+            }
+            break;
+        }
+    }
+
+    /*
+     * Wrapper value confirmed.
+     */
+    switch(xer_check_tag(ptr, ch_size, elm->name)) {
+    case XCT_CLOSING:
+        ADVANCE(ch_size);
+        break;
+    case XCT_BROKEN:
+    default:
+        ASN__DECODE_FAILED;
+    }
+
+    rv.consumed += consumed_myself;
+
+    return rv;
+}
+
+
+#ifndef  ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+OPEN_TYPE_uper_get(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td, void *sptr,
+                   const asn_TYPE_member_t *elm, asn_per_data_t *pd) {
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    assert(elm->flags == ATF_OPEN_TYPE);
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+           != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    rv = uper_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+                            &inner_value, pd);
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            break;
+        } else {
+            rv.code = RC_FAIL;
+        }
+        /* Fall through */
+    case RC_WMORE:
+    case RC_FAIL:
+        if(*memb_ptr2) {
+            if(elm->flags & ATF_POINTER) {
+                ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+                *memb_ptr2 = NULL;
+            } else {
+                ASN_STRUCT_RESET(*selected.type_descriptor,
+                                              inner_value);
+            }
+        }
+    }
+    return rv;
+}
+
+asn_enc_rval_t
+OPEN_TYPE_encode_uper(const asn_TYPE_descriptor_t *td,
+                      const asn_per_constraints_t *constraints,
+                      const void *sptr, asn_per_outp_t *po) {
+    const void *memb_ptr;   /* Pointer to the member */
+    asn_TYPE_member_t *elm; /* CHOICE's element */
+    asn_enc_rval_t er = {0,0,0};
+    unsigned present;
+
+    (void)constraints;
+
+    present = CHOICE_variant_get_presence(td, sptr);
+    if(present == 0 || present > td->elements_count) {
+        ASN__ENCODE_FAILED;
+    } else {
+        present--;
+    }
+
+    ASN_DEBUG("Encoding %s OPEN TYPE element %d", td->name, present);
+
+    elm = &td->elements[present];
+    if(elm->flags & ATF_POINTER) {
+        /* Member is a pointer to another structure */
+        memb_ptr =
+            *(const void *const *)((const char *)sptr + elm->memb_offset);
+        if(!memb_ptr) ASN__ENCODE_FAILED;
+    } else {
+        memb_ptr = (const char *)sptr + elm->memb_offset;
+    }
+
+    if(uper_open_type_put(elm->type, NULL, memb_ptr, po) < 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    er.encoded = 0;
+    ASN__ENCODED_OK(er);
+}
+
+asn_dec_rval_t
+OPEN_TYPE_aper_get(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td, void *sptr,
+                   const asn_TYPE_member_t *elm, asn_per_data_t *pd) {
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    assert(elm->flags == ATF_OPEN_TYPE);
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+           != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    rv = aper_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+                            &inner_value, pd);
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            break;
+        } else {
+            rv.code = RC_FAIL;
+        }
+        /* Fall through */
+    case RC_WMORE:
+    case RC_FAIL:
+        if(*memb_ptr2) {
+            if(elm->flags & ATF_POINTER) {
+                ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+                *memb_ptr2 = NULL;
+            } else {
+                ASN_STRUCT_RESET(*selected.type_descriptor,
+                                              inner_value);
+            }
+        }
+    }
+    return rv;
+}
+
+asn_enc_rval_t
+OPEN_TYPE_encode_aper(const asn_TYPE_descriptor_t *td,
+                      const asn_per_constraints_t *constraints,
+                      const void *sptr, asn_per_outp_t *po) {
+    const void *memb_ptr;   /* Pointer to the member */
+    asn_TYPE_member_t *elm; /* CHOICE's element */
+    asn_enc_rval_t er = {0,0,0};
+    unsigned present;
+
+    (void)constraints;
+
+    present = CHOICE_variant_get_presence(td, sptr);
+    if(present == 0 || present > td->elements_count) {
+        ASN__ENCODE_FAILED;
+    } else {
+        present--;
+    }
+
+    ASN_DEBUG("Encoding %s OPEN TYPE element %d", td->name, present);
+
+    elm = &td->elements[present];
+    if(elm->flags & ATF_POINTER) {
+        /* Member is a pointer to another structure */
+        memb_ptr =
+            *(const void *const *)((const char *)sptr + elm->memb_offset);
+        if(!memb_ptr) ASN__ENCODE_FAILED;
+    } else {
+        memb_ptr = (const char *)sptr + elm->memb_offset;
+    }
+
+    if(aper_open_type_put(elm->type, NULL, memb_ptr, po) < 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    er.encoded = 0;
+    ASN__ENCODED_OK(er);
+}
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/OPEN_TYPE.h

@@ -0,0 +1,77 @@
+/*-
+ * Copyright (c) 2017-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_OPEN_TYPE_H
+#define ASN_OPEN_TYPE_H
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPEN_TYPE_free CHOICE_free
+#define OPEN_TYPE_print CHOICE_print
+#define OPEN_TYPE_compare CHOICE_compare
+#define OPEN_TYPE_constraint CHOICE_constraint
+#define OPEN_TYPE_decode_ber NULL
+#define OPEN_TYPE_encode_der CHOICE_encode_der
+#define OPEN_TYPE_decode_xer NULL
+#define OPEN_TYPE_encode_xer CHOICE_encode_xer
+#define OPEN_TYPE_decode_oer NULL
+#define OPEN_TYPE_encode_oer CHOICE_encode_oer
+#define OPEN_TYPE_decode_uper NULL
+#define OPEN_TYPE_decode_aper NULL
+
+extern asn_TYPE_operation_t asn_OP_OPEN_TYPE;
+
+/*
+ * Decode an Open Type which is potentially constraiend
+ * by the other members of the parent structure.
+ */
+asn_dec_rval_t OPEN_TYPE_ber_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                 const asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 const asn_TYPE_member_t *element,
+                                 const void *ptr, size_t size);
+
+asn_dec_rval_t OPEN_TYPE_xer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                 const asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 const asn_TYPE_member_t *element,
+                                 const void *ptr, size_t size);
+
+asn_dec_rval_t OPEN_TYPE_oer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                 const asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 asn_TYPE_member_t *element, const void *ptr,
+                                 size_t size);
+
+asn_dec_rval_t OPEN_TYPE_uper_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                  const asn_TYPE_descriptor_t *parent_type,
+                                  void *parent_structure,
+                                  const asn_TYPE_member_t *element,
+                                  asn_per_data_t *pd);
+
+asn_dec_rval_t OPEN_TYPE_aper_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                  const asn_TYPE_descriptor_t *parent_type,
+                                  void *parent_structure,
+                                  const asn_TYPE_member_t *element,
+                                  asn_per_data_t *pd);
+
+asn_enc_rval_t OPEN_TYPE_encode_uper(
+    const asn_TYPE_descriptor_t *type_descriptor,
+    const asn_per_constraints_t *constraints, const void *struct_ptr,
+    asn_per_outp_t *per_output);
+
+asn_enc_rval_t OPEN_TYPE_encode_aper(
+    const asn_TYPE_descriptor_t *type_descriptor,
+    const asn_per_constraints_t *constraints, const void *struct_ptr,
+    asn_per_outp_t *per_output);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* ASN_OPEN_TYPE_H */

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/PLMN-Identity.c

@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "PLMN-Identity.h"
+
+int
+PLMN_Identity_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_PLMN_Identity_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  3,  3 }	/* (SIZE(3..3)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_PLMN_Identity_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_PLMN_Identity = {
+	"PLMN-Identity",
+	"PLMN-Identity",
+	&asn_OP_OCTET_STRING,
+	asn_DEF_PLMN_Identity_tags_1,
+	sizeof(asn_DEF_PLMN_Identity_tags_1)
+		/sizeof(asn_DEF_PLMN_Identity_tags_1[0]), /* 1 */
+	asn_DEF_PLMN_Identity_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PLMN_Identity_tags_1)
+		/sizeof(asn_DEF_PLMN_Identity_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_PLMN_Identity_constr_1, PLMN_Identity_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_OCTET_STRING_specs	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/PLMN-Identity.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_PLMN_Identity_H_
+#define	_PLMN_Identity_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "OCTET_STRING.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* PLMN-Identity */
+typedef OCTET_STRING_t	 PLMN_Identity_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_PLMN_Identity_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_PLMN_Identity;
+asn_struct_free_f PLMN_Identity_free;
+asn_struct_print_f PLMN_Identity_print;
+asn_constr_check_f PLMN_Identity_constraint;
+ber_type_decoder_f PLMN_Identity_decode_ber;
+der_type_encoder_f PLMN_Identity_encode_der;
+xer_type_decoder_f PLMN_Identity_decode_xer;
+xer_type_encoder_f PLMN_Identity_encode_xer;
+per_type_decoder_f PLMN_Identity_decode_uper;
+per_type_encoder_f PLMN_Identity_encode_uper;
+per_type_decoder_f PLMN_Identity_decode_aper;
+per_type_encoder_f PLMN_Identity_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _PLMN_Identity_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/PrintableString.c

@@ -0,0 +1,148 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*-
+ * Copyright (c) 2003, 2004, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <PrintableString.h>
+
+/*
+ * ASN.1:1984 (X.409)
+ */
+static const int _PrintableString_alphabet[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int _PrintableString_code2value[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122};
+
+/*
+ * PrintableString basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_PrintableString_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (19 << 2)),	/* [UNIVERSAL 19] IMPLICIT ...*/
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))	/* ... OCTET STRING */
+};
+static int asn_DEF_PrintableString_v2c(unsigned int value) {
+	return _PrintableString_alphabet[value > 255 ? 0 : value] - 1;
+}
+static int asn_DEF_PrintableString_c2v(unsigned int code) {
+	if(code < 74)
+		return _PrintableString_code2value[code];
+	return -1;
+}
+static asn_per_constraints_t asn_DEF_PrintableString_per_constraints = {
+	{ APC_CONSTRAINED, 4, 4, 0x20, 0x39 },	/* Value */
+	{ APC_SEMI_CONSTRAINED, -1, -1, 0, 0 },	/* Size */
+	asn_DEF_PrintableString_v2c,
+	asn_DEF_PrintableString_c2v
+};
+asn_TYPE_operation_t asn_OP_PrintableString = {
+	OCTET_STRING_free,
+	OCTET_STRING_print_utf8,	/* ASCII subset */
+	OCTET_STRING_compare,
+	OCTET_STRING_decode_ber,      /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_encode_der,
+	OCTET_STRING_decode_xer_utf8,
+	OCTET_STRING_encode_xer_utf8,
+#ifdef	ASN_DISABLE_OER_SUPPORT
+	0,
+	0,
+#else
+	OCTET_STRING_decode_oer,
+	OCTET_STRING_encode_oer,
+#endif	/* ASN_DISABLE_OER_SUPPORT */
+#ifdef	ASN_DISABLE_PER_SUPPORT
+	0,
+	0,
+	0,
+	0,
+#else
+	OCTET_STRING_decode_uper,
+	OCTET_STRING_encode_uper,
+	OCTET_STRING_decode_aper,
+	OCTET_STRING_encode_aper,
+#endif	/* ASN_DISABLE_PER_SUPPORT */
+	OCTET_STRING_random_fill,
+	0	/* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_PrintableString = {
+	"PrintableString",
+	"PrintableString",
+	&asn_OP_PrintableString,
+	asn_DEF_PrintableString_tags,
+	sizeof(asn_DEF_PrintableString_tags)
+	  / sizeof(asn_DEF_PrintableString_tags[0]) - 1,
+	asn_DEF_PrintableString_tags,
+	sizeof(asn_DEF_PrintableString_tags)
+	  / sizeof(asn_DEF_PrintableString_tags[0]),
+	{ 0, &asn_DEF_PrintableString_per_constraints, PrintableString_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+int
+PrintableString_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+                           asn_app_constraint_failed_f *ctfailcb,
+                           void *app_key) {
+    const PrintableString_t *st = (const PrintableString_t *)sptr;
+
+	if(st && st->buf) {
+		uint8_t *buf = st->buf;
+		uint8_t *end = buf + st->size;
+
+		/*
+		 * Check the alphabet of the PrintableString.
+		 * ASN.1:1984 (X.409)
+		 */
+		for(; buf < end; buf++) {
+			if(!_PrintableString_alphabet[*buf]) {
+				ASN__CTFAIL(app_key, td, sptr,
+					"%s: value byte %ld (%d) "
+					"not in PrintableString alphabet "
+					"(%s:%d)",
+					td->name,
+					(long)((buf - st->buf) + 1),
+					*buf,
+					__FILE__, __LINE__);
+				return -1;
+			}
+		}
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/PrintableString.h

@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_PrintableString_H_
+#define	_PrintableString_H_
+
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef OCTET_STRING_t PrintableString_t;  /* Implemented via OCTET STRING */
+
+extern asn_TYPE_descriptor_t asn_DEF_PrintableString;
+extern asn_TYPE_operation_t asn_OP_PrintableString;
+
+asn_constr_check_f PrintableString_constraint;
+
+#define PrintableString_free            OCTET_STRING_free
+#define PrintableString_print           OCTET_STRING_print_utf8
+#define PrintableString_compare         OCTET_STRING_compare
+#define PrintableString_decode_ber      OCTET_STRING_decode_ber
+#define PrintableString_encode_der      OCTET_STRING_encode_der
+#define PrintableString_decode_xer      OCTET_STRING_decode_xer_utf8
+#define PrintableString_encode_xer      OCTET_STRING_encode_xer_utf8
+#define PrintableString_decode_uper     OCTET_STRING_decode_uper
+#define PrintableString_encode_uper     OCTET_STRING_encode_uper
+#define PrintableString_decode_aper     OCTET_STRING_decode_aper
+#define PrintableString_encode_aper     OCTET_STRING_encode_aper
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _PrintableString_H_ */

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANfunction-Name.c

@@ -0,0 +1,325 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANfunction-Name.h"
+
+static const int permitted_alphabet_table_2[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int permitted_alphabet_code2value_2[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122,};
+
+
+static int check_permitted_alphabet_2(const void *sptr) {
+	const int *table = permitted_alphabet_table_2;
+	/* The underlying type is PrintableString */
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+static const int permitted_alphabet_table_3[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int permitted_alphabet_code2value_3[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122,};
+
+
+static int check_permitted_alphabet_3(const void *sptr) {
+	const int *table = permitted_alphabet_table_3;
+	/* The underlying type is PrintableString */
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+static const int permitted_alphabet_table_4[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int permitted_alphabet_code2value_4[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122,};
+
+
+static int check_permitted_alphabet_4(const void *sptr) {
+	const int *table = permitted_alphabet_table_4;
+	/* The underlying type is PrintableString */
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+static int
+memb_ranFunction_ShortName_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 150)
+		 && !check_permitted_alphabet_2(st)) {
+		/* 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 asn_PER_MAP_ranFunction_ShortName_2_v2c(unsigned int value) {
+	if(value >= sizeof(permitted_alphabet_table_2)/sizeof(permitted_alphabet_table_2[0]))
+		return -1;
+	return permitted_alphabet_table_2[value] - 1;
+}
+static int asn_PER_MAP_ranFunction_ShortName_2_c2v(unsigned int code) {
+	if(code >= sizeof(permitted_alphabet_code2value_2)/sizeof(permitted_alphabet_code2value_2[0]))
+		return -1;
+	return permitted_alphabet_code2value_2[code];
+}
+static int
+memb_ranFunction_E2SM_OID_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 1000)
+		 && !check_permitted_alphabet_3(st)) {
+		/* 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 asn_PER_MAP_ranFunction_E2SM_OID_3_v2c(unsigned int value) {
+	if(value >= sizeof(permitted_alphabet_table_3)/sizeof(permitted_alphabet_table_3[0]))
+		return -1;
+	return permitted_alphabet_table_3[value] - 1;
+}
+static int asn_PER_MAP_ranFunction_E2SM_OID_3_c2v(unsigned int code) {
+	if(code >= sizeof(permitted_alphabet_code2value_3)/sizeof(permitted_alphabet_code2value_3[0]))
+		return -1;
+	return permitted_alphabet_code2value_3[code];
+}
+static int
+memb_ranFunction_Description_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 150)
+		 && !check_permitted_alphabet_4(st)) {
+		/* 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 asn_PER_MAP_ranFunction_Description_4_v2c(unsigned int value) {
+	if(value >= sizeof(permitted_alphabet_table_4)/sizeof(permitted_alphabet_table_4[0]))
+		return -1;
+	return permitted_alphabet_table_4[value] - 1;
+}
+static int asn_PER_MAP_ranFunction_Description_4_c2v(unsigned int code) {
+	if(code >= sizeof(permitted_alphabet_code2value_4)/sizeof(permitted_alphabet_code2value_4[0]))
+		return -1;
+	return permitted_alphabet_code2value_4[code];
+}
+static asn_per_constraints_t asn_PER_memb_ranFunction_ShortName_constr_2 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  32,  122 }	/* (32..122) */,
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  150 }	/* (SIZE(1..150,...)) */,
+	asn_PER_MAP_ranFunction_ShortName_2_v2c,	/* Value to PER code map */
+	asn_PER_MAP_ranFunction_ShortName_2_c2v	/* PER code to value map */
+};
+static asn_per_constraints_t asn_PER_memb_ranFunction_E2SM_OID_constr_3 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  32,  122 }	/* (32..122) */,
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  10,  10,  1,  1000 }	/* (SIZE(1..1000,...)) */,
+	asn_PER_MAP_ranFunction_E2SM_OID_3_v2c,	/* Value to PER code map */
+	asn_PER_MAP_ranFunction_E2SM_OID_3_c2v	/* PER code to value map */
+};
+static asn_per_constraints_t asn_PER_memb_ranFunction_Description_constr_4 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  32,  122 }	/* (32..122) */,
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  150 }	/* (SIZE(1..150,...)) */,
+	asn_PER_MAP_ranFunction_Description_4_v2c,	/* Value to PER code map */
+	asn_PER_MAP_ranFunction_Description_4_c2v	/* PER code to value map */
+};
+asn_TYPE_member_t asn_MBR_RANfunction_Name_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RANfunction_Name, ranFunction_ShortName),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PrintableString,
+		0,
+		{ 0, &asn_PER_memb_ranFunction_ShortName_constr_2,  memb_ranFunction_ShortName_constraint_1 },
+		0, 0, /* No default value */
+		"ranFunction-ShortName"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANfunction_Name, ranFunction_E2SM_OID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PrintableString,
+		0,
+		{ 0, &asn_PER_memb_ranFunction_E2SM_OID_constr_3,  memb_ranFunction_E2SM_OID_constraint_1 },
+		0, 0, /* No default value */
+		"ranFunction-E2SM-OID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANfunction_Name, ranFunction_Description),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PrintableString,
+		0,
+		{ 0, &asn_PER_memb_ranFunction_Description_constr_4,  memb_ranFunction_Description_constraint_1 },
+		0, 0, /* No default value */
+		"ranFunction-Description"
+		},
+	{ ATF_POINTER, 1, offsetof(struct RANfunction_Name, ranFunction_Instance),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranFunction-Instance"
+		},
+};
+static const int asn_MAP_RANfunction_Name_oms_1[] = { 3 };
+static const ber_tlv_tag_t asn_DEF_RANfunction_Name_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RANfunction_Name_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ranFunction-ShortName */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ranFunction-E2SM-OID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ranFunction-Description */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* ranFunction-Instance */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RANfunction_Name_specs_1 = {
+	sizeof(struct RANfunction_Name),
+	offsetof(struct RANfunction_Name, _asn_ctx),
+	asn_MAP_RANfunction_Name_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_RANfunction_Name_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	4,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_RANfunction_Name = {
+	"RANfunction-Name",
+	"RANfunction-Name",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RANfunction_Name_tags_1,
+	sizeof(asn_DEF_RANfunction_Name_tags_1)
+		/sizeof(asn_DEF_RANfunction_Name_tags_1[0]), /* 1 */
+	asn_DEF_RANfunction_Name_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANfunction_Name_tags_1)
+		/sizeof(asn_DEF_RANfunction_Name_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RANfunction_Name_1,
+	4,	/* Elements count */
+	&asn_SPC_RANfunction_Name_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANfunction-Name.h

@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANfunction_Name_H_
+#define	_RANfunction_Name_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "PrintableString.h"
+#include "NativeInteger.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RANfunction-Name */
+typedef struct RANfunction_Name {
+	PrintableString_t	 ranFunction_ShortName;
+	PrintableString_t	 ranFunction_E2SM_OID;
+	PrintableString_t	 ranFunction_Description;
+	long	*ranFunction_Instance;	/* OPTIONAL */
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RANfunction_Name_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RANfunction_Name;
+extern asn_SEQUENCE_specifics_t asn_SPC_RANfunction_Name_specs_1;
+extern asn_TYPE_member_t asn_MBR_RANfunction_Name_1[4];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANfunction_Name_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-ID.c

@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameter-ID.h"
+
+int
+RANparameter_ID_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_RANparameter_ID_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 8,  8,  0,  255 }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_RANparameter_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RANparameter_ID = {
+	"RANparameter-ID",
+	"RANparameter-ID",
+	&asn_OP_NativeInteger,
+	asn_DEF_RANparameter_ID_tags_1,
+	sizeof(asn_DEF_RANparameter_ID_tags_1)
+		/sizeof(asn_DEF_RANparameter_ID_tags_1[0]), /* 1 */
+	asn_DEF_RANparameter_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANparameter_ID_tags_1)
+		/sizeof(asn_DEF_RANparameter_ID_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_RANparameter_ID_constr_1, RANparameter_ID_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-ID.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameter_ID_H_
+#define	_RANparameter_ID_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RANparameter-ID */
+typedef long	 RANparameter_ID_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_RANparameter_ID_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_RANparameter_ID;
+asn_struct_free_f RANparameter_ID_free;
+asn_struct_print_f RANparameter_ID_print;
+asn_constr_check_f RANparameter_ID_constraint;
+ber_type_decoder_f RANparameter_ID_decode_ber;
+der_type_encoder_f RANparameter_ID_encode_der;
+xer_type_decoder_f RANparameter_ID_decode_xer;
+xer_type_encoder_f RANparameter_ID_encode_xer;
+per_type_decoder_f RANparameter_ID_decode_uper;
+per_type_encoder_f RANparameter_ID_encode_uper;
+per_type_decoder_f RANparameter_ID_decode_aper;
+per_type_encoder_f RANparameter_ID_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameter_ID_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Item.c

@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameter-Item.h"
+
+asn_TYPE_member_t asn_MBR_RANparameter_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Item, ranParameter_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RANparameter_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranParameter-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Item, ranParameter_Value),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_RANparameter_Value,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranParameter-Value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RANparameter_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RANparameter_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ranParameter-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* ranParameter-Value */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RANparameter_Item_specs_1 = {
+	sizeof(struct RANparameter_Item),
+	offsetof(struct RANparameter_Item, _asn_ctx),
+	asn_MAP_RANparameter_Item_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_RANparameter_Item = {
+	"RANparameter-Item",
+	"RANparameter-Item",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RANparameter_Item_tags_1,
+	sizeof(asn_DEF_RANparameter_Item_tags_1)
+		/sizeof(asn_DEF_RANparameter_Item_tags_1[0]), /* 1 */
+	asn_DEF_RANparameter_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANparameter_Item_tags_1)
+		/sizeof(asn_DEF_RANparameter_Item_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RANparameter_Item_1,
+	2,	/* Elements count */
+	&asn_SPC_RANparameter_Item_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Item.h

@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameter_Item_H_
+#define	_RANparameter_Item_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RANparameter-ID.h"
+#include "RANparameter-Value.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RANparameter-Item */
+typedef struct RANparameter_Item {
+	RANparameter_ID_t	 ranParameter_ID;
+	RANparameter_Value_t	 ranParameter_Value;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RANparameter_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RANparameter_Item;
+extern asn_SEQUENCE_specifics_t asn_SPC_RANparameter_Item_specs_1;
+extern asn_TYPE_member_t asn_MBR_RANparameter_Item_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameter_Item_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Name.c

@@ -0,0 +1,124 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameter-Name.h"
+
+static const int permitted_alphabet_table_1[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int permitted_alphabet_code2value_1[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122,};
+
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	const int *table = permitted_alphabet_table_1;
+	/* The underlying type is PrintableString */
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+int
+RANparameter_Name_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 150)
+		 && !check_permitted_alphabet_1(st)) {
+		/* 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 asn_PER_MAP_RANparameter_Name_1_v2c(unsigned int value) {
+	if(value >= sizeof(permitted_alphabet_table_1)/sizeof(permitted_alphabet_table_1[0]))
+		return -1;
+	return permitted_alphabet_table_1[value] - 1;
+}
+static int asn_PER_MAP_RANparameter_Name_1_c2v(unsigned int code) {
+	if(code >= sizeof(permitted_alphabet_code2value_1)/sizeof(permitted_alphabet_code2value_1[0]))
+		return -1;
+	return permitted_alphabet_code2value_1[code];
+}
+/*
+ * This type is implemented using PrintableString,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_RANparameter_Name_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  32,  122 }	/* (32..122) */,
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  150 }	/* (SIZE(1..150,...)) */,
+	asn_PER_MAP_RANparameter_Name_1_v2c,	/* Value to PER code map */
+	asn_PER_MAP_RANparameter_Name_1_c2v	/* PER code to value map */
+};
+static const ber_tlv_tag_t asn_DEF_RANparameter_Name_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (19 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RANparameter_Name = {
+	"RANparameter-Name",
+	"RANparameter-Name",
+	&asn_OP_PrintableString,
+	asn_DEF_RANparameter_Name_tags_1,
+	sizeof(asn_DEF_RANparameter_Name_tags_1)
+		/sizeof(asn_DEF_RANparameter_Name_tags_1[0]), /* 1 */
+	asn_DEF_RANparameter_Name_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANparameter_Name_tags_1)
+		/sizeof(asn_DEF_RANparameter_Name_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_RANparameter_Name_constr_1, RANparameter_Name_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Name.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameter_Name_H_
+#define	_RANparameter_Name_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "PrintableString.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RANparameter-Name */
+typedef PrintableString_t	 RANparameter_Name_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_RANparameter_Name_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_RANparameter_Name;
+asn_struct_free_f RANparameter_Name_free;
+asn_struct_print_f RANparameter_Name_print;
+asn_constr_check_f RANparameter_Name_constraint;
+ber_type_decoder_f RANparameter_Name_decode_ber;
+der_type_encoder_f RANparameter_Name_encode_der;
+xer_type_decoder_f RANparameter_Name_decode_xer;
+xer_type_encoder_f RANparameter_Name_encode_xer;
+per_type_decoder_f RANparameter_Name_decode_uper;
+per_type_encoder_f RANparameter_Name_encode_uper;
+per_type_decoder_f RANparameter_Name_decode_aper;
+per_type_encoder_f RANparameter_Name_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameter_Name_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Test.c

@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameter-Test.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static asn_per_constraints_t asn_PER_type_RANparameter_Test_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 */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_RANparameter_Test_value2enum_1[] = {
+	{ 0,	5,	"equal" },
+	{ 1,	11,	"greaterthan" },
+	{ 2,	8,	"lessthan" },
+	{ 3,	8,	"contains" },
+	{ 4,	7,	"present" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_RANparameter_Test_enum2value_1[] = {
+	3,	/* contains(3) */
+	0,	/* equal(0) */
+	1,	/* greaterthan(1) */
+	2,	/* lessthan(2) */
+	4	/* present(4) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_RANparameter_Test_specs_1 = {
+	asn_MAP_RANparameter_Test_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_RANparameter_Test_enum2value_1,	/* N => "tag"; sorted by N */
+	5,	/* Number of elements in the maps */
+	6,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_RANparameter_Test_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RANparameter_Test = {
+	"RANparameter-Test",
+	"RANparameter-Test",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_RANparameter_Test_tags_1,
+	sizeof(asn_DEF_RANparameter_Test_tags_1)
+		/sizeof(asn_DEF_RANparameter_Test_tags_1[0]), /* 1 */
+	asn_DEF_RANparameter_Test_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANparameter_Test_tags_1)
+		/sizeof(asn_DEF_RANparameter_Test_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_RANparameter_Test_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_RANparameter_Test_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Test.h

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameter_Test_H_
+#define	_RANparameter_Test_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeEnumerated.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum RANparameter_Test {
+	RANparameter_Test_equal	= 0,
+	RANparameter_Test_greaterthan	= 1,
+	RANparameter_Test_lessthan	= 2,
+	RANparameter_Test_contains	= 3,
+	RANparameter_Test_present	= 4
+	/*
+	 * Enumeration is extensible
+	 */
+} e_RANparameter_Test;
+
+/* RANparameter-Test */
+typedef long	 RANparameter_Test_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RANparameter_Test;
+asn_struct_free_f RANparameter_Test_free;
+asn_struct_print_f RANparameter_Test_print;
+asn_constr_check_f RANparameter_Test_constraint;
+ber_type_decoder_f RANparameter_Test_decode_ber;
+der_type_encoder_f RANparameter_Test_encode_der;
+xer_type_decoder_f RANparameter_Test_decode_xer;
+xer_type_encoder_f RANparameter_Test_encode_xer;
+per_type_decoder_f RANparameter_Test_decode_uper;
+per_type_encoder_f RANparameter_Test_encode_uper;
+per_type_decoder_f RANparameter_Test_decode_aper;
+per_type_encoder_f RANparameter_Test_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameter_Test_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Type.c

@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameter-Type.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_RANparameter_Type_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  5 }	/* (0..5,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_RANparameter_Type_value2enum_1[] = {
+	{ 0,	7,	"integer" },
+	{ 1,	10,	"enumerated" },
+	{ 2,	7,	"boolean" },
+	{ 3,	10,	"bit-string" },
+	{ 4,	12,	"octet-string" },
+	{ 5,	16,	"printable-string" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_RANparameter_Type_enum2value_1[] = {
+	3,	/* bit-string(3) */
+	2,	/* boolean(2) */
+	1,	/* enumerated(1) */
+	0,	/* integer(0) */
+	4,	/* octet-string(4) */
+	5	/* printable-string(5) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_RANparameter_Type_specs_1 = {
+	asn_MAP_RANparameter_Type_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_RANparameter_Type_enum2value_1,	/* N => "tag"; sorted by N */
+	6,	/* Number of elements in the maps */
+	7,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_RANparameter_Type_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RANparameter_Type = {
+	"RANparameter-Type",
+	"RANparameter-Type",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_RANparameter_Type_tags_1,
+	sizeof(asn_DEF_RANparameter_Type_tags_1)
+		/sizeof(asn_DEF_RANparameter_Type_tags_1[0]), /* 1 */
+	asn_DEF_RANparameter_Type_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANparameter_Type_tags_1)
+		/sizeof(asn_DEF_RANparameter_Type_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_RANparameter_Type_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_RANparameter_Type_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Type.h

@@ -0,0 +1,76 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameter_Type_H_
+#define	_RANparameter_Type_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeEnumerated.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum RANparameter_Type {
+	RANparameter_Type_integer	= 0,
+	RANparameter_Type_enumerated	= 1,
+	RANparameter_Type_boolean	= 2,
+	RANparameter_Type_bit_string	= 3,
+	RANparameter_Type_octet_string	= 4,
+	RANparameter_Type_printable_string	= 5
+	/*
+	 * Enumeration is extensible
+	 */
+} e_RANparameter_Type;
+
+/* RANparameter-Type */
+typedef long	 RANparameter_Type_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_RANparameter_Type_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_RANparameter_Type;
+extern const asn_INTEGER_specifics_t asn_SPC_RANparameter_Type_specs_1;
+asn_struct_free_f RANparameter_Type_free;
+asn_struct_print_f RANparameter_Type_print;
+asn_constr_check_f RANparameter_Type_constraint;
+ber_type_decoder_f RANparameter_Type_decode_ber;
+der_type_encoder_f RANparameter_Type_encode_der;
+xer_type_decoder_f RANparameter_Type_decode_xer;
+xer_type_encoder_f RANparameter_Type_encode_xer;
+per_type_decoder_f RANparameter_Type_decode_uper;
+per_type_encoder_f RANparameter_Type_encode_uper;
+per_type_decoder_f RANparameter_Type_decode_aper;
+per_type_encoder_f RANparameter_Type_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameter_Type_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Value.c

@@ -0,0 +1,120 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameter-Value.h"
+
+asn_per_constraints_t asn_PER_type_RANparameter_Value_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  5 }	/* (0..5,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_RANparameter_Value_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Value, choice.valueInt),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"valueInt"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Value, choice.valueEnum),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"valueEnum"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Value, choice.valueBool),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BOOLEAN,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"valueBool"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Value, choice.valueBitS),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"valueBitS"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Value, choice.valueOctS),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"valueOctS"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameter_Value, choice.valuePrtS),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PrintableString,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"valuePrtS"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_RANparameter_Value_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* valueInt */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* valueEnum */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* valueBool */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* valueBitS */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* valueOctS */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 } /* valuePrtS */
+};
+asn_CHOICE_specifics_t asn_SPC_RANparameter_Value_specs_1 = {
+	sizeof(struct RANparameter_Value),
+	offsetof(struct RANparameter_Value, _asn_ctx),
+	offsetof(struct RANparameter_Value, present),
+	sizeof(((struct RANparameter_Value *)0)->present),
+	asn_MAP_RANparameter_Value_tag2el_1,
+	6,	/* Count of tags in the map */
+	0, 0,
+	6	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_RANparameter_Value = {
+	"RANparameter-Value",
+	"RANparameter-Value",
+	&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_RANparameter_Value_constr_1, CHOICE_constraint },
+	asn_MBR_RANparameter_Value_1,
+	6,	/* Elements count */
+	&asn_SPC_RANparameter_Value_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameter-Value.h

@@ -0,0 +1,88 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameter_Value_H_
+#define	_RANparameter_Value_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+#include "BOOLEAN.h"
+#include "BIT_STRING.h"
+#include "OCTET_STRING.h"
+#include "PrintableString.h"
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum RANparameter_Value_PR {
+	RANparameter_Value_PR_NOTHING,	/* No components present */
+	RANparameter_Value_PR_valueInt,
+	RANparameter_Value_PR_valueEnum,
+	RANparameter_Value_PR_valueBool,
+	RANparameter_Value_PR_valueBitS,
+	RANparameter_Value_PR_valueOctS,
+	RANparameter_Value_PR_valuePrtS
+	/* Extensions may appear below */
+	
+} RANparameter_Value_PR;
+
+/* RANparameter-Value */
+typedef struct RANparameter_Value {
+	RANparameter_Value_PR present;
+	union RANparameter_Value_u {
+		long	 valueInt;
+		long	 valueEnum;
+		BOOLEAN_t	 valueBool;
+		BIT_STRING_t	 valueBitS;
+		OCTET_STRING_t	 valueOctS;
+		PrintableString_t	 valuePrtS;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RANparameter_Value_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RANparameter_Value;
+extern asn_CHOICE_specifics_t asn_SPC_RANparameter_Value_specs_1;
+extern asn_TYPE_member_t asn_MBR_RANparameter_Value_1[6];
+extern asn_per_constraints_t asn_PER_type_RANparameter_Value_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameter_Value_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameterDef-Item.c

@@ -0,0 +1,88 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RANparameterDef-Item.h"
+
+asn_TYPE_member_t asn_MBR_RANparameterDef_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameterDef_Item, ranParameter_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RANparameter_ID,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranParameter-ID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameterDef_Item, ranParameter_Name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RANparameter_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranParameter-Name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RANparameterDef_Item, ranParameter_Type),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RANparameter_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ranParameter-Type"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RANparameterDef_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RANparameterDef_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ranParameter-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ranParameter-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* ranParameter-Type */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RANparameterDef_Item_specs_1 = {
+	sizeof(struct RANparameterDef_Item),
+	offsetof(struct RANparameterDef_Item, _asn_ctx),
+	asn_MAP_RANparameterDef_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_RANparameterDef_Item = {
+	"RANparameterDef-Item",
+	"RANparameterDef-Item",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RANparameterDef_Item_tags_1,
+	sizeof(asn_DEF_RANparameterDef_Item_tags_1)
+		/sizeof(asn_DEF_RANparameterDef_Item_tags_1[0]), /* 1 */
+	asn_DEF_RANparameterDef_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RANparameterDef_Item_tags_1)
+		/sizeof(asn_DEF_RANparameterDef_Item_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RANparameterDef_Item_1,
+	3,	/* Elements count */
+	&asn_SPC_RANparameterDef_Item_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RANparameterDef-Item.h

@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RANparameterDef_Item_H_
+#define	_RANparameterDef_Item_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RANparameter-ID.h"
+#include "RANparameter-Name.h"
+#include "RANparameter-Type.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RANparameterDef-Item */
+typedef struct RANparameterDef_Item {
+	RANparameter_ID_t	 ranParameter_ID;
+	RANparameter_Name_t	 ranParameter_Name;
+	RANparameter_Type_t	 ranParameter_Type;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RANparameterDef_Item_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RANparameterDef_Item;
+extern asn_SEQUENCE_specifics_t asn_SPC_RANparameterDef_Item_specs_1;
+extern asn_TYPE_member_t asn_MBR_RANparameterDef_Item_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RANparameterDef_Item_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-ControlStyle-List.c

@@ -0,0 +1,108 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-ControlStyle-List.h"
+
+asn_TYPE_member_t asn_MBR_RIC_ControlStyle_List_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ControlStyle_List, ric_ControlStyle_Type),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ControlStyle-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ControlStyle_List, ric_ControlStyle_Name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ControlStyle-Name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ControlStyle_List, ric_ControlHeaderFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ControlHeaderFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ControlStyle_List, ric_ControlMessageFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ControlMessageFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ControlStyle_List, ric_CallProcessIDFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-CallProcessIDFormat-Type"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RIC_ControlStyle_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RIC_ControlStyle_List_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ric-ControlStyle-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ric-ControlStyle-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ric-ControlHeaderFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* ric-ControlMessageFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* ric-CallProcessIDFormat-Type */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RIC_ControlStyle_List_specs_1 = {
+	sizeof(struct RIC_ControlStyle_List),
+	offsetof(struct RIC_ControlStyle_List, _asn_ctx),
+	asn_MAP_RIC_ControlStyle_List_tag2el_1,
+	5,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	5,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_ControlStyle_List = {
+	"RIC-ControlStyle-List",
+	"RIC-ControlStyle-List",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RIC_ControlStyle_List_tags_1,
+	sizeof(asn_DEF_RIC_ControlStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_ControlStyle_List_tags_1[0]), /* 1 */
+	asn_DEF_RIC_ControlStyle_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_ControlStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_ControlStyle_List_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RIC_ControlStyle_List_1,
+	5,	/* Elements count */
+	&asn_SPC_RIC_ControlStyle_List_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-ControlStyle-List.h

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_ControlStyle_List_H_
+#define	_RIC_ControlStyle_List_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RIC-Style-Type.h"
+#include "RIC-Style-Name.h"
+#include "RIC-Format-Type.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RIC-ControlStyle-List */
+typedef struct RIC_ControlStyle_List {
+	RIC_Style_Type_t	 ric_ControlStyle_Type;
+	RIC_Style_Name_t	 ric_ControlStyle_Name;
+	RIC_Format_Type_t	 ric_ControlHeaderFormat_Type;
+	RIC_Format_Type_t	 ric_ControlMessageFormat_Type;
+	RIC_Format_Type_t	 ric_CallProcessIDFormat_Type;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RIC_ControlStyle_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_ControlStyle_List;
+extern asn_SEQUENCE_specifics_t asn_SPC_RIC_ControlStyle_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_RIC_ControlStyle_List_1[5];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_ControlStyle_List_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-EventTriggerStyle-List.c

@@ -0,0 +1,88 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-EventTriggerStyle-List.h"
+
+asn_TYPE_member_t asn_MBR_RIC_EventTriggerStyle_List_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_EventTriggerStyle_List, ric_EventTriggerStyle_Type),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-EventTriggerStyle-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_EventTriggerStyle_List, ric_EventTriggerStyle_Name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-EventTriggerStyle-Name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_EventTriggerStyle_List, ric_EventTriggerFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-EventTriggerFormat-Type"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RIC_EventTriggerStyle_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RIC_EventTriggerStyle_List_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ric-EventTriggerStyle-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ric-EventTriggerStyle-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* ric-EventTriggerFormat-Type */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RIC_EventTriggerStyle_List_specs_1 = {
+	sizeof(struct RIC_EventTriggerStyle_List),
+	offsetof(struct RIC_EventTriggerStyle_List, _asn_ctx),
+	asn_MAP_RIC_EventTriggerStyle_List_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_RIC_EventTriggerStyle_List = {
+	"RIC-EventTriggerStyle-List",
+	"RIC-EventTriggerStyle-List",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RIC_EventTriggerStyle_List_tags_1,
+	sizeof(asn_DEF_RIC_EventTriggerStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_EventTriggerStyle_List_tags_1[0]), /* 1 */
+	asn_DEF_RIC_EventTriggerStyle_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_EventTriggerStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_EventTriggerStyle_List_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RIC_EventTriggerStyle_List_1,
+	3,	/* Elements count */
+	&asn_SPC_RIC_EventTriggerStyle_List_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-EventTriggerStyle-List.h

@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_EventTriggerStyle_List_H_
+#define	_RIC_EventTriggerStyle_List_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RIC-Style-Type.h"
+#include "RIC-Style-Name.h"
+#include "RIC-Format-Type.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RIC-EventTriggerStyle-List */
+typedef struct RIC_EventTriggerStyle_List {
+	RIC_Style_Type_t	 ric_EventTriggerStyle_Type;
+	RIC_Style_Name_t	 ric_EventTriggerStyle_Name;
+	RIC_Format_Type_t	 ric_EventTriggerFormat_Type;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RIC_EventTriggerStyle_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_EventTriggerStyle_List;
+extern asn_SEQUENCE_specifics_t asn_SPC_RIC_EventTriggerStyle_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_RIC_EventTriggerStyle_List_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_EventTriggerStyle_List_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-Format-Type.c

@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-Format-Type.h"
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static const ber_tlv_tag_t asn_DEF_RIC_Format_Type_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_Format_Type = {
+	"RIC-Format-Type",
+	"RIC-Format-Type",
+	&asn_OP_NativeInteger,
+	asn_DEF_RIC_Format_Type_tags_1,
+	sizeof(asn_DEF_RIC_Format_Type_tags_1)
+		/sizeof(asn_DEF_RIC_Format_Type_tags_1[0]), /* 1 */
+	asn_DEF_RIC_Format_Type_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_Format_Type_tags_1)
+		/sizeof(asn_DEF_RIC_Format_Type_tags_1[0]), /* 1 */
+	{ 0, 0, NativeInteger_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-Format-Type.h

@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_Format_Type_H_
+#define	_RIC_Format_Type_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RIC-Format-Type */
+typedef long	 RIC_Format_Type_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_Format_Type;
+asn_struct_free_f RIC_Format_Type_free;
+asn_struct_print_f RIC_Format_Type_print;
+asn_constr_check_f RIC_Format_Type_constraint;
+ber_type_decoder_f RIC_Format_Type_decode_ber;
+der_type_encoder_f RIC_Format_Type_encode_der;
+xer_type_decoder_f RIC_Format_Type_decode_xer;
+xer_type_encoder_f RIC_Format_Type_encode_xer;
+per_type_decoder_f RIC_Format_Type_decode_uper;
+per_type_encoder_f RIC_Format_Type_encode_uper;
+per_type_decoder_f RIC_Format_Type_decode_aper;
+per_type_encoder_f RIC_Format_Type_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_Format_Type_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-InsertStyle-List.c

@@ -0,0 +1,202 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-InsertStyle-List.h"
+
+#include "RANparameterDef-Item.h"
+static int
+memb_ric_InsertRanParameterDef_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_ric_InsertRanParameterDef_List_constr_5 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_ric_InsertRanParameterDef_List_constr_5 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_ric_InsertRanParameterDef_List_5[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RANparameterDef_Item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_InsertRanParameterDef_List_tags_5[] = {
+	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_InsertRanParameterDef_List_specs_5 = {
+	sizeof(struct RIC_InsertStyle_List__ric_InsertRanParameterDef_List),
+	offsetof(struct RIC_InsertStyle_List__ric_InsertRanParameterDef_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_InsertRanParameterDef_List_5 = {
+	"ric-InsertRanParameterDef-List",
+	"ric-InsertRanParameterDef-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_InsertRanParameterDef_List_tags_5,
+	sizeof(asn_DEF_ric_InsertRanParameterDef_List_tags_5)
+		/sizeof(asn_DEF_ric_InsertRanParameterDef_List_tags_5[0]) - 1, /* 1 */
+	asn_DEF_ric_InsertRanParameterDef_List_tags_5,	/* Same as above */
+	sizeof(asn_DEF_ric_InsertRanParameterDef_List_tags_5)
+		/sizeof(asn_DEF_ric_InsertRanParameterDef_List_tags_5[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_InsertRanParameterDef_List_constr_5, SEQUENCE_OF_constraint },
+	asn_MBR_ric_InsertRanParameterDef_List_5,
+	1,	/* Single element */
+	&asn_SPC_ric_InsertRanParameterDef_List_specs_5	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_RIC_InsertStyle_List_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_InsertStyle_Type),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-InsertStyle-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_InsertStyle_Name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-InsertStyle-Name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_InsertActionFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-InsertActionFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_InsertRanParameterDef_List),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		0,
+		&asn_DEF_ric_InsertRanParameterDef_List_5,
+		0,
+		{ 0, &asn_PER_memb_ric_InsertRanParameterDef_List_constr_5,  memb_ric_InsertRanParameterDef_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-InsertRanParameterDef-List"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_IndicationHeaderFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-IndicationHeaderFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_IndicationMessageFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-IndicationMessageFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_InsertStyle_List, ric_CallProcessIDFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-CallProcessIDFormat-Type"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RIC_InsertStyle_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RIC_InsertStyle_List_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ric-InsertStyle-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ric-InsertStyle-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ric-InsertActionFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* ric-InsertRanParameterDef-List */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ric-IndicationHeaderFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* ric-IndicationMessageFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 } /* ric-CallProcessIDFormat-Type */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RIC_InsertStyle_List_specs_1 = {
+	sizeof(struct RIC_InsertStyle_List),
+	offsetof(struct RIC_InsertStyle_List, _asn_ctx),
+	asn_MAP_RIC_InsertStyle_List_tag2el_1,
+	7,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	7,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_InsertStyle_List = {
+	"RIC-InsertStyle-List",
+	"RIC-InsertStyle-List",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RIC_InsertStyle_List_tags_1,
+	sizeof(asn_DEF_RIC_InsertStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_InsertStyle_List_tags_1[0]), /* 1 */
+	asn_DEF_RIC_InsertStyle_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_InsertStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_InsertStyle_List_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RIC_InsertStyle_List_1,
+	7,	/* Elements count */
+	&asn_SPC_RIC_InsertStyle_List_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-InsertStyle-List.h

@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_InsertStyle_List_H_
+#define	_RIC_InsertStyle_List_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RIC-Style-Type.h"
+#include "RIC-Style-Name.h"
+#include "RIC-Format-Type.h"
+#include "asn_SEQUENCE_OF.h"
+#include "constr_SEQUENCE_OF.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct RANparameterDef_Item;
+
+/* RIC-InsertStyle-List */
+typedef struct RIC_InsertStyle_List {
+	RIC_Style_Type_t	 ric_InsertStyle_Type;
+	RIC_Style_Name_t	 ric_InsertStyle_Name;
+	RIC_Format_Type_t	 ric_InsertActionFormat_Type;
+	struct RIC_InsertStyle_List__ric_InsertRanParameterDef_List {
+		A_SEQUENCE_OF(struct RANparameterDef_Item) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} ric_InsertRanParameterDef_List;
+	RIC_Format_Type_t	 ric_IndicationHeaderFormat_Type;
+	RIC_Format_Type_t	 ric_IndicationMessageFormat_Type;
+	RIC_Format_Type_t	 ric_CallProcessIDFormat_Type;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RIC_InsertStyle_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_InsertStyle_List;
+extern asn_SEQUENCE_specifics_t asn_SPC_RIC_InsertStyle_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_RIC_InsertStyle_List_1[7];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_InsertStyle_List_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-PolicyStyle-List.c

@@ -0,0 +1,172 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-PolicyStyle-List.h"
+
+#include "RANparameterDef-Item.h"
+static int
+memb_ric_PolicyRanParameterDef_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_ric_PolicyRanParameterDef_List_constr_5 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_ric_PolicyRanParameterDef_List_constr_5 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_ric_PolicyRanParameterDef_List_5[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RANparameterDef_Item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_PolicyRanParameterDef_List_tags_5[] = {
+	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_PolicyRanParameterDef_List_specs_5 = {
+	sizeof(struct RIC_PolicyStyle_List__ric_PolicyRanParameterDef_List),
+	offsetof(struct RIC_PolicyStyle_List__ric_PolicyRanParameterDef_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_PolicyRanParameterDef_List_5 = {
+	"ric-PolicyRanParameterDef-List",
+	"ric-PolicyRanParameterDef-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_PolicyRanParameterDef_List_tags_5,
+	sizeof(asn_DEF_ric_PolicyRanParameterDef_List_tags_5)
+		/sizeof(asn_DEF_ric_PolicyRanParameterDef_List_tags_5[0]) - 1, /* 1 */
+	asn_DEF_ric_PolicyRanParameterDef_List_tags_5,	/* Same as above */
+	sizeof(asn_DEF_ric_PolicyRanParameterDef_List_tags_5)
+		/sizeof(asn_DEF_ric_PolicyRanParameterDef_List_tags_5[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_PolicyRanParameterDef_List_constr_5, SEQUENCE_OF_constraint },
+	asn_MBR_ric_PolicyRanParameterDef_List_5,
+	1,	/* Single element */
+	&asn_SPC_ric_PolicyRanParameterDef_List_specs_5	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_RIC_PolicyStyle_List_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_PolicyStyle_List, ric_PolicyStyle_Type),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-PolicyStyle-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_PolicyStyle_List, ric_PolicyStyle_Name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-PolicyStyle-Name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_PolicyStyle_List, ric_PolicyActionFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-PolicyActionFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_PolicyStyle_List, ric_PolicyRanParameterDef_List),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		0,
+		&asn_DEF_ric_PolicyRanParameterDef_List_5,
+		0,
+		{ 0, &asn_PER_memb_ric_PolicyRanParameterDef_List_constr_5,  memb_ric_PolicyRanParameterDef_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-PolicyRanParameterDef-List"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RIC_PolicyStyle_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RIC_PolicyStyle_List_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ric-PolicyStyle-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ric-PolicyStyle-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ric-PolicyActionFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* ric-PolicyRanParameterDef-List */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RIC_PolicyStyle_List_specs_1 = {
+	sizeof(struct RIC_PolicyStyle_List),
+	offsetof(struct RIC_PolicyStyle_List, _asn_ctx),
+	asn_MAP_RIC_PolicyStyle_List_tag2el_1,
+	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	4,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_PolicyStyle_List = {
+	"RIC-PolicyStyle-List",
+	"RIC-PolicyStyle-List",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RIC_PolicyStyle_List_tags_1,
+	sizeof(asn_DEF_RIC_PolicyStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_PolicyStyle_List_tags_1[0]), /* 1 */
+	asn_DEF_RIC_PolicyStyle_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_PolicyStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_PolicyStyle_List_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RIC_PolicyStyle_List_1,
+	4,	/* Elements count */
+	&asn_SPC_RIC_PolicyStyle_List_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-PolicyStyle-List.h

@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_PolicyStyle_List_H_
+#define	_RIC_PolicyStyle_List_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RIC-Style-Type.h"
+#include "RIC-Style-Name.h"
+#include "RIC-Format-Type.h"
+#include "asn_SEQUENCE_OF.h"
+#include "constr_SEQUENCE_OF.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct RANparameterDef_Item;
+
+/* RIC-PolicyStyle-List */
+typedef struct RIC_PolicyStyle_List {
+	RIC_Style_Type_t	 ric_PolicyStyle_Type;
+	RIC_Style_Name_t	 ric_PolicyStyle_Name;
+	RIC_Format_Type_t	 ric_PolicyActionFormat_Type;
+	struct RIC_PolicyStyle_List__ric_PolicyRanParameterDef_List {
+		A_SEQUENCE_OF(struct RANparameterDef_Item) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} ric_PolicyRanParameterDef_List;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RIC_PolicyStyle_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_PolicyStyle_List;
+extern asn_SEQUENCE_specifics_t asn_SPC_RIC_PolicyStyle_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_RIC_PolicyStyle_List_1[4];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_PolicyStyle_List_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-ReportStyle-List.c

@@ -0,0 +1,192 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-ReportStyle-List.h"
+
+#include "RANparameterDef-Item.h"
+static int
+memb_ric_ReportRanParameterDef_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_ric_ReportRanParameterDef_List_constr_5 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_ric_ReportRanParameterDef_List_constr_5 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_ric_ReportRanParameterDef_List_5[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_RANparameterDef_Item,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_ric_ReportRanParameterDef_List_tags_5[] = {
+	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ric_ReportRanParameterDef_List_specs_5 = {
+	sizeof(struct RIC_ReportStyle_List__ric_ReportRanParameterDef_List),
+	offsetof(struct RIC_ReportStyle_List__ric_ReportRanParameterDef_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ric_ReportRanParameterDef_List_5 = {
+	"ric-ReportRanParameterDef-List",
+	"ric-ReportRanParameterDef-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_ric_ReportRanParameterDef_List_tags_5,
+	sizeof(asn_DEF_ric_ReportRanParameterDef_List_tags_5)
+		/sizeof(asn_DEF_ric_ReportRanParameterDef_List_tags_5[0]) - 1, /* 1 */
+	asn_DEF_ric_ReportRanParameterDef_List_tags_5,	/* Same as above */
+	sizeof(asn_DEF_ric_ReportRanParameterDef_List_tags_5)
+		/sizeof(asn_DEF_ric_ReportRanParameterDef_List_tags_5[0]), /* 2 */
+	{ 0, &asn_PER_type_ric_ReportRanParameterDef_List_constr_5, SEQUENCE_OF_constraint },
+	asn_MBR_ric_ReportRanParameterDef_List_5,
+	1,	/* Single element */
+	&asn_SPC_ric_ReportRanParameterDef_List_specs_5	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_RIC_ReportStyle_List_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ReportStyle_List, ric_ReportStyle_Type),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ReportStyle-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ReportStyle_List, ric_ReportStyle_Name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Style_Name,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ReportStyle-Name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ReportStyle_List, ric_ReportActionFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-ReportActionFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ReportStyle_List, ric_ReportRanParameterDef_List),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		0,
+		&asn_DEF_ric_ReportRanParameterDef_List_5,
+		0,
+		{ 0, &asn_PER_memb_ric_ReportRanParameterDef_List_constr_5,  memb_ric_ReportRanParameterDef_List_constraint_1 },
+		0, 0, /* No default value */
+		"ric-ReportRanParameterDef-List"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ReportStyle_List, ric_IndicationHeaderFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-IndicationHeaderFormat-Type"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RIC_ReportStyle_List, ric_IndicationMessageFormat_Type),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RIC_Format_Type,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"ric-IndicationMessageFormat-Type"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RIC_ReportStyle_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RIC_ReportStyle_List_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ric-ReportStyle-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ric-ReportStyle-Name */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ric-ReportActionFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* ric-ReportRanParameterDef-List */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ric-IndicationHeaderFormat-Type */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 } /* ric-IndicationMessageFormat-Type */
+};
+asn_SEQUENCE_specifics_t asn_SPC_RIC_ReportStyle_List_specs_1 = {
+	sizeof(struct RIC_ReportStyle_List),
+	offsetof(struct RIC_ReportStyle_List, _asn_ctx),
+	asn_MAP_RIC_ReportStyle_List_tag2el_1,
+	6,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	6,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_ReportStyle_List = {
+	"RIC-ReportStyle-List",
+	"RIC-ReportStyle-List",
+	&asn_OP_SEQUENCE,
+	asn_DEF_RIC_ReportStyle_List_tags_1,
+	sizeof(asn_DEF_RIC_ReportStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_ReportStyle_List_tags_1[0]), /* 1 */
+	asn_DEF_RIC_ReportStyle_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_ReportStyle_List_tags_1)
+		/sizeof(asn_DEF_RIC_ReportStyle_List_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_RIC_ReportStyle_List_1,
+	6,	/* Elements count */
+	&asn_SPC_RIC_ReportStyle_List_specs_1	/* Additional specs */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-ReportStyle-List.h

@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_ReportStyle_List_H_
+#define	_RIC_ReportStyle_List_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "RIC-Style-Type.h"
+#include "RIC-Style-Name.h"
+#include "RIC-Format-Type.h"
+#include "asn_SEQUENCE_OF.h"
+#include "constr_SEQUENCE_OF.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct RANparameterDef_Item;
+
+/* RIC-ReportStyle-List */
+typedef struct RIC_ReportStyle_List {
+	RIC_Style_Type_t	 ric_ReportStyle_Type;
+	RIC_Style_Name_t	 ric_ReportStyle_Name;
+	RIC_Format_Type_t	 ric_ReportActionFormat_Type;
+	struct RIC_ReportStyle_List__ric_ReportRanParameterDef_List {
+		A_SEQUENCE_OF(struct RANparameterDef_Item) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} ric_ReportRanParameterDef_List;
+	RIC_Format_Type_t	 ric_IndicationHeaderFormat_Type;
+	RIC_Format_Type_t	 ric_IndicationMessageFormat_Type;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RIC_ReportStyle_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_ReportStyle_List;
+extern asn_SEQUENCE_specifics_t asn_SPC_RIC_ReportStyle_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_RIC_ReportStyle_List_1[6];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_ReportStyle_List_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-Style-Name.c

@@ -0,0 +1,124 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-Style-Name.h"
+
+static const int permitted_alphabet_table_1[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/*                  */
+ 1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,	/* .      '() +,-./ */
+10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,	/* 0123456789:  = ? */
+ 0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,	/*  ABCDEFGHIJKLMNO */
+38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,	/* PQRSTUVWXYZ      */
+ 0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,	/*  abcdefghijklmno */
+64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,	/* pqrstuvwxyz      */
+};
+static const int permitted_alphabet_code2value_1[74] = {
+32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
+55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
+75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
+97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
+113,114,115,116,117,118,119,120,121,122,};
+
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	const int *table = permitted_alphabet_table_1;
+	/* The underlying type is PrintableString */
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+int
+RIC_Style_Name_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const PrintableString_t *st = (const PrintableString_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 150)
+		 && !check_permitted_alphabet_1(st)) {
+		/* 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 asn_PER_MAP_RIC_Style_Name_1_v2c(unsigned int value) {
+	if(value >= sizeof(permitted_alphabet_table_1)/sizeof(permitted_alphabet_table_1[0]))
+		return -1;
+	return permitted_alphabet_table_1[value] - 1;
+}
+static int asn_PER_MAP_RIC_Style_Name_1_c2v(unsigned int code) {
+	if(code >= sizeof(permitted_alphabet_code2value_1)/sizeof(permitted_alphabet_code2value_1[0]))
+		return -1;
+	return permitted_alphabet_code2value_1[code];
+}
+/*
+ * This type is implemented using PrintableString,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_RIC_Style_Name_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  32,  122 }	/* (32..122) */,
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  150 }	/* (SIZE(1..150,...)) */,
+	asn_PER_MAP_RIC_Style_Name_1_v2c,	/* Value to PER code map */
+	asn_PER_MAP_RIC_Style_Name_1_c2v	/* PER code to value map */
+};
+static const ber_tlv_tag_t asn_DEF_RIC_Style_Name_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (19 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_Style_Name = {
+	"RIC-Style-Name",
+	"RIC-Style-Name",
+	&asn_OP_PrintableString,
+	asn_DEF_RIC_Style_Name_tags_1,
+	sizeof(asn_DEF_RIC_Style_Name_tags_1)
+		/sizeof(asn_DEF_RIC_Style_Name_tags_1[0]), /* 1 */
+	asn_DEF_RIC_Style_Name_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_Style_Name_tags_1)
+		/sizeof(asn_DEF_RIC_Style_Name_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_RIC_Style_Name_constr_1, RIC_Style_Name_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-Style-Name.h

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_Style_Name_H_
+#define	_RIC_Style_Name_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "PrintableString.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RIC-Style-Name */
+typedef PrintableString_t	 RIC_Style_Name_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_RIC_Style_Name_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_RIC_Style_Name;
+asn_struct_free_f RIC_Style_Name_free;
+asn_struct_print_f RIC_Style_Name_print;
+asn_constr_check_f RIC_Style_Name_constraint;
+ber_type_decoder_f RIC_Style_Name_decode_ber;
+der_type_encoder_f RIC_Style_Name_encode_der;
+xer_type_decoder_f RIC_Style_Name_decode_xer;
+xer_type_encoder_f RIC_Style_Name_encode_xer;
+per_type_decoder_f RIC_Style_Name_decode_uper;
+per_type_encoder_f RIC_Style_Name_encode_uper;
+per_type_decoder_f RIC_Style_Name_decode_aper;
+per_type_encoder_f RIC_Style_Name_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_Style_Name_H_ */
+#include "asn_internal.h"

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-Style-Type.c

@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#include "RIC-Style-Type.h"
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static const ber_tlv_tag_t asn_DEF_RIC_Style_Type_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_RIC_Style_Type = {
+	"RIC-Style-Type",
+	"RIC-Style-Type",
+	&asn_OP_NativeInteger,
+	asn_DEF_RIC_Style_Type_tags_1,
+	sizeof(asn_DEF_RIC_Style_Type_tags_1)
+		/sizeof(asn_DEF_RIC_Style_Type_tags_1[0]), /* 1 */
+	asn_DEF_RIC_Style_Type_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RIC_Style_Type_tags_1)
+		/sizeof(asn_DEF_RIC_Style_Type_tags_1[0]), /* 1 */
+	{ 0, 0, NativeInteger_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

setup/e2/RIC-E2-TERMINATION/3rdparty/oranE2SM/RIC-Style-Type.h

@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2020 AT&T Intellectual Property
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "E2SM-gNB-NRT-IEs"
+ * 	found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
+ * 	`asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
+ */
+
+#ifndef	_RIC_Style_Type_H_
+#define	_RIC_Style_Type_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RIC-Style-Type */
+typedef long	 RIC_Style_Type_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RIC_Style_Type;
+asn_struct_free_f RIC_Style_Type_free;
+asn_struct_print_f RIC_Style_Type_print;
+asn_constr_check_f RIC_Style_Type_constraint;
+ber_type_decoder_f RIC_Style_Type_decode_ber;
+der_type_encoder_f RIC_Style_Type_encode_der;
+xer_type_decoder_f RIC_Style_Type_decode_xer;
+xer_type_encoder_f RIC_Style_Type_encode_xer;
+per_type_decoder_f RIC_Style_Type_decode_uper;
+per_type_encoder_f RIC_Style_Type_encode_uper;
+per_type_decoder_f RIC_Style_Type_decode_aper;
+per_type_encoder_f RIC_Style_Type_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RIC_Style_Type_H_ */
+#include "asn_internal.h"