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<std::vector<RICactionAdmittedItemIEs>>(); _count_list = 0;};
+
+ std::vector<RICactionAdmittedItemIEs> * 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<std::vector<RICactionAdmittedItemIEs>> _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<std::vector<RICactionNotAdmittedItemIEs>>(); _count_list = 0;};
+
+ std::vector<RICactionNotAdmittedItemIEs> * 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<std::vector<RICactionNotAdmittedItemIEs>> _ref_list;
+ int _count_list;
+
+};
+
#endif /* XAPP_ASN_REFACTOR_E2AP_ACTION_HPP_ */
#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_ */
_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);
}
*size = retval.encoded;
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
+
return true;
}
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.
}
}
+// xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
return true;
_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);
}
*size = retval.encoded;
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
+
return true;
}
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;
*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;
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);
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.
}
}
+ //xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
return true;
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;};
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;}
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){
}
*size = retval.encoded;
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
+
return true;
}
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
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;
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
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;
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;
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
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;
--- /dev/null
+/*
+==================================================================================
+
+ 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 <mdclog/mdclog.h>
+
+#include <string>
+#include <memory>
+#include <sstream>
+#include <vector>
+
+#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<std::vector<CriticalityDiagnosticsIEs>> _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<std::vector<CriticalityDiagnosticsIEs>>(); _count_list = 0;};
+
+ std::vector<CriticalityDiagnosticsIEs> * 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<CriticalityDiagnosticsIEs> &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_ */
}
free(IE_array);
+ free(initMsg);
ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
mdclog_write(MDCLOG_DEBUG, "Freed E2AP Indication object memory");
}
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){
}
}
+ // xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
return true;
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));
}
*size = retval.encoded;
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
+
return true;
}
--- /dev/null
+/*
+==================================================================================
+
+ 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<e2ap_subscription_failure.hpp>
+
+E2APSubscriptionFailure::E2APSubscriptionFailure(SubscriptionFailureIEs& subObj){
+
+ _failureIEs = std::make_unique<SubscriptionFailureIEs>();
+ *_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<RICactionNotAdmittedList::RICactionNotAdmittedItemIEs> * 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<SubscriptionFailureIEs>();
+ 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;
+}
+
+
+
+
+
+
--- /dev/null
+/*
+ * 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 <mdclog/mdclog.h>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <memory>
+#include <E2AP-PDU.h>
+#include <UnsuccessfulOutcome.h>
+#include <ProtocolIE-Field.h>
+#include <ProcedureCode.h>
+#include <CriticalityDiagnostics.h>
+#include <CriticalityDiagnostics-IE-Item.h>
+#include <CriticalityDiagnostics-IE-List.h>
+#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<SubscriptionFailureIEs> _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_ */
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){
}
*size = retval.encoded;
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
+
return true;
}
--- /dev/null
+/*
+==================================================================================
+
+ 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<e2ap_subscription_response.hpp>
+
+E2APSubscriptionResponse::E2APSubscriptionResponse(SubscriptionResponseIEs& subObj){
+
+ _responseIEs = std::make_unique<SubscriptionResponseIEs>();
+ *_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<RICactionAdmittedList::RICactionAdmittedItemIEs> * 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<RICactionNotAdmittedList::RICactionNotAdmittedItemIEs> * 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<SubscriptionResponseIEs>();
+ 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;
+}
+
+
+
+
+
+
--- /dev/null
+/*
+==================================================================================
+
+ 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 <mdclog/mdclog.h>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <memory>
+#include <E2AP-PDU.h>
+#include <SuccessfulOutcome.h>
+#include <ProtocolIE-Field.h>
+#include <ProcedureCode.h>
+#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<SubscriptionResponseIEs> _responseIEs;
+
+
+ std::string _error_string;
+ char _errbuf[ERR_LEN];
+ size_t _errbuf_len = ERR_LEN;
+
+};
+
+
+
+
+#endif /* SRC_XAPP_ASN_E2AP_SUBSCRIPTION_RESPONSE_HPP_ */
--- /dev/null
+/*
+==================================================================================
+
+ 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<SubscriptionDeleteFailureIEs>();
+ *_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<SubscriptionDeleteFailureIEs>();
+
+ 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;
+};
+
+
+
+
+
--- /dev/null
+/*
+==================================================================================
+
+ 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 <mdclog/mdclog.h>
+#include <vector>
+#include <sstream>
+#include <memory>
+#include <iostream>
+#include <mdclog/mdclog.h>
+#include <asn_application.h>
+#include <E2AP-PDU.h>
+#include <UnsuccessfulOutcome.h>
+#include <RICsubscriptionDeleteFailure.h>
+#include <CriticalityDiagnostics.h>
+#include <CriticalityDiagnostics-IE-Item.h>
+#include <CriticalityDiagnostics-IE-List.h>
+#include <ProtocolIE-Field.h>
+#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<SubscriptionDeleteFailureIEs> _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_ */
-
-
/*
==================================================================================
Copyright (c) 2019-2020 AT&T Intellectual Property.
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);
}
*size = res.encoded;
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
+
return true;
}
--- /dev/null
+/*
+==================================================================================
+ 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<SubscriptionDeleteResponseIEs>();
+ *_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<SubscriptionDeleteResponseIEs>();
+ 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;
+};
+
+
+
+
+
--- /dev/null
+/*
+==================================================================================
+
+ 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 <mdclog/mdclog.h>
+#include <vector>
+#include <sstream>
+#include <memory>
+#include <mdclog/mdclog.h>
+#include <asn_application.h>
+#include <E2AP-PDU.h>
+#include <SuccessfulOutcome.h>
+#include <RICsubscriptionDeleteResponse.h>
+#include <ProtocolIE-Field.h>
+#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<SubscriptionDeleteResponseIEs> _responseIEs;
+
+ std::string _error_string;
+ char _errbuf[ERR_LEN];
+ size_t _errbuf_len = ERR_LEN;
+
+};
+
+
+
+
+
+#endif /* SRC_XAPP_ASN_E2AP_E2AP_SUBSDEL_RESPONSE_HPP_ */
+++ /dev/null
-/*
-==================================================================================
- 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 <cstddef>
-
-/* 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
+++ /dev/null
-/*
-==================================================================================
- 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 <vector>
-#include <memory>
-
-/* 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<ActionResponse>;
-
- subscription_response_helper(void){
- _action_admitted_ref = std::make_unique<action_t>();
- _action_not_admitted_ref = std::make_unique<action_t>();
-
- };
-
- // copy operator
- subscription_response_helper(const subscription_response_helper &he ){
- _action_admitted_ref = std::make_unique<action_t>();
- _action_not_admitted_ref = std::make_unique<action_t>();
-
- _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_t>();
- _action_not_admitted_ref = std::make_unique<action_t>();
-
- _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_t> _action_admitted_ref;
- std::unique_ptr<action_t> _action_not_admitted_ref;
-
-};
-
-
-#endif
+++ /dev/null
-
-
-/*
-==================================================================================
- 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;
-}
-
-
-
+++ /dev/null
-/*
-==================================================================================
- 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 <mdclog/mdclog.h>
-#include <vector>
-#include <sstream>
-#include <mdclog/mdclog.h>
-#include <asn_application.h>
-#include <E2AP-PDU.h>
-#include <InitiatingMessage.h>
-#include <RICsubscriptionDeleteRequest.h>
-#include <ProtocolIE-Field.h>
-#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
+++ /dev/null
-/*
-==================================================================================
- 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);
-}
-
-
-
+++ /dev/null
-/*
-==================================================================================
- 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 <mdclog/mdclog.h>
-#include <vector>
-#include <iostream>
-#include <sstream>
-#include <mdclog/mdclog.h>
-#include <asn_application.h>
-#include <E2AP-PDU.h>
-#include <SuccessfulOutcome.h>
-#include <UnsuccessfulOutcome.h>
-#include <RICsubscriptionDeleteResponse.h>
-#include <RICsubscriptionDeleteFailure.h>
-#include <ProtocolIE-Field.h>
-#include <ProcedureCode.h>
-#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
+++ /dev/null
-/*
-==================================================================================
- 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 <iostream>
-#include <vector>
-#include <memory>
-
-#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<Action>;
- subscription_helper(){
- _action_ref = std::make_unique<action_t>();
- };
-
- 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_t> _action_ref;
- int curr_index;
- int _req_id, _func_id;
- octet_helper _event_def;
-
-};
-
-#endif
+++ /dev/null
-
-
-/*
-==================================================================================
- 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<Action> * 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;
-};
-
-
-
+++ /dev/null
-/*
-==================================================================================
- 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 <mdclog/mdclog.h>
-#include <vector>
-#include <sstream>
-
-#include <asn_application.h>
-#include <E2AP-PDU.h>
-#include <InitiatingMessage.h>
-#include <RICsubscriptionRequest.h>
-#include <RICsubscriptionRequest.h>
-#include <ProtocolIE-Field.h>
-#include <ProtocolIE-SingleContainer.h>
-#include <RICactions-ToBeSetup-List.h>
-#include <RICsubsequentAction.h>
-#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
+++ /dev/null
-/*
-==================================================================================
- 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<ActionResponse> * 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<ActionResponse> * 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<ActionResponse> * 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);
-}
-
-
-
+++ /dev/null
-/*
-==================================================================================
- 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 <mdclog/mdclog.h>
-#include <vector>
-#include <iostream>
-#include <sstream>
-#include <asn_application.h>
-#include <E2AP-PDU.h>
-#include <SuccessfulOutcome.h>
-#include <UnsuccessfulOutcome.h>
-#include <ProtocolIE-Field.h>
-#include <ProtocolIE-SingleContainer.h>
-#include <ProcedureCode.h>
-#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
#include<stdlib.h>
#include<gtest/gtest.h>
+#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;
dm_xapp->Run();
testing::InitGoogleTest(&argc, argv);
+ ::testing::GTEST_FLAG(filter) = "E2AP*";
+
int res = RUN_ALL_TESTS();
--- /dev/null
+/*
+==================================================================================
+
+ 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<iostream>
+#include<gtest/gtest.h>
+
+#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<HWControlHeader,HWControlMessage>::ControlRequestIEs infoObj;
+ infoObj.set_ranFunctionID(1);
+ infoObj.set_ricRequestorID(1);
+ infoObj.set_ricControlHeader(headObj);
+ infoObj.set_ricControlMessage(msgObj);
+// infoObj.set_ricCallProcessID("ProcessID");
+
+ E2APControlMessage<HWControlHeader,HWControlMessage> 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_ */
#include<iostream>
#include<gtest/gtest.h>
-#include "xapp.hpp"
+
using namespace std;
#include<gtest/gtest.h>
#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)
{
}
}
-TEST(E2SM, ControlAcknowledgementDecode)
+TEST(E2AP, ControlAcknowledgementDecode)
{
unsigned char e2ap_buff[4096];
char filename[100] = "controlack1.per";
}
}
-TEST(E2SM, ControlFailureDecode)
+TEST(E2AP, ControlFailureDecode)
{
unsigned char e2ap_buff[1024];
char filename[100] = "controlfail1.per";
}
+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<CriticalityDiagnosticsIEs> *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<RICactionAdmittedList::RICactionAdmittedItemIEs> *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<RICactionNotAdmittedList::RICactionNotAdmittedItemIEs> *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<CriticalityDiagnosticsIEs> *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<RICactionNotAdmittedList::RICactionNotAdmittedItemIEs> *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_ */
#include<iostream>
#include<gtest/gtest.h>
-#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)
{
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)
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);
}
-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<HWControlHeader,HWControlMessage>::ControlRequestIEs infoObj;
- infoObj.set_ranFunctionID(1);
- infoObj.set_ricRequestorID(1);
- infoObj.set_ricControlHeader(headObj);
- infoObj.set_ricControlMessage(msgObj);
- infoObj.set_ricCallProcessID("ProcessID");
-
- E2APControlMessage<HWControlHeader,HWControlMessage> 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_ */
#include<gtest/gtest.h>
#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;
ASSERT_TRUE(res);
}
-TEST(SubscriptionRequest, MultipleActions)
+TEST(E2SMSubREQ, SubRespMultipleActions)
{
unsigned char buff[1024];
size_t buff_size = 1024;
}
-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
Code Review / ric-app / hw.git / commitdiff