From ac9c0244322f8c128891ede4f527aca4a5d64da4 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Thu, 10 Sep 2015 21:18:16 +0200 Subject: ranap: Add more manual definitions to RANAP-PDUs It seems that individual IEs contain nested containers, and asn1c is not generating code for that unless we help it by some hand-crafted additional definitions. *sigh* --- asn1/ranap/RANAP-PDU.asn | 121 +++++++++++++++++ src/ranap/Makefile | 48 ++++++- src/ranap/RANAP_DataVolumeReportList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_DataVolumeReportList.h | 48 +++++++ ...GERAN-Iumode-RAB-FailedList-RABAssgntResponse.c | 145 +++++++++++++++++++++ ...GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h | 48 +++++++ src/ranap/RANAP_RAB-ContextFailedtoTransferList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-ContextFailedtoTransferList.h | 48 +++++++ src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.h | 48 +++++++ src/ranap/RANAP_RAB-ContextList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-ContextList.h | 48 +++++++ .../RANAP_RAB-DataForwardingList-SRNS-CtxReq.c | 145 +++++++++++++++++++++ .../RANAP_RAB-DataForwardingList-SRNS-CtxReq.h | 48 +++++++ src/ranap/RANAP_RAB-DataForwardingList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-DataForwardingList.h | 48 +++++++ src/ranap/RANAP_RAB-DataVolumeReportRequestList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-DataVolumeReportRequestList.h | 48 +++++++ src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.h | 48 +++++++ src/ranap/RANAP_RAB-FailedList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-FailedList.h | 48 +++++++ src/ranap/RANAP_RAB-FailedtoReportList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-FailedtoReportList.h | 48 +++++++ src/ranap/RANAP_RAB-ModifyList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-ModifyList.h | 48 +++++++ src/ranap/RANAP_RAB-QueuedList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-QueuedList.h | 48 +++++++ src/ranap/RANAP_RAB-ReleasedList-IuRelComp.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-ReleasedList-IuRelComp.h | 48 +++++++ src/ranap/RANAP_RAB-ReleasedList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-ReleasedList.h | 48 +++++++ src/ranap/RANAP_RAB-RelocationReleaseList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-RelocationReleaseList.h | 48 +++++++ src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.h | 48 +++++++ src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.h | 48 +++++++ .../RANAP_RAB-SetupList-EnhancedRelocCompleteReq.c | 145 +++++++++++++++++++++ .../RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h | 48 +++++++ .../RANAP_RAB-SetupList-EnhancedRelocCompleteRes.c | 145 +++++++++++++++++++++ .../RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h | 48 +++++++ src/ranap/RANAP_RAB-SetupList-RelocReq.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-SetupList-RelocReq.h | 48 +++++++ src/ranap/RANAP_RAB-SetupList-RelocReqAck.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-SetupList-RelocReqAck.h | 48 +++++++ src/ranap/RANAP_RAB-SetupOrModifiedList.c | 145 +++++++++++++++++++++ src/ranap/RANAP_RAB-SetupOrModifiedList.h | 48 +++++++ ...RAB-ToBeReleasedList-EnhancedRelocCompleteRes.c | 145 +++++++++++++++++++++ ...RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h | 48 +++++++ src/ranap_common.c | 138 ++++++++++++++++++++ src/ranap_common.h | 24 ++++ src/regen-common-includes.sh | 3 +- 53 files changed, 4963 insertions(+), 3 deletions(-) create mode 100644 src/ranap/RANAP_DataVolumeReportList.c create mode 100644 src/ranap/RANAP_DataVolumeReportList.h create mode 100644 src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.c create mode 100644 src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h create mode 100644 src/ranap/RANAP_RAB-ContextFailedtoTransferList.c create mode 100644 src/ranap/RANAP_RAB-ContextFailedtoTransferList.h create mode 100644 src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.c create mode 100644 src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.h create mode 100644 src/ranap/RANAP_RAB-ContextList.c create mode 100644 src/ranap/RANAP_RAB-ContextList.h create mode 100644 src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.c create mode 100644 src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.h create mode 100644 src/ranap/RANAP_RAB-DataForwardingList.c create mode 100644 src/ranap/RANAP_RAB-DataForwardingList.h create mode 100644 src/ranap/RANAP_RAB-DataVolumeReportRequestList.c create mode 100644 src/ranap/RANAP_RAB-DataVolumeReportRequestList.h create mode 100644 src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.c create mode 100644 src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.h create mode 100644 src/ranap/RANAP_RAB-FailedList.c create mode 100644 src/ranap/RANAP_RAB-FailedList.h create mode 100644 src/ranap/RANAP_RAB-FailedtoReportList.c create mode 100644 src/ranap/RANAP_RAB-FailedtoReportList.h create mode 100644 src/ranap/RANAP_RAB-ModifyList.c create mode 100644 src/ranap/RANAP_RAB-ModifyList.h create mode 100644 src/ranap/RANAP_RAB-QueuedList.c create mode 100644 src/ranap/RANAP_RAB-QueuedList.h create mode 100644 src/ranap/RANAP_RAB-ReleasedList-IuRelComp.c create mode 100644 src/ranap/RANAP_RAB-ReleasedList-IuRelComp.h create mode 100644 src/ranap/RANAP_RAB-ReleasedList.c create mode 100644 src/ranap/RANAP_RAB-ReleasedList.h create mode 100644 src/ranap/RANAP_RAB-RelocationReleaseList.c create mode 100644 src/ranap/RANAP_RAB-RelocationReleaseList.h create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.c create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.h create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.c create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.h create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.c create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.c create mode 100644 src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h create mode 100644 src/ranap/RANAP_RAB-SetupList-RelocReq.c create mode 100644 src/ranap/RANAP_RAB-SetupList-RelocReq.h create mode 100644 src/ranap/RANAP_RAB-SetupList-RelocReqAck.c create mode 100644 src/ranap/RANAP_RAB-SetupList-RelocReqAck.h create mode 100644 src/ranap/RANAP_RAB-SetupOrModifiedList.c create mode 100644 src/ranap/RANAP_RAB-SetupOrModifiedList.h create mode 100644 src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.c create mode 100644 src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h create mode 100644 src/ranap_common.c diff --git a/asn1/ranap/RANAP-PDU.asn b/asn1/ranap/RANAP-PDU.asn index ec04f46..cde8d25 100644 --- a/asn1/ranap/RANAP-PDU.asn +++ b/asn1/ranap/RANAP-PDU.asn @@ -467,4 +467,125 @@ IE ::= SEQUENCE { value ANY } +DataVolumeReportList ::= SEQUENCE { + dataVolumeReportListe-ies SEQUENCE (SIZE (0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ReleasedList-IuRelComp ::= SEQUENCE { + rabReleasedListIuRelComp-ies SEQUENCE (SIZE (0..maxProtocolIEs)) OF IE, + ... +} + +RAB-RelocationReleaseList ::= SEQUENCE { + rabRelocationReleaseList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-DataForwardingList ::= SEQUENCE { + rabDataForwardingList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupList-RelocReq ::= SEQUENCE { + rabSetupListRelocReq-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupList-RelocReqAck ::= SEQUENCE { + rabSetupListRelocReqAck-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-FailedList ::= SEQUENCE { + rabFailedList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-DataForwardingList-SRNS-CtxReq ::= SEQUENCE { + rabDataForwardingListSRNSCtxReq-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ContextList ::= SEQUENCE { + rabContextList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ContextFailedtoTransferList ::= SEQUENCE { + rabContextFailedtoTransferList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-DataVolumeReportRequestList ::= SEQUENCE { + rabDataVolumeReportRequestList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-FailedtoReportList ::= SEQUENCE { + rabFailedtoReportList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupList-EnhancedRelocCompleteReq ::= SEQUENCE { + rabSetupListEnhancedRElocCompleteReq-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupList-EnhancedRelocCompleteRes ::= SEQUENCE { + rabSetupListEnhancedRelocCompleteRes-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ToBeReleasedList-EnhancedRelocCompleteRes ::= SEQUENCE { + rabToBeReleasedListEnhancedRelocCompleteRes-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupOrModifiedList ::= SEQUENCE { + rabSetupOrModifiedList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ReleasedList ::= SEQUENCE { + rabReleaesdList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-QueuedList ::= SEQUENCE { + rabQueuedList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +GERAN-Iumode-RAB-FailedList-RABAssgntResponse ::= SEQUENCE { + foo-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ContextList-RANAP-RelocInf ::= SEQUENCE { + rabContextListRANAPRelocInf-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupList-EnhRelocInfoReq ::= SEQUENCE { + rabSetupListEnhRelocInfoReq-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-SetupList-EnhRelocInfoRes ::= SEQUENCE { + rabSetupListEnhRelocInfoRes-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-FailedList-EnhRelocInfoRes ::= SEQUENCE { + rabFailedListEnhRelocInfoRes-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + +RAB-ModifyList ::= SEQUENCE { + rabModifyList-ies SEQUENCE (SIZE(0..maxProtocolIEs)) OF IE, + ... +} + + END diff --git a/src/ranap/Makefile b/src/ranap/Makefile index 4f84d8a..59db793 100644 --- a/src/ranap/Makefile +++ b/src/ranap/Makefile @@ -494,7 +494,27 @@ ASN_MODULE_SOURCES= \ RANAP_SRVCC-CSKeysResponse.c \ RANAP_UeRadioCapabilityMatchRequest.c \ RANAP_UeRadioCapabilityMatchResponse.c \ - RANAP_IE.c + RANAP_IE.c \ + RANAP_DataVolumeReportList.c \ + RANAP_RAB-ReleasedList-IuRelComp.c \ + RANAP_RAB-RelocationReleaseList.c \ + RANAP_RAB-DataForwardingList.c \ + RANAP_RAB-SetupList-RelocReq.c \ + RANAP_RAB-SetupList-RelocReqAck.c \ + RANAP_RAB-FailedList.c \ + RANAP_RAB-DataForwardingList-SRNS-CtxReq.c \ + RANAP_RAB-ContextList.c \ + RANAP_RAB-ContextFailedtoTransferList.c \ + RANAP_RAB-DataVolumeReportRequestList.c \ + RANAP_RAB-FailedtoReportList.c \ + RANAP_RAB-SetupList-EnhancedRelocCompleteReq.c \ + RANAP_RAB-SetupList-EnhancedRelocCompleteRes.c \ + RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.c \ + RANAP_RAB-SetupOrModifiedList.c \ + RANAP_RAB-ReleasedList.c \ + RANAP_RAB-QueuedList.c \ + RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.c \ + RANAP_RAB-ContextList-RANAP-RelocInf.c ASN_MODULE_HEADERS= \ RANAP_Criticality.h \ @@ -992,7 +1012,31 @@ ASN_MODULE_HEADERS= \ RANAP_SRVCC-CSKeysResponse.h \ RANAP_UeRadioCapabilityMatchRequest.h \ RANAP_UeRadioCapabilityMatchResponse.h \ - RANAP_IE.h + RANAP_IE.h \ + RANAP_DataVolumeReportList.h \ + RANAP_RAB-ReleasedList-IuRelComp.h \ + RANAP_RAB-RelocationReleaseList.h \ + RANAP_RAB-DataForwardingList.h \ + RANAP_RAB-SetupList-RelocReq.h \ + RANAP_RAB-SetupList-RelocReqAck.h \ + RANAP_RAB-FailedList.h \ + RANAP_RAB-DataForwardingList-SRNS-CtxReq.h \ + RANAP_RAB-ContextList.h \ + RANAP_RAB-ContextFailedtoTransferList.h \ + RANAP_RAB-DataVolumeReportRequestList.h \ + RANAP_RAB-FailedtoReportList.h \ + RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h \ + RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h \ + RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h \ + RANAP_RAB-SetupOrModifiedList.h \ + RANAP_RAB-ReleasedList.h \ + RANAP_RAB-QueuedList.h \ + RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h \ + RANAP_RAB-ContextList-RANAP-RelocInf.h \ + RANAP_RAB-SetupList-EnhRelocInfoReq.h \ + RANAP_RAB-SetupList-EnhRelocInfoRes.h \ + RANAP_RAB-FailedList-EnhRelocInfoRes.h \ + RANAP_RAB-ModifyList.h lib_LTLIBRARIES=libosmo-asn1-ranap.la diff --git a/src/ranap/RANAP_DataVolumeReportList.c b/src/ranap/RANAP_DataVolumeReportList.c new file mode 100644 index 0000000..391f673 --- /dev/null +++ b/src/ranap/RANAP_DataVolumeReportList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_DataVolumeReportList.h" + +static int +memb_dataVolumeReportListe_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_dataVolumeReportListe_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_dataVolumeReportListe_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_dataVolumeReportListe_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_dataVolumeReportListe_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_dataVolumeReportListe_ies_specs_2 = { + sizeof(struct dataVolumeReportListe_ies), + offsetof(struct dataVolumeReportListe_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_dataVolumeReportListe_ies_2 = { + "dataVolumeReportListe-ies", + "dataVolumeReportListe-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_dataVolumeReportListe_ies_tags_2, + sizeof(asn_DEF_dataVolumeReportListe_ies_tags_2) + /sizeof(asn_DEF_dataVolumeReportListe_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_dataVolumeReportListe_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_dataVolumeReportListe_ies_tags_2) + /sizeof(asn_DEF_dataVolumeReportListe_ies_tags_2[0]), /* 2 */ + &asn_PER_type_dataVolumeReportListe_ies_constr_2, + asn_MBR_dataVolumeReportListe_ies_2, + 1, /* Single element */ + &asn_SPC_dataVolumeReportListe_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_DataVolumeReportList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_DataVolumeReportList, dataVolumeReportListe_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_dataVolumeReportListe_ies_2, + memb_dataVolumeReportListe_ies_constraint_1, + &asn_PER_memb_dataVolumeReportListe_ies_constr_2, + 0, + "dataVolumeReportListe-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_DataVolumeReportList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_DataVolumeReportList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* dataVolumeReportListe-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_DataVolumeReportList_specs_1 = { + sizeof(struct RANAP_DataVolumeReportList), + offsetof(struct RANAP_DataVolumeReportList, _asn_ctx), + asn_MAP_RANAP_DataVolumeReportList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_DataVolumeReportList = { + "RANAP_DataVolumeReportList", + "RANAP_DataVolumeReportList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_DataVolumeReportList_tags_1, + sizeof(asn_DEF_RANAP_DataVolumeReportList_tags_1) + /sizeof(asn_DEF_RANAP_DataVolumeReportList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_DataVolumeReportList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_DataVolumeReportList_tags_1) + /sizeof(asn_DEF_RANAP_DataVolumeReportList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_DataVolumeReportList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_DataVolumeReportList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_DataVolumeReportList.h b/src/ranap/RANAP_DataVolumeReportList.h new file mode 100644 index 0000000..98aba41 --- /dev/null +++ b/src/ranap/RANAP_DataVolumeReportList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_DataVolumeReportList_H_ +#define _RANAP_DataVolumeReportList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_DataVolumeReportList */ +typedef struct RANAP_DataVolumeReportList { + struct dataVolumeReportListe_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } dataVolumeReportListe_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_DataVolumeReportList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_DataVolumeReportList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_DataVolumeReportList_H_ */ +#include diff --git a/src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.c b/src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.c new file mode 100644 index 0000000..15ddafe --- /dev/null +++ b/src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h" + +static int +memb_foo_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_foo_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_foo_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_foo_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_foo_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_foo_ies_specs_2 = { + sizeof(struct foo_ies), + offsetof(struct foo_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_foo_ies_2 = { + "foo-ies", + "foo-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_foo_ies_tags_2, + sizeof(asn_DEF_foo_ies_tags_2) + /sizeof(asn_DEF_foo_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_foo_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_foo_ies_tags_2) + /sizeof(asn_DEF_foo_ies_tags_2[0]), /* 2 */ + &asn_PER_type_foo_ies_constr_2, + asn_MBR_foo_ies_2, + 1, /* Single element */ + &asn_SPC_foo_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse, foo_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_foo_ies_2, + memb_foo_ies_constraint_1, + &asn_PER_memb_foo_ies_constr_2, + 0, + "foo-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* foo-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_specs_1 = { + sizeof(struct RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse), + offsetof(struct RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse, _asn_ctx), + asn_MAP_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse = { + "RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse", + "RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1, + sizeof(asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1) + /sizeof(asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1[0]), /* 1 */ + asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1) + /sizeof(asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_1, + 1, /* Elements count */ + &asn_SPC_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h b/src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h new file mode 100644 index 0000000..0678df0 --- /dev/null +++ b/src/ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_H_ +#define _RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse */ +typedef struct RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse { + struct foo_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } foo_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_GERAN_Iumode_RAB_FailedList_RABAssgntResponse_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ContextFailedtoTransferList.c b/src/ranap/RANAP_RAB-ContextFailedtoTransferList.c new file mode 100644 index 0000000..836b5a5 --- /dev/null +++ b/src/ranap/RANAP_RAB-ContextFailedtoTransferList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ContextFailedtoTransferList.h" + +static int +memb_rabContextFailedtoTransferList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabContextFailedtoTransferList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabContextFailedtoTransferList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabContextFailedtoTransferList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabContextFailedtoTransferList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabContextFailedtoTransferList_ies_specs_2 = { + sizeof(struct rabContextFailedtoTransferList_ies), + offsetof(struct rabContextFailedtoTransferList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabContextFailedtoTransferList_ies_2 = { + "rabContextFailedtoTransferList-ies", + "rabContextFailedtoTransferList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabContextFailedtoTransferList_ies_tags_2, + sizeof(asn_DEF_rabContextFailedtoTransferList_ies_tags_2) + /sizeof(asn_DEF_rabContextFailedtoTransferList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabContextFailedtoTransferList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabContextFailedtoTransferList_ies_tags_2) + /sizeof(asn_DEF_rabContextFailedtoTransferList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabContextFailedtoTransferList_ies_constr_2, + asn_MBR_rabContextFailedtoTransferList_ies_2, + 1, /* Single element */ + &asn_SPC_rabContextFailedtoTransferList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ContextFailedtoTransferList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ContextFailedtoTransferList, rabContextFailedtoTransferList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabContextFailedtoTransferList_ies_2, + memb_rabContextFailedtoTransferList_ies_constraint_1, + &asn_PER_memb_rabContextFailedtoTransferList_ies_constr_2, + 0, + "rabContextFailedtoTransferList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ContextFailedtoTransferList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabContextFailedtoTransferList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ContextFailedtoTransferList_specs_1 = { + sizeof(struct RANAP_RAB_ContextFailedtoTransferList), + offsetof(struct RANAP_RAB_ContextFailedtoTransferList, _asn_ctx), + asn_MAP_RANAP_RAB_ContextFailedtoTransferList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ContextFailedtoTransferList = { + "RANAP_RAB-ContextFailedtoTransferList", + "RANAP_RAB-ContextFailedtoTransferList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1, + sizeof(asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ContextFailedtoTransferList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ContextFailedtoTransferList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ContextFailedtoTransferList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ContextFailedtoTransferList.h b/src/ranap/RANAP_RAB-ContextFailedtoTransferList.h new file mode 100644 index 0000000..85c07b3 --- /dev/null +++ b/src/ranap/RANAP_RAB-ContextFailedtoTransferList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ContextFailedtoTransferList_H_ +#define _RANAP_RAB_ContextFailedtoTransferList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ContextFailedtoTransferList */ +typedef struct RANAP_RAB_ContextFailedtoTransferList { + struct rabContextFailedtoTransferList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabContextFailedtoTransferList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ContextFailedtoTransferList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ContextFailedtoTransferList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ContextFailedtoTransferList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.c b/src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.c new file mode 100644 index 0000000..de6c6ae --- /dev/null +++ b/src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ContextList-RANAP-RelocInf.h" + +static int +memb_rabContextListRANAPRelocInf_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabContextListRANAPRelocInf_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabContextListRANAPRelocInf_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabContextListRANAPRelocInf_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabContextListRANAPRelocInf_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabContextListRANAPRelocInf_ies_specs_2 = { + sizeof(struct rabContextListRANAPRelocInf_ies), + offsetof(struct rabContextListRANAPRelocInf_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabContextListRANAPRelocInf_ies_2 = { + "rabContextListRANAPRelocInf-ies", + "rabContextListRANAPRelocInf-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabContextListRANAPRelocInf_ies_tags_2, + sizeof(asn_DEF_rabContextListRANAPRelocInf_ies_tags_2) + /sizeof(asn_DEF_rabContextListRANAPRelocInf_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabContextListRANAPRelocInf_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabContextListRANAPRelocInf_ies_tags_2) + /sizeof(asn_DEF_rabContextListRANAPRelocInf_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabContextListRANAPRelocInf_ies_constr_2, + asn_MBR_rabContextListRANAPRelocInf_ies_2, + 1, /* Single element */ + &asn_SPC_rabContextListRANAPRelocInf_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ContextList_RANAP_RelocInf_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ContextList_RANAP_RelocInf, rabContextListRANAPRelocInf_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabContextListRANAPRelocInf_ies_2, + memb_rabContextListRANAPRelocInf_ies_constraint_1, + &asn_PER_memb_rabContextListRANAPRelocInf_ies_constr_2, + 0, + "rabContextListRANAPRelocInf-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ContextList_RANAP_RelocInf_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabContextListRANAPRelocInf-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ContextList_RANAP_RelocInf_specs_1 = { + sizeof(struct RANAP_RAB_ContextList_RANAP_RelocInf), + offsetof(struct RANAP_RAB_ContextList_RANAP_RelocInf, _asn_ctx), + asn_MAP_RANAP_RAB_ContextList_RANAP_RelocInf_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf = { + "RANAP_RAB-ContextList-RANAP-RelocInf", + "RANAP_RAB-ContextList-RANAP-RelocInf", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1, + sizeof(asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ContextList_RANAP_RelocInf_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ContextList_RANAP_RelocInf_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.h b/src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.h new file mode 100644 index 0000000..dfa50ef --- /dev/null +++ b/src/ranap/RANAP_RAB-ContextList-RANAP-RelocInf.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ContextList_RANAP_RelocInf_H_ +#define _RANAP_RAB_ContextList_RANAP_RelocInf_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ContextList-RANAP-RelocInf */ +typedef struct RANAP_RAB_ContextList_RANAP_RelocInf { + struct rabContextListRANAPRelocInf_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabContextListRANAPRelocInf_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ContextList_RANAP_RelocInf_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ContextList_RANAP_RelocInf; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ContextList_RANAP_RelocInf_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ContextList.c b/src/ranap/RANAP_RAB-ContextList.c new file mode 100644 index 0000000..6650b91 --- /dev/null +++ b/src/ranap/RANAP_RAB-ContextList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ContextList.h" + +static int +memb_rabContextList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabContextList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabContextList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabContextList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabContextList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabContextList_ies_specs_2 = { + sizeof(struct rabContextList_ies), + offsetof(struct rabContextList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabContextList_ies_2 = { + "rabContextList-ies", + "rabContextList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabContextList_ies_tags_2, + sizeof(asn_DEF_rabContextList_ies_tags_2) + /sizeof(asn_DEF_rabContextList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabContextList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabContextList_ies_tags_2) + /sizeof(asn_DEF_rabContextList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabContextList_ies_constr_2, + asn_MBR_rabContextList_ies_2, + 1, /* Single element */ + &asn_SPC_rabContextList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ContextList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ContextList, rabContextList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabContextList_ies_2, + memb_rabContextList_ies_constraint_1, + &asn_PER_memb_rabContextList_ies_constr_2, + 0, + "rabContextList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ContextList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ContextList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabContextList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ContextList_specs_1 = { + sizeof(struct RANAP_RAB_ContextList), + offsetof(struct RANAP_RAB_ContextList, _asn_ctx), + asn_MAP_RANAP_RAB_ContextList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ContextList = { + "RANAP_RAB-ContextList", + "RANAP_RAB-ContextList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ContextList_tags_1, + sizeof(asn_DEF_RANAP_RAB_ContextList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ContextList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ContextList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ContextList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ContextList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ContextList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ContextList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ContextList.h b/src/ranap/RANAP_RAB-ContextList.h new file mode 100644 index 0000000..b480389 --- /dev/null +++ b/src/ranap/RANAP_RAB-ContextList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ContextList_H_ +#define _RANAP_RAB_ContextList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ContextList */ +typedef struct RANAP_RAB_ContextList { + struct rabContextList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabContextList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ContextList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ContextList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ContextList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.c b/src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.c new file mode 100644 index 0000000..aa44e11 --- /dev/null +++ b/src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-DataForwardingList-SRNS-CtxReq.h" + +static int +memb_rabDataForwardingListSRNSCtxReq_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabDataForwardingListSRNSCtxReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabDataForwardingListSRNSCtxReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabDataForwardingListSRNSCtxReq_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabDataForwardingListSRNSCtxReq_ies_specs_2 = { + sizeof(struct rabDataForwardingListSRNSCtxReq_ies), + offsetof(struct rabDataForwardingListSRNSCtxReq_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabDataForwardingListSRNSCtxReq_ies_2 = { + "rabDataForwardingListSRNSCtxReq-ies", + "rabDataForwardingListSRNSCtxReq-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2, + sizeof(asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2) + /sizeof(asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2) + /sizeof(asn_DEF_rabDataForwardingListSRNSCtxReq_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabDataForwardingListSRNSCtxReq_ies_constr_2, + asn_MBR_rabDataForwardingListSRNSCtxReq_ies_2, + 1, /* Single element */ + &asn_SPC_rabDataForwardingListSRNSCtxReq_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_DataForwardingList_SRNS_CtxReq_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_DataForwardingList_SRNS_CtxReq, rabDataForwardingListSRNSCtxReq_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabDataForwardingListSRNSCtxReq_ies_2, + memb_rabDataForwardingListSRNSCtxReq_ies_constraint_1, + &asn_PER_memb_rabDataForwardingListSRNSCtxReq_ies_constr_2, + 0, + "rabDataForwardingListSRNSCtxReq-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabDataForwardingListSRNSCtxReq-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_DataForwardingList_SRNS_CtxReq_specs_1 = { + sizeof(struct RANAP_RAB_DataForwardingList_SRNS_CtxReq), + offsetof(struct RANAP_RAB_DataForwardingList_SRNS_CtxReq, _asn_ctx), + asn_MAP_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq = { + "RANAP_RAB-DataForwardingList-SRNS-CtxReq", + "RANAP_RAB-DataForwardingList-SRNS-CtxReq", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1, + sizeof(asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_DataForwardingList_SRNS_CtxReq_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_DataForwardingList_SRNS_CtxReq_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.h b/src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.h new file mode 100644 index 0000000..50d5771 --- /dev/null +++ b/src/ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_DataForwardingList_SRNS_CtxReq_H_ +#define _RANAP_RAB_DataForwardingList_SRNS_CtxReq_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-DataForwardingList-SRNS-CtxReq */ +typedef struct RANAP_RAB_DataForwardingList_SRNS_CtxReq { + struct rabDataForwardingListSRNSCtxReq_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabDataForwardingListSRNSCtxReq_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_DataForwardingList_SRNS_CtxReq_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_DataForwardingList_SRNS_CtxReq; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_DataForwardingList_SRNS_CtxReq_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-DataForwardingList.c b/src/ranap/RANAP_RAB-DataForwardingList.c new file mode 100644 index 0000000..ae67293 --- /dev/null +++ b/src/ranap/RANAP_RAB-DataForwardingList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-DataForwardingList.h" + +static int +memb_rabDataForwardingList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabDataForwardingList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabDataForwardingList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabDataForwardingList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabDataForwardingList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabDataForwardingList_ies_specs_2 = { + sizeof(struct rabDataForwardingList_ies), + offsetof(struct rabDataForwardingList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabDataForwardingList_ies_2 = { + "rabDataForwardingList-ies", + "rabDataForwardingList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabDataForwardingList_ies_tags_2, + sizeof(asn_DEF_rabDataForwardingList_ies_tags_2) + /sizeof(asn_DEF_rabDataForwardingList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabDataForwardingList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabDataForwardingList_ies_tags_2) + /sizeof(asn_DEF_rabDataForwardingList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabDataForwardingList_ies_constr_2, + asn_MBR_rabDataForwardingList_ies_2, + 1, /* Single element */ + &asn_SPC_rabDataForwardingList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_DataForwardingList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_DataForwardingList, rabDataForwardingList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabDataForwardingList_ies_2, + memb_rabDataForwardingList_ies_constraint_1, + &asn_PER_memb_rabDataForwardingList_ies_constr_2, + 0, + "rabDataForwardingList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_DataForwardingList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_DataForwardingList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabDataForwardingList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_DataForwardingList_specs_1 = { + sizeof(struct RANAP_RAB_DataForwardingList), + offsetof(struct RANAP_RAB_DataForwardingList, _asn_ctx), + asn_MAP_RANAP_RAB_DataForwardingList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_DataForwardingList = { + "RANAP_RAB-DataForwardingList", + "RANAP_RAB-DataForwardingList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_DataForwardingList_tags_1, + sizeof(asn_DEF_RANAP_RAB_DataForwardingList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_DataForwardingList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_DataForwardingList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_DataForwardingList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_DataForwardingList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_DataForwardingList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_DataForwardingList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-DataForwardingList.h b/src/ranap/RANAP_RAB-DataForwardingList.h new file mode 100644 index 0000000..c049071 --- /dev/null +++ b/src/ranap/RANAP_RAB-DataForwardingList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_DataForwardingList_H_ +#define _RANAP_RAB_DataForwardingList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-DataForwardingList */ +typedef struct RANAP_RAB_DataForwardingList { + struct rabDataForwardingList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabDataForwardingList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_DataForwardingList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_DataForwardingList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_DataForwardingList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-DataVolumeReportRequestList.c b/src/ranap/RANAP_RAB-DataVolumeReportRequestList.c new file mode 100644 index 0000000..fc1feaa --- /dev/null +++ b/src/ranap/RANAP_RAB-DataVolumeReportRequestList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-DataVolumeReportRequestList.h" + +static int +memb_rabDataVolumeReportRequestList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabDataVolumeReportRequestList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabDataVolumeReportRequestList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabDataVolumeReportRequestList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabDataVolumeReportRequestList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabDataVolumeReportRequestList_ies_specs_2 = { + sizeof(struct rabDataVolumeReportRequestList_ies), + offsetof(struct rabDataVolumeReportRequestList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabDataVolumeReportRequestList_ies_2 = { + "rabDataVolumeReportRequestList-ies", + "rabDataVolumeReportRequestList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabDataVolumeReportRequestList_ies_tags_2, + sizeof(asn_DEF_rabDataVolumeReportRequestList_ies_tags_2) + /sizeof(asn_DEF_rabDataVolumeReportRequestList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabDataVolumeReportRequestList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabDataVolumeReportRequestList_ies_tags_2) + /sizeof(asn_DEF_rabDataVolumeReportRequestList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabDataVolumeReportRequestList_ies_constr_2, + asn_MBR_rabDataVolumeReportRequestList_ies_2, + 1, /* Single element */ + &asn_SPC_rabDataVolumeReportRequestList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_DataVolumeReportRequestList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_DataVolumeReportRequestList, rabDataVolumeReportRequestList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabDataVolumeReportRequestList_ies_2, + memb_rabDataVolumeReportRequestList_ies_constraint_1, + &asn_PER_memb_rabDataVolumeReportRequestList_ies_constr_2, + 0, + "rabDataVolumeReportRequestList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_DataVolumeReportRequestList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabDataVolumeReportRequestList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_DataVolumeReportRequestList_specs_1 = { + sizeof(struct RANAP_RAB_DataVolumeReportRequestList), + offsetof(struct RANAP_RAB_DataVolumeReportRequestList, _asn_ctx), + asn_MAP_RANAP_RAB_DataVolumeReportRequestList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_DataVolumeReportRequestList = { + "RANAP_RAB-DataVolumeReportRequestList", + "RANAP_RAB-DataVolumeReportRequestList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1, + sizeof(asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_DataVolumeReportRequestList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_DataVolumeReportRequestList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_DataVolumeReportRequestList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-DataVolumeReportRequestList.h b/src/ranap/RANAP_RAB-DataVolumeReportRequestList.h new file mode 100644 index 0000000..c76bd48 --- /dev/null +++ b/src/ranap/RANAP_RAB-DataVolumeReportRequestList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_DataVolumeReportRequestList_H_ +#define _RANAP_RAB_DataVolumeReportRequestList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-DataVolumeReportRequestList */ +typedef struct RANAP_RAB_DataVolumeReportRequestList { + struct rabDataVolumeReportRequestList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabDataVolumeReportRequestList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_DataVolumeReportRequestList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_DataVolumeReportRequestList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_DataVolumeReportRequestList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.c b/src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.c new file mode 100644 index 0000000..a113cf1 --- /dev/null +++ b/src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-FailedList-EnhRelocInfoRes.h" + +static int +memb_rabFailedListEnhRelocInfoRes_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabFailedListEnhRelocInfoRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabFailedListEnhRelocInfoRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabFailedListEnhRelocInfoRes_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabFailedListEnhRelocInfoRes_ies_specs_2 = { + sizeof(struct rabFailedListEnhRelocInfoRes_ies), + offsetof(struct rabFailedListEnhRelocInfoRes_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabFailedListEnhRelocInfoRes_ies_2 = { + "rabFailedListEnhRelocInfoRes-ies", + "rabFailedListEnhRelocInfoRes-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2, + sizeof(asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2) + /sizeof(asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2) + /sizeof(asn_DEF_rabFailedListEnhRelocInfoRes_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabFailedListEnhRelocInfoRes_ies_constr_2, + asn_MBR_rabFailedListEnhRelocInfoRes_ies_2, + 1, /* Single element */ + &asn_SPC_rabFailedListEnhRelocInfoRes_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_FailedList_EnhRelocInfoRes_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_FailedList_EnhRelocInfoRes, rabFailedListEnhRelocInfoRes_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabFailedListEnhRelocInfoRes_ies_2, + memb_rabFailedListEnhRelocInfoRes_ies_constraint_1, + &asn_PER_memb_rabFailedListEnhRelocInfoRes_ies_constr_2, + 0, + "rabFailedListEnhRelocInfoRes-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_FailedList_EnhRelocInfoRes_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabFailedListEnhRelocInfoRes-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_FailedList_EnhRelocInfoRes_specs_1 = { + sizeof(struct RANAP_RAB_FailedList_EnhRelocInfoRes), + offsetof(struct RANAP_RAB_FailedList_EnhRelocInfoRes, _asn_ctx), + asn_MAP_RANAP_RAB_FailedList_EnhRelocInfoRes_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes = { + "RANAP_RAB-FailedList-EnhRelocInfoRes", + "RANAP_RAB-FailedList-EnhRelocInfoRes", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1, + sizeof(asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_FailedList_EnhRelocInfoRes_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_FailedList_EnhRelocInfoRes_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.h b/src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.h new file mode 100644 index 0000000..23a0357 --- /dev/null +++ b/src/ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_FailedList_EnhRelocInfoRes_H_ +#define _RANAP_RAB_FailedList_EnhRelocInfoRes_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-FailedList-EnhRelocInfoRes */ +typedef struct RANAP_RAB_FailedList_EnhRelocInfoRes { + struct rabFailedListEnhRelocInfoRes_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabFailedListEnhRelocInfoRes_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_FailedList_EnhRelocInfoRes_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_FailedList_EnhRelocInfoRes; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_FailedList_EnhRelocInfoRes_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-FailedList.c b/src/ranap/RANAP_RAB-FailedList.c new file mode 100644 index 0000000..3dc8d53 --- /dev/null +++ b/src/ranap/RANAP_RAB-FailedList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-FailedList.h" + +static int +memb_rabFailedList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabFailedList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabFailedList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabFailedList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabFailedList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabFailedList_ies_specs_2 = { + sizeof(struct rabFailedList_ies), + offsetof(struct rabFailedList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabFailedList_ies_2 = { + "rabFailedList-ies", + "rabFailedList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabFailedList_ies_tags_2, + sizeof(asn_DEF_rabFailedList_ies_tags_2) + /sizeof(asn_DEF_rabFailedList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabFailedList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabFailedList_ies_tags_2) + /sizeof(asn_DEF_rabFailedList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabFailedList_ies_constr_2, + asn_MBR_rabFailedList_ies_2, + 1, /* Single element */ + &asn_SPC_rabFailedList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_FailedList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_FailedList, rabFailedList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabFailedList_ies_2, + memb_rabFailedList_ies_constraint_1, + &asn_PER_memb_rabFailedList_ies_constr_2, + 0, + "rabFailedList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_FailedList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_FailedList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabFailedList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_FailedList_specs_1 = { + sizeof(struct RANAP_RAB_FailedList), + offsetof(struct RANAP_RAB_FailedList, _asn_ctx), + asn_MAP_RANAP_RAB_FailedList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_FailedList = { + "RANAP_RAB-FailedList", + "RANAP_RAB-FailedList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_FailedList_tags_1, + sizeof(asn_DEF_RANAP_RAB_FailedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_FailedList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_FailedList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_FailedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_FailedList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_FailedList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_FailedList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-FailedList.h b/src/ranap/RANAP_RAB-FailedList.h new file mode 100644 index 0000000..70b01dc --- /dev/null +++ b/src/ranap/RANAP_RAB-FailedList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_FailedList_H_ +#define _RANAP_RAB_FailedList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-FailedList */ +typedef struct RANAP_RAB_FailedList { + struct rabFailedList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabFailedList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_FailedList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_FailedList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_FailedList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-FailedtoReportList.c b/src/ranap/RANAP_RAB-FailedtoReportList.c new file mode 100644 index 0000000..5dfe091 --- /dev/null +++ b/src/ranap/RANAP_RAB-FailedtoReportList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-FailedtoReportList.h" + +static int +memb_rabFailedtoReportList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabFailedtoReportList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabFailedtoReportList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabFailedtoReportList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabFailedtoReportList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabFailedtoReportList_ies_specs_2 = { + sizeof(struct rabFailedtoReportList_ies), + offsetof(struct rabFailedtoReportList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabFailedtoReportList_ies_2 = { + "rabFailedtoReportList-ies", + "rabFailedtoReportList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabFailedtoReportList_ies_tags_2, + sizeof(asn_DEF_rabFailedtoReportList_ies_tags_2) + /sizeof(asn_DEF_rabFailedtoReportList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabFailedtoReportList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabFailedtoReportList_ies_tags_2) + /sizeof(asn_DEF_rabFailedtoReportList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabFailedtoReportList_ies_constr_2, + asn_MBR_rabFailedtoReportList_ies_2, + 1, /* Single element */ + &asn_SPC_rabFailedtoReportList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_FailedtoReportList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_FailedtoReportList, rabFailedtoReportList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabFailedtoReportList_ies_2, + memb_rabFailedtoReportList_ies_constraint_1, + &asn_PER_memb_rabFailedtoReportList_ies_constr_2, + 0, + "rabFailedtoReportList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_FailedtoReportList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_FailedtoReportList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabFailedtoReportList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_FailedtoReportList_specs_1 = { + sizeof(struct RANAP_RAB_FailedtoReportList), + offsetof(struct RANAP_RAB_FailedtoReportList, _asn_ctx), + asn_MAP_RANAP_RAB_FailedtoReportList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_FailedtoReportList = { + "RANAP_RAB-FailedtoReportList", + "RANAP_RAB-FailedtoReportList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_FailedtoReportList_tags_1, + sizeof(asn_DEF_RANAP_RAB_FailedtoReportList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_FailedtoReportList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_FailedtoReportList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_FailedtoReportList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_FailedtoReportList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_FailedtoReportList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_FailedtoReportList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-FailedtoReportList.h b/src/ranap/RANAP_RAB-FailedtoReportList.h new file mode 100644 index 0000000..71a2024 --- /dev/null +++ b/src/ranap/RANAP_RAB-FailedtoReportList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_FailedtoReportList_H_ +#define _RANAP_RAB_FailedtoReportList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-FailedtoReportList */ +typedef struct RANAP_RAB_FailedtoReportList { + struct rabFailedtoReportList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabFailedtoReportList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_FailedtoReportList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_FailedtoReportList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_FailedtoReportList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ModifyList.c b/src/ranap/RANAP_RAB-ModifyList.c new file mode 100644 index 0000000..8e86394 --- /dev/null +++ b/src/ranap/RANAP_RAB-ModifyList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ModifyList.h" + +static int +memb_rabModifyList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabModifyList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabModifyList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabModifyList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabModifyList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabModifyList_ies_specs_2 = { + sizeof(struct rabModifyList_ies), + offsetof(struct rabModifyList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabModifyList_ies_2 = { + "rabModifyList-ies", + "rabModifyList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabModifyList_ies_tags_2, + sizeof(asn_DEF_rabModifyList_ies_tags_2) + /sizeof(asn_DEF_rabModifyList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabModifyList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabModifyList_ies_tags_2) + /sizeof(asn_DEF_rabModifyList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabModifyList_ies_constr_2, + asn_MBR_rabModifyList_ies_2, + 1, /* Single element */ + &asn_SPC_rabModifyList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ModifyList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ModifyList, rabModifyList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabModifyList_ies_2, + memb_rabModifyList_ies_constraint_1, + &asn_PER_memb_rabModifyList_ies_constr_2, + 0, + "rabModifyList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ModifyList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ModifyList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabModifyList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ModifyList_specs_1 = { + sizeof(struct RANAP_RAB_ModifyList), + offsetof(struct RANAP_RAB_ModifyList, _asn_ctx), + asn_MAP_RANAP_RAB_ModifyList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ModifyList = { + "RANAP_RAB-ModifyList", + "RANAP_RAB-ModifyList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ModifyList_tags_1, + sizeof(asn_DEF_RANAP_RAB_ModifyList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ModifyList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ModifyList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ModifyList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ModifyList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ModifyList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ModifyList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ModifyList.h b/src/ranap/RANAP_RAB-ModifyList.h new file mode 100644 index 0000000..9ec1662 --- /dev/null +++ b/src/ranap/RANAP_RAB-ModifyList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ModifyList_H_ +#define _RANAP_RAB_ModifyList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ModifyList */ +typedef struct RANAP_RAB_ModifyList { + struct rabModifyList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabModifyList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ModifyList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ModifyList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ModifyList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-QueuedList.c b/src/ranap/RANAP_RAB-QueuedList.c new file mode 100644 index 0000000..d8bf291 --- /dev/null +++ b/src/ranap/RANAP_RAB-QueuedList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-QueuedList.h" + +static int +memb_rabQueuedList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabQueuedList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabQueuedList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabQueuedList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabQueuedList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabQueuedList_ies_specs_2 = { + sizeof(struct rabQueuedList_ies), + offsetof(struct rabQueuedList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabQueuedList_ies_2 = { + "rabQueuedList-ies", + "rabQueuedList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabQueuedList_ies_tags_2, + sizeof(asn_DEF_rabQueuedList_ies_tags_2) + /sizeof(asn_DEF_rabQueuedList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabQueuedList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabQueuedList_ies_tags_2) + /sizeof(asn_DEF_rabQueuedList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabQueuedList_ies_constr_2, + asn_MBR_rabQueuedList_ies_2, + 1, /* Single element */ + &asn_SPC_rabQueuedList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_QueuedList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_QueuedList, rabQueuedList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabQueuedList_ies_2, + memb_rabQueuedList_ies_constraint_1, + &asn_PER_memb_rabQueuedList_ies_constr_2, + 0, + "rabQueuedList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_QueuedList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_QueuedList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabQueuedList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_QueuedList_specs_1 = { + sizeof(struct RANAP_RAB_QueuedList), + offsetof(struct RANAP_RAB_QueuedList, _asn_ctx), + asn_MAP_RANAP_RAB_QueuedList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_QueuedList = { + "RANAP_RAB-QueuedList", + "RANAP_RAB-QueuedList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_QueuedList_tags_1, + sizeof(asn_DEF_RANAP_RAB_QueuedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_QueuedList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_QueuedList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_QueuedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_QueuedList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_QueuedList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_QueuedList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-QueuedList.h b/src/ranap/RANAP_RAB-QueuedList.h new file mode 100644 index 0000000..5380eb3 --- /dev/null +++ b/src/ranap/RANAP_RAB-QueuedList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_QueuedList_H_ +#define _RANAP_RAB_QueuedList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-QueuedList */ +typedef struct RANAP_RAB_QueuedList { + struct rabQueuedList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabQueuedList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_QueuedList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_QueuedList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_QueuedList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ReleasedList-IuRelComp.c b/src/ranap/RANAP_RAB-ReleasedList-IuRelComp.c new file mode 100644 index 0000000..d97baa5 --- /dev/null +++ b/src/ranap/RANAP_RAB-ReleasedList-IuRelComp.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ReleasedList-IuRelComp.h" + +static int +memb_rabReleasedListIuRelComp_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabReleasedListIuRelComp_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabReleasedListIuRelComp_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabReleasedListIuRelComp_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabReleasedListIuRelComp_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabReleasedListIuRelComp_ies_specs_2 = { + sizeof(struct rabReleasedListIuRelComp_ies), + offsetof(struct rabReleasedListIuRelComp_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabReleasedListIuRelComp_ies_2 = { + "rabReleasedListIuRelComp-ies", + "rabReleasedListIuRelComp-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabReleasedListIuRelComp_ies_tags_2, + sizeof(asn_DEF_rabReleasedListIuRelComp_ies_tags_2) + /sizeof(asn_DEF_rabReleasedListIuRelComp_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabReleasedListIuRelComp_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabReleasedListIuRelComp_ies_tags_2) + /sizeof(asn_DEF_rabReleasedListIuRelComp_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabReleasedListIuRelComp_ies_constr_2, + asn_MBR_rabReleasedListIuRelComp_ies_2, + 1, /* Single element */ + &asn_SPC_rabReleasedListIuRelComp_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ReleasedList_IuRelComp_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ReleasedList_IuRelComp, rabReleasedListIuRelComp_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabReleasedListIuRelComp_ies_2, + memb_rabReleasedListIuRelComp_ies_constraint_1, + &asn_PER_memb_rabReleasedListIuRelComp_ies_constr_2, + 0, + "rabReleasedListIuRelComp-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ReleasedList_IuRelComp_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabReleasedListIuRelComp-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ReleasedList_IuRelComp_specs_1 = { + sizeof(struct RANAP_RAB_ReleasedList_IuRelComp), + offsetof(struct RANAP_RAB_ReleasedList_IuRelComp, _asn_ctx), + asn_MAP_RANAP_RAB_ReleasedList_IuRelComp_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ReleasedList_IuRelComp = { + "RANAP_RAB-ReleasedList-IuRelComp", + "RANAP_RAB-ReleasedList-IuRelComp", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1, + sizeof(asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ReleasedList_IuRelComp_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ReleasedList_IuRelComp_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ReleasedList_IuRelComp_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ReleasedList-IuRelComp.h b/src/ranap/RANAP_RAB-ReleasedList-IuRelComp.h new file mode 100644 index 0000000..0a555e7 --- /dev/null +++ b/src/ranap/RANAP_RAB-ReleasedList-IuRelComp.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ReleasedList_IuRelComp_H_ +#define _RANAP_RAB_ReleasedList_IuRelComp_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ReleasedList-IuRelComp */ +typedef struct RANAP_RAB_ReleasedList_IuRelComp { + struct rabReleasedListIuRelComp_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabReleasedListIuRelComp_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ReleasedList_IuRelComp_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ReleasedList_IuRelComp; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ReleasedList_IuRelComp_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ReleasedList.c b/src/ranap/RANAP_RAB-ReleasedList.c new file mode 100644 index 0000000..d4f55d3 --- /dev/null +++ b/src/ranap/RANAP_RAB-ReleasedList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ReleasedList.h" + +static int +memb_rabReleaesdList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabReleaesdList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabReleaesdList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabReleaesdList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabReleaesdList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabReleaesdList_ies_specs_2 = { + sizeof(struct rabReleaesdList_ies), + offsetof(struct rabReleaesdList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabReleaesdList_ies_2 = { + "rabReleaesdList-ies", + "rabReleaesdList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabReleaesdList_ies_tags_2, + sizeof(asn_DEF_rabReleaesdList_ies_tags_2) + /sizeof(asn_DEF_rabReleaesdList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabReleaesdList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabReleaesdList_ies_tags_2) + /sizeof(asn_DEF_rabReleaesdList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabReleaesdList_ies_constr_2, + asn_MBR_rabReleaesdList_ies_2, + 1, /* Single element */ + &asn_SPC_rabReleaesdList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ReleasedList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ReleasedList, rabReleaesdList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabReleaesdList_ies_2, + memb_rabReleaesdList_ies_constraint_1, + &asn_PER_memb_rabReleaesdList_ies_constr_2, + 0, + "rabReleaesdList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ReleasedList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ReleasedList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabReleaesdList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ReleasedList_specs_1 = { + sizeof(struct RANAP_RAB_ReleasedList), + offsetof(struct RANAP_RAB_ReleasedList, _asn_ctx), + asn_MAP_RANAP_RAB_ReleasedList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ReleasedList = { + "RANAP_RAB-ReleasedList", + "RANAP_RAB-ReleasedList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ReleasedList_tags_1, + sizeof(asn_DEF_RANAP_RAB_ReleasedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ReleasedList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ReleasedList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ReleasedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ReleasedList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ReleasedList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ReleasedList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ReleasedList.h b/src/ranap/RANAP_RAB-ReleasedList.h new file mode 100644 index 0000000..5d815d8 --- /dev/null +++ b/src/ranap/RANAP_RAB-ReleasedList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ReleasedList_H_ +#define _RANAP_RAB_ReleasedList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ReleasedList */ +typedef struct RANAP_RAB_ReleasedList { + struct rabReleaesdList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabReleaesdList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ReleasedList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ReleasedList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ReleasedList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-RelocationReleaseList.c b/src/ranap/RANAP_RAB-RelocationReleaseList.c new file mode 100644 index 0000000..b836c55 --- /dev/null +++ b/src/ranap/RANAP_RAB-RelocationReleaseList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-RelocationReleaseList.h" + +static int +memb_rabRelocationReleaseList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabRelocationReleaseList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabRelocationReleaseList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabRelocationReleaseList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabRelocationReleaseList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabRelocationReleaseList_ies_specs_2 = { + sizeof(struct rabRelocationReleaseList_ies), + offsetof(struct rabRelocationReleaseList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabRelocationReleaseList_ies_2 = { + "rabRelocationReleaseList-ies", + "rabRelocationReleaseList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabRelocationReleaseList_ies_tags_2, + sizeof(asn_DEF_rabRelocationReleaseList_ies_tags_2) + /sizeof(asn_DEF_rabRelocationReleaseList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabRelocationReleaseList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabRelocationReleaseList_ies_tags_2) + /sizeof(asn_DEF_rabRelocationReleaseList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabRelocationReleaseList_ies_constr_2, + asn_MBR_rabRelocationReleaseList_ies_2, + 1, /* Single element */ + &asn_SPC_rabRelocationReleaseList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_RelocationReleaseList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_RelocationReleaseList, rabRelocationReleaseList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabRelocationReleaseList_ies_2, + memb_rabRelocationReleaseList_ies_constraint_1, + &asn_PER_memb_rabRelocationReleaseList_ies_constr_2, + 0, + "rabRelocationReleaseList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_RelocationReleaseList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabRelocationReleaseList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_RelocationReleaseList_specs_1 = { + sizeof(struct RANAP_RAB_RelocationReleaseList), + offsetof(struct RANAP_RAB_RelocationReleaseList, _asn_ctx), + asn_MAP_RANAP_RAB_RelocationReleaseList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_RelocationReleaseList = { + "RANAP_RAB-RelocationReleaseList", + "RANAP_RAB-RelocationReleaseList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1, + sizeof(asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_RelocationReleaseList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_RelocationReleaseList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_RelocationReleaseList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-RelocationReleaseList.h b/src/ranap/RANAP_RAB-RelocationReleaseList.h new file mode 100644 index 0000000..a68f756 --- /dev/null +++ b/src/ranap/RANAP_RAB-RelocationReleaseList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_RelocationReleaseList_H_ +#define _RANAP_RAB_RelocationReleaseList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-RelocationReleaseList */ +typedef struct RANAP_RAB_RelocationReleaseList { + struct rabRelocationReleaseList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabRelocationReleaseList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_RelocationReleaseList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_RelocationReleaseList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_RelocationReleaseList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.c b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.c new file mode 100644 index 0000000..d606080 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupList-EnhRelocInfoReq.h" + +static int +memb_rabSetupListEnhRelocInfoReq_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupListEnhRelocInfoReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupListEnhRelocInfoReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupListEnhRelocInfoReq_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupListEnhRelocInfoReq_ies_specs_2 = { + sizeof(struct rabSetupListEnhRelocInfoReq_ies), + offsetof(struct rabSetupListEnhRelocInfoReq_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupListEnhRelocInfoReq_ies_2 = { + "rabSetupListEnhRelocInfoReq-ies", + "rabSetupListEnhRelocInfoReq-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2, + sizeof(asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhRelocInfoReq_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupListEnhRelocInfoReq_ies_constr_2, + asn_MBR_rabSetupListEnhRelocInfoReq_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupListEnhRelocInfoReq_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupList_EnhRelocInfoReq_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupList_EnhRelocInfoReq, rabSetupListEnhRelocInfoReq_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupListEnhRelocInfoReq_ies_2, + memb_rabSetupListEnhRelocInfoReq_ies_constraint_1, + &asn_PER_memb_rabSetupListEnhRelocInfoReq_ies_constr_2, + 0, + "rabSetupListEnhRelocInfoReq-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupList_EnhRelocInfoReq_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupListEnhRelocInfoReq-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupList_EnhRelocInfoReq_specs_1 = { + sizeof(struct RANAP_RAB_SetupList_EnhRelocInfoReq), + offsetof(struct RANAP_RAB_SetupList_EnhRelocInfoReq, _asn_ctx), + asn_MAP_RANAP_RAB_SetupList_EnhRelocInfoReq_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq = { + "RANAP_RAB-SetupList-EnhRelocInfoReq", + "RANAP_RAB-SetupList-EnhRelocInfoReq", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupList_EnhRelocInfoReq_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupList_EnhRelocInfoReq_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.h b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.h new file mode 100644 index 0000000..92f034e --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupList_EnhRelocInfoReq_H_ +#define _RANAP_RAB_SetupList_EnhRelocInfoReq_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupList-EnhRelocInfoReq */ +typedef struct RANAP_RAB_SetupList_EnhRelocInfoReq { + struct rabSetupListEnhRelocInfoReq_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupListEnhRelocInfoReq_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupList_EnhRelocInfoReq_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoReq; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupList_EnhRelocInfoReq_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.c b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.c new file mode 100644 index 0000000..b580e2f --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupList-EnhRelocInfoRes.h" + +static int +memb_rabSetupListEnhRelocInfoRes_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupListEnhRelocInfoRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupListEnhRelocInfoRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupListEnhRelocInfoRes_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupListEnhRelocInfoRes_ies_specs_2 = { + sizeof(struct rabSetupListEnhRelocInfoRes_ies), + offsetof(struct rabSetupListEnhRelocInfoRes_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupListEnhRelocInfoRes_ies_2 = { + "rabSetupListEnhRelocInfoRes-ies", + "rabSetupListEnhRelocInfoRes-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2, + sizeof(asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhRelocInfoRes_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupListEnhRelocInfoRes_ies_constr_2, + asn_MBR_rabSetupListEnhRelocInfoRes_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupListEnhRelocInfoRes_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupList_EnhRelocInfoRes_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupList_EnhRelocInfoRes, rabSetupListEnhRelocInfoRes_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupListEnhRelocInfoRes_ies_2, + memb_rabSetupListEnhRelocInfoRes_ies_constraint_1, + &asn_PER_memb_rabSetupListEnhRelocInfoRes_ies_constr_2, + 0, + "rabSetupListEnhRelocInfoRes-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupList_EnhRelocInfoRes_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupListEnhRelocInfoRes-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupList_EnhRelocInfoRes_specs_1 = { + sizeof(struct RANAP_RAB_SetupList_EnhRelocInfoRes), + offsetof(struct RANAP_RAB_SetupList_EnhRelocInfoRes, _asn_ctx), + asn_MAP_RANAP_RAB_SetupList_EnhRelocInfoRes_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes = { + "RANAP_RAB-SetupList-EnhRelocInfoRes", + "RANAP_RAB-SetupList-EnhRelocInfoRes", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupList_EnhRelocInfoRes_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupList_EnhRelocInfoRes_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.h b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.h new file mode 100644 index 0000000..611bd03 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupList_EnhRelocInfoRes_H_ +#define _RANAP_RAB_SetupList_EnhRelocInfoRes_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupList-EnhRelocInfoRes */ +typedef struct RANAP_RAB_SetupList_EnhRelocInfoRes { + struct rabSetupListEnhRelocInfoRes_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupListEnhRelocInfoRes_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupList_EnhRelocInfoRes_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhRelocInfoRes; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupList_EnhRelocInfoRes_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.c b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.c new file mode 100644 index 0000000..2b7579c --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h" + +static int +memb_rabSetupListEnhancedRElocCompleteReq_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupListEnhancedRElocCompleteReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupListEnhancedRElocCompleteReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupListEnhancedRElocCompleteReq_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupListEnhancedRElocCompleteReq_ies_specs_2 = { + sizeof(struct rabSetupListEnhancedRElocCompleteReq_ies), + offsetof(struct rabSetupListEnhancedRElocCompleteReq_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_2 = { + "rabSetupListEnhancedRElocCompleteReq-ies", + "rabSetupListEnhancedRElocCompleteReq-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2, + sizeof(asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupListEnhancedRElocCompleteReq_ies_constr_2, + asn_MBR_rabSetupListEnhancedRElocCompleteReq_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupListEnhancedRElocCompleteReq_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupList_EnhancedRelocCompleteReq, rabSetupListEnhancedRElocCompleteReq_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupListEnhancedRElocCompleteReq_ies_2, + memb_rabSetupListEnhancedRElocCompleteReq_ies_constraint_1, + &asn_PER_memb_rabSetupListEnhancedRElocCompleteReq_ies_constr_2, + 0, + "rabSetupListEnhancedRElocCompleteReq-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupListEnhancedRElocCompleteReq-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_specs_1 = { + sizeof(struct RANAP_RAB_SetupList_EnhancedRelocCompleteReq), + offsetof(struct RANAP_RAB_SetupList_EnhancedRelocCompleteReq, _asn_ctx), + asn_MAP_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq = { + "RANAP_RAB-SetupList-EnhancedRelocCompleteReq", + "RANAP_RAB-SetupList-EnhancedRelocCompleteReq", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupList_EnhancedRelocCompleteReq_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h new file mode 100644 index 0000000..6a6c9bc --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupList_EnhancedRelocCompleteReq_H_ +#define _RANAP_RAB_SetupList_EnhancedRelocCompleteReq_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupList-EnhancedRelocCompleteReq */ +typedef struct RANAP_RAB_SetupList_EnhancedRelocCompleteReq { + struct rabSetupListEnhancedRElocCompleteReq_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupListEnhancedRElocCompleteReq_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupList_EnhancedRelocCompleteReq_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteReq; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupList_EnhancedRelocCompleteReq_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.c b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.c new file mode 100644 index 0000000..6c3d464 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h" + +static int +memb_rabSetupListEnhancedRelocCompleteRes_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupListEnhancedRelocCompleteRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupListEnhancedRelocCompleteRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupListEnhancedRelocCompleteRes_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupListEnhancedRelocCompleteRes_ies_specs_2 = { + sizeof(struct rabSetupListEnhancedRelocCompleteRes_ies), + offsetof(struct rabSetupListEnhancedRelocCompleteRes_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_2 = { + "rabSetupListEnhancedRelocCompleteRes-ies", + "rabSetupListEnhancedRelocCompleteRes-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2, + sizeof(asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2) + /sizeof(asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupListEnhancedRelocCompleteRes_ies_constr_2, + asn_MBR_rabSetupListEnhancedRelocCompleteRes_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupListEnhancedRelocCompleteRes_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupList_EnhancedRelocCompleteRes, rabSetupListEnhancedRelocCompleteRes_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupListEnhancedRelocCompleteRes_ies_2, + memb_rabSetupListEnhancedRelocCompleteRes_ies_constraint_1, + &asn_PER_memb_rabSetupListEnhancedRelocCompleteRes_ies_constr_2, + 0, + "rabSetupListEnhancedRelocCompleteRes-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupListEnhancedRelocCompleteRes-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_specs_1 = { + sizeof(struct RANAP_RAB_SetupList_EnhancedRelocCompleteRes), + offsetof(struct RANAP_RAB_SetupList_EnhancedRelocCompleteRes, _asn_ctx), + asn_MAP_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes = { + "RANAP_RAB-SetupList-EnhancedRelocCompleteRes", + "RANAP_RAB-SetupList-EnhancedRelocCompleteRes", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupList_EnhancedRelocCompleteRes_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h new file mode 100644 index 0000000..d1f3999 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupList_EnhancedRelocCompleteRes_H_ +#define _RANAP_RAB_SetupList_EnhancedRelocCompleteRes_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupList-EnhancedRelocCompleteRes */ +typedef struct RANAP_RAB_SetupList_EnhancedRelocCompleteRes { + struct rabSetupListEnhancedRelocCompleteRes_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupListEnhancedRelocCompleteRes_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupList_EnhancedRelocCompleteRes_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_EnhancedRelocCompleteRes; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupList_EnhancedRelocCompleteRes_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupList-RelocReq.c b/src/ranap/RANAP_RAB-SetupList-RelocReq.c new file mode 100644 index 0000000..ac4b3a6 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-RelocReq.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupList-RelocReq.h" + +static int +memb_rabSetupListRelocReq_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupListRelocReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupListRelocReq_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupListRelocReq_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupListRelocReq_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupListRelocReq_ies_specs_2 = { + sizeof(struct rabSetupListRelocReq_ies), + offsetof(struct rabSetupListRelocReq_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupListRelocReq_ies_2 = { + "rabSetupListRelocReq-ies", + "rabSetupListRelocReq-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupListRelocReq_ies_tags_2, + sizeof(asn_DEF_rabSetupListRelocReq_ies_tags_2) + /sizeof(asn_DEF_rabSetupListRelocReq_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupListRelocReq_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupListRelocReq_ies_tags_2) + /sizeof(asn_DEF_rabSetupListRelocReq_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupListRelocReq_ies_constr_2, + asn_MBR_rabSetupListRelocReq_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupListRelocReq_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupList_RelocReq_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupList_RelocReq, rabSetupListRelocReq_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupListRelocReq_ies_2, + memb_rabSetupListRelocReq_ies_constraint_1, + &asn_PER_memb_rabSetupListRelocReq_ies_constr_2, + 0, + "rabSetupListRelocReq-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupList_RelocReq_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupListRelocReq-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupList_RelocReq_specs_1 = { + sizeof(struct RANAP_RAB_SetupList_RelocReq), + offsetof(struct RANAP_RAB_SetupList_RelocReq, _asn_ctx), + asn_MAP_RANAP_RAB_SetupList_RelocReq_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_RelocReq = { + "RANAP_RAB-SetupList-RelocReq", + "RANAP_RAB-SetupList-RelocReq", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReq_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupList_RelocReq_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupList_RelocReq_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupList-RelocReq.h b/src/ranap/RANAP_RAB-SetupList-RelocReq.h new file mode 100644 index 0000000..84a3a56 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-RelocReq.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupList_RelocReq_H_ +#define _RANAP_RAB_SetupList_RelocReq_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupList-RelocReq */ +typedef struct RANAP_RAB_SetupList_RelocReq { + struct rabSetupListRelocReq_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupListRelocReq_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupList_RelocReq_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_RelocReq; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupList_RelocReq_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupList-RelocReqAck.c b/src/ranap/RANAP_RAB-SetupList-RelocReqAck.c new file mode 100644 index 0000000..0c95d4d --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-RelocReqAck.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupList-RelocReqAck.h" + +static int +memb_rabSetupListRelocReqAck_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupListRelocReqAck_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupListRelocReqAck_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupListRelocReqAck_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupListRelocReqAck_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupListRelocReqAck_ies_specs_2 = { + sizeof(struct rabSetupListRelocReqAck_ies), + offsetof(struct rabSetupListRelocReqAck_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupListRelocReqAck_ies_2 = { + "rabSetupListRelocReqAck-ies", + "rabSetupListRelocReqAck-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupListRelocReqAck_ies_tags_2, + sizeof(asn_DEF_rabSetupListRelocReqAck_ies_tags_2) + /sizeof(asn_DEF_rabSetupListRelocReqAck_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupListRelocReqAck_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupListRelocReqAck_ies_tags_2) + /sizeof(asn_DEF_rabSetupListRelocReqAck_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupListRelocReqAck_ies_constr_2, + asn_MBR_rabSetupListRelocReqAck_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupListRelocReqAck_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupList_RelocReqAck_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupList_RelocReqAck, rabSetupListRelocReqAck_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupListRelocReqAck_ies_2, + memb_rabSetupListRelocReqAck_ies_constraint_1, + &asn_PER_memb_rabSetupListRelocReqAck_ies_constr_2, + 0, + "rabSetupListRelocReqAck-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupList_RelocReqAck_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupListRelocReqAck-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupList_RelocReqAck_specs_1 = { + sizeof(struct RANAP_RAB_SetupList_RelocReqAck), + offsetof(struct RANAP_RAB_SetupList_RelocReqAck, _asn_ctx), + asn_MAP_RANAP_RAB_SetupList_RelocReqAck_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_RelocReqAck = { + "RANAP_RAB-SetupList-RelocReqAck", + "RANAP_RAB-SetupList-RelocReqAck", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupList_RelocReqAck_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupList_RelocReqAck_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupList_RelocReqAck_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupList-RelocReqAck.h b/src/ranap/RANAP_RAB-SetupList-RelocReqAck.h new file mode 100644 index 0000000..a1b16dc --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupList-RelocReqAck.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupList_RelocReqAck_H_ +#define _RANAP_RAB_SetupList_RelocReqAck_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupList-RelocReqAck */ +typedef struct RANAP_RAB_SetupList_RelocReqAck { + struct rabSetupListRelocReqAck_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupListRelocReqAck_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupList_RelocReqAck_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupList_RelocReqAck; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupList_RelocReqAck_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-SetupOrModifiedList.c b/src/ranap/RANAP_RAB-SetupOrModifiedList.c new file mode 100644 index 0000000..499b8b7 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupOrModifiedList.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-SetupOrModifiedList.h" + +static int +memb_rabSetupOrModifiedList_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabSetupOrModifiedList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabSetupOrModifiedList_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabSetupOrModifiedList_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabSetupOrModifiedList_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabSetupOrModifiedList_ies_specs_2 = { + sizeof(struct rabSetupOrModifiedList_ies), + offsetof(struct rabSetupOrModifiedList_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabSetupOrModifiedList_ies_2 = { + "rabSetupOrModifiedList-ies", + "rabSetupOrModifiedList-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabSetupOrModifiedList_ies_tags_2, + sizeof(asn_DEF_rabSetupOrModifiedList_ies_tags_2) + /sizeof(asn_DEF_rabSetupOrModifiedList_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabSetupOrModifiedList_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabSetupOrModifiedList_ies_tags_2) + /sizeof(asn_DEF_rabSetupOrModifiedList_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabSetupOrModifiedList_ies_constr_2, + asn_MBR_rabSetupOrModifiedList_ies_2, + 1, /* Single element */ + &asn_SPC_rabSetupOrModifiedList_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_SetupOrModifiedList_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_SetupOrModifiedList, rabSetupOrModifiedList_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabSetupOrModifiedList_ies_2, + memb_rabSetupOrModifiedList_ies_constraint_1, + &asn_PER_memb_rabSetupOrModifiedList_ies_constr_2, + 0, + "rabSetupOrModifiedList-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_SetupOrModifiedList_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabSetupOrModifiedList-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_SetupOrModifiedList_specs_1 = { + sizeof(struct RANAP_RAB_SetupOrModifiedList), + offsetof(struct RANAP_RAB_SetupOrModifiedList, _asn_ctx), + asn_MAP_RANAP_RAB_SetupOrModifiedList_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupOrModifiedList = { + "RANAP_RAB-SetupOrModifiedList", + "RANAP_RAB-SetupOrModifiedList", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1, + sizeof(asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1) + /sizeof(asn_DEF_RANAP_RAB_SetupOrModifiedList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_SetupOrModifiedList_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_SetupOrModifiedList_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-SetupOrModifiedList.h b/src/ranap/RANAP_RAB-SetupOrModifiedList.h new file mode 100644 index 0000000..5165ea9 --- /dev/null +++ b/src/ranap/RANAP_RAB-SetupOrModifiedList.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_SetupOrModifiedList_H_ +#define _RANAP_RAB_SetupOrModifiedList_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-SetupOrModifiedList */ +typedef struct RANAP_RAB_SetupOrModifiedList { + struct rabSetupOrModifiedList_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabSetupOrModifiedList_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_SetupOrModifiedList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_SetupOrModifiedList; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_SetupOrModifiedList_H_ */ +#include diff --git a/src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.c b/src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.c new file mode 100644 index 0000000..de451a0 --- /dev/null +++ b/src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.c @@ -0,0 +1,145 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#include "RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h" + +static int +memb_rabToBeReleasedListEnhancedRelocCompleteRes_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* Determine the number of elements */ + size = _A_CSEQUENCE_FROM_VOID(sptr)->count; + + if((size <= 65535l)) { + /* Perform validation of the inner elements */ + return td->check_constraints(td, sptr, ctfailcb, app_key); + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_per_constraints_t asn_PER_type_rabToBeReleasedListEnhancedRelocCompleteRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_per_constraints_t asn_PER_memb_rabToBeReleasedListEnhancedRelocCompleteRes_ies_constr_2 GCC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 16, 16, 0l, 65535l } /* (SIZE(0..65535)) */, + 0, 0 /* No PER value map */ +}; +static asn_TYPE_member_t asn_MBR_rabToBeReleasedListEnhancedRelocCompleteRes_ies_2[] = { + { ATF_POINTER, 0, 0, + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_RANAP_IE, + 0, /* Defer constraints checking to the member type */ + 0, /* No PER visible constraints */ + 0, + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_rabToBeReleasedListEnhancedRelocCompleteRes_ies_specs_2 = { + sizeof(struct rabToBeReleasedListEnhancedRelocCompleteRes_ies), + offsetof(struct rabToBeReleasedListEnhancedRelocCompleteRes_ies, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_2 = { + "rabToBeReleasedListEnhancedRelocCompleteRes-ies", + "rabToBeReleasedListEnhancedRelocCompleteRes-ies", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + SEQUENCE_OF_decode_uper, + SEQUENCE_OF_encode_uper, + SEQUENCE_OF_decode_aper, + SEQUENCE_OF_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2, + sizeof(asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2) + /sizeof(asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2[0]) - 1, /* 1 */ + asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2, /* Same as above */ + sizeof(asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2) + /sizeof(asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_tags_2[0]), /* 2 */ + &asn_PER_type_rabToBeReleasedListEnhancedRelocCompleteRes_ies_constr_2, + asn_MBR_rabToBeReleasedListEnhancedRelocCompleteRes_ies_2, + 1, /* Single element */ + &asn_SPC_rabToBeReleasedListEnhancedRelocCompleteRes_ies_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes, rabToBeReleasedListEnhancedRelocCompleteRes_ies), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_rabToBeReleasedListEnhancedRelocCompleteRes_ies_2, + memb_rabToBeReleasedListEnhancedRelocCompleteRes_ies_constraint_1, + &asn_PER_memb_rabToBeReleasedListEnhancedRelocCompleteRes_ies_constr_2, + 0, + "rabToBeReleasedListEnhancedRelocCompleteRes-ies" + }, +}; +static const ber_tlv_tag_t asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* rabToBeReleasedListEnhancedRelocCompleteRes-ies */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_specs_1 = { + sizeof(struct RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes), + offsetof(struct RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes, _asn_ctx), + asn_MAP_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tag2el_1, + 1, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 2 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes = { + "RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes", + "RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + SEQUENCE_decode_uper, + SEQUENCE_encode_uper, + SEQUENCE_decode_aper, + SEQUENCE_encode_aper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1, + sizeof(asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1[0]), /* 1 */ + asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1, /* Same as above */ + sizeof(asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1) + /sizeof(asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_1, + 1, /* Elements count */ + &asn_SPC_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_specs_1 /* Additional specs */ +}; + diff --git a/src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h b/src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h new file mode 100644 index 0000000..cffd964 --- /dev/null +++ b/src/ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.28 (http://lionet.info/asn1c) + * From ASN.1 module "RANAP-PDU" + * found in "../../asn1/ranap/RANAP-PDU.asn" + */ + +#ifndef _RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_H_ +#define _RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_H_ + + +#include + +/* Including external dependencies */ +#include "RANAP_IE.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes */ +typedef struct RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes { + struct rabToBeReleasedListEnhancedRelocCompleteRes_ies { + A_SEQUENCE_OF(RANAP_IE_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; + } rabToBeReleasedListEnhancedRelocCompleteRes_ies; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes; + +#ifdef __cplusplus +} +#endif + +#endif /* _RANAP_RAB_ToBeReleasedList_EnhancedRelocCompleteRes_H_ */ +#include diff --git a/src/ranap_common.c b/src/ranap_common.c new file mode 100644 index 0000000..03cad64 --- /dev/null +++ b/src/ranap_common.c @@ -0,0 +1,138 @@ +#include + +#include + +#include "ranap_common.h" +#include "hnbgw.h" + +extern int asn1_xer_print; + +static struct msgb *ranap_msgb_alloc(void) +{ + return msgb_alloc(1024, "RANAP Tx"); +} + +#if 0 +ssize_t ranap_generate_initiating_message(uint8_t ** buffer, + uint32_t * length, + e_RANAP_ProcedureCode procedureCode, + RANAP_Criticality_t criticality, + asn_TYPE_descriptor_t * td, void *sptr) +{ + RANAP_RANAP_PDU_t pdu; + ssize_t encoded; + + memset(&pdu, 0, sizeof(pdu)); + + pdu.present = RANAP_RANAP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage.procedureCode = procedureCode; + pdu.choice.initiatingMessage.criticality = criticality; + ANY_fromType_aper(&pdu.choice.initiatingMessage.value, td, sptr); + + if (asn1_xer_print) + xer_fprint(stdout, &asn_DEF_RANAP_RAMAP_PDU, (void *)&pdu); + + if ((encoded = + aper_encode_to_new_buffer(&asn_DEF_RANAP_RANAP_PDU, 0, &pdu, + (void **)buffer)) < 0) { + return -1; + } + + *length = encoded; + return encoded; +} +#endif + +struct msgb *ranap_generate_successful_outcome( + e_RANAP_ProcedureCode procedureCode, + RANAP_Criticality_t criticality, + asn_TYPE_descriptor_t * td, + void *sptr) +{ + + RANAP_RANAP_PDU_t pdu; + struct msgb *msg = ranap_msgb_alloc(); + asn_enc_rval_t rval; + int rc; + + memset(&pdu, 0, sizeof(pdu)); + pdu.present = RANAP_RANAP_PDU_PR_successfulOutcome; + pdu.choice.successfulOutcome.procedureCode = procedureCode; + pdu.choice.successfulOutcome.criticality = criticality; + rc = ANY_fromType_aper(&pdu.choice.successfulOutcome.value, td, sptr); + if (rc < 0) { + LOGP(DMAIN, LOGL_ERROR, "Error in ANY_fromType_aper\n"); + msgb_free(msg); + return NULL; + } + + rval = aper_encode_to_buffer(&asn_DEF_RANAP_RANAP_PDU, &pdu, + msg->data, msgb_tailroom(msg)); + if (rval.encoded < 0) { + LOGP(DMAIN, LOGL_ERROR, "Error encoding type %s\n", rval.failed_type->name); + msgb_free(msg); + return NULL; + } + + msgb_put(msg, rval.encoded); + + return msg; +} + +#if 0 +ssize_t ranap_generate_unsuccessful_outcome(uint8_t ** buffer, + uint32_t * length, + e_RANAP_ProcedureCode procedureCode, + RANAP_Criticality_t criticality, + asn_TYPE_descriptor_t * td, + void *sptr) +{ + + RANAP_RANAP_PDU_t pdu; + ssize_t encoded; + + memset(&pdu, 0, sizeof(pdu)); + + pdu.present = RANAP_RANAP_PDU_PR_unsuccessfulOutcome; + pdu.choice.successfulOutcome.procedureCode = procedureCode; + pdu.choice.successfulOutcome.criticality = criticality; + ANY_fromType_aper(&pdu.choice.successfulOutcome.value, td, sptr); + + if ((encoded = + aper_encode_to_new_buffer(&asn_DEF_RANAP_RANAP_PDU, 0, &pdu, + (void **)buffer)) < 0) { + return -1; + } + + *length = encoded; + + return encoded; +} +#endif + +RANAP_IE_t *ranap_new_ie(RANAP_ProtocolIE_ID_t id, + RANAP_Criticality_t criticality, + asn_TYPE_descriptor_t * type, void *sptr) +{ + + RANAP_IE_t *buff; + + if ((buff = malloc(sizeof(*buff))) == NULL) { + // Possible error on malloc + return NULL; + } + memset((void *)buff, 0, sizeof(*buff)); + + buff->id = id; + buff->criticality = criticality; + + ANY_fromType_aper(&buff->value, type, sptr); + + if (asn1_xer_print) + if (xer_fprint(stdout, &asn_DEF_RANAP_IE, buff) < 0) { + free(buff); + return NULL; + } + + return buff; +} diff --git a/src/ranap_common.h b/src/ranap_common.h index d57b0e8..3847053 100644 --- a/src/ranap_common.h +++ b/src/ranap_common.h @@ -80,6 +80,7 @@ #include "ranap/RANAP_DataPDUType.h" #include "ranap/RANAP_DataVolumeReference.h" #include "ranap/RANAP_DataVolumeReport.h" +#include "ranap/RANAP_DataVolumeReportList.h" #include "ranap/RANAP_DataVolumeReportRequest.h" #include "ranap/RANAP_DataVolumeReportingIndication.h" #include "ranap/RANAP_DeliveryOfErroneousSDU.h" @@ -127,6 +128,7 @@ #include "ranap/RANAP_GERAN-BSC-Container.h" #include "ranap/RANAP_GERAN-Cell-ID.h" #include "ranap/RANAP_GERAN-Classmark.h" +#include "ranap/RANAP_GERAN-Iumode-RAB-FailedList-RABAssgntResponse.h" #include "ranap/RANAP_GTP-TEI.h" #include "ranap/RANAP_GeographicalArea.h" #include "ranap/RANAP_GeographicalCoordinates.h" @@ -316,15 +318,37 @@ #include "ranap/RANAP_RAB-AssignmentRequest.h" #include "ranap/RANAP_RAB-AssignmentResponse.h" #include "ranap/RANAP_RAB-AsymmetryIndicator.h" +#include "ranap/RANAP_RAB-ContextFailedtoTransferList.h" +#include "ranap/RANAP_RAB-ContextList-RANAP-RelocInf.h" +#include "ranap/RANAP_RAB-ContextList.h" +#include "ranap/RANAP_RAB-DataForwardingList-SRNS-CtxReq.h" +#include "ranap/RANAP_RAB-DataForwardingList.h" +#include "ranap/RANAP_RAB-DataVolumeReportRequestList.h" +#include "ranap/RANAP_RAB-FailedList-EnhRelocInfoRes.h" +#include "ranap/RANAP_RAB-FailedList.h" +#include "ranap/RANAP_RAB-FailedtoReportList.h" #include "ranap/RANAP_RAB-ID.h" +#include "ranap/RANAP_RAB-ModifyList.h" #include "ranap/RANAP_RAB-ModifyRequest.h" #include "ranap/RANAP_RAB-Parameter-ExtendedGuaranteedBitrateList.h" #include "ranap/RANAP_RAB-Parameter-ExtendedMaxBitrateList.h" #include "ranap/RANAP_RAB-Parameter-GuaranteedBitrateList.h" #include "ranap/RANAP_RAB-Parameter-MaxBitrateList.h" #include "ranap/RANAP_RAB-Parameters.h" +#include "ranap/RANAP_RAB-QueuedList.h" #include "ranap/RANAP_RAB-ReleaseRequest.h" +#include "ranap/RANAP_RAB-ReleasedList-IuRelComp.h" +#include "ranap/RANAP_RAB-ReleasedList.h" +#include "ranap/RANAP_RAB-RelocationReleaseList.h" +#include "ranap/RANAP_RAB-SetupList-EnhRelocInfoReq.h" +#include "ranap/RANAP_RAB-SetupList-EnhRelocInfoRes.h" +#include "ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteReq.h" +#include "ranap/RANAP_RAB-SetupList-EnhancedRelocCompleteRes.h" +#include "ranap/RANAP_RAB-SetupList-RelocReq.h" +#include "ranap/RANAP_RAB-SetupList-RelocReqAck.h" +#include "ranap/RANAP_RAB-SetupOrModifiedList.h" #include "ranap/RANAP_RAB-SubflowCombinationBitRate.h" +#include "ranap/RANAP_RAB-ToBeReleasedList-EnhancedRelocCompleteRes.h" #include "ranap/RANAP_RAB-TrCH-Mapping.h" #include "ranap/RANAP_RAB-TrCH-MappingItem.h" #include "ranap/RANAP_RABDataVolumeReport.h" diff --git a/src/regen-common-includes.sh b/src/regen-common-includes.sh index bc029e6..8754995 100755 --- a/src/regen-common-includes.sh +++ b/src/regen-common-includes.sh @@ -1,2 +1,3 @@ #!/bin/sh -for f in `(cd ../asn1/hnbap/asn1c && ls --color=none -1 *.h)`; do echo "#include \"$f\""; done +#for f in `(cd ../asn1/hnbap/asn1c && ls --color=none -1 *.h)`; do echo "#include \"$f\""; done +for f in ranap/*.h; do echo "#include \"$f\""; done -- cgit v1.2.3