From 858eb3785ad300196cf677143a6759f857344702 Mon Sep 17 00:00:00 2001 From: sjana Date: Fri, 6 Nov 2020 10:46:46 -0800 Subject: [PATCH] E2AP Wrapper Implementation Issue-ID: RICAPP-119 Signed-off-by: sjana Change-Id: Ide68ceeb685a8d481d7cbe7fb94cdba34e074f12 --- src/xapp-asn/e2ap/e2ap_action.hpp | 66 +++ src/xapp-asn/e2ap/e2ap_consts.hpp | 8 +- src/xapp-asn/e2ap/e2ap_control_ack.cc | 7 +- src/xapp-asn/e2ap/e2ap_control_failure.cc | 14 +- src/xapp-asn/e2ap/e2ap_control_failure.hpp | 4 +- src/xapp-asn/e2ap/e2ap_control_request.hpp | 20 +- src/xapp-asn/e2ap/e2ap_criticality_diagnostics.hpp | 123 +++++ src/xapp-asn/e2ap/e2ap_indication.hpp | 8 +- src/xapp-asn/e2ap/e2ap_subscription_failure.cc | 383 ++++++++++++++ src/xapp-asn/e2ap/e2ap_subscription_failure.hpp | 106 ++++ src/xapp-asn/e2ap/e2ap_subscription_request.hpp | 4 +- src/xapp-asn/e2ap/e2ap_subscription_response.cc | 353 +++++++++++++ src/xapp-asn/e2ap/e2ap_subscription_response.hpp | 145 +++++ src/xapp-asn/e2ap/e2ap_subsdel_failure.cc | 339 ++++++++++++ src/xapp-asn/e2ap/e2ap_subsdel_failure.hpp | 122 +++++ src/xapp-asn/e2ap/e2ap_subsdel_request.cc | 10 +- src/xapp-asn/e2ap/e2ap_subsdel_response.cc | 204 +++++++ src/xapp-asn/e2ap/e2ap_subsdel_response.hpp | 102 ++++ src/xapp-asn/e2ap/generic_helpers.hpp | 49 -- src/xapp-asn/e2ap/response_helper.hpp | 181 ------- src/xapp-asn/e2ap/subscription_delete_request.cc | 180 ------- src/xapp-asn/e2ap/subscription_delete_request.hpp | 67 --- src/xapp-asn/e2ap/subscription_delete_response.cc | 292 ----------- src/xapp-asn/e2ap/subscription_delete_response.hpp | 79 --- src/xapp-asn/e2ap/subscription_helper.hpp | 181 ------- src/xapp-asn/e2ap/subscription_request.cc | 306 ----------- src/xapp-asn/e2ap/subscription_request.hpp | 73 --- src/xapp-asn/e2ap/subscription_response.cc | 583 --------------------- src/xapp-asn/e2ap/subscription_response.hpp | 81 --- test/hw_unit_tests.cc | 13 +- test/test_cntrl.h | 68 +++ test/test_db.h | 2 +- test/test_e2ap.h | 407 +++++++++++++- test/{test_e2sm.h => test_indc.h} | 42 +- test/test_subs.h | 28 +- 35 files changed, 2476 insertions(+), 2174 deletions(-) create mode 100644 src/xapp-asn/e2ap/e2ap_criticality_diagnostics.hpp create mode 100644 src/xapp-asn/e2ap/e2ap_subscription_failure.cc create mode 100644 src/xapp-asn/e2ap/e2ap_subscription_failure.hpp create mode 100644 src/xapp-asn/e2ap/e2ap_subscription_response.cc create mode 100644 src/xapp-asn/e2ap/e2ap_subscription_response.hpp create mode 100644 src/xapp-asn/e2ap/e2ap_subsdel_failure.cc create mode 100644 src/xapp-asn/e2ap/e2ap_subsdel_failure.hpp create mode 100644 src/xapp-asn/e2ap/e2ap_subsdel_response.cc create mode 100644 src/xapp-asn/e2ap/e2ap_subsdel_response.hpp delete mode 100644 src/xapp-asn/e2ap/generic_helpers.hpp delete mode 100644 src/xapp-asn/e2ap/response_helper.hpp delete mode 100644 src/xapp-asn/e2ap/subscription_delete_request.cc delete mode 100644 src/xapp-asn/e2ap/subscription_delete_request.hpp delete mode 100644 src/xapp-asn/e2ap/subscription_delete_response.cc delete mode 100644 src/xapp-asn/e2ap/subscription_delete_response.hpp delete mode 100644 src/xapp-asn/e2ap/subscription_helper.hpp delete mode 100644 src/xapp-asn/e2ap/subscription_request.cc delete mode 100644 src/xapp-asn/e2ap/subscription_request.hpp delete mode 100644 src/xapp-asn/e2ap/subscription_response.cc delete mode 100644 src/xapp-asn/e2ap/subscription_response.hpp create mode 100644 test/test_cntrl.h rename test/{test_e2sm.h => test_indc.h} (80%) diff --git a/src/xapp-asn/e2ap/e2ap_action.hpp b/src/xapp-asn/e2ap/e2ap_action.hpp index d5fad65..7db80cd 100644 --- a/src/xapp-asn/e2ap/e2ap_action.hpp +++ b/src/xapp-asn/e2ap/e2ap_action.hpp @@ -107,5 +107,71 @@ private: int _count_list; }; +/*RICaction-Admitted-Item ::= SEQUENCE { + ricActionID RICactionID, + ... +} + + +RICaction-NotAdmitted-Item ::= SEQUENCE { + ricActionID RICactionID, + cause Cause, + ... +}*/ + +class RICactionAdmittedList{ + +public: + class RICactionAdmittedItemIEs{ + private: + long int ricActionID; + public: + RICactionAdmittedItemIEs(void):ricActionID(0){}; + RICactionAdmittedItemIEs& set_ricActionID(long int actID){ricActionID = actID; return *this;}; + long int get_ricActionID(){return this->ricActionID;}; + + }; + RICactionAdmittedList(){ _ref_list = std::make_unique>(); _count_list = 0;}; + + std::vector * get_list() const {return _ref_list.get();}; + int get_list_count() {return _count_list;}; + + void add(RICactionAdmittedItemIEs &actionObj) { _ref_list.get()->push_back(actionObj); _count_list++;}; +private: + + std::unique_ptr> _ref_list; + int _count_list; + +}; + +class RICactionNotAdmittedList{ + public: + class RICactionNotAdmittedItemIEs{ + private: + long int ricActionID; + unsigned int ricCause, ricSubCause; + public: + RICactionNotAdmittedItemIEs(void):ricActionID(0),ricCause(0),ricSubCause(0){}; + RICactionNotAdmittedItemIEs& set_ricCause(long int cause){ricCause = cause; return *this;}; + RICactionNotAdmittedItemIEs& set_ricSubCause(long int subcause){ricSubCause = subcause; return *this;}; + RICactionNotAdmittedItemIEs& set_ricActionID(long int actID){ricActionID = actID; return *this;}; + + long int get_ricCause(){return this->ricCause;}; + long int get_ricSubCause(){return this->ricSubCause;}; + long int get_ricActionID(){return this->ricActionID;}; + }; + RICactionNotAdmittedList(){ _ref_list = std::make_unique>(); _count_list = 0;}; + + std::vector * get_list() const {return _ref_list.get();}; + int get_list_count() {return _count_list;}; + + void add(RICactionNotAdmittedItemIEs &actionObj) { _ref_list.get()->push_back(actionObj); _count_list++;}; +private: + + std::unique_ptr> _ref_list; + int _count_list; + +}; + #endif /* XAPP_ASN_REFACTOR_E2AP_ACTION_HPP_ */ diff --git a/src/xapp-asn/e2ap/e2ap_consts.hpp b/src/xapp-asn/e2ap/e2ap_consts.hpp index fc18dde..78a468d 100644 --- a/src/xapp-asn/e2ap/e2ap_consts.hpp +++ b/src/xapp-asn/e2ap/e2ap_consts.hpp @@ -28,11 +28,17 @@ #define SRC_XAPP_ASN_E2AP_CONSTS_HPP_ #define IE_SIZE ((int)128) +#define ERR_LEN ((int)128) #define RIC_CONTROL_ACK_IES_COUNT 5 #define RIC_CONTROL_FAILURE_IES_COUNT 5 #define RIC_CONTROL_REQUEST_IES_COUNT 6 #define RIC_INDICATION_IES_COUNT 8 + #define RIC_SUBDEL_REQUEST_IES_COUNT 2 -#define RIC_SUB_REQUEST_IES_COUNT 3 +#define RIC_SUBDEL_RESPONSE_IES_COUNT 2 +#define RIC_SUBDEL_FAILURE_IES_COUNT 4 +#define RIC_SUB_REQUEST_IES_COUNT 3 +#define RIC_SUB_RESPONSE_IES_COUNT 4 +#define RIC_SUB_FAILURE_IES_COUNT 4 #endif /* SRC_XAPP_ASN_E2AP_CONSTS_HPP_ */ diff --git a/src/xapp-asn/e2ap/e2ap_control_ack.cc b/src/xapp-asn/e2ap/e2ap_control_ack.cc index 9768cec..8650998 100644 --- a/src/xapp-asn/e2ap/e2ap_control_ack.cc +++ b/src/xapp-asn/e2ap/e2ap_control_ack.cc @@ -102,8 +102,6 @@ bool E2APControlAcknowledge::encode(unsigned char *buf, size_t *size){ _e2ap_pdu_obj->choice.successfulOutcome = _successMsg; _e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome ; - xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len); if(ret_constr){ _error_string.assign(_errbuf, _errbuf_len); @@ -127,6 +125,8 @@ bool E2APControlAcknowledge::encode(unsigned char *buf, size_t *size){ } *size = retval.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + return true; } @@ -215,8 +215,6 @@ bool E2APControlAcknowledge::decode(unsigned char *buf, size_t *size) mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Control Ack Message"); } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); - _successMsg = _e2ap_pdu_obj->choice.successfulOutcome; //write the decoding code. @@ -257,6 +255,7 @@ bool E2APControlAcknowledge::decode(unsigned char *buf, size_t *size) } } +// xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); return true; diff --git a/src/xapp-asn/e2ap/e2ap_control_failure.cc b/src/xapp-asn/e2ap/e2ap_control_failure.cc index 099233c..495bd1a 100644 --- a/src/xapp-asn/e2ap/e2ap_control_failure.cc +++ b/src/xapp-asn/e2ap/e2ap_control_failure.cc @@ -102,8 +102,6 @@ bool E2APControlFailure::encode(unsigned char *buf, size_t *size){ _e2ap_pdu_obj->choice.unsuccessfulOutcome = _unsuccessMsg; _e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome ; - xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len); if(ret_constr){ _error_string.assign(_errbuf, _errbuf_len); @@ -127,6 +125,8 @@ bool E2APControlFailure::encode(unsigned char *buf, size_t *size){ } *size = retval.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + return true; } @@ -153,7 +153,7 @@ bool E2APControlFailure::setfields(UnsuccessfulOutcome_t *successMsg){ ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID(); ASN_SEQUENCE_ADD(&(ric_failure->protocolIEs), ies_ricreq); - ie_index = 1; + ie_index++; RICcontrolFailure_IEs_t *ies_ranfunc = &IE_array[ie_index]; ies_ranfunc->criticality = Criticality_reject; ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; @@ -163,7 +163,7 @@ bool E2APControlFailure::setfields(UnsuccessfulOutcome_t *successMsg){ *ranfunction_ie = this->getIEs().get_ranFunctionID(); ASN_SEQUENCE_ADD(&(ric_failure->protocolIEs), ies_ranfunc); - ie_index = 2; + ie_index++; RICcontrolFailure_IEs_t *ies_ric_cause = &IE_array[ie_index]; ies_ric_cause->criticality = Criticality_ignore; ies_ric_cause->id = ProtocolIE_ID_id_Cause; @@ -187,8 +187,8 @@ bool E2APControlFailure::setfields(UnsuccessfulOutcome_t *successMsg){ ric_cause->choice.ricRequest = this->getIEs().get_ricSubCause(); break; default: - std::cout <<"Error ! Illegal cause enum" << this->getIEs().get_ricCause() << std::endl; - return false; + mdclog_write(MDCLOG_INFO, "Error ! Illegal cause enum %ld",this->getIEs().get_ricCause()); + return false; } ASN_SEQUENCE_ADD(&(ric_failure->protocolIEs), ies_ric_cause); @@ -234,7 +234,6 @@ bool E2APControlFailure::decode(unsigned char *buf, size_t *size) mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Control Ack Message"); } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); _unsuccessMsg = _e2ap_pdu_obj->choice.unsuccessfulOutcome; //write the decoding code. @@ -304,6 +303,7 @@ bool E2APControlFailure::decode(unsigned char *buf, size_t *size) } } + //xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); return true; diff --git a/src/xapp-asn/e2ap/e2ap_control_failure.hpp b/src/xapp-asn/e2ap/e2ap_control_failure.hpp index 2566b87..e60bdaa 100644 --- a/src/xapp-asn/e2ap/e2ap_control_failure.hpp +++ b/src/xapp-asn/e2ap/e2ap_control_failure.hpp @@ -84,7 +84,7 @@ public: long int get_ricInstanceID(){return this->ricInstanceID;}; long int get_ranFunctionID(){return this->ranFunctionID;}; long int get_ricCause(){return this->ricCause;}; - long int get_ricSubCause(){return this->ricCause;}; + long int get_ricSubCause(){return this->ricSubCause;}; bool get_is_ricCallProcessId(){return is_ricCallProcessId;}; @@ -117,7 +117,7 @@ public: ControlFailureIEs& set_ricRequestorID(long int reqID){this->ricRequestorID = reqID; return *this;} ControlFailureIEs& set_ricCause(long int cause){this->ricCause = cause; return *this;} - ControlFailureIEs& set_ricSubCause(long int cause){this->ricCause = cause; return *this;} + ControlFailureIEs& set_ricSubCause(long int cause){this->ricSubCause = cause; return *this;} ControlFailureIEs& set_ricInstanceID(long int reqID){this->ricInstanceID = reqID; return *this;} ControlFailureIEs& set_ranFunctionID(long int funcID){this->ranFunctionID = funcID; return *this;} diff --git a/src/xapp-asn/e2ap/e2ap_control_request.hpp b/src/xapp-asn/e2ap/e2ap_control_request.hpp index d3b0c61..c544fd4 100644 --- a/src/xapp-asn/e2ap/e2ap_control_request.hpp +++ b/src/xapp-asn/e2ap/e2ap_control_request.hpp @@ -210,8 +210,6 @@ bool E2APControlMessage::encode(unsigned char *buf, size_t *size){ return false; } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); - asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size); if(retval.encoded == -1){ @@ -228,6 +226,8 @@ bool E2APControlMessage::encode(unsigned char *buf, size_t *size){ } *size = retval.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + return true; } @@ -241,8 +241,8 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ return false; } - RICcontrolRequest_t * E2APControlMessage = &(_initMsg->value.choice.RICcontrolRequest); - E2APControlMessage->protocolIEs.list.count = 0; + RICcontrolRequest_t * cntrlMsg = &(_initMsg->value.choice.RICcontrolRequest); + cntrlMsg->protocolIEs.list.count = 0; // Mandatory IE @@ -254,7 +254,7 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID(); ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID(); - ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index])); + ASN_SEQUENCE_ADD(&(cntrlMsg->protocolIEs), &(IE_array[ie_index])); // Mandatory IE ie_index = 1; @@ -264,7 +264,7 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ ies_ranfunc->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID; RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; *ranfunction_ie = this->getIEs().get_ranFunctionID(); - ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index])); + ASN_SEQUENCE_ADD(&(cntrlMsg->protocolIEs), &(IE_array[ie_index])); // Mandatory IE @@ -276,7 +276,7 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ RICcontrolHeader_t *richeader_ie = &ies_richead->value.choice.RICcontrolHeader; richeader_ie->buf = (uint8_t*)this->getIEs().get_ricControlHeader(); richeader_ie->size = this->getIEs().get_ricControlHeaderSize(); - ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index])); + ASN_SEQUENCE_ADD(&(cntrlMsg->protocolIEs), &(IE_array[ie_index])); // Mandatory IE ie_index = 3; @@ -287,7 +287,7 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ RICcontrolMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICcontrolMessage; ricmsg_ie->buf = (uint8_t*)this->getIEs().get_ricControlMessage(); ricmsg_ie->size = this->getIEs().get_ricControlMessageSize(); - ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index])); + ASN_SEQUENCE_ADD(&(cntrlMsg->protocolIEs), &(IE_array[ie_index])); // Optional IE ie_index = 4; @@ -298,7 +298,7 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ ies_indtyp->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolAckRequest; RICcontrolAckRequest_t *ricackreq_ie = &ies_indtyp->value.choice.RICcontrolAckRequest; *ricackreq_ie = this->getIEs().get_ricControlAckRequest(); - ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index])); + ASN_SEQUENCE_ADD(&(cntrlMsg->protocolIEs), &(IE_array[ie_index])); } // Optional IE @@ -311,7 +311,7 @@ bool E2APControlMessage::setfields(InitiatingMessage_t *_initMsg){ RICcallProcessID_t *riccallprocessid_ie = &ies_callprocid->value.choice.RICcallProcessID; riccallprocessid_ie->buf = (uint8_t*)this->getIEs().get_ricCallProcessId(); riccallprocessid_ie->size = this->getIEs().get_ricCallProcessIdSize(); - ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index])); + ASN_SEQUENCE_ADD(&(cntrlMsg->protocolIEs), &(IE_array[ie_index])); } return true; diff --git a/src/xapp-asn/e2ap/e2ap_criticality_diagnostics.hpp b/src/xapp-asn/e2ap/e2ap_criticality_diagnostics.hpp new file mode 100644 index 0000000..62772e8 --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_criticality_diagnostics.hpp @@ -0,0 +1,123 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * e2ap_criticality_diagnostics.hpp + * + * Created on: Oct 29, 2020 + * Author: Shraboni Jana + */ +/* +-- ************************************************************** +-- copied from 3GPP 38.413 NGAP IEs v15.5.0 +-- note: ie-Extensions removed +-- ************************************************************** +CriticalityDiagnostics ::= SEQUENCE { + procedureCode ProcedureCode OPTIONAL, + triggeringMessage TriggeringMessage OPTIONAL, + procedureCriticality Criticality OPTIONAL, + ricRequestorID RICrequestID OPTIONAL, + iEsCriticalityDiagnostics CriticalityDiagnostics-IE-List OPTIONAL, + ... +} + +CriticalityDiagnostics-IE-List ::= SEQUENCE (SIZE(1..maxnoofErrors)) OF CriticalityDiagnostics-IE-Item + +CriticalityDiagnostics-IE-Item ::= SEQUENCE { + iECriticality Criticality, + iE-ID ProtocolIE-ID, + typeOfError TypeOfError, + ... +} + * + */ + +#ifndef SRC_XAPP_ASN_E2AP_E2AP_CRITICALITY_DIAGNOSTICS_HPP_ +#define SRC_XAPP_ASN_E2AP_E2AP_CRITICALITY_DIAGNOSTICS_HPP_ + +#include + +#include +#include +#include +#include + +#include "e2ap_consts.hpp" + + +class CriticalityDiagnosticsIEs{ + unsigned int typeOferror,iEcriticality; + long int ieID; + + + public: + CriticalityDiagnosticsIEs():typeOferror(0), ieID(0), iEcriticality(0){}; + CriticalityDiagnosticsIEs& set_typeOferror(unsigned int typ_err){this->typeOferror = typ_err; return *this;}; + CriticalityDiagnosticsIEs& set_ieID(long int ieID){this->ieID = ieID; return *this;}; + CriticalityDiagnosticsIEs& set_iEcriticality(unsigned int crit){this->iEcriticality =crit; return *this;} + + unsigned int get_typeOferror(){return this->typeOferror;}; + unsigned int get_iEcriticality(){return this->iEcriticality;}; + long int get_ieID(){return this->ieID;}; + + +}; + +class E2APCriticalityDiagnostics{ + + private: + + long int procedureCode,ricRequestorID, ricInstanceID; + unsigned int triggeringMessage,procedureCriticality; + bool is_criticalityDiagnostics_list; + std::unique_ptr> _ref_list; + int _count_list; + + public: + + E2APCriticalityDiagnostics():procedureCode(0),ricRequestorID(0),ricInstanceID(0),triggeringMessage(0), procedureCriticality(0),is_criticalityDiagnostics_list(false) + { _ref_list = std::make_unique>(); _count_list = 0;}; + + std::vector * get_list() const {return _ref_list.get();}; + int get_list_count() {return _count_list;}; + + void add(CriticalityDiagnosticsIEs &ieObj) { _ref_list.get()->push_back(ieObj); _count_list++;}; + void add(std::vector &obj){ *(_ref_list.get()) = obj; _count_list = obj.size();}; + + long int get_procedureCode(){return this->procedureCode;}; + long int get_ricRequestorID(){return this->ricRequestorID;}; + long int get_ricInstanceID(){return this->ricInstanceID;}; + unsigned int get_triggeringMessage(){return this->triggeringMessage;}; + unsigned int get_procedureCriticality(){return this->procedureCriticality;}; + bool get_is_criticalityDiagnostics_list(){if(this->get_list_count()>0) {is_criticalityDiagnostics_list = true;} return this->is_criticalityDiagnostics_list; }; + + E2APCriticalityDiagnostics& set_procedureCode(long int proc_code){this->procedureCode = proc_code; return *this;}; + E2APCriticalityDiagnostics& set_ricRequestorID(long int req_id){this->ricRequestorID = req_id; return *this;}; + E2APCriticalityDiagnostics& set_ricInstanceID(long int inst_id){this->ricInstanceID = inst_id; return *this;}; + + E2APCriticalityDiagnostics& set_triggeringMessage(unsigned int trigMsg){this->triggeringMessage = trigMsg; return *this;}; + E2APCriticalityDiagnostics& set_procedureCriticality(unsigned int pvalue){this->triggeringMessage = pvalue; return *this;}; + E2APCriticalityDiagnostics& set_iEsCriticalityDiagnostics(unsigned int pvalue){this->triggeringMessage = pvalue; return *this;}; + + +}; + + + + +#endif /* SRC_XAPP_ASN_E2AP_E2AP_CRITICALITY_DIAGNOSTICS_HPP_ */ diff --git a/src/xapp-asn/e2ap/e2ap_indication.hpp b/src/xapp-asn/e2ap/e2ap_indication.hpp index 48051db..a3e2ede 100644 --- a/src/xapp-asn/e2ap/e2ap_indication.hpp +++ b/src/xapp-asn/e2ap/e2ap_indication.hpp @@ -225,6 +225,7 @@ E2APIndication::~E2APIndication(void){ } free(IE_array); + free(initMsg); ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj); mdclog_write(MDCLOG_DEBUG, "Freed E2AP Indication object memory"); } @@ -241,8 +242,6 @@ bool E2APIndication::decode(unsigned char *buf, size_t *size) mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Indication Message"); } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - initMsg = e2ap_pdu_obj->choice.initiatingMessage; //write the decoding code. if (initMsg == 0){ @@ -292,6 +291,7 @@ bool E2APIndication::decode(unsigned char *buf, size_t *size) } } + // xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); return true; @@ -319,8 +319,6 @@ bool E2APIndication::encode(unsigned char *buf, size_t *size){ return false; } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size); if(retval.encoded == -1){ _error_string.assign(strerror(errno)); @@ -337,6 +335,8 @@ bool E2APIndication::encode(unsigned char *buf, size_t *size){ } *size = retval.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); + return true; } diff --git a/src/xapp-asn/e2ap/e2ap_subscription_failure.cc b/src/xapp-asn/e2ap/e2ap_subscription_failure.cc new file mode 100644 index 0000000..c0ffe1c --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subscription_failure.cc @@ -0,0 +1,383 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * e2ap_E2APSubscriptionFailure.cc + * + * + * Author: SJana, Ashwin Sridharan + */ +#include + +E2APSubscriptionFailure::E2APSubscriptionFailure(SubscriptionFailureIEs& subObj){ + + _failureIEs = std::make_unique(); + *_failureIEs = subObj; + + _e2ap_pdu_obj = 0; + _e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t)); + assert(_e2ap_pdu_obj != 0); + + _unsuccessMsg = 0; + _unsuccessMsg = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t)); + assert(_unsuccessMsg != 0); + + + + IE_array = 0; + IE_array = (RICsubscriptionFailure_IEs_t *)calloc(RIC_SUB_FAILURE_IES_COUNT, sizeof(RICsubscriptionFailure_IEs_t)); + assert(IE_array != 0); + + + ie_not_admitted_list = 0; + CD_array = 0; + +}; + +// Clear assigned protocolIE list from RIC indication IE container +E2APSubscriptionFailure::~E2APSubscriptionFailure(void){ + + RICsubscriptionFailure_t * ric_subscriptionFailure = &(_unsuccessMsg->value.choice.RICsubscriptionFailure); + for(int i = 0; i < ric_subscriptionFailure->protocolIEs.list.size ; i++){ + ric_subscriptionFailure->protocolIEs.list.array[i] = 0; + } + + if (ric_subscriptionFailure->protocolIEs.list.size > 0){ + free(ric_subscriptionFailure->protocolIEs.list.array); + ric_subscriptionFailure->protocolIEs.list.array = 0; + ric_subscriptionFailure->protocolIEs.list.size = 0; + ric_subscriptionFailure->protocolIEs.list.count = 0; + } + + free(ie_not_admitted_list); + free(IE_array); + free(_unsuccessMsg); + _e2ap_pdu_obj->choice.unsuccessfulOutcome = 0; + + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + mdclog_write(MDCLOG_DEBUG, "Freed Subscription Failure Object memory"); + + +}; + + +bool E2APSubscriptionFailure::encode(unsigned char *buf, size_t *size){ + + _e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome; + _e2ap_pdu_obj->choice.unsuccessfulOutcome = _unsuccessMsg; + + bool eres = setfields( _unsuccessMsg); + if(!eres) + return eres; + + _unsuccessMsg->procedureCode = ProcedureCode_id_RICsubscription; + _unsuccessMsg->criticality = Criticality_reject; + _unsuccessMsg->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure; + + int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len); + if(ret_constr){ + _error_string.assign(_errbuf, _errbuf_len); + _error_string = "Constraints failed for encoding subscription failure. Reason = " + _error_string; + return false; + } + + asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size); + if(res.encoded == -1){ + mdclog_write(MDCLOG_DEBUG, "Error encoding PDU. Reason =%s",strerror(errno)); + + return false; + } + else { + if(*size < res.encoded){ + fprintf(stderr, "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2AP_PDU.name)); + res.encoded = -1; + return false; + } + } + + *size = res.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + return true; + +} + +bool E2APSubscriptionFailure::setfields(UnsuccessfulOutcome_t *_unsuccessMsg){ + + int ie_index; + + + RICsubscriptionFailure_t * subsFailure = &(_unsuccessMsg->value.choice.RICsubscriptionFailure); + //reset list count .. + subsFailure->protocolIEs.list.count = 0; + + ie_index = 0; + RICsubscriptionFailure_IEs_t *ies_ricreq = &IE_array[ie_index]; + + ies_ricreq->criticality = Criticality_reject; + ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; + ies_ricreq->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID; + RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; + ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID(); + ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID(); + ASN_SEQUENCE_ADD(&subsFailure->protocolIEs, &(IE_array[ie_index])); + + + ie_index++; + RICsubscriptionFailure_IEs_t *ies_ranfunc = &IE_array[ie_index]; + ies_ranfunc->criticality = Criticality_reject; + ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; + ies_ranfunc->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID; + RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; + *ranfunction_ie = this->getIEs().get_ranFunctionID(); + ASN_SEQUENCE_ADD(&subsFailure->protocolIEs, &(IE_array[ie_index])); + + + if(this->getIEs().get_is_ricActionNotAdmitlst()){ + int notadmit_lst_count = this->getIEs().get_actionsNotAdmitted_list().get_list_count(); + + ie_index++; + std::vector * ref_notadmitted_action_array = this->getIEs().get_actionsNotAdmitted_list().get_list(); + + RICsubscriptionFailure_IEs_t *ies_notadmitted_actid = &IE_array[ie_index]; + ies_notadmitted_actid->criticality = Criticality_reject; + ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted; + + RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List; + ric_not_admitted_actions_ie->list.count = 0; + + + ies_notadmitted_actid->value.present = RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List; + + + ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(notadmit_lst_count, sizeof(RICaction_NotAdmitted_ItemIEs_t)); + assert(ie_not_admitted_list != 0); + + + for(unsigned int i = 0; i < ref_notadmitted_action_array->size(); i ++){ + ie_not_admitted_list[i].criticality = Criticality_ignore; + ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ; + ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;; + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_ricActionID(); + + int cause = (*ref_notadmitted_action_array)[i].get_ricCause(); + switch(cause){ + case Cause_PR_ricService: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_transport: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.transport = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_protocol: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol= (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_misc: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.misc = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_ricRequest: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + default: + mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause); + break; + } + + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.present = (Cause_PR)cause; + ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i])); + } + ASN_SEQUENCE_ADD(&subsFailure->protocolIEs, &(IE_array[ie_index])); + + } + if(this->getIEs().get_is_criticality_diagnostic()) { + ie_index++; + RICsubscriptionFailure_IEs_t *ies_criticdiag = &IE_array[ie_index]; + ies_criticdiag->criticality = Criticality_ignore; + ies_criticdiag->id = ProtocolIE_ID_id_CriticalityDiagnostics; + ies_criticdiag->value.present = RICsubscriptionFailure_IEs__value_PR_CriticalityDiagnostics; + CriticalityDiagnostics_t *critic_diag = &ies_criticdiag->value.choice.CriticalityDiagnostics; + + TriggeringMessage_t *tmsg = (TriggeringMessage_t*) calloc(1, sizeof(TriggeringMessage_t)); + *tmsg = this->getIEs().get_critical_diagnostic()->get_triggeringMessage(); + critic_diag->triggeringMessage= tmsg; + + RICrequestID_t *ricreq = (RICrequestID_t *)calloc(1, sizeof(RICrequestID_t)); + ricrequest_ie->ricRequestorID = this->getIEs().get_critical_diagnostic()->get_ricRequestorID(); + ricrequest_ie->ricInstanceID = this->getIEs().get_critical_diagnostic()->get_ricInstanceID(); + critic_diag->ricRequestorID = ricreq; + + ProcedureCode_t *pcode = (ProcedureCode_t*)calloc(1, sizeof(ProcedureCode_t)); + *pcode = this->getIEs().get_critical_diagnostic()->get_procedureCode(); + critic_diag->procedureCode =pcode; + + Criticality_t *pcritical = (Criticality_t*)calloc(1, sizeof(Criticality_t)); + *pcritical = this->getIEs().get_critical_diagnostic()->get_procedureCriticality(); + critic_diag->procedureCriticality = pcritical; + + + if(this->getIEs().get_critical_diagnostic()->get_is_criticalityDiagnostics_list()){ + + critic_diag->iEsCriticalityDiagnostics = (CriticalityDiagnostics_IE_List_t*)calloc(1, sizeof(CriticalityDiagnostics_IE_List_t)); + critic_diag->iEsCriticalityDiagnostics->list.count=0; + + int lst_count = this->getIEs().get_critical_diagnostic()->get_list_count(); + auto *lst = this->getIEs().get_critical_diagnostic()->get_list(); + CD_array = (CriticalityDiagnostics_IE_Item_t*)calloc(lst_count, sizeof(CriticalityDiagnostics_IE_Item_t)); + int i = 0; + for(auto l:*lst){ + CD_array[i].iE_ID = l.get_typeOferror(); + CD_array[i].typeOfError = l.get_ieID(); + CD_array[i].iECriticality = l.get_iEcriticality(); + int result = ASN_SEQUENCE_ADD(&(critic_diag->iEsCriticalityDiagnostics->list.array), &(CD_array[i])); + if (result == -1){ + _error_string = "Error : Unable to assign memory to add CriticalityDiagnostics_IE item to set up list"; + return false; + } + i++; + } + + } + ASN_SEQUENCE_ADD(&subsFailure->protocolIEs, &(IE_array[ie_index])); + + } + + + return true; +} + +E2APSubscriptionFailure::E2APSubscriptionFailure(unsigned char *buf, size_t *size){ + _e2ap_pdu_obj = 0; + _unsuccessMsg = 0; + IE_array = 0; + ie_not_admitted_list = 0; + + _failureIEs = std::make_unique(); + bool status = this->decode(buf, size); + if(!status) + throw "E2AP Subscription Failure Decode Failed: "+this->get_error(); +} +bool E2APSubscriptionFailure::decode(unsigned char *buf, size_t *size) +{ + + asn_dec_rval_t dec_res = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(_e2ap_pdu_obj), buf, *size); + if(dec_res.code != RC_OK){ + mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Subscription Failure"); + return false; + } else { + + mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Subscription Failure"); + } + + _unsuccessMsg = _e2ap_pdu_obj->choice.unsuccessfulOutcome; + //write the decoding code. + + if (_unsuccessMsg == 0){ + _error_string = "Invalid reference to unsuccess message in get fields subscription failure"; + return false; + } + + RANfunctionID_t * ranfunctionid; + RICaction_NotAdmitted_List_t * ric_not_admitted_action_list; + RICrequestID_t* ricReq; + + for(int edx = 0; edx < _unsuccessMsg->value.choice.RICsubscriptionFailure.protocolIEs.list.count; edx++) { + RICsubscriptionFailure_IEs_t *memb_ptr = _unsuccessMsg->value.choice.RICsubscriptionFailure.protocolIEs.list.array[edx]; + + switch(memb_ptr->id) + { + case (ProtocolIE_ID_id_RICrequestID): + _failureIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID); + _failureIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID); + break; + case (ProtocolIE_ID_id_RANfunctionID): + _failureIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID); + break; + + + case (ProtocolIE_ID_id_RICactions_NotAdmitted): + ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List; + + for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){ + RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index]; + long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID; + int cause = item->value.choice.RICaction_NotAdmitted_Item.cause.present; + int sub_cause; + switch(cause){ + + case Cause_PR_ricService : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService; + break; + + case Cause_PR_transport : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport; + break; + + case Cause_PR_protocol : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol; + break; + + case Cause_PR_misc : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc; + break; + + case Cause_PR_ricRequest : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest; + break; + + default: + mdclog_write(MDCLOG_DEBUG, "Error ! Illegal cause enum %d", cause); + return false; + } + _notadmitlst.add(RICactionNotAdmittedList::RICactionNotAdmittedItemIEs().set_ricActionID(id).set_ricCause(cause).set_ricSubCause(sub_cause)); + this->getIEs().set_actionsNotAdmitted_list(_notadmitlst); + } + break; + + case (ProtocolIE_ID_id_CriticalityDiagnostics): + + _cdWrapperIEs.set_procedureCode(*(memb_ptr->value.choice.CriticalityDiagnostics.procedureCode)); + _cdWrapperIEs.set_procedureCriticality(*(memb_ptr->value.choice.CriticalityDiagnostics.procedureCriticality)); + _cdWrapperIEs.set_triggeringMessage(*(memb_ptr->value.choice.CriticalityDiagnostics.triggeringMessage)); + + + ricReq = (RICrequestID_t*)memb_ptr->value.choice.CriticalityDiagnostics.ricRequestorID; + _cdWrapperIEs.set_ricRequestorID(ricReq->ricRequestorID); + _cdWrapperIEs.set_ricInstanceID(ricReq->ricInstanceID); + + int lstcount = memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.count; + auto *lst = _failureIEs->get_critical_diagnostic()->get_list(); + for(int i=0; i < lstcount; i++){ + CriticalityDiagnosticsIEs tmpObj; + tmpObj.set_iEcriticality(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->iECriticality); + tmpObj.set_ieID(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->iE_ID); + tmpObj.set_typeOferror(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->typeOfError); + _cdWrapperIEs.add(tmpObj); + } + _failureIEs->set_critical_diagnostic(_cdWrapperIEs); + break; + + } + + } + + return true; +} + + + + + + diff --git a/src/xapp-asn/e2ap/e2ap_subscription_failure.hpp b/src/xapp-asn/e2ap/e2ap_subscription_failure.hpp new file mode 100644 index 0000000..3067e0d --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subscription_failure.hpp @@ -0,0 +1,106 @@ +/* + * e2ap_subscription_failure.hpp + * + * Created on: Nov 5, 2020 + * Author: Shraboni Jana + */ + +#ifndef SRC_XAPP_ASN_E2AP_E2AP_SUBSCRIPTION_FAILURE_HPP_ +#define SRC_XAPP_ASN_E2AP_E2AP_SUBSCRIPTION_FAILURE_HPP_ + +/* + * -- ************************************************************** +-- +-- RIC SUBSCRIPTION FAILURE +-- +-- ************************************************************** +RICsubscriptionFailure ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionFailure-IEs}}, + ... +} + +RICsubscriptionFailure-IEs E2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory }| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory }| + { ID id-RICactions-NotAdmitted CRITICALITY reject TYPE RICaction-NotAdmitted-List PRESENCE mandatory }| + { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional }, + ... +} + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "e2ap_consts.hpp" +#include "e2ap_action.hpp" +#include "e2ap_criticality_diagnostics.hpp" +class E2APSubscriptionFailure { +public: + + class SubscriptionFailureIEs{ + private: + long int ricRequestorID, ricInstanceID, ranFunctionID; + RICactionNotAdmittedList *ricActionNotAdmittedlst; + bool is_ricActionNotAdmitlst; + E2APCriticalityDiagnostics *critical_diagnostic; + bool is_criticality_diagnostic; + public: + SubscriptionFailureIEs(void):ricRequestorID(0), ricInstanceID(0),ranFunctionID(0),ricActionNotAdmittedlst(0),is_ricActionNotAdmitlst(false),critical_diagnostic(NULL), is_criticality_diagnostic(false){}; + + SubscriptionFailureIEs& set_ricRequestorID(long int req_id){ricRequestorID = req_id; return *this;}; + SubscriptionFailureIEs& set_ranFunctionID(long int func_id){ranFunctionID = func_id; return *this;}; + SubscriptionFailureIEs& set_ricInstanceID(long int inst_id){ricInstanceID = inst_id; return *this;}; + SubscriptionFailureIEs& set_actionsNotAdmitted_list(RICactionNotAdmittedList &lstobj){ricActionNotAdmittedlst= &lstobj; is_ricActionNotAdmitlst = true; return *this;}; + SubscriptionFailureIEs& set_critical_diagnostic(E2APCriticalityDiagnostics &obj){this->is_criticality_diagnostic = true; critical_diagnostic = &obj; return *this;}; + + long int get_ricInstanceID(){return this->ricInstanceID;}; + long int get_ricRequestorID(){return this->ricRequestorID;}; + long int get_ranFunctionID(){return this->ranFunctionID;}; + bool get_is_ricActionNotAdmitlst(){return this->is_ricActionNotAdmitlst;}; + RICactionNotAdmittedList& get_actionsNotAdmitted_list() {return *(this->ricActionNotAdmittedlst);}; + E2APCriticalityDiagnostics* get_critical_diagnostic(){return (this->critical_diagnostic);}; + bool get_is_criticality_diagnostic(){return this->is_criticality_diagnostic;} + }; + + E2APSubscriptionFailure(SubscriptionFailureIEs&); + E2APSubscriptionFailure(unsigned char *, size_t *); + ~E2APSubscriptionFailure(); + bool encode(unsigned char *, size_t * ); + bool decode(unsigned char*, size_t *); + std::string get_error (void) const {return _error_string ;}; + SubscriptionFailureIEs& getIEs(){ return *_failureIEs.get();}; + + +private: + + bool setfields(UnsuccessfulOutcome_t *); + + UnsuccessfulOutcome_t * _unsuccessMsg; + E2AP_PDU_t * _e2ap_pdu_obj; + RICsubscriptionFailure_IEs_t * IE_array; + RICaction_NotAdmitted_ItemIEs_t * ie_not_admitted_list; + + RICactionNotAdmittedList _notadmitlst; + E2APCriticalityDiagnostics _cdWrapperIEs; + std::unique_ptr _failureIEs; + CriticalityDiagnostics_IE_Item_t *CD_array; + + + std::string _error_string; + char _errbuf[ERR_LEN]; + size_t _errbuf_len = ERR_LEN; + +}; + + + +#endif /* SRC_XAPP_ASN_E2AP_E2AP_SUBSCRIPTION_FAILURE_HPP_ */ diff --git a/src/xapp-asn/e2ap/e2ap_subscription_request.hpp b/src/xapp-asn/e2ap/e2ap_subscription_request.hpp index 51eb209..a98a7c7 100644 --- a/src/xapp-asn/e2ap/e2ap_subscription_request.hpp +++ b/src/xapp-asn/e2ap/e2ap_subscription_request.hpp @@ -230,8 +230,6 @@ bool E2APSubscriptionRequest::encode(unsigned char *buf, size_t *size){ return false; } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size); if(retval.encoded == -1){ @@ -250,6 +248,8 @@ bool E2APSubscriptionRequest::encode(unsigned char *buf, size_t *size){ } *size = retval.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); + return true; } diff --git a/src/xapp-asn/e2ap/e2ap_subscription_response.cc b/src/xapp-asn/e2ap/e2ap_subscription_response.cc new file mode 100644 index 0000000..9a2d903 --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subscription_response.cc @@ -0,0 +1,353 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * e2ap_E2APSubscriptionResponse.cc + * + * + * Author: SJana, Ashwin Sridharan + */ +#include + +E2APSubscriptionResponse::E2APSubscriptionResponse(SubscriptionResponseIEs& subObj){ + + _responseIEs = std::make_unique(); + *_responseIEs = subObj; + + _e2ap_pdu_obj = 0; + _e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t)); + assert(_e2ap_pdu_obj != 0); + + _successMsg = 0; + _successMsg = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t)); + assert(_successMsg != 0); + + + + IE_array = 0; + IE_array = (RICsubscriptionResponse_IEs_t *)calloc(RIC_SUB_RESPONSE_IES_COUNT, sizeof(RICsubscriptionResponse_IEs_t)); + assert(IE_array != 0); + + ie_admitted_list = 0; + + ie_not_admitted_list = 0; + + +}; + +// Clear assigned protocolIE list from RIC indication IE container +E2APSubscriptionResponse::~E2APSubscriptionResponse(void){ + + RICsubscriptionResponse_t * ric_subscriptionResponse = &(_successMsg->value.choice.RICsubscriptionResponse); + for(int i = 0; i < ric_subscriptionResponse->protocolIEs.list.size ; i++){ + ric_subscriptionResponse->protocolIEs.list.array[i] = 0; + } + + if (ric_subscriptionResponse->protocolIEs.list.size > 0){ + free(ric_subscriptionResponse->protocolIEs.list.array); + ric_subscriptionResponse->protocolIEs.list.array = 0; + ric_subscriptionResponse->protocolIEs.list.size = 0; + ric_subscriptionResponse->protocolIEs.list.count = 0; + } + + free(ie_admitted_list); + free(ie_not_admitted_list); + free(IE_array); + free(_successMsg); + _e2ap_pdu_obj->choice.successfulOutcome = 0; + + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + mdclog_write(MDCLOG_DEBUG, "Freed Subscription Response Object memory"); + + +}; + + +bool E2APSubscriptionResponse::encode(unsigned char *buf, size_t *size){ + + _e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome; + _e2ap_pdu_obj->choice.successfulOutcome = _successMsg; + + bool eres = setfields( _successMsg); + if(!eres) + return eres; + + _successMsg->procedureCode = ProcedureCode_id_RICsubscription; + _successMsg->criticality = Criticality_reject; + _successMsg->value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse; + + int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len); + if(ret_constr){ + _error_string.assign(_errbuf, _errbuf_len); + _error_string = "Constraints failed for encoding subscription response. Reason = " + _error_string; + return false; + } + + asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size); + if(res.encoded == -1){ + mdclog_write(MDCLOG_DEBUG, "Error encoding PDU. Reason =%s",strerror(errno)); + + return false; + } + else { + if(*size < res.encoded){ + fprintf(stderr, "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2AP_PDU.name)); + res.encoded = -1; + return false; + } + } + + *size = res.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + return true; + +} + +bool E2APSubscriptionResponse::setfields(SuccessfulOutcome_t *_successMsg){ + + int ie_index; + + + RICsubscriptionResponse_t * subsResponse = &(_successMsg->value.choice.RICsubscriptionResponse); + //reset list count .. + subsResponse->protocolIEs.list.count = 0; + + ie_index = 0; + RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index]; + + ies_ricreq->criticality = Criticality_reject; + ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; + ies_ricreq->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID; + RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; + ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID(); + ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID(); + ASN_SEQUENCE_ADD(&subsResponse->protocolIEs, &(IE_array[ie_index])); + + + ie_index++; + RICsubscriptionResponse_IEs_t *ies_ranfunc = &IE_array[ie_index]; + ies_ranfunc->criticality = Criticality_reject; + ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; + ies_ranfunc->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID; + RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; + *ranfunction_ie = this->getIEs().get_ranFunctionID(); + ASN_SEQUENCE_ADD(&subsResponse->protocolIEs, &(IE_array[ie_index])); + + + int admit_lst_count = 0; + if(this->getIEs().get_is_ricActionAdmitlst()){ + admit_lst_count = this->getIEs().get_actionsAdmitted_list().get_list_count(); + + ie_index++; + RICsubscriptionResponse_IEs_t *ies_admitted_actid = &IE_array[ie_index]; + ies_admitted_actid->criticality = Criticality_reject; + ies_admitted_actid->id = ProtocolIE_ID_id_RICactions_Admitted; + RICaction_Admitted_List_t *ric_admitted_actions_ie = &ies_admitted_actid->value.choice.RICaction_Admitted_List; + ric_admitted_actions_ie->list.count = 0; + + std::vector * ref_admitted_action_array = this->getIEs().get_actionsAdmitted_list().get_list(); + if(admit_lst_count == 0){ + ies_admitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_NOTHING; + } + else{ + ies_admitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List; + } + ie_admitted_list = (RICaction_Admitted_ItemIEs_t *)calloc(admit_lst_count, sizeof(RICaction_Admitted_ItemIEs_t)); + + assert(ie_admitted_list != 0); + for(unsigned int i = 0; i < ref_admitted_action_array->size(); i ++){ + ie_admitted_list[i].criticality = Criticality_ignore; + ie_admitted_list[i].id = ProtocolIE_ID_id_RICaction_Admitted_Item ; + ie_admitted_list[i].value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item; + ie_admitted_list[i].value.choice.RICaction_Admitted_Item.ricActionID = (*ref_admitted_action_array)[i].get_ricActionID(); + ASN_SEQUENCE_ADD(ric_admitted_actions_ie, &(ie_admitted_list[i])); + } + ASN_SEQUENCE_ADD(&subsResponse->protocolIEs, &(IE_array[ie_index])); + + } + + if(this->getIEs().get_is_ricActionNotAdmitlst()){ + int notadmit_lst_count = this->getIEs().get_actionsNotAdmitted_list().get_list_count(); + + ie_index++; + std::vector * ref_notadmitted_action_array = this->getIEs().get_actionsNotAdmitted_list().get_list(); + + RICsubscriptionResponse_IEs_t *ies_notadmitted_actid = &IE_array[ie_index]; + ies_notadmitted_actid->criticality = Criticality_reject; + ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted; + + RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List; + ric_not_admitted_actions_ie->list.count = 0; + + + ies_notadmitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List; + + + ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(notadmit_lst_count, sizeof(RICaction_NotAdmitted_ItemIEs_t)); + assert(ie_not_admitted_list != 0); + + + for(unsigned int i = 0; i < ref_notadmitted_action_array->size(); i ++){ + ie_not_admitted_list[i].criticality = Criticality_ignore; + ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ; + ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;; + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_ricActionID(); + + int cause = (*ref_notadmitted_action_array)[i].get_ricCause(); + switch(cause){ + case Cause_PR_ricService: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_transport: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.transport = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_protocol: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol= (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_misc: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.misc = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + case Cause_PR_ricRequest: + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest = (*ref_notadmitted_action_array)[i].get_ricSubCause(); + break; + default: + mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause); + break; + } + + ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.present = (Cause_PR)cause; + ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i])); + } + ASN_SEQUENCE_ADD(&subsResponse->protocolIEs, &(IE_array[ie_index])); + + } + + return true; +} + +E2APSubscriptionResponse::E2APSubscriptionResponse(unsigned char *buf, size_t *size){ + _e2ap_pdu_obj = 0; + _successMsg = 0; + IE_array = 0; + ie_admitted_list = 0; + ie_not_admitted_list = 0; + + _responseIEs = std::make_unique(); + bool status = this->decode(buf, size); + if(!status) + throw "E2AP Subscription Delete Response Decode Failed: "+this->get_error(); +} +bool E2APSubscriptionResponse:: decode(unsigned char *buf, size_t *size) +{ + + asn_dec_rval_t dec_res = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(_e2ap_pdu_obj), buf, *size); + if(dec_res.code != RC_OK){ + mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Subscription Response"); + return false; + } else { + + mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Subscription Response"); + } + + _successMsg = _e2ap_pdu_obj->choice.successfulOutcome; + //write the decoding code. + + if (_successMsg == 0){ + _error_string = "Invalid reference to success message in get fields subscription response"; + return false; + } + + RANfunctionID_t * ranfunctionid; + RICaction_Admitted_List_t * ric_admitted_action_list; + RICaction_NotAdmitted_List_t * ric_not_admitted_action_list; + + + for(int edx = 0; edx < _successMsg->value.choice.RICsubscriptionResponse.protocolIEs.list.count; edx++) { + RICsubscriptionResponse_IEs_t *memb_ptr = _successMsg->value.choice.RICsubscriptionResponse.protocolIEs.list.array[edx]; + + switch(memb_ptr->id) + { + case (ProtocolIE_ID_id_RICrequestID): + _responseIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID); + _responseIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID); + break; + case (ProtocolIE_ID_id_RANfunctionID): + _responseIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID); + break; + + case (ProtocolIE_ID_id_RICactions_Admitted): + ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List; + for(int index = 0; index < ric_admitted_action_list->list.count; index ++){ + RICaction_Admitted_ItemIEs_t * item = (RICaction_Admitted_ItemIEs_t *)ric_admitted_action_list->list.array[index]; + long int id = item->value.choice.RICaction_Admitted_Item.ricActionID; + RICactionAdmittedList::RICactionAdmittedItemIEs ricActID; ricActID.set_ricActionID(id); + _admitlst.add(ricActID); + }; + this->getIEs().set_actionsAdmitted_list(_admitlst); + break; + + case (ProtocolIE_ID_id_RICactions_NotAdmitted): + ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List; + + for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){ + RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index]; + long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID; + int cause = item->value.choice.RICaction_NotAdmitted_Item.cause.present; + int sub_cause; + switch(cause){ + + case Cause_PR_ricService : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService; + break; + + case Cause_PR_transport : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport; + break; + + case Cause_PR_protocol : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol; + break; + + case Cause_PR_misc : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc; + break; + + case Cause_PR_ricRequest : + sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest; + break; + + default: + mdclog_write(MDCLOG_DEBUG, "Error ! Illegal cause enum %d", cause); + return false; + } + _notadmitlst.add(RICactionNotAdmittedList::RICactionNotAdmittedItemIEs().set_ricActionID(id).set_ricCause(cause).set_ricSubCause(sub_cause)); + this->getIEs().set_actionsNotAdmitted_list(_notadmitlst); + } + break; + } + + } + + return true; +} + + + + + + diff --git a/src/xapp-asn/e2ap/e2ap_subscription_response.hpp b/src/xapp-asn/e2ap/e2ap_subscription_response.hpp new file mode 100644 index 0000000..1ec74aa --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subscription_response.hpp @@ -0,0 +1,145 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * e2ap_subscription_response.hpp + * + * Created on: Nov 1, 2020 + * Author: Shraboni Jana + */ + +#ifndef SRC_XAPP_ASN_E2AP_SUBSCRIPTION_RESPONSE_HPP_ +#define SRC_XAPP_ASN_E2AP_SUBSCRIPTION_RESPONSE_HPP_ +/*-- ************************************************************** +-- +-- RIC SUBSCRIPTION RESPONSE +-- +-- ************************************************************** +RICsubscriptionResponse ::= SEQUENCE { + protocolIEs ProtocolIE-Container{{RICsubscriptionResponse-IEs}}, + ... +} + +RICsubscriptionResponse-IEs E2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory } | + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory } | + { ID id-RICactions-Admitted CRITICALITY reject TYPE RICaction-Admitted-List PRESENCE mandatory } | + { ID id-RICactions-NotAdmitted CRITICALITY reject TYPE RICaction-NotAdmitted-List PRESENCE optional }, + ... +} + + + +RICaction-Admitted-List ::= SEQUENCE (SIZE(1..maxofRICactionID)) OF ProtocolIE-SingleContainer{{RICaction-Admitted-ItemIEs}} + +RICaction-Admitted-ItemIEs E2AP-PROTOCOL-IES ::= { + { ID id-RICaction-Admitted-Item CRITICALITY ignore TYPE RICaction-Admitted-Item PRESENCE mandatory }, + ... +} + +RICaction-Admitted-Item ::= SEQUENCE { + ricActionID RICactionID, + ... +} + +RICaction-NotAdmitted-List ::= SEQUENCE (SIZE(0..maxofRICactionID)) OF ProtocolIE-SingleContainer { {RICaction-NotAdmitted-ItemIEs} } + +RICaction-NotAdmitted-ItemIEs E2AP-PROTOCOL-IES ::= { + { ID id-RICaction-NotAdmitted-Item CRITICALITY ignore TYPE RICaction-NotAdmitted-Item PRESENCE mandatory }, + ... +} + +RICaction-NotAdmitted-Item ::= SEQUENCE { + ricActionID RICactionID, + cause Cause, + ... +}*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "e2ap_consts.hpp" +#include "e2ap_action.hpp" +class E2APSubscriptionResponse { +public: + + class SubscriptionResponseIEs{ + private: + long int ricRequestorID, ricInstanceID, ranFunctionID; + RICactionNotAdmittedList *ricActionNotAdmittedlst; + RICactionAdmittedList *ricActionAdmittedlst; + bool is_ricActionAdmitlst; + bool is_ricActionNotAdmitlst; + public: + SubscriptionResponseIEs(void):ricRequestorID(0), ricInstanceID(0),ranFunctionID(0),ricActionNotAdmittedlst(0),ricActionAdmittedlst(0),is_ricActionAdmitlst(false),is_ricActionNotAdmitlst(false){}; + + SubscriptionResponseIEs& set_ricRequestorID(long int req_id){ricRequestorID = req_id; return *this;}; + SubscriptionResponseIEs& set_ranFunctionID(long int func_id){ranFunctionID = func_id; return *this;}; + SubscriptionResponseIEs& set_ricInstanceID(long int inst_id){ricInstanceID = inst_id; return *this;}; + SubscriptionResponseIEs& set_actionsAdmitted_list(RICactionAdmittedList &lstobj){ricActionAdmittedlst= &lstobj;is_ricActionAdmitlst=true; return *this;}; + SubscriptionResponseIEs& set_actionsNotAdmitted_list(RICactionNotAdmittedList &lstobj){ricActionNotAdmittedlst= &lstobj; is_ricActionNotAdmitlst = true; return *this;}; + + long int get_ricInstanceID(){return this->ricInstanceID;}; + long int get_ricRequestorID(){return this->ricRequestorID;}; + long int get_ranFunctionID(){return this->ranFunctionID;}; + bool get_is_ricActionNotAdmitlst(){return this->is_ricActionNotAdmitlst;}; + bool get_is_ricActionAdmitlst(){return this->is_ricActionAdmitlst;}; + RICactionAdmittedList& get_actionsAdmitted_list() {return *(this->ricActionAdmittedlst);}; + RICactionNotAdmittedList& get_actionsNotAdmitted_list() {return *(this->ricActionNotAdmittedlst);}; + + }; + + E2APSubscriptionResponse(SubscriptionResponseIEs&); + E2APSubscriptionResponse(unsigned char *, size_t *); + ~E2APSubscriptionResponse(); + bool encode(unsigned char *, size_t * ); + bool decode(unsigned char*, size_t *); + std::string get_error (void) const {return _error_string ;}; + SubscriptionResponseIEs& getIEs(){ return *_responseIEs.get();}; + + +private: + + bool setfields(SuccessfulOutcome_t *); + + SuccessfulOutcome_t * _successMsg; + E2AP_PDU_t * _e2ap_pdu_obj; + RICsubscriptionResponse_IEs_t * IE_array; + RICaction_Admitted_ItemIEs_t * ie_admitted_list; + RICaction_NotAdmitted_ItemIEs_t * ie_not_admitted_list; + + RICactionAdmittedList _admitlst; + RICactionNotAdmittedList _notadmitlst; + std::unique_ptr _responseIEs; + + + std::string _error_string; + char _errbuf[ERR_LEN]; + size_t _errbuf_len = ERR_LEN; + +}; + + + + +#endif /* SRC_XAPP_ASN_E2AP_SUBSCRIPTION_RESPONSE_HPP_ */ diff --git a/src/xapp-asn/e2ap/e2ap_subsdel_failure.cc b/src/xapp-asn/e2ap/e2ap_subsdel_failure.cc new file mode 100644 index 0000000..b2fab40 --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subsdel_failure.cc @@ -0,0 +1,339 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ + +/* + * e2ap_subsdel_failure.cc + * + * Author: Shraboni Jana + */ + + + +#include "e2ap_subsdel_failure.hpp" + +E2APSubscriptionDeleteFailure::E2APSubscriptionDeleteFailure(SubscriptionDeleteFailureIEs& ieObj){ + + + + _failureIEs = std::make_unique(); + *_failureIEs = ieObj; + + _e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t)); + assert(_e2ap_pdu_obj != 0); + + _unsuccessMsg = (UnsuccessfulOutcome_t * )calloc(1, sizeof(UnsuccessfulOutcome_t)); + assert(_unsuccessMsg != 0); + + IE_array = (RICsubscriptionDeleteFailure_IEs_t *)calloc(RIC_SUBDEL_FAILURE_IES_COUNT, sizeof(RICsubscriptionDeleteFailure_IEs_t)); + assert(IE_array != 0); + + RICsubscriptionDeleteFailure_t * subDelfail = &(_unsuccessMsg->value.choice.RICsubscriptionDeleteFailure); + for(int i = 0; i < RIC_SUBDEL_FAILURE_IES_COUNT; i++){ + ASN_SEQUENCE_ADD(&subDelfail->protocolIEs, &(IE_array[i])); + } + CD_array = 0; + + +}; + +E2APSubscriptionDeleteFailure::E2APSubscriptionDeleteFailure(unsigned char *buf, size_t *size){ + _e2ap_pdu_obj = 0; + _unsuccessMsg = 0; + IE_array = 0; + CD_array = 0; + _failureIEs = std::make_unique(); + + bool status = this->decode(buf, size); + if(!status) + throw "E2AP Subscription Delete Failure Decode Failed: "+this->get_error(); +} + +// Clear assigned protocolIE list from RIC indication IE container +E2APSubscriptionDeleteFailure::~E2APSubscriptionDeleteFailure(void){ + + mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete request object memory"); + RICsubscriptionDeleteFailure_t * E2APSubscriptionDeleteFailure = &(_unsuccessMsg->value.choice.RICsubscriptionDeleteFailure); + + for(int i = 0; i < E2APSubscriptionDeleteFailure->protocolIEs.list.size; i++){ + E2APSubscriptionDeleteFailure->protocolIEs.list.array[i] = 0; + } + + if (E2APSubscriptionDeleteFailure->protocolIEs.list.size > 0){ + free(E2APSubscriptionDeleteFailure->protocolIEs.list.array); + E2APSubscriptionDeleteFailure->protocolIEs.list.count = 0; + E2APSubscriptionDeleteFailure->protocolIEs.list.size = 0; + E2APSubscriptionDeleteFailure->protocolIEs.list.array = 0; + } + + free(IE_array); + free(CD_array); + free(_unsuccessMsg); + _e2ap_pdu_obj->choice.unsuccessfulOutcome = 0; + + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + mdclog_write(MDCLOG_DEBUG, "Freed subscription delete request object memory"); + + +}; + + + +bool E2APSubscriptionDeleteFailure::decode(unsigned char *buf, size_t *size) +{ + + asn_dec_rval_t dec_res = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(_e2ap_pdu_obj), buf, *size); + if(dec_res.code != RC_OK){ + mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Subscription Delete Failure"); + return false; + } else { + mdclog_write(MDCLOG_INFO, "Unsuccessfully decoded: %s","RIC Subscription Delete Failure"); + } + + _unsuccessMsg = _e2ap_pdu_obj->choice.unsuccessfulOutcome; + //write the decoding code. + + if (_unsuccessMsg == 0){ + _error_string = "Invalid reference to success message in get fields subscription delete failure"; + return false; + } + + + for(int edx = 0; edx < _unsuccessMsg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.count; edx++) { + RICsubscriptionDeleteFailure_IEs_t *memb_ptr = _unsuccessMsg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.array[edx]; + + switch(memb_ptr->id) + { + //1. + case (ProtocolIE_ID_id_RICrequestID): + _failureIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID); + _failureIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID); + break; + //2. + case (ProtocolIE_ID_id_RANfunctionID): + _failureIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID); + + break; + //3. + case (ProtocolIE_ID_id_Cause): + + _failureIEs->set_ricCause(memb_ptr->value.choice.Cause.present); + switch(memb_ptr->value.choice.Cause.present){ + case Cause_PR_ricService : + _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.ricService); + break; + case Cause_PR_transport : + _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.transport); + break; + case Cause_PR_protocol : + _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.protocol); + break; + case Cause_PR_misc : + _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.misc); + break; + case Cause_PR_ricRequest : + _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.ricRequest); + break; + default: + _failureIEs->set_ricSubCause(-1); + break; + } + + + break; + //4. + case (ProtocolIE_ID_id_CriticalityDiagnostics): + + _cdWrapperIEs.set_procedureCode(*(memb_ptr->value.choice.CriticalityDiagnostics.procedureCode)); + _cdWrapperIEs.set_procedureCriticality(*(memb_ptr->value.choice.CriticalityDiagnostics.procedureCriticality)); + _cdWrapperIEs.set_triggeringMessage(*(memb_ptr->value.choice.CriticalityDiagnostics.triggeringMessage)); + + + RICrequestID_t* ricReq = (RICrequestID_t*)memb_ptr->value.choice.CriticalityDiagnostics.ricRequestorID; + _cdWrapperIEs.set_ricRequestorID(ricReq->ricRequestorID); + _cdWrapperIEs.set_ricInstanceID(ricReq->ricInstanceID); + + int lstcount = memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.count; + auto *lst = _failureIEs->get_critical_diagnostic()->get_list(); + for(int i=0; i < lstcount; i++){ + CriticalityDiagnosticsIEs tmpObj; + tmpObj.set_iEcriticality(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->iECriticality); + tmpObj.set_ieID(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->iE_ID); + tmpObj.set_typeOferror(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->typeOfError); + _cdWrapperIEs.add(tmpObj); + } + _failureIEs->set_critical_diagnostic(_cdWrapperIEs); + break; + + } + } + // xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + return true; +} + + +bool E2APSubscriptionDeleteFailure::encode(unsigned char *buf, size_t *size){ + + _e2ap_pdu_obj->choice.unsuccessfulOutcome = _unsuccessMsg; + _e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome; + bool result = setfields( _unsuccessMsg); + if(!result){ + return result; + } + _unsuccessMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete; + _unsuccessMsg->criticality = Criticality_reject; + _unsuccessMsg->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure; + + int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len); + if(ret_constr){ + _error_string.assign(_errbuf, _errbuf_len); + _error_string = "Constraints failed for encoding subscription delete request. Reason = " + _error_string; + return false; + } + + asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size); + + if(res.encoded == -1){ + _error_string.assign(strerror(errno)); + _error_string = "Error encoding Subscription Delete Request. Reason = " + _error_string; + return false; + } + else { + if(*size < res.encoded){ + std::stringstream ss; + ss <<"Error encoding Subscription Delete Request . Reason = encoded pdu size " << res.encoded << " exceeds buffer size " << *size << std::endl; + _error_string = ss.str(); + res.encoded = -1; + return false; + } + } + + *size = res.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + + return true; + +} + + +bool E2APSubscriptionDeleteFailure::setfields( UnsuccessfulOutcome_t *_unsuccessMsg){ + unsigned int ie_index; + + ie_index = 0; + RICsubscriptionDeleteFailure_IEs_t *ies_ricreq = &IE_array[ie_index]; + ies_ricreq->criticality = Criticality_reject; + ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; + ies_ricreq->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID; + RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; + ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID(); + ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID(); + + + ie_index++; + RICsubscriptionDeleteFailure_IEs_t *ies_ranfunc = &IE_array[ie_index]; + ies_ranfunc->criticality = Criticality_reject; + ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; + ies_ranfunc->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID; + RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; + *ranfunction_ie = this->getIEs().get_ranFunctionID(); + + ie_index++; + RICsubscriptionDeleteFailure_IEs_t *ies_ric_cause = &IE_array[ie_index]; + ies_ric_cause->criticality = Criticality_ignore; + ies_ric_cause->id = ProtocolIE_ID_id_Cause; + ies_ric_cause->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_Cause; + Cause_t * ric_cause = &(ies_ric_cause->value.choice.Cause); + ric_cause->present = (Cause_PR)this->getIEs().get_ricCause(); + switch(this->getIEs().get_ricCause()){ + case Cause_PR_ricService: + ric_cause->choice.ricService = this->getIEs().get_ricSubCause(); + break; + case Cause_PR_transport: + ric_cause->choice.transport = this->getIEs().get_ricSubCause(); + break; + case Cause_PR_protocol: + ric_cause->choice.protocol= this->getIEs().get_ricSubCause(); + break; + case Cause_PR_misc: + ric_cause->choice.misc = this->getIEs().get_ricSubCause(); + break; + case Cause_PR_ricRequest: + ric_cause->choice.ricRequest = this->getIEs().get_ricSubCause(); + break; + default: + _error_string = _error_string + "Error ! Illegal cause enum " + std::to_string(this->getIEs().get_ricCause()); + return false; + } + + if(this->getIEs().get_is_criticality_diagnostic()) { + ie_index++; + RICsubscriptionDeleteFailure_IEs_t *ies_criticdiag = &IE_array[ie_index]; + ies_criticdiag->criticality = Criticality_ignore; + ies_criticdiag->id = ProtocolIE_ID_id_CriticalityDiagnostics; + ies_criticdiag->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CriticalityDiagnostics; + CriticalityDiagnostics_t *critic_diag = &ies_criticdiag->value.choice.CriticalityDiagnostics; + + TriggeringMessage_t *tmsg = (TriggeringMessage_t*) calloc(1, sizeof(TriggeringMessage_t)); + *tmsg = this->getIEs().get_critical_diagnostic()->get_triggeringMessage(); + critic_diag->triggeringMessage= tmsg; + + RICrequestID_t *ricreq = (RICrequestID_t *)calloc(1, sizeof(RICrequestID_t)); + ricrequest_ie->ricRequestorID = this->getIEs().get_critical_diagnostic()->get_ricRequestorID(); + ricrequest_ie->ricInstanceID = this->getIEs().get_critical_diagnostic()->get_ricInstanceID(); + critic_diag->ricRequestorID = ricreq; + + ProcedureCode_t *pcode = (ProcedureCode_t*)calloc(1, sizeof(ProcedureCode_t)); + *pcode = this->getIEs().get_critical_diagnostic()->get_procedureCode(); + critic_diag->procedureCode =pcode; + + Criticality_t *pcritical = (Criticality_t*)calloc(1, sizeof(Criticality_t)); + *pcritical = this->getIEs().get_critical_diagnostic()->get_procedureCriticality(); + critic_diag->procedureCriticality = pcritical; + + + if(this->getIEs().get_critical_diagnostic()->get_is_criticalityDiagnostics_list()){ + + critic_diag->iEsCriticalityDiagnostics = (CriticalityDiagnostics_IE_List_t*)calloc(1, sizeof(CriticalityDiagnostics_IE_List_t)); + critic_diag->iEsCriticalityDiagnostics->list.count=0; + + int lst_count = this->getIEs().get_critical_diagnostic()->get_list_count(); + auto *lst = this->getIEs().get_critical_diagnostic()->get_list(); + CD_array = (CriticalityDiagnostics_IE_Item_t*)calloc(lst_count, sizeof(CriticalityDiagnostics_IE_Item_t)); + int i = 0; + for(auto l:*lst){ + CD_array[i].iE_ID = l.get_typeOferror(); + CD_array[i].typeOfError = l.get_ieID(); + CD_array[i].iECriticality = l.get_iEcriticality(); + int result = ASN_SEQUENCE_ADD(&(critic_diag->iEsCriticalityDiagnostics->list.array), &(CD_array[i])); + if (result == -1){ + _error_string = "Error : Unable to assign memory to add CriticalityDiagnostics_IE item to set up list"; + return false; + } + i++; + } + + } + } + + return true; +}; + + + + + diff --git a/src/xapp-asn/e2ap/e2ap_subsdel_failure.hpp b/src/xapp-asn/e2ap/e2ap_subsdel_failure.hpp new file mode 100644 index 0000000..69b0aaa --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subsdel_failure.hpp @@ -0,0 +1,122 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ + +/* + * e2ap_subsdel_failure.hpp + * + * Created on: Oct 29, 2020 + * Author: Shraboni Jana + */ +/*-- ************************************************************** +-- +-- RIC SUBSCRIPTION DELETE FAILURE +-- +-- ************************************************************** +RICsubscriptionDeleteFailure ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionDeleteFailure-IEs}}, + ... +} + +RICsubscriptionDeleteFailure-IEs E2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory }| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory }| + { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory }| + { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional }, + ... +} +*/ +#ifndef SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_FAILURE_HPP_ +#define SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_FAILURE_HPP_ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "e2ap_criticality_diagnostics.hpp" +#include "e2ap_consts.hpp" + +class E2APSubscriptionDeleteFailure{ +public: + + class SubscriptionDeleteFailureIEs{ + private: + long int ricRequestorID, ricInstanceID, ranFunctionID, ricCause, ricSubCause; + E2APCriticalityDiagnostics *critical_diagnostic; + bool is_criticality_diagnostic; + public: + SubscriptionDeleteFailureIEs(void):ricRequestorID(0), ricInstanceID(0),ranFunctionID(0), ricCause(0), ricSubCause(0),critical_diagnostic(NULL), is_criticality_diagnostic(false){}; + SubscriptionDeleteFailureIEs& set_ricRequestorID(long int req_id){ricRequestorID = req_id; return *this;}; + SubscriptionDeleteFailureIEs& set_ranFunctionID(long int func_id){ranFunctionID = func_id; return *this;}; + SubscriptionDeleteFailureIEs& set_ricInstanceID(long int inst_id){ricInstanceID = inst_id; return *this;}; + SubscriptionDeleteFailureIEs& set_ricCause(long int cause){ricCause = cause; return *this;}; + SubscriptionDeleteFailureIEs& set_ricSubCause(long int subcause){ricSubCause = subcause; return *this;}; + SubscriptionDeleteFailureIEs& set_critical_diagnostic(E2APCriticalityDiagnostics &obj){this->is_criticality_diagnostic = true; critical_diagnostic = &obj; return *this;}; + + long int get_ricInstanceID(){return this->ricInstanceID;}; + long int get_ricRequestorID(){return this->ricRequestorID;}; + long int get_ranFunctionID(){return this->ranFunctionID;}; + long int get_ricCause(){return this->ricCause;}; + long int get_ricSubCause(){return this->ricSubCause;}; + E2APCriticalityDiagnostics* get_critical_diagnostic(){return (this->critical_diagnostic);}; + bool get_is_criticality_diagnostic(){return this->is_criticality_diagnostic;} + + }; + E2APSubscriptionDeleteFailure(SubscriptionDeleteFailureIEs&); + E2APSubscriptionDeleteFailure(unsigned char *, size_t *); + ~E2APSubscriptionDeleteFailure(); + bool encode(unsigned char *, size_t * ); + bool decode(unsigned char*, size_t *); + std::string get_error (void) const {return _error_string ;}; + SubscriptionDeleteFailureIEs& getIEs(){ return *_failureIEs.get();}; + +private: + + bool setfields(UnsuccessfulOutcome_t *); + UnsuccessfulOutcome_t * _unsuccessMsg; + E2AP_PDU_t * _e2ap_pdu_obj; + RICsubscriptionDeleteFailure_IEs_t * IE_array; + CriticalityDiagnostics_IE_Item_t *CD_array; + std::unique_ptr _failureIEs; + E2APCriticalityDiagnostics _cdWrapperIEs; + + std::string _error_string; + char _errbuf[ERR_LEN]; + size_t _errbuf_len = ERR_LEN; + +}; + + + + + + + + +#endif /* SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_FAILURE_HPP_ */ diff --git a/src/xapp-asn/e2ap/e2ap_subsdel_request.cc b/src/xapp-asn/e2ap/e2ap_subsdel_request.cc index fa40ce9..6c4819f 100644 --- a/src/xapp-asn/e2ap/e2ap_subsdel_request.cc +++ b/src/xapp-asn/e2ap/e2ap_subsdel_request.cc @@ -1,5 +1,3 @@ - - /* ================================================================================== Copyright (c) 2019-2020 AT&T Intellectual Property. @@ -83,14 +81,14 @@ bool E2APSubscriptionDeleteRequest::encode(unsigned char *buf, size_t *size){ e2ap_pdu_obj->choice.initiatingMessage = initMsg; e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage; - setfields( initMsg); + bool result = setfields( initMsg); + if(!result) + return result; initMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete; initMsg->criticality = Criticality_reject; initMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest; - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, _errbuf, &_errbuf_len); if(ret_constr){ _error_string.assign(_errbuf, _errbuf_len); @@ -116,6 +114,8 @@ bool E2APSubscriptionDeleteRequest::encode(unsigned char *buf, size_t *size){ } *size = res.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); + return true; } diff --git a/src/xapp-asn/e2ap/e2ap_subsdel_response.cc b/src/xapp-asn/e2ap/e2ap_subsdel_response.cc new file mode 100644 index 0000000..c092511 --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subsdel_response.cc @@ -0,0 +1,204 @@ +/* +================================================================================== + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * e2ap_subsdel_response.cc + * + * Author: SJana, Ashwin Sridharan + */ + + +#include "e2ap_subsdel_response.hpp" + +E2APSubscriptionDeleteResponse::E2APSubscriptionDeleteResponse(SubscriptionDeleteResponseIEs& ieObj){ + + + + _responseIEs = std::make_unique(); + *_responseIEs = ieObj; + + _e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t)); + assert(_e2ap_pdu_obj != 0); + + _successMsg = (SuccessfulOutcome_t * )calloc(1, sizeof(SuccessfulOutcome_t)); + assert(_successMsg != 0); + + IE_array = (RICsubscriptionDeleteResponse_IEs_t *)calloc(RIC_SUBDEL_RESPONSE_IES_COUNT, sizeof(RICsubscriptionDeleteResponse_IEs_t)); + assert(IE_array != 0); + + RICsubscriptionDeleteResponse_t * subDelresponse = &(_successMsg->value.choice.RICsubscriptionDeleteResponse); + for(int i = 0; i < RIC_SUBDEL_RESPONSE_IES_COUNT; i++){ + ASN_SEQUENCE_ADD(&subDelresponse->protocolIEs, &(IE_array[i])); + } + +}; + +E2APSubscriptionDeleteResponse::E2APSubscriptionDeleteResponse(unsigned char *buf, size_t *size){ + _e2ap_pdu_obj = 0; + _successMsg = 0; + IE_array = 0; + + _responseIEs = std::make_unique(); + bool status = this->decode(buf, size); + if(!status) + throw "E2AP Subscription Delete Response Decode Failed: "+this->get_error(); +} + +bool E2APSubscriptionDeleteResponse::decode(unsigned char *buf, size_t *size) +{ + + asn_dec_rval_t dec_res = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(_e2ap_pdu_obj), buf, *size); + if(dec_res.code != RC_OK){ + mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Subscription Delete Response"); + return false; + } else { + mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Subscription Delete Response"); + } + + _successMsg = _e2ap_pdu_obj->choice.successfulOutcome; + //write the decoding code. + + if (_successMsg == 0){ + _error_string = "Invalid reference to success message in get fields subscription delete response"; + return false; + } + + + for(int edx = 0; edx < _successMsg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.count; edx++) { + RICsubscriptionDeleteResponse_IEs_t *memb_ptr = _successMsg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.array[edx]; + + switch(memb_ptr->id) + { + case (ProtocolIE_ID_id_RICrequestID): + _responseIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID); + _responseIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID); + + break; + + case (ProtocolIE_ID_id_RANfunctionID): + _responseIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID); + + break; + } + +} +// xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + +return true; +} + +// Clear assigned protocolIE list from RIC indication IE container +E2APSubscriptionDeleteResponse::~E2APSubscriptionDeleteResponse(void){ + + mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete request object memory"); + RICsubscriptionDeleteResponse_t * E2APSubscriptionDeleteResponse = &(_successMsg->value.choice.RICsubscriptionDeleteResponse); + + for(int i = 0; i < E2APSubscriptionDeleteResponse->protocolIEs.list.size; i++){ + E2APSubscriptionDeleteResponse->protocolIEs.list.array[i] = 0; + } + + if (E2APSubscriptionDeleteResponse->protocolIEs.list.size > 0){ + free(E2APSubscriptionDeleteResponse->protocolIEs.list.array); + E2APSubscriptionDeleteResponse->protocolIEs.list.count = 0; + E2APSubscriptionDeleteResponse->protocolIEs.list.size = 0; + E2APSubscriptionDeleteResponse->protocolIEs.list.array = 0; + } + + free(IE_array); + free(_successMsg); + _e2ap_pdu_obj->choice.successfulOutcome = 0; + + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + mdclog_write(MDCLOG_DEBUG, "Freed subscription delete request object memory"); + + +}; + + +bool E2APSubscriptionDeleteResponse::encode(unsigned char *buf, size_t *size){ + + _e2ap_pdu_obj->choice.successfulOutcome = _successMsg; + _e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome; + bool eres = setfields( _successMsg); + if(!eres) + return eres; + + _successMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete; + _successMsg->criticality = Criticality_reject; + _successMsg->value.present = SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse; + + int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len); + if(ret_constr){ + _error_string.assign(_errbuf, _errbuf_len); + _error_string = "Constraints failed for encoding subscription delete request. Reason = " + _error_string; + return false; + } + + asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size); + + if(res.encoded == -1){ + _error_string.assign(strerror(errno)); + _error_string = "Error encoding Subscription Delete Request. Reason = " + _error_string; + return false; + } + else { + if(*size < res.encoded){ + std::stringstream ss; + ss <<"Error encoding Subscription Delete Request . Reason = encoded pdu size " << res.encoded << " exceeds buffer size " << *size << std::endl; + _error_string = ss.str(); + res.encoded = -1; + return false; + } + } + + *size = res.encoded; + xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj); + + return true; + +} + + +bool E2APSubscriptionDeleteResponse::setfields( SuccessfulOutcome_t *_successMsg){ + unsigned int ie_index; + + ie_index = 0; + RICsubscriptionDeleteResponse_IEs_t *ies_ricresp = &IE_array[ie_index]; + ies_ricresp->criticality = Criticality_reject; + ies_ricresp->id = ProtocolIE_ID_id_RICrequestID; + ies_ricresp->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID; + RICrequestID_t *ricrequest_ie = &ies_ricresp->value.choice.RICrequestID; + ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID(); + ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID(); + + + ie_index = 1; + RICsubscriptionDeleteResponse_IEs_t *ies_ranfunc = &IE_array[ie_index]; + ies_ranfunc->criticality = Criticality_reject; + ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; + ies_ranfunc->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID; + RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; + *ranfunction_ie = this->getIEs().get_ranFunctionID(); + + + return true; +}; + + + + + diff --git a/src/xapp-asn/e2ap/e2ap_subsdel_response.hpp b/src/xapp-asn/e2ap/e2ap_subsdel_response.hpp new file mode 100644 index 0000000..5615a76 --- /dev/null +++ b/src/xapp-asn/e2ap/e2ap_subsdel_response.hpp @@ -0,0 +1,102 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * e2ap_subsdel_response.hpp + * + * Created on: Oct 28, 2020 + * Author: Shraboni Jana + */ +/*-- ************************************************************** +-- +-- RIC SUBSCRIPTION DELETE RESPONSE +-- +-- ************************************************************** +RICsubscriptionDeleteResponse ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionDeleteResponse-IEs}}, + ... +} + +RICsubscriptionDeleteResponse-IEs E2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory }| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory }, + ... +} +*/ +#ifndef SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_RESPONSE_HPP_ +#define SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_RESPONSE_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "e2ap_consts.hpp" +class E2APSubscriptionDeleteResponse { +public: + + class SubscriptionDeleteResponseIEs{ + private: + long int ricRequestorID, ricInstanceID, ranFunctionID; + + public: + SubscriptionDeleteResponseIEs(void):ricRequestorID(0), ricInstanceID(0),ranFunctionID(0){}; + SubscriptionDeleteResponseIEs& set_ricRequestorID(long int req_id){ricRequestorID = req_id; return *this;}; + SubscriptionDeleteResponseIEs& set_ranFunctionID(long int func_id){ranFunctionID = func_id; return *this;}; + SubscriptionDeleteResponseIEs& set_ricInstanceID(long int inst_id){ricInstanceID = inst_id; return *this;}; + + long int get_ricInstanceID(){return this->ricInstanceID;}; + long int get_ricRequestorID(){return this->ricRequestorID;}; + long int get_ranFunctionID(){return this->ranFunctionID;}; + + + }; + + E2APSubscriptionDeleteResponse(SubscriptionDeleteResponseIEs&); + E2APSubscriptionDeleteResponse(unsigned char *, size_t *); + ~E2APSubscriptionDeleteResponse(); + bool encode(unsigned char *, size_t * ); + bool decode(unsigned char*, size_t *); + std::string get_error (void) const {return _error_string ;}; + SubscriptionDeleteResponseIEs& getIEs(){ return *_responseIEs.get();}; +private: + + bool setfields(SuccessfulOutcome_t *); + + SuccessfulOutcome_t * _successMsg; + E2AP_PDU_t * _e2ap_pdu_obj; + RICsubscriptionDeleteResponse_IEs_t * IE_array; + + std::unique_ptr _responseIEs; + + std::string _error_string; + char _errbuf[ERR_LEN]; + size_t _errbuf_len = ERR_LEN; + +}; + + + + + +#endif /* SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_RESPONSE_HPP_ */ diff --git a/src/xapp-asn/e2ap/generic_helpers.hpp b/src/xapp-asn/e2ap/generic_helpers.hpp deleted file mode 100644 index 3e0c2df..0000000 --- a/src/xapp-asn/e2ap/generic_helpers.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - - -#pragma once -#ifndef GENERIC_HELPERS -#define GENERIC_HELPERS - -#include - -/* Utilities */ - -class octet_helper { - -public: - octet_helper(void):_ref(NULL), _size(0){}; - octet_helper(const void *ref, int size):_ref(ref), _size(size){}; - void set_ref(const void *ref){ - _ref = ref; - } - - void set_size(size_t size){ - _size = size; - } - - const void * get_ref(void){return _ref ; }; - size_t get_size(void) const {return _size ; } ; - -private: - const void *_ref; - size_t _size; -}; - -#endif diff --git a/src/xapp-asn/e2ap/response_helper.hpp b/src/xapp-asn/e2ap/response_helper.hpp deleted file mode 100644 index e6aa65e..0000000 --- a/src/xapp-asn/e2ap/response_helper.hpp +++ /dev/null @@ -1,181 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - -#pragma once - -#ifndef S_RESPONSE_HELPER_ -#define S_RESPONSE_HELPER_ - -#include -#include - -/* Simple structure to store action for RICaction of the Subscription response based on E2 v0.31 */ -struct ActionResponse { -public: - ActionResponse(int id): _is_admit(true), _id(id), _cause(-1), _sub_cause(-1){}; - ActionResponse(int id, int cause, int sub_cause): _is_admit(false), _id(id), _cause(cause), _sub_cause(sub_cause){}; - - int get_id() const{ - return _id; - }; - - int get_cause() const{ - return _cause; - }; - - int get_sub_cause() const{ - return _sub_cause; - }; - - bool is_admitted(void){ - return _is_admit; - }; - -private: - - bool _is_admit; - int _id, _cause, _sub_cause; - -}; - - -struct subscription_response_helper { - -public: - - using action_t = std::vector; - - subscription_response_helper(void){ - _action_admitted_ref = std::make_unique(); - _action_not_admitted_ref = std::make_unique(); - - }; - - // copy operator - subscription_response_helper(const subscription_response_helper &he ){ - _action_admitted_ref = std::make_unique(); - _action_not_admitted_ref = std::make_unique(); - - _req_id = he.get_request_id(); - _req_seq_no = he.get_req_seq(); - _func_id = he.get_function_id(); - - // Take care of the actions - for (auto const & e: *(he.get_admitted_list())){ - add_action(e.get_id()); - } - - for(auto const & e: *(he.get_not_admitted_list())){ - add_action(e.get_id(), e.get_cause(), e.get_sub_cause()); - }; - } - - - // assignment operator - void operator=(const subscription_response_helper & he){ - _action_admitted_ref = std::make_unique(); - _action_not_admitted_ref = std::make_unique(); - - _req_id = he.get_request_id(); - _req_seq_no = he.get_req_seq(); - _func_id = he.get_function_id(); - - - // Take care of the actions - for (auto const & e: *(he.get_admitted_list())){ - add_action(e.get_id()); - } - - for(auto const & e: *(he.get_not_admitted_list())){ - add_action(e.get_id(), e.get_cause(), e.get_sub_cause()); - }; - - } - - action_t * get_admitted_list (void ) const {return _action_admitted_ref.get();}; - action_t * get_not_admitted_list (void ) const{return _action_not_admitted_ref.get();}; - - void set_request(int id, int seq_no){ - _req_id = id; - _req_seq_no = seq_no; - - }; - - void clear(void){ - _action_admitted_ref.get()->clear(); - _action_not_admitted_ref.get()->clear(); - } - - - void set_function_id(int id){ - _func_id = id; - }; - - void add_action(int id){ - ActionResponse a(id) ; - _action_admitted_ref.get()->push_back(a); - }; - - void add_action(int id, int cause, int sub_cause){ - ActionResponse a (id, cause, sub_cause); - _action_not_admitted_ref.get()->push_back(a); - }; - - - int get_request_id(void) const{ - return _req_id; - } - - int get_req_seq(void) const{ - return _req_seq_no; - } - - int get_function_id(void) const{ - return _func_id; - } - - std::string to_string(void){ - std::string Info; - Info += "Request ID = " + std::to_string(_req_id) + "\n"; - Info += "Request Sequence No = " + std::to_string(_req_seq_no) + "\n"; - Info += "RAN Function ID = " + std::to_string(_func_id) + "\n"; - Info += "Actions Admitted =\n"; - int i = 0; - for(auto & e: *(_action_admitted_ref)){ - Info += std::to_string(i) + ": ID=" + std::to_string(e.get_id()) + "\n"; - i++; - } - Info += "Actions Not Admitted =\n"; - i = 0; - for(auto & e: *(_action_not_admitted_ref)){ - Info += std::to_string(i) + ": ID=" + std::to_string(e.get_id()) + ": Cause =" + std::to_string(e.get_cause()) + ": Sub-Cause=" + std::to_string(e.get_sub_cause()) + "\n"; - i++; - } - - return Info; - } - -private: - int _req_id, _req_seq_no, _func_id; - std::unique_ptr _action_admitted_ref; - std::unique_ptr _action_not_admitted_ref; - -}; - - -#endif diff --git a/src/xapp-asn/e2ap/subscription_delete_request.cc b/src/xapp-asn/e2ap/subscription_delete_request.cc deleted file mode 100644 index 6a1ffc8..0000000 --- a/src/xapp-asn/e2ap/subscription_delete_request.cc +++ /dev/null @@ -1,180 +0,0 @@ - - -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - - -#include "subscription_delete_request.hpp" - -subscription_delete::subscription_delete(void){ - - _name = "default"; - - e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t)); - assert(e2ap_pdu_obj != 0); - - initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t)); - assert(initMsg != 0); - - IE_array = (RICsubscriptionDeleteRequest_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_IES, sizeof(RICsubscriptionDeleteRequest_IEs_t)); - assert(IE_array != 0); - - RICsubscriptionDeleteRequest_t * subscription_delete = &(initMsg->value.choice.RICsubscriptionDeleteRequest); - for(int i = 0; i < NUM_SUBSCRIPTION_DELETE_IES; i++){ - ASN_SEQUENCE_ADD(&subscription_delete->protocolIEs, &(IE_array[i])); - } - -}; - - - -// Clear assigned protocolIE list from RIC indication IE container -subscription_delete::~subscription_delete(void){ - - mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete request object memory"); - RICsubscriptionDeleteRequest_t * subscription_delete = &(initMsg->value.choice.RICsubscriptionDeleteRequest); - - for(int i = 0; i < subscription_delete->protocolIEs.list.size; i++){ - subscription_delete->protocolIEs.list.array[i] = 0; - } - - if (subscription_delete->protocolIEs.list.size > 0){ - free(subscription_delete->protocolIEs.list.array); - subscription_delete->protocolIEs.list.count = 0; - subscription_delete->protocolIEs.list.size = 0; - subscription_delete->protocolIEs.list.array = 0; - } - - free(IE_array); - free(initMsg); - e2ap_pdu_obj->choice.initiatingMessage = 0; - - ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj); - mdclog_write(MDCLOG_DEBUG, "Freed subscription delete request object memory"); - - -}; - - -bool subscription_delete::encode_e2ap_subscription(unsigned char *buf, size_t *size, subscription_helper &dinput){ - - e2ap_pdu_obj->choice.initiatingMessage = initMsg; - e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage; - set_fields( dinput); - - initMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete; - initMsg->criticality = Criticality_reject; - initMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest; - - //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len); - if(ret_constr){ - error_string.assign(errbuf, errbuf_len); - error_string = "Constraints failed for encoding subscription delete request. Reason = " + error_string; - return false; - } - - asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size); - - if(res.encoded == -1){ - error_string.assign(strerror(errno)); - error_string = "Error encoding Subscription Delete Request. Reason = " + error_string; - return false; - } - else { - if(*size < res.encoded){ - std::stringstream ss; - ss <<"Error encoding Subscription Delete Request . Reason = encoded pdu size " << res.encoded << " exceeds buffer size " << *size << std::endl; - error_string = ss.str(); - res.encoded = -1; - return false; - } - } - - *size = res.encoded; - return true; - -} - - -bool subscription_delete::set_fields( subscription_helper &helper){ - unsigned int ie_index; - - ie_index = 0; - RICsubscriptionDeleteRequest_IEs_t *ies_ricreq = &IE_array[ie_index]; - ies_ricreq->criticality = Criticality_reject; - ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; - ies_ricreq->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID; - RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; - ricrequest_ie->ricRequestorID = helper.get_request_id(); - //ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq(); - - - - ie_index = 1; - RICsubscriptionDeleteRequest_IEs_t *ies_ranfunc = &IE_array[ie_index]; - ies_ranfunc->criticality = Criticality_reject; - ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; - ies_ranfunc->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID; - RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; - *ranfunction_ie = helper.get_function_id(); - - - return true; -}; - - - - -bool subscription_delete:: get_fields(InitiatingMessage_t * init_msg, subscription_helper & dout) -{ - - if (init_msg == 0){ - error_string = "Invalid reference for initiating message for get string"; - return false; - } - - RICrequestID_t *requestid; - RANfunctionID_t * ranfunctionid; - - for(int edx = 0; edx < init_msg->value.choice.RICsubscriptionDeleteRequest.protocolIEs.list.count; edx++) { - RICsubscriptionDeleteRequest_IEs_t *memb_ptr = init_msg->value.choice.RICsubscriptionDeleteRequest.protocolIEs.list.array[edx]; - - switch(memb_ptr->id) - { - case (ProtocolIE_ID_id_RICrequestID): - requestid = &memb_ptr->value.choice.RICrequestID; - //dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber); - break; - - case (ProtocolIE_ID_id_RANfunctionID): - ranfunctionid = &memb_ptr->value.choice.RANfunctionID; - dout.set_function_id(*ranfunctionid); - break; - - } - - //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu); - } - - return true; -} - - - diff --git a/src/xapp-asn/e2ap/subscription_delete_request.hpp b/src/xapp-asn/e2ap/subscription_delete_request.hpp deleted file mode 100644 index b6d5bba..0000000 --- a/src/xapp-asn/e2ap/subscription_delete_request.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - -#pragma once - -#ifndef S_DELETE_ -#define S_DELETE_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "subscription_helper.hpp" - -#define NUM_SUBSCRIPTION_DELETE_IES 2 - -class subscription_delete{ -public: - - subscription_delete(void); - ~subscription_delete(void); - - bool encode_e2ap_subscription(unsigned char *, size_t *, subscription_helper &); - bool set_fields(subscription_helper &); - bool get_fields(InitiatingMessage_t *, subscription_helper &); - - std::string get_error(void) const { - return error_string ; - } - -private: - - InitiatingMessage_t *initMsg; - E2AP_PDU_t * e2ap_pdu_obj; - - RICsubscriptionDeleteRequest_IEs_t * IE_array; - - - char errbuf[128]; - size_t errbuf_len = 128; - std::string _name; - std::string error_string; -}; - - - -#endif diff --git a/src/xapp-asn/e2ap/subscription_delete_response.cc b/src/xapp-asn/e2ap/subscription_delete_response.cc deleted file mode 100644 index 249b3cd..0000000 --- a/src/xapp-asn/e2ap/subscription_delete_response.cc +++ /dev/null @@ -1,292 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - - -#include "subscription_delete_response.hpp" - -/* The xAPP need only worry about the get_fields from a response, since it does -not generate a response. Generating response however is included to support testing. -*/ - - -// Primarly for generation -subscription_delete_response::subscription_delete_response(void){ - - e2ap_pdu_obj = 0; - e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t)); - assert(e2ap_pdu_obj != 0); - - successMsg = 0; - successMsg = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t)); - assert(successMsg != 0); - - unsuccessMsg = 0; - unsuccessMsg = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t)); - assert(unsuccessMsg != 0); - - IE_array = 0; - IE_array = (RICsubscriptionDeleteResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_RESPONSE_IES, sizeof(RICsubscriptionDeleteResponse_IEs_t)); - assert(IE_array != 0); - - IE_Failure_array = 0; - IE_Failure_array = (RICsubscriptionDeleteFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_FAILURE_IES, sizeof(RICsubscriptionDeleteFailure_IEs_t)); - assert(IE_Failure_array != 0); - - - -}; - - - -// Clear assigned protocolIE list from RIC indication IE container -subscription_delete_response::~subscription_delete_response(void){ - - mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete response memory"); - RICsubscriptionDeleteResponse_t * ric_subscription_delete_response = &(successMsg->value.choice.RICsubscriptionDeleteResponse); - - for(unsigned int i = 0; i < ric_subscription_delete_response->protocolIEs.list.size ; i++){ - ric_subscription_delete_response->protocolIEs.list.array[i] = 0; - } - - - RICsubscriptionDeleteFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionDeleteFailure); - for(unsigned int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){ - ric_subscription_failure->protocolIEs.list.array[i] = 0; - } - - free(IE_array); - free(IE_Failure_array); - - ASN_STRUCT_FREE(asn_DEF_SuccessfulOutcome, successMsg); - - ASN_STRUCT_FREE(asn_DEF_UnsuccessfulOutcome, unsuccessMsg); - - e2ap_pdu_obj->choice.successfulOutcome = NULL; - e2ap_pdu_obj->choice.unsuccessfulOutcome = NULL; - - ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj); - mdclog_write(MDCLOG_DEBUG, "Freed subscription delete response memory"); - -}; - - -bool subscription_delete_response::encode_e2ap_subscription_delete_response(unsigned char *buf, size_t *size, subscription_response_helper &dinput, bool is_success){ - - bool res; - - if(is_success){ - res = set_fields(successMsg, dinput); - if (!res){ - return false; - } - e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome; - e2ap_pdu_obj->choice.successfulOutcome = successMsg; - } - else{ - res = set_fields(unsuccessMsg, dinput); - if(! res){ - return false; - } - e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome; - e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg; - } - - - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len); - if(ret_constr){ - error_string.assign(errbuf, errbuf_len); - return false; - } - - //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - - asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size); - - if(retval.encoded == -1){ - error_string.assign(strerror(errno)); - error_string = "Error encoding subcription delete response. Reason = " + error_string; - return false; - } - else { - if(*size < retval.encoded){ - std::stringstream ss; - ss <<"Error encoding Subscription Delete Response . Reason = encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl; - error_string = ss.str(); - retval.encoded = -1; - return false; - } - } - - *size = retval.encoded; - return true; - -} - -bool subscription_delete_response::set_fields(SuccessfulOutcome_t *success, subscription_response_helper &helper){ - - if (success == 0){ - error_string = "Invalid reference to success message in set fields subscription delete response"; - return false; - } - - unsigned int ie_index; - - success->procedureCode = ProcedureCode_id_RICsubscriptionDelete; - success->criticality = Criticality_reject; - success->value.present = SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse; - - RICsubscriptionDeleteResponse_t * subscription_delete_response = &(success->value.choice.RICsubscriptionDeleteResponse); - subscription_delete_response->protocolIEs.list.count = 0; - - ie_index = 0; - RICsubscriptionDeleteResponse_IEs_t *ies_ricreq = &IE_array[ie_index]; - - ies_ricreq->criticality = Criticality_reject; - ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; - ies_ricreq->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID; - RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; - ricrequest_ie->ricRequestorID = helper.get_request_id(); - //ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq(); - ASN_SEQUENCE_ADD(&subscription_delete_response->protocolIEs, ies_ricreq); - - - ie_index = 1; - RICsubscriptionDeleteResponse_IEs_t *ies_ranfunc = &IE_array[ie_index]; - ies_ranfunc->criticality = Criticality_reject; - ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; - ies_ranfunc->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID; - RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; - *ranfunction_ie = helper.get_function_id(); - ASN_SEQUENCE_ADD(&subscription_delete_response->protocolIEs, ies_ranfunc); - - return true; - - -} - -bool subscription_delete_response:: get_fields(SuccessfulOutcome_t * success_msg, subscription_response_helper & dout) -{ - - if (success_msg == 0){ - error_string = "Invalid reference to success message inn get fields subscription delete response"; - return false; - } - - RICrequestID_t *requestid; - RANfunctionID_t * ranfunctionid; - - for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.count; edx++) { - RICsubscriptionDeleteResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.array[edx]; - - switch(memb_ptr->id) - { - case (ProtocolIE_ID_id_RICrequestID): - requestid = &memb_ptr->value.choice.RICrequestID; - //dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber); - break; - - case (ProtocolIE_ID_id_RANfunctionID): - ranfunctionid = &memb_ptr->value.choice.RANfunctionID; - dout.set_function_id(*ranfunctionid); - break; - } - - } - - return true; - //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu); -} - - -bool subscription_delete_response::set_fields(UnsuccessfulOutcome_t *unsuccess, subscription_response_helper &helper){ - - if (unsuccess == 0){ - error_string = "Invalid reference to unsuccess message in set fields subscription delete response"; - return false; - } - - unsigned int ie_index; - - unsuccess->procedureCode = ProcedureCode_id_RICsubscriptionDelete; - unsuccess->criticality = Criticality_reject; - unsuccess->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure; - - RICsubscriptionDeleteFailure_t * ric_subscription_failure = &(unsuccess->value.choice.RICsubscriptionDeleteFailure); - ric_subscription_failure->protocolIEs.list.count = 0; - - ie_index = 0; - RICsubscriptionDeleteFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index]; - - ies_ricreq->criticality = Criticality_reject; - ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; - ies_ricreq->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID; - RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; - ricrequest_ie->ricRequestorID = helper.get_request_id(); - //ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq(); - ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ricreq); - - ie_index = 1; - RICsubscriptionDeleteFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index]; - ies_ranfunc->criticality = Criticality_reject; - ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; - ies_ranfunc->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID; - RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; - *ranfunction_ie = helper.get_function_id(); - ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ranfunc); - - - return true; - -} - -bool subscription_delete_response:: get_fields(UnsuccessfulOutcome_t * unsuccess_msg, subscription_response_helper & dout) -{ - - if (unsuccess_msg == 0){ - error_string = "Invalid reference to unsuccess message in get fields subscription delete response"; - return false; - } - - RICrequestID_t *requestid; - RANfunctionID_t * ranfunctionid; - - for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.count; edx++) { - RICsubscriptionDeleteFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.array[edx]; - - switch(memb_ptr->id) - { - case (ProtocolIE_ID_id_RICrequestID): - requestid = &memb_ptr->value.choice.RICrequestID; - //dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber); - break; - - case (ProtocolIE_ID_id_RANfunctionID): - ranfunctionid = &memb_ptr->value.choice.RANfunctionID; - dout.set_function_id(*ranfunctionid); - break; - - } - - } - - return true; - //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu); -} - - - diff --git a/src/xapp-asn/e2ap/subscription_delete_response.hpp b/src/xapp-asn/e2ap/subscription_delete_response.hpp deleted file mode 100644 index 14589e5..0000000 --- a/src/xapp-asn/e2ap/subscription_delete_response.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - -#pragma once - -#ifndef S_DEL_RESPONSE_ -#define S_DEL_RESPONSE_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "response_helper.hpp" - -#define NUM_SUBSCRIPTION_DELETE_RESPONSE_IES 2 -#define NUM_SUBSCRIPTION_DELETE_FAILURE_IES 2 - -class subscription_delete_response { -public: - - subscription_delete_response(void); - ~subscription_delete_response(void); - - bool encode_e2ap_subscription_delete_response(unsigned char *, size_t *, subscription_response_helper &, bool); - bool set_fields(SuccessfulOutcome_t *, subscription_response_helper &); - bool get_fields(SuccessfulOutcome_t *, subscription_response_helper &); - - bool set_fields(UnsuccessfulOutcome_t *, subscription_response_helper &); - bool get_fields(UnsuccessfulOutcome_t *, subscription_response_helper &); - - std::string get_error_string(void) const { - return error_string; - } - -private: - - E2AP_PDU_t * e2ap_pdu_obj; - SuccessfulOutcome_t * successMsg; - UnsuccessfulOutcome_t * unsuccessMsg; - - - RICsubscriptionDeleteResponse_IEs_t *IE_array; - RICsubscriptionDeleteFailure_IEs_t *IE_Failure_array; - - - char errbuf[128]; - size_t errbuf_len = 128; - std::string error_string; - -}; - - - - -#endif diff --git a/src/xapp-asn/e2ap/subscription_helper.hpp b/src/xapp-asn/e2ap/subscription_helper.hpp deleted file mode 100644 index b43df7d..0000000 --- a/src/xapp-asn/e2ap/subscription_helper.hpp +++ /dev/null @@ -1,181 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - - -#ifndef SUB_HELPER_ -#define SUB_HELPER_ - -/* - Simple structure to store action related information based on E2 v0.22 - Used for subscription request, response etc - - ricActionID RICactionID, - ricActionType RICactionType, - ricActionDefinition RICactionDefinition OPTIONAL, - ricSubsequentAction RICsubsequentAction OPTIONAL, - ricCause -*/ - -#include -#include -#include - -#include "generic_helpers.hpp" - - -// Note : if no action definition specified, octet length of action definition is NULL -// If no subsequent action specified, default is subsequent_action = 0, time to wait is 0 -struct Action { - -public: - - Action(int id, int type): _is_def(false), _is_subs_act(false), _id(id), _type(type), _next_action(0){}; - Action(int id, int type, const void *def, size_t def_size, int next_action): _is_def(false), _is_subs_act(false), _id(id), _type(type){ - - _is_def = true; - _action_definition.set_ref(def); - _action_definition.set_size(def_size); - _is_subs_act = true; - _next_action = next_action; - - }; - - - int get_id() const{ - return _id; - } - - int get_type() const { - return _type; - } - - - const void * get_definition(void ) { - return _action_definition.get_ref(); - } - - int get_definition_size(void) const { - return _action_definition.get_size(); - }; - - - int get_subsequent_action() const { - return _next_action; - }; - - bool is_definition() const{ - - return _is_def; - } - - bool is_subsequent_action() const{ - return _is_subs_act; - } - -private: - - bool _is_def; - bool _is_subs_act; - int _id, _type, _next_action, _cause, _sub_cause; - bool _is_admit; - octet_helper _action_definition; - -}; - - -/* - Helper class that stores subscription data -*/ - - -struct subscription_helper { - -public: - - using action_t = std::vector; - subscription_helper(){ - _action_ref = std::make_unique(); - }; - - action_t * get_list() const {return _action_ref.get();}; - - void clear(void){ - _action_ref.get()->clear(); - } - - void set_request(int id){ - _req_id = id; - - }; - - void set_function_id(int id){ - _func_id = id; - }; - - void set_event_def(const void *ref, size_t size){ - _event_def.set_ref(ref); - _event_def.set_size(size); - }; - - - void add_action(int id, int type){ - Action a(id, type) ; - _action_ref.get()->push_back(a); - }; - - void add_action(int id, int type, const void *action_def, size_t size, int next_action){ - Action a (id, type, action_def, size, next_action); - _action_ref.get()->push_back(a); - }; - - - int get_request_id(void) const{ - return _req_id; - } - - - int get_function_id(void) const{ - return _func_id; - } - - const void * get_event_def(void) { - return _event_def.get_ref(); - } - - int get_event_def_size(void) const { - return _event_def.get_size(); - } - - void print_sub_info(void){ - std::cout <<"Request ID = " << _req_id << std::endl; - std::cout <<"RAN Function ID = " << _func_id << std::endl; - for(auto const & e: *(_action_ref.get())){ - std::cout <<"Action ID = " << e.get_id() << " Action Type = " << e.get_type() << std::endl; - } - }; - -private: - - std::unique_ptr _action_ref; - int curr_index; - int _req_id, _func_id; - octet_helper _event_def; - -}; - -#endif diff --git a/src/xapp-asn/e2ap/subscription_request.cc b/src/xapp-asn/e2ap/subscription_request.cc deleted file mode 100644 index 91071b3..0000000 --- a/src/xapp-asn/e2ap/subscription_request.cc +++ /dev/null @@ -1,306 +0,0 @@ - - -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - - -#include "subscription_request.hpp" - - -// Set up memory allocations for each IE for encoding -// We are responsible for memory management for each IE for encoding -// Hence destructor should clear out memory -// When decoding, we rely on asn1c macro (ASN_STRUCT_FREE to be called -// for releasing memory by external calling function) -subscription_request::subscription_request(void){ - - _name = "default"; - - e2ap_pdu_obj = 0; - e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t)); - assert(e2ap_pdu_obj != 0); - - initMsg = 0; - initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t)); - assert(initMsg != 0); - - IE_array = 0; - IE_array = (RICsubscriptionRequest_IEs_t *)calloc(NUM_SUBSCRIPTION_REQUEST_IES, sizeof(RICsubscriptionRequest_IEs_t)); - assert(IE_array != 0); - - action_array = 0; - action_array = (RICaction_ToBeSetup_ItemIEs_t *)calloc(INITIAL_REQUEST_LIST_SIZE, sizeof(RICaction_ToBeSetup_ItemIEs_t)); - assert(action_array != 0); - action_array_size = INITIAL_REQUEST_LIST_SIZE; - // also need to add subsequent action and time to wait .. - for (unsigned int i = 0; i < action_array_size; i++){ - action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction = (struct RICsubsequentAction *)calloc(1, sizeof(struct RICsubsequentAction)); - assert(action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction != 0); - } - - e2ap_pdu_obj->choice.initiatingMessage = initMsg; - e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage; - - - -}; - - - -// Clear assigned protocolIE list from RIC indication IE container -subscription_request::~subscription_request(void){ - - mdclog_write(MDCLOG_DEBUG, "Freeing subscription request memory");; - - // Sequence of actions to be admitted causes special heart-ache. Free ric subscription element manually and reset the ie pointer - RICsubscriptionDetails_t * ricsubscription_ie = &(IE_array[2].value.choice.RICsubscriptionDetails); - - for(int i = 0; i < ricsubscription_ie->ricAction_ToBeSetup_List.list.size; i++){ - ricsubscription_ie->ricAction_ToBeSetup_List.list.array[i] = 0; - } - - if (ricsubscription_ie->ricAction_ToBeSetup_List.list.size > 0){ - free(ricsubscription_ie->ricAction_ToBeSetup_List.list.array); - ricsubscription_ie->ricAction_ToBeSetup_List.list.size = 0; - ricsubscription_ie->ricAction_ToBeSetup_List.list.count = 0; - ricsubscription_ie->ricAction_ToBeSetup_List.list.array = 0; - } - - // clear subsequent action array - for (unsigned int i = 0; i < action_array_size; i++){ - free(action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction ); - } - - free(action_array); - RICsubscriptionRequest_t * subscription_request = &(initMsg->value.choice.RICsubscriptionRequest); - - for(int i = 0; i < subscription_request->protocolIEs.list.size; i++){ - subscription_request->protocolIEs.list.array[i] = 0; - } - - if( subscription_request->protocolIEs.list.size > 0){ - free( subscription_request->protocolIEs.list.array); - subscription_request->protocolIEs.list.array = 0; - subscription_request->protocolIEs.list.size = 0; - subscription_request->protocolIEs.list.count = 0; - } - - free(IE_array); - free(initMsg); - e2ap_pdu_obj->choice.initiatingMessage = 0; - - ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj); - mdclog_write(MDCLOG_DEBUG, "Freed subscription request memory "); -}; - - -bool subscription_request::encode_e2ap_subscription(unsigned char *buf, size_t *size, subscription_helper &dinput){ - - bool res; - - initMsg->procedureCode = ProcedureCode_id_RICsubscription; - initMsg->criticality = Criticality_ignore; - initMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionRequest; - - res = set_fields(initMsg, dinput); - if (!res){ - return false; - } - - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len); - if(ret_constr){ - error_string.assign(errbuf, errbuf_len); - error_string = "Constraints failed for encoding subscription request. Reason = " + error_string; - return false; - } - - //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - - asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size); - - if(retval.encoded == -1){ - error_string.assign(strerror(errno)); - error_string = "Error encoding Subscription Request. Reason = " + error_string; - return false; - } - else { - if(*size < retval.encoded){ - std::stringstream ss; - ss <<"Error encoding Subscription Request . Reason = encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl; - error_string = ss.str(); - retval.encoded = -1; - return false; - } - } - - *size = retval.encoded; - return true; - -} - - -bool subscription_request::set_fields( InitiatingMessage_t * init_msg, subscription_helper &helper){ - - - int ie_index; - int result = 0; - - if (init_msg == 0){ - error_string = "Error. Invalid reference when getting fields from subscription request"; - return false; - } - - RICsubscriptionRequest_t * ric_subscription = &(init_msg->value.choice.RICsubscriptionRequest); - ric_subscription->protocolIEs.list.count = 0; - - ie_index = 0; - RICsubscriptionRequest_IEs_t *ies_ricreq = &IE_array[ie_index]; - ies_ricreq->criticality = Criticality_reject; - ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; - ies_ricreq->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID; - RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; - ricrequest_ie->ricRequestorID = helper.get_request_id(); - //ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq(); - result = ASN_SEQUENCE_ADD(&(ric_subscription->protocolIEs), &IE_array[ie_index]); - assert(result == 0); - - ie_index = 1; - RICsubscriptionRequest_IEs_t *ies_ranfunc = &IE_array[ie_index]; - ies_ranfunc->criticality = Criticality_reject; - ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; - ies_ranfunc->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID; - RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; - *ranfunction_ie = helper.get_function_id(); - result = ASN_SEQUENCE_ADD(&(ric_subscription->protocolIEs), &IE_array[ie_index]); - assert(result == 0); - - - ie_index = 2; - RICsubscriptionRequest_IEs_t *ies_actid = &IE_array[ie_index]; - ies_actid->criticality = Criticality_reject; - ies_actid->id = ProtocolIE_ID_id_RICsubscriptionDetails; - ies_actid->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails; - RICsubscriptionDetails_t *ricsubscription_ie = &ies_actid->value.choice.RICsubscriptionDetails; - - ricsubscription_ie->ricEventTriggerDefinition.buf = (uint8_t *) helper.get_event_def(); - ricsubscription_ie->ricEventTriggerDefinition.size = helper.get_event_def_size(); - - std::vector * ref_action_array = helper.get_list(); - // do we need to resize ? - // we don't care about contents, so just do a free/calloc - if(action_array_size < ref_action_array->size()){ - std::cout <<"re-allocating action array from " << action_array_size << " to " << 2 * ref_action_array->size() << std::endl; - // free subsequent allocation - for (unsigned int i = 0; i < action_array_size; i++){ - free(action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction ); - } - - action_array_size = 2 * ref_action_array->size(); - free(action_array); - action_array = (RICaction_ToBeSetup_ItemIEs_t *)calloc(action_array_size, sizeof(RICaction_ToBeSetup_ItemIEs_t)); - assert(action_array != 0); - - // also need to add subsequent action and time to wait .. - for (unsigned int i = 0; i < action_array_size; i++){ - action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction = (struct RICsubsequentAction *)calloc(1, sizeof(struct RICsubsequentAction)); - assert(action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction != 0); - } - - } - - // reset the list count on ricAction_ToBeSetup_List; - ricsubscription_ie->ricAction_ToBeSetup_List.list.count = 0; - - for(unsigned int i = 0; i < ref_action_array->size(); i ++){ - action_array[i].criticality = Criticality_ignore; - action_array[i].id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item ; - action_array[i].value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item; - action_array[i].value.choice.RICaction_ToBeSetup_Item.ricActionID = (*ref_action_array)[i].get_id(); - action_array[i].value.choice.RICaction_ToBeSetup_Item.ricActionType = (*ref_action_array)[i].get_type(); - action_array[i].value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction->ricSubsequentActionType = (*ref_action_array)[i].get_subsequent_action(); - - result = ASN_SEQUENCE_ADD(&ricsubscription_ie->ricAction_ToBeSetup_List, &(action_array[i])); - if (result == -1){ - error_string = "Erorr : Unable to assign memory to add Action item to set up list"; - return false; - } - - } - - result = ASN_SEQUENCE_ADD(&(ric_subscription->protocolIEs), &IE_array[ie_index]); - assert(result == 0); - - - - return true; -}; - - - -bool subscription_request:: get_fields(InitiatingMessage_t * init_msg, subscription_helper & dout) -{ - - if (init_msg == 0){ - error_string = "Error. Invalid reference when getting fields from subscription request"; - return false; - } - - RICrequestID_t *requestid; - RANfunctionID_t * ranfunctionid; - RICsubscriptionDetails_t * ricsubscription; - - for(int edx = 0; edx < init_msg->value.choice.RICsubscriptionRequest.protocolIEs.list.count; edx++) { - RICsubscriptionRequest_IEs_t *memb_ptr = init_msg->value.choice.RICsubscriptionRequest.protocolIEs.list.array[edx]; - - switch(memb_ptr->id) - { - case (ProtocolIE_ID_id_RICrequestID): - requestid = &memb_ptr->value.choice.RICrequestID; - //dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber); - break; - - case (ProtocolIE_ID_id_RANfunctionID): - ranfunctionid = &memb_ptr->value.choice.RANfunctionID; - dout.set_function_id(*ranfunctionid); - break; - - case (ProtocolIE_ID_id_RICsubscriptionDetails): - ricsubscription = &memb_ptr->value.choice.RICsubscriptionDetails; - dout.set_event_def(ricsubscription->ricEventTriggerDefinition.buf, ricsubscription->ricEventTriggerDefinition.size); - - for(int index = 0; index < ricsubscription->ricAction_ToBeSetup_List.list.count; index ++){ - RICaction_ToBeSetup_ItemIEs_t * item = (RICaction_ToBeSetup_ItemIEs_t *)ricsubscription->ricAction_ToBeSetup_List.list.array[index]; - if (item->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction == NULL){ - dout.add_action(item->value.choice.RICaction_ToBeSetup_Item.ricActionID, item->value.choice.RICaction_ToBeSetup_Item.ricActionType); - } - else{ - std::string action_def = ""; // for now we are ignoring action definition - } - }; - - break; - } - - } - - //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu); - return true; -}; - - - diff --git a/src/xapp-asn/e2ap/subscription_request.hpp b/src/xapp-asn/e2ap/subscription_request.hpp deleted file mode 100644 index 15695c3..0000000 --- a/src/xapp-asn/e2ap/subscription_request.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - -#pragma once - -#ifndef S_REQUEST_ -#define S_REQUEST_ - -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "subscription_helper.hpp" - -#define NUM_SUBSCRIPTION_REQUEST_IES 3 -#define INITIAL_REQUEST_LIST_SIZE 4 - -class subscription_request{ -public: - - subscription_request(std::string name); - subscription_request(void); - ~subscription_request(void); - - bool encode_e2ap_subscription(unsigned char *, size_t *, subscription_helper &); - bool set_fields(InitiatingMessage_t *, subscription_helper &); - bool get_fields(InitiatingMessage_t *, subscription_helper &); - - std::string get_error(void) const{ - return error_string; - } - -private: - - InitiatingMessage_t *initMsg; - E2AP_PDU_t * e2ap_pdu_obj; - - RICsubscriptionRequest_IEs_t * IE_array; - RICaction_ToBeSetup_ItemIEs_t * action_array; - unsigned int action_array_size; - char errbuf[128]; - size_t errbuf_len = 128; - std::string _name; - std::string error_string; -}; - - - -#endif diff --git a/src/xapp-asn/e2ap/subscription_response.cc b/src/xapp-asn/e2ap/subscription_response.cc deleted file mode 100644 index 5ed72fa..0000000 --- a/src/xapp-asn/e2ap/subscription_response.cc +++ /dev/null @@ -1,583 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - - -#include "subscription_response.hpp" - -/* The xAPP need only worry about the get_fields from a response, since it does -not generate a response. Generating response however is included to support testing. -*/ - - -// Primarly for generation -subscription_response::subscription_response(void){ - - e2ap_pdu_obj = 0; - e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t)); - assert(e2ap_pdu_obj != 0); - - successMsg = 0; - successMsg = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t)); - assert(successMsg != 0); - - unsuccessMsg = 0; - unsuccessMsg = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t)); - assert(unsuccessMsg != 0); - - IE_array = 0; - IE_array = (RICsubscriptionResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_RESPONSE_IES, sizeof(RICsubscriptionResponse_IEs_t)); - assert(IE_array != 0); - - IE_Failure_array = 0; - IE_Failure_array = (RICsubscriptionFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_FAILURE_IES, sizeof(RICsubscriptionFailure_IEs_t)); - assert(IE_Failure_array != 0); - - ie_admitted_list = 0; - ie_admitted_list = (RICaction_Admitted_ItemIEs_t *)calloc(INITIAL_RESPONSE_LIST_SIZE, sizeof(RICaction_Admitted_ItemIEs_t)); - assert(ie_admitted_list != 0); - ie_admitted_list_size = INITIAL_RESPONSE_LIST_SIZE; - - ie_not_admitted_list = 0; - ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(INITIAL_RESPONSE_LIST_SIZE, sizeof(RICaction_NotAdmitted_ItemIEs_t)); - assert(ie_not_admitted_list != 0); - ie_not_admitted_list_size = INITIAL_RESPONSE_LIST_SIZE; - - - - - -}; - - - -// Clear assigned protocolIE list from RIC indication IE container -subscription_response::~subscription_response(void){ - - mdclog_write(MDCLOG_DEBUG, "Freeing subscription response memory"); - RICaction_Admitted_List_t * response_admitted_list = (RICaction_Admitted_List_t *) &(IE_array[2].value.choice.RICaction_Admitted_List); - - for(int i = 0; i < response_admitted_list->list.size; i++){ - response_admitted_list->list.array[i] = 0; - } - - - if (response_admitted_list->list.size > 0){ - free(response_admitted_list->list.array); - response_admitted_list->list.array = 0; - response_admitted_list->list.size = 0; - response_admitted_list->list.count = 0; - } - - - RICaction_NotAdmitted_List_t * response_not_admitted_list = &(IE_array[3].value.choice.RICaction_NotAdmitted_List); - for(int i = 0; i < response_not_admitted_list->list.size; i++){ - response_not_admitted_list->list.array[i] = 0; - } - - if (response_not_admitted_list->list.size > 0){ - free(response_not_admitted_list->list.array); - response_not_admitted_list->list.array = 0; - response_not_admitted_list->list.size = 0; - response_not_admitted_list->list.count = 0; - } - - RICsubscriptionResponse_t * ric_subscription_response = &(successMsg->value.choice.RICsubscriptionResponse); - for(int i = 0; i < ric_subscription_response->protocolIEs.list.size ; i++){ - ric_subscription_response->protocolIEs.list.array[i] = 0; - } - - if (ric_subscription_response->protocolIEs.list.size > 0){ - free(ric_subscription_response->protocolIEs.list.array); - ric_subscription_response->protocolIEs.list.array = 0; - ric_subscription_response->protocolIEs.list.size = 0; - ric_subscription_response->protocolIEs.list.count = 0; - } - - - RICaction_NotAdmitted_List_t * failure_not_admitted_list = &(IE_Failure_array[2].value.choice.RICaction_NotAdmitted_List); - for(int i = 0; i < failure_not_admitted_list->list.size; i++){ - failure_not_admitted_list->list.array[i] = 0; - } - - if ( failure_not_admitted_list->list.size > 0){ - free( failure_not_admitted_list->list.array); - failure_not_admitted_list->list.array = 0; - failure_not_admitted_list->list.size = 0; - failure_not_admitted_list->list.count = 0; - } - - - RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure); - for(int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){ - ric_subscription_failure->protocolIEs.list.array[i] = 0; - } - - if ( ric_subscription_failure->protocolIEs.list.size > 0){ - free(ric_subscription_failure->protocolIEs.list.array); - ric_subscription_failure->protocolIEs.list.array = 0; - ric_subscription_failure->protocolIEs.list.size = 0; - ric_subscription_failure->protocolIEs.list.count = 0; - } - - - free(ie_admitted_list); - free(ie_not_admitted_list); - free(IE_Failure_array); - free(IE_array); - - - ASN_STRUCT_FREE(asn_DEF_SuccessfulOutcome, successMsg); - ASN_STRUCT_FREE(asn_DEF_UnsuccessfulOutcome, unsuccessMsg); - - - e2ap_pdu_obj->choice.initiatingMessage = NULL; - e2ap_pdu_obj->present = E2AP_PDU_PR_NOTHING; - ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj); - - mdclog_write(MDCLOG_DEBUG, "Freed subscription response memory "); - - -}; - - -bool subscription_response::encode_e2ap_subscription_response(unsigned char *buf, size_t *size, subscription_response_helper &dinput, bool is_success){ - - - if(is_success){ - set_fields_success(dinput); - e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome; - e2ap_pdu_obj->choice.successfulOutcome = successMsg; - - successMsg->procedureCode = ProcedureCode_id_RICsubscription; - successMsg->criticality = Criticality_reject; - successMsg->value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse; - - } - else{ - set_fields_unsuccess(dinput); - e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome; - e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg; - - unsuccessMsg->procedureCode = ProcedureCode_id_RICsubscription; - unsuccessMsg->criticality = Criticality_reject; - unsuccessMsg->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure; - - } - - //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj); - - int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len); - if(ret_constr){ - error_string.assign(errbuf, errbuf_len); - error_string = "Constraints failed for encoding subscription response. Reason = " + error_string; - return false; - } - - asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size); - - if(res.encoded == -1){ - std::cout <<"Error encoding PDU. Reason =" << strerror(errno) << std::endl; - return false; - } - else { - if(*size < res.encoded){ - fprintf(stderr, "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2AP_PDU.name)); - res.encoded = -1; - return false; - } - } - - *size = res.encoded; - return true; - -} - -void subscription_response::set_fields_success(subscription_response_helper &helper){ - - int ie_index; - - RICsubscriptionResponse_t * subscription_response = &(successMsg->value.choice.RICsubscriptionResponse); - //reset list count .. - subscription_response->protocolIEs.list.count = 0; - - ie_index = 0; - RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index]; - - ies_ricreq->criticality = Criticality_reject; - ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; - ies_ricreq->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID; - RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; - ricrequest_ie->ricRequestorID = helper.get_request_id(); - // ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq(); - ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index])); - - - ie_index = 1; - RICsubscriptionResponse_IEs_t *ies_ranfunc = &IE_array[ie_index]; - ies_ranfunc->criticality = Criticality_reject; - ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; - ies_ranfunc->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID; - RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; - *ranfunction_ie = helper.get_function_id(); - ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index])); - - - ie_index = 2; - RICsubscriptionResponse_IEs_t *ies_admitted_actid = &IE_array[ie_index]; - ies_admitted_actid->criticality = Criticality_reject; - ies_admitted_actid->id = ProtocolIE_ID_id_RICactions_Admitted; - RICaction_Admitted_List_t *ric_admitted_actions_ie = &ies_admitted_actid->value.choice.RICaction_Admitted_List; - ric_admitted_actions_ie->list.count = 0; - std::vector * ref_admitted_action_array = helper.get_admitted_list(); - - if(ref_admitted_action_array->size() == 0){ - ies_admitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_NOTHING; - } - else{ - ies_admitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List; - - // resize memory ? - if (ref_admitted_action_array->size() >= ie_admitted_list_size){ - ie_admitted_list_size = 2 * ref_admitted_action_array->size(); - free(ie_admitted_list); - ie_admitted_list = (RICaction_Admitted_ItemIEs_t *)calloc(ie_admitted_list_size, sizeof(RICaction_Admitted_ItemIEs_t)); - assert(ie_admitted_list != 0); - }; - - - for(unsigned int i = 0; i < ref_admitted_action_array->size(); i ++){ - ie_admitted_list[i].criticality = Criticality_ignore; - ie_admitted_list[i].id = ProtocolIE_ID_id_RICaction_Admitted_Item ; - ie_admitted_list[i].value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item; - ie_admitted_list[i].value.choice.RICaction_Admitted_Item.ricActionID = (*ref_admitted_action_array)[i].get_id(); - ASN_SEQUENCE_ADD(ric_admitted_actions_ie, &(ie_admitted_list[i])); - } - } - ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index])); - - // optional IE : add only if non-zero list - ie_index = 3; - std::vector * ref_notadmitted_action_array = helper.get_not_admitted_list(); - if (ref_notadmitted_action_array->size() > 0){ - - RICsubscriptionResponse_IEs_t *ies_notadmitted_actid = &IE_array[ie_index]; - ies_notadmitted_actid->criticality = Criticality_reject; - ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted; - - RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List; - ric_not_admitted_actions_ie->list.count = 0; - - - ies_notadmitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List; - - // resize memory ? - if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){ - ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size(); - free(ie_not_admitted_list); - ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(ie_not_admitted_list_size, sizeof(RICaction_NotAdmitted_ItemIEs_t)); - assert(ie_not_admitted_list != 0); - - }; - - - for(unsigned int i = 0; i < ref_notadmitted_action_array->size(); i ++){ - ie_not_admitted_list[i].criticality = Criticality_ignore; - ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ; - ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;; - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id(); - - int cause = (*ref_notadmitted_action_array)[i].get_cause(); - switch(cause){ - case Cause_PR_ricService: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_transport: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_protocol: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_misc: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_ricRequest: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - default: - mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause); - return; - } - - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.present = (Cause_PR)cause; - ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i])); - } - - ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index])); - } - -} - -void subscription_response:: get_fields(SuccessfulOutcome_t * success_msg, subscription_response_helper & dout) -{ - - assert(success_msg != NULL); - - RICrequestID_t *requestid; - RANfunctionID_t * ranfunctionid; - RICaction_Admitted_List_t * ric_admitted_action_list; - RICaction_NotAdmitted_List_t * ric_not_admitted_action_list; - - for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.count; edx++) { - RICsubscriptionResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.array[edx]; - - switch(memb_ptr->id) - { - case (ProtocolIE_ID_id_RICrequestID): - requestid = &memb_ptr->value.choice.RICrequestID; - //dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber); - break; - - case (ProtocolIE_ID_id_RANfunctionID): - ranfunctionid = &memb_ptr->value.choice.RANfunctionID; - dout.set_function_id(*ranfunctionid); - break; - - case (ProtocolIE_ID_id_RICactions_Admitted): - ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List; - - // admitted actions - for(int index = 0; index < ric_admitted_action_list->list.count; index ++){ - RICaction_Admitted_ItemIEs_t * item = (RICaction_Admitted_ItemIEs_t *)ric_admitted_action_list->list.array[index]; - long int id = item->value.choice.RICaction_Admitted_Item.ricActionID; - dout.get_admitted_list()->push_back(ActionResponse(id)); - }; - - break; - - case (ProtocolIE_ID_id_RICactions_NotAdmitted): - ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List; - - for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){ - RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index]; - long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID; - int cause = item->value.choice.RICaction_NotAdmitted_Item.cause.present; - int sub_cause; - switch(cause){ - - case Cause_PR_ricService : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService; - break; - - case Cause_PR_transport : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport; - break; - - case Cause_PR_protocol : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol; - break; - - case Cause_PR_misc : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc; - break; - - case Cause_PR_ricRequest : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest; - break; - - default: - std::cout <<"Error ! Illegal cause enum" << cause << std::endl; - return; - } - dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause)); - } - break; - } - - } - - //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu); -} - - -void subscription_response::set_fields_unsuccess( subscription_response_helper &helper){ - - int ie_index; - RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure); - // reset list count - ric_subscription_failure->protocolIEs.list.count = 0; - - ie_index = 0; - RICsubscriptionFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index]; - ies_ricreq->criticality = Criticality_reject; - ies_ricreq->id = ProtocolIE_ID_id_RICrequestID; - ies_ricreq->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID; - RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID; - ricrequest_ie->ricRequestorID = helper.get_request_id(); -// ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq(); - ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index])); - - ie_index = 1; - RICsubscriptionFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index]; - ies_ranfunc->criticality = Criticality_reject; - ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID; - ies_ranfunc->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID; - RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID; - *ranfunction_ie = helper.get_function_id(); - ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index])); - - ie_index = 2; - RICsubscriptionFailure_IEs_t *ies_notadmitted_actid = &IE_Failure_array[ie_index]; - ies_notadmitted_actid->criticality = Criticality_reject; - ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted; - RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List; - ric_not_admitted_actions_ie->list.count = 0; - std::vector * ref_notadmitted_action_array = helper.get_not_admitted_list(); - if(ref_notadmitted_action_array->size() == 0){ - ies_notadmitted_actid->value.present = RICsubscriptionFailure_IEs__value_PR_NOTHING; - } - else{ - ies_notadmitted_actid->value.present = RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List; - - // resize memory ? - if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){ - ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size(); - free(ie_not_admitted_list); - ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(ie_not_admitted_list_size, sizeof(RICaction_NotAdmitted_ItemIEs_t)); - assert(ie_not_admitted_list != 0); - }; - - - // reset the list count on ricAction_ToBeSetup_List; - for(unsigned int i = 0; i < ref_notadmitted_action_array->size(); i ++){ - ie_not_admitted_list[i].criticality = Criticality_ignore; - ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ; - ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;; - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id(); - - int cause = (*ref_notadmitted_action_array)[i].get_cause(); - switch(cause){ - case Cause_PR_ricService: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_transport: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_protocol: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_misc: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - case Cause_PR_ricRequest: - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest = (*ref_notadmitted_action_array)[i].get_sub_cause(); - break; - default: - mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause); - return ; - } - - ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.cause.present = (Cause_PR)cause; - - ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i])); - } - - } - ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index])); - - - // // criticality diagnostics is not generated/parsed currently since optional - // i = 3; - // RICsubscriptionFailure_IEs_t *ies_criticality_diagnostics= &IE_Failure_array[i]; - // ies_criticality_diagnostics->criticality = Criticality_ignore; - // ies_criticality_diagnostics->id = ProtocolIE_ID_id_CriticalityDiagnostics ; - // ies_criticality_diagnostics->value.present = RICsubscriptionFailure_IEs__value_PR_NOTHING; - - -} - -void subscription_response:: get_fields(UnsuccessfulOutcome_t * unsuccess_msg, subscription_response_helper & dout) -{ - - assert(unsuccess_msg != NULL); - - RICrequestID_t *requestid; - RANfunctionID_t * ranfunctionid; - RICaction_NotAdmitted_List_t * ric_not_admitted_action_list; - - for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.count; edx++) { - RICsubscriptionFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.array[edx]; - - switch(memb_ptr->id) - { - case (ProtocolIE_ID_id_RICrequestID): - requestid = &memb_ptr->value.choice.RICrequestID; - //dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber); - break; - - case (ProtocolIE_ID_id_RANfunctionID): - ranfunctionid = &memb_ptr->value.choice.RANfunctionID; - dout.set_function_id(*ranfunctionid); - break; - - - case (ProtocolIE_ID_id_RICactions_NotAdmitted): - ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List; - - for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){ - RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index]; - long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID; - int cause = item->value.choice.RICaction_NotAdmitted_Item.cause.present; - int sub_cause; - switch(cause){ - - case Cause_PR_ricService : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService; - break; - - case Cause_PR_transport : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport; - break; - - case Cause_PR_protocol : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol; - break; - - case Cause_PR_misc : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc; - break; - - case Cause_PR_ricRequest : - sub_cause = item->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest; - break; - - default: - mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause); - return; - } - dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause)); - } - break; - } - - } - - //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu); -} - - - diff --git a/src/xapp-asn/e2ap/subscription_response.hpp b/src/xapp-asn/e2ap/subscription_response.hpp deleted file mode 100644 index 85469bf..0000000 --- a/src/xapp-asn/e2ap/subscription_response.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/* -================================================================================== - Copyright (c) 2019-2020 AT&T Intellectual Property. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -================================================================================== -*/ - -#pragma once - -#ifndef S_RESPONSE_ -#define S_RESPONSE_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "response_helper.hpp" - -#define NUM_SUBSCRIPTION_RESPONSE_IES 4 -#define NUM_SUBSCRIPTION_FAILURE_IES 3 -#define INITIAL_RESPONSE_LIST_SIZE 4 - -class subscription_response{ -public: - - subscription_response(void); - ~subscription_response(void); - - bool encode_e2ap_subscription_response(unsigned char *, size_t *, subscription_response_helper &, bool); - void get_fields(SuccessfulOutcome_t *, subscription_response_helper &); - void get_fields(UnsuccessfulOutcome_t *, subscription_response_helper &); - - std::string get_error(void) const{ - return error_string; - } - -private: - - void set_fields_success( subscription_response_helper &); - void set_fields_unsuccess( subscription_response_helper &); - - E2AP_PDU_t * e2ap_pdu_obj; - SuccessfulOutcome_t * successMsg; - UnsuccessfulOutcome_t * unsuccessMsg; - - - RICsubscriptionResponse_IEs_t *IE_array; - RICsubscriptionFailure_IEs_t *IE_Failure_array; - - - RICaction_Admitted_ItemIEs_t * ie_admitted_list; - RICaction_NotAdmitted_ItemIEs_t * ie_not_admitted_list; - unsigned int ie_admitted_list_size, ie_not_admitted_list_size; - - char errbuf[128]; - size_t errbuf_len = 128; - std::string error_string; -}; - - - - -#endif diff --git a/test/hw_unit_tests.cc b/test/hw_unit_tests.cc index 99187c5..94377f5 100644 --- a/test/hw_unit_tests.cc +++ b/test/hw_unit_tests.cc @@ -26,11 +26,18 @@ #include #include +#include "xapp.hpp" + +#include "test_indc.h" +#include "test_subs.h" +#include "test_cntrl.h" + +#include "test_e2ap.h" + #include "test_db.h" #include "test_rmr.h" #include "test_hc.h" -#include "test_subs.h" -#include "test_e2sm.h" + using namespace std; @@ -59,6 +66,8 @@ int main(int argc, char* argv[]) dm_xapp->Run(); testing::InitGoogleTest(&argc, argv); + ::testing::GTEST_FLAG(filter) = "E2AP*"; + int res = RUN_ALL_TESTS(); diff --git a/test/test_cntrl.h b/test/test_cntrl.h new file mode 100644 index 0000000..c2fe244 --- /dev/null +++ b/test/test_cntrl.h @@ -0,0 +1,68 @@ +/* +================================================================================== + + Copyright (c) 2019-2020 AT&T Intellectual Property. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ +/* + * test_cntrl.h + * + * Created on: Nov 4, 2020 + * Author: Shraboni Jana + */ + +#ifndef TEST_TEST_CNTRL_H_ +#define TEST_TEST_CNTRL_H_ + +#include +#include + +#include "e2ap_control_request.hpp" +#include "e2sm_control.hpp" + + +TEST(E2SM, ControlMessage) +{ + + unsigned char buff[1024]; + size_t buf_len = 1024; + + HWControlMessage msgObj; + msgObj.set_ricControlMessage("ControlMessage"); + + HWControlHeader headObj; + headObj.set_ricControlHeader(1); + + E2APControlMessage::ControlRequestIEs infoObj; + infoObj.set_ranFunctionID(1); + infoObj.set_ricRequestorID(1); + infoObj.set_ricControlHeader(headObj); + infoObj.set_ricControlMessage(msgObj); +// infoObj.set_ricCallProcessID("ProcessID"); + + E2APControlMessage cntrlObj(infoObj); + + bool res = cntrlObj.encode(buff, &buf_len); + if(!res) + { + std::cout << cntrlObj.get_error() << std::endl; + } + ASSERT_TRUE(res); +} + + + + +#endif /* TEST_TEST_CNTRL_H_ */ diff --git a/test/test_db.h b/test/test_db.h index 478af92..e7cbe7f 100644 --- a/test/test_db.h +++ b/test/test_db.h @@ -27,7 +27,7 @@ #include #include -#include "xapp.hpp" + using namespace std; diff --git a/test/test_e2ap.h b/test/test_e2ap.h index 427d840..727cade 100644 --- a/test/test_e2ap.h +++ b/test/test_e2ap.h @@ -29,8 +29,15 @@ #include #include "e2ap_control_failure.hpp" -#include "xapp.hpp" #include "e2ap_control_ack.hpp" +#include "e2ap_subsdel_request.hpp" +#include "e2ap_subsdel_response.hpp" +#include "e2ap_subsdel_failure.hpp" +#include "e2ap_criticality_diagnostics.hpp" +#include "e2ap_subscription_response.hpp" +#include "e2ap_subscription_failure.hpp" + + TEST(E2AP, ControlAcknowledgementEncode) { @@ -64,7 +71,7 @@ TEST(E2AP, ControlAcknowledgementEncode) } } -TEST(E2SM, ControlAcknowledgementDecode) +TEST(E2AP, ControlAcknowledgementDecode) { unsigned char e2ap_buff[4096]; char filename[100] = "controlack1.per"; @@ -131,7 +138,7 @@ TEST(E2AP, ControlFailureEncode) } } -TEST(E2SM, ControlFailureDecode) +TEST(E2AP, ControlFailureDecode) { unsigned char e2ap_buff[1024]; char filename[100] = "controlfail1.per"; @@ -165,4 +172,398 @@ TEST(E2SM, ControlFailureDecode) } +TEST(E2AP, SubscriptionDeleteRequest){ + + unsigned char buff[1024]; + size_t buff_size = 1024; + + + E2APSubscriptionDeleteRequest::SubscriptionDeleteRequestIEs dataObj; + + dataObj.set_ranFunctionID(1); + dataObj.set_ricInstanceID(1); + dataObj.set_ricRequestorID(3); + + E2APSubscriptionDeleteRequest requestObj(dataObj); + bool res = requestObj.encode(buff, &buff_size); + if(!res) + { + std::cout << requestObj.get_error() << std::endl; + } + ASSERT_TRUE(res); + + +} + +TEST(E2AP, SubDelResponseEncode) +{ + + unsigned char buff[1024]; + size_t buf_len = 1024; + + E2APSubscriptionDeleteResponse::SubscriptionDeleteResponseIEs infoObj; + infoObj.set_ranFunctionID(1); + infoObj.set_ricRequestorID(1); + infoObj.set_ricInstanceID(1); + + + E2APSubscriptionDeleteResponse subdelObj(infoObj); + + bool res = subdelObj.encode(buff, &buf_len); + if(!res) + { + std::cout << subdelObj.get_error() << std::endl; + } + ASSERT_TRUE(res); + FILE * pFile; + pFile = fopen ("subdelresponse1.per","w"); + if (pFile!=NULL) + { + fwrite (buff , sizeof(char), buf_len, pFile); + sleep(2); + fclose (pFile); + } + +} +TEST(E2AP, SubDelResponseDecode) +{ + sleep(10); + unsigned char e2ap_buff[1024]; + char filename[100] = "subdelresponse1.per"; + FILE *fp; + fp = fopen(filename,"rb"); + if(!fp) { + perror(filename); + exit(1); } + + size_t e2ap_buff_size = fread(e2ap_buff, 1, 1024, fp); + fclose(fp); + if(!e2ap_buff_size){ + fprintf(stderr, "%s: Empty or broken\n", filename); + exit(1); + } else { + fprintf(stderr, "e2ap buffer size: %ld \n", e2ap_buff_size); + } + + bool decode_status = true; + try{ + E2APSubscriptionDeleteResponse e2obj(&e2ap_buff[0],&e2ap_buff_size); + + + } catch(const char* e){ + decode_status = false; + std::cout << "Error Message: " << e << std::endl; + } + + + ASSERT_TRUE(decode_status); + +} + +TEST(E2AP, SubDelFailureEncode){ + unsigned char buff[1024]; + size_t buf_len = 1024; + + CriticalityDiagnosticsIEs crIEs1; + crIEs1.set_ieID(1); + crIEs1.set_typeOferror(1); + crIEs1.set_iEcriticality(2); + + CriticalityDiagnosticsIEs crIEs2; + crIEs2.set_ieID(1); + crIEs2.set_typeOferror(1); + crIEs2.set_iEcriticality(1); + + + + E2APCriticalityDiagnostics critObj; + critObj.set_procedureCode(10); + critObj.set_procedureCriticality(1); + critObj.set_ricInstanceID(101); + critObj.set_ricRequestorID(102); + critObj.set_triggeringMessage(1); + critObj.add(crIEs1); + critObj.add(crIEs2); + + E2APSubscriptionDeleteFailure::SubscriptionDeleteFailureIEs infoObj; + infoObj.set_ranFunctionID(1); + infoObj.set_ricRequestorID(1); + infoObj.set_ricInstanceID(1); + infoObj.set_ricCause(1); + infoObj.set_ricSubCause(2); + infoObj.set_critical_diagnostic(critObj); + + + E2APSubscriptionDeleteFailure subdelObj(infoObj); + + bool res = subdelObj.encode(buff, &buf_len); + if(!res) + { + std::cout << "Subscribtion Delete Failure Error Message" << subdelObj.get_error() << std::endl; + } + ASSERT_TRUE(res); + FILE * pFile; + pFile = fopen ("subdelfailure2.per","w"); + if (pFile!=NULL) + { + fwrite (buff , sizeof(char), buf_len, pFile); + sleep(2); + fclose (pFile); + } + +} + +TEST(E2AP, SubDelFailureDecode) +{ + sleep(10); + unsigned char e2ap_buff[1024]; + char filename[100] = "subdelfailure2.per"; + FILE *fp; + fp = fopen(filename,"rb"); + if(!fp) { + perror(filename); + exit(1); } + + size_t e2ap_buff_size = fread(e2ap_buff, 1, 1024, fp); + fclose(fp); + if(!e2ap_buff_size){ + fprintf(stderr, "%s: Empty or broken\n", filename); + exit(1); + } else { + fprintf(stderr, "e2ap buffer size: %ld \n", e2ap_buff_size); + } + + bool decode_status = true; + try{ + E2APSubscriptionDeleteFailure e2obj(&e2ap_buff[0],&e2ap_buff_size); + + std::cout << "Procedure Code: " << e2obj.getIEs().get_critical_diagnostic()->get_procedureCode() << std::endl; + std::cout << "Procedure Criticality: " << e2obj.getIEs().get_critical_diagnostic()->get_procedureCriticality() << std::endl; + std::cout << "Size OF LIST :" << e2obj.getIEs().get_critical_diagnostic()->get_list_count() << std::endl; + + int count = e2obj.getIEs().get_critical_diagnostic()->get_list_count() ; + std::vector *lst = e2obj.getIEs().get_critical_diagnostic()->get_list(); + for(int i=0; i< count; i++){ + std::cout<< "Typ Error:::" << (*lst)[i].get_typeOferror() << std::endl; + std::cout<< "iEcriticality:::" << (*lst)[i].get_iEcriticality() << std::endl; + std::cout<< "ieID:::" << (*lst)[i].get_ieID() << std::endl; + } + + } catch(const char* e){ + decode_status = false; + std::cout << "Error Message: " << e << std::endl; + } + + + ASSERT_TRUE(decode_status); + +} + +TEST(E2AP, SubResponseEncode){ + unsigned char buff[512]; + size_t buf_len = 512; + + RICactionAdmittedList::RICactionAdmittedItemIEs tmp1; + tmp1.set_ricActionID(1); + + RICactionAdmittedList admitlst; + admitlst.add(tmp1); + admitlst.add(RICactionAdmittedList::RICactionAdmittedItemIEs().set_ricActionID(2)); + + RICactionNotAdmittedList::RICactionNotAdmittedItemIEs tmp2; + tmp2.set_ricActionID(2); + tmp2.set_ricCause(1); + tmp2.set_ricSubCause(3); + RICactionNotAdmittedList notadmitlst; + notadmitlst.add(tmp2); + notadmitlst.add(RICactionNotAdmittedList::RICactionNotAdmittedItemIEs().set_ricActionID(2).set_ricCause(1).set_ricSubCause(1)); + + E2APSubscriptionResponse::SubscriptionResponseIEs infoObj; + infoObj.set_ranFunctionID(1); + infoObj.set_ricRequestorID(1); + infoObj.set_ricInstanceID(1); + infoObj.set_actionsNotAdmitted_list(notadmitlst); + infoObj.set_actionsAdmitted_list(admitlst); + + E2APSubscriptionResponse subObj(infoObj); + + bool res = subObj.encode(buff, &buf_len); + if(!res) + { + std::cout << "Subscription Response Error Message" << subObj.get_error() << std::endl; + } + ASSERT_TRUE(res); + FILE * pFile; + pFile = fopen ("subresponse1.per","w"); + if (pFile!=NULL) + { + fwrite (buff , sizeof(char), buf_len, pFile); + fclose (pFile); + } + +} +TEST(E2AP, SubResponseDecode) +{ + sleep(10); + unsigned char e2ap_buff[1024]; + char filename[100] = "subresponse2.per"; + FILE *fp; + fp = fopen(filename,"rb"); + if(!fp) { + perror(filename); + exit(1); } + + size_t e2ap_buff_size = fread(e2ap_buff, 1, 1024, fp); + fclose(fp); + if(!e2ap_buff_size){ + fprintf(stderr, "%s: Empty or broken\n", filename); + exit(1); + } else { + fprintf(stderr, "e2ap buffer size: %ld \n", e2ap_buff_size); + } + + bool decode_status = true; + try{ + E2APSubscriptionResponse e2obj(&e2ap_buff[0],&e2ap_buff_size); + + std::cout << "RAN Function ID: " << e2obj.getIEs().get_ranFunctionID() << std::endl; + std::cout << "Requestor ID: " << e2obj.getIEs().get_ricRequestorID() << std::endl; + std::cout << "Instance ID :" << e2obj.getIEs().get_ricInstanceID() << std::endl; + + int count = e2obj.getIEs().get_actionsAdmitted_list().get_list_count() ; + std::vector *lst = e2obj.getIEs().get_actionsAdmitted_list().get_list(); + for(int i=0; i< count; i++){ + std::cout<< "Action ID:::" << (*lst)[i].get_ricActionID() << std::endl; + + } + int count2 = e2obj.getIEs().get_actionsNotAdmitted_list().get_list_count() ; + std::vector *lst2 = e2obj.getIEs().get_actionsNotAdmitted_list().get_list(); + for(int i=0; i< count2; i++){ + std::cout<< "Action ID:::" << (*lst2)[i].get_ricActionID() << std::endl; + std::cout<< "Cause:::" << (*lst2)[i].get_ricCause() << std::endl; + std::cout<< "Sub Cause:::" << (*lst2)[i].get_ricSubCause() << std::endl; + } + + } catch(const char* e){ + decode_status = false; + std::cout << "Error Message: " << e << std::endl; + } + + + ASSERT_TRUE(decode_status); + +} + +TEST(E2AP, SubFailureEncode){ + unsigned char buff[512]; + size_t buf_len = 512; + + CriticalityDiagnosticsIEs crIEs1; + crIEs1.set_ieID(1); + crIEs1.set_typeOferror(1); + crIEs1.set_iEcriticality(2); + + CriticalityDiagnosticsIEs crIEs2; + crIEs2.set_ieID(1); + crIEs2.set_typeOferror(1); + crIEs2.set_iEcriticality(1); + + + + E2APCriticalityDiagnostics critObj; + critObj.set_procedureCode(10); + critObj.set_procedureCriticality(1); + critObj.set_ricInstanceID(101); + critObj.set_ricRequestorID(102); + critObj.set_triggeringMessage(1); + critObj.add(crIEs1); + critObj.add(crIEs2); + + RICactionNotAdmittedList::RICactionNotAdmittedItemIEs tmp2; + tmp2.set_ricActionID(2); + tmp2.set_ricCause(1); + tmp2.set_ricSubCause(3); + RICactionNotAdmittedList notadmitlst; + notadmitlst.add(tmp2); + notadmitlst.add(RICactionNotAdmittedList::RICactionNotAdmittedItemIEs().set_ricActionID(2).set_ricCause(1).set_ricSubCause(1)); + + E2APSubscriptionFailure::SubscriptionFailureIEs infoObj; + infoObj.set_ranFunctionID(1); + infoObj.set_ricRequestorID(1); + infoObj.set_ricInstanceID(1); + infoObj.set_actionsNotAdmitted_list(notadmitlst); + infoObj.set_critical_diagnostic(critObj); + + + E2APSubscriptionFailure subObj(infoObj); + + bool res = subObj.encode(buff, &buf_len); + if(!res) + { + std::cout << "Subscription Failure Error Message" << subObj.get_error() << std::endl; + } + ASSERT_TRUE(res); + FILE * pFile; + pFile = fopen ("subfailure1.per","w"); + if (pFile!=NULL) + { + fwrite (buff , sizeof(char), buf_len, pFile); + fclose (pFile); + } + +} + +TEST(E2AP, SubFailureDecode) +{ + sleep(10); + unsigned char e2ap_buff[1024]; + char filename[100] = "subfailure1.per"; + FILE *fp; + fp = fopen(filename,"rb"); + if(!fp) { + perror(filename); + exit(1); } + + size_t e2ap_buff_size = fread(e2ap_buff, 1, 1024, fp); + fclose(fp); + if(!e2ap_buff_size){ + fprintf(stderr, "%s: Empty or broken\n", filename); + exit(1); + } else { + fprintf(stderr, "e2ap buffer size: %ld \n", e2ap_buff_size); + } + + bool decode_status = true; + try{ + E2APSubscriptionFailure e2obj(&e2ap_buff[0],&e2ap_buff_size); + + std::cout << "RAN Function ID: " << e2obj.getIEs().get_ranFunctionID() << std::endl; + std::cout << "Requestor ID: " << e2obj.getIEs().get_ricRequestorID() << std::endl; + std::cout << "Instance ID :" << e2obj.getIEs().get_ricInstanceID() << std::endl; + int count = e2obj.getIEs().get_critical_diagnostic()->get_list_count() ; + std::vector *lst = e2obj.getIEs().get_critical_diagnostic()->get_list(); + for(int i=0; i< count; i++){ + std::cout<< "Typ Error:::" << (*lst)[i].get_typeOferror() << std::endl; + std::cout<< "iEcriticality:::" << (*lst)[i].get_iEcriticality() << std::endl; + std::cout<< "ieID:::" << (*lst)[i].get_ieID() << std::endl; + } + + int count2 = e2obj.getIEs().get_actionsNotAdmitted_list().get_list_count() ; + std::vector *lst2 = e2obj.getIEs().get_actionsNotAdmitted_list().get_list(); + for(int i=0; i< count2; i++){ + std::cout<< "Action ID:::" << (*lst2)[i].get_ricActionID() << std::endl; + std::cout<< "Cause:::" << (*lst2)[i].get_ricCause() << std::endl; + std::cout<< "Sub Cause:::" << (*lst2)[i].get_ricSubCause() << std::endl; + } + + } catch(const char* e){ + decode_status = false; + std::cout << "Error Message: " << e << std::endl; + } + + + ASSERT_TRUE(decode_status); + +} + #endif /* TEST_TEST_E2AP_H_ */ diff --git a/test/test_e2sm.h b/test/test_indc.h similarity index 80% rename from test/test_e2sm.h rename to test/test_indc.h index a973df2..a347618 100644 --- a/test/test_e2sm.h +++ b/test/test_indc.h @@ -27,12 +27,11 @@ #include #include -#include "e2ap_control_request.hpp" -#include "xapp.hpp" -#include "e2sm_control.hpp" #include "e2ap_indication.hpp" #include "e2sm_indication.hpp" +#include "e2ap_subscription_request.hpp" +#include "e2sm_subscription.hpp" using namespace std; TEST(E2SM, IndicationMessageEncode) { @@ -66,13 +65,14 @@ TEST(E2SM, IndicationMessageEncode) FILE * pFile; - pFile = fopen ("indication2.per","w"); + pFile = fopen ("indication1.per","w"); if (pFile!=NULL) { fwrite (buff , sizeof(char), buf_len, pFile); sleep(2); fclose (pFile); - } + sleep(2); + } } TEST(E2SM, IndicationMessageDecode) @@ -87,6 +87,7 @@ TEST(E2SM, IndicationMessageDecode) size_t e2ap_buff_size = fread(e2ap_buff, 1, 4096, fp); fclose(fp); + sleep(2); if(!e2ap_buff_size){ fprintf(stderr, "%s: Empty or broken\n", filename); exit(1); @@ -118,35 +119,6 @@ TEST(E2SM, IndicationMessageDecode) } -TEST(E2SM, ControlMessage) -{ - - unsigned char buff[1024]; - size_t buf_len = 1024; - - - - HWControlMessage msgObj; - msgObj.set_ricControlMessage("ControlMessage"); - - HWControlHeader headObj; - headObj.set_ricControlHeader(1); - - E2APControlMessage::ControlRequestIEs infoObj; - infoObj.set_ranFunctionID(1); - infoObj.set_ricRequestorID(1); - infoObj.set_ricControlHeader(headObj); - infoObj.set_ricControlMessage(msgObj); - infoObj.set_ricCallProcessID("ProcessID"); - - E2APControlMessage cntrlObj(infoObj); - - bool res = cntrlObj.encode(buff, &buf_len); - if(!res) - { - std::cout << cntrlObj.get_error() << std::endl; - } - ASSERT_TRUE(res); -} +/**/ #endif /* TEST_TEST_ASN_H_ */ diff --git a/test/test_subs.h b/test/test_subs.h index ea540bf..666a90a 100644 --- a/test/test_subs.h +++ b/test/test_subs.h @@ -30,14 +30,13 @@ #include #include "e2ap_subscription_request.hpp" -#include "e2ap_subsdel_request.hpp" #include "xapp.hpp" #define BUFFER_SIZE 1024 using namespace std; //generating a E2AP Subscription Message -TEST(SubscriptionRequest, MultipleRANParameters) +TEST(E2SMSubREQ, MultipleRANParameters) { unsigned char buff[1024]; size_t buff_size = 1024; @@ -97,7 +96,7 @@ TEST(SubscriptionRequest, MultipleRANParameters) ASSERT_TRUE(res); } -TEST(SubscriptionRequest, MultipleActions) +TEST(E2SMSubREQ, SubRespMultipleActions) { unsigned char buff[1024]; size_t buff_size = 1024; @@ -162,29 +161,6 @@ TEST(SubscriptionRequest, MultipleActions) } -TEST(E2AP, SubscriptionDeleteRequest){ - - unsigned char buff[1024]; - size_t buff_size = 1024; - - - E2APSubscriptionDeleteRequest::SubscriptionDeleteRequestIEs dataObj; - - dataObj.set_ranFunctionID(1); - dataObj.set_ricInstanceID(1); - dataObj.set_ricRequestorID(3); - - E2APSubscriptionDeleteRequest requestObj(dataObj); - bool res = requestObj.encode(buff, &buff_size); - if(!res) - { - std::cout << requestObj.get_error() << std::endl; - } - ASSERT_TRUE(res); - - -} - //create a MOck e2term -- 2.16.6