3 ==================================================================================
5 Copyright (c) 2019-2020 AT&T Intellectual Property.
7 Licensed under the Apache License, Version 2.0 (the "License");
8 you may not use this file except in compliance with the License.
9 You may obtain a copy of the License at
11 http://www.apache.org/licenses/LICENSE-2.0
13 Unless required by applicable law or agreed to in writing, software
14 distributed under the License is distributed on an "AS IS" BASIS,
15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 See the License for the specific language governing permissions and
17 limitations under the License.
18 ==================================================================================
24 * Created on: Sep 18, 2020
25 * Author: Shraboni Jana
27 /*-- **************************************************************
29 -- RIC Indication Elementary Procedure
31 -- **************************************************************
32 -- **************************************************************
36 -- **************************************************************
37 RICindication ::= SEQUENCE {
38 protocolIEs ProtocolIE-Container {{RICindication-IEs}},
42 RICindication-IEs E2AP-PROTOCOL-IES ::= {
43 { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory }|
44 { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory }|
45 { ID id-RICactionID CRITICALITY reject TYPE RICactionID PRESENCE mandatory }|
46 { ID id-RICindicationSN CRITICALITY reject TYPE RICindicationSN PRESENCE optional }|
47 { ID id-RICindicationType CRITICALITY reject TYPE RICindicationType PRESENCE mandatory }|
48 { ID id-RICindicationHeader CRITICALITY reject TYPE RICindicationHeader PRESENCE mandatory }|
49 { ID id-RICindicationMessage CRITICALITY reject TYPE RICindicationMessage PRESENCE mandatory }|
50 { ID id-RICcallProcessID CRITICALITY reject TYPE RICcallProcessID PRESENCE optional },
55 #ifndef SRC_XAPP_ASN_E2AP_E2AP_INDICATION_HPP_
56 #define SRC_XAPP_ASN_E2AP_E2AP_INDICATION_HPP_
60 #include <InitiatingMessage.h>
61 #include <RICindication.h>
62 #include <ProtocolIE-Field.h>
65 #include <mdclog/mdclog.h>
69 #include "e2ap_consts.hpp"
71 template <typename E2SMIndicationHeader, typename E2SMIndicationMessage>
78 long int ricRequestorID, ranFunctionID, ricActionID, ricIndicationSN, ricIndicationType;
79 size_t ricIndicationHeader_size = IE_SIZE;
80 unsigned char ricIndicationHeader[IE_SIZE];
82 size_t ricIndicationMessage_size = IE_SIZE;
83 unsigned char ricIndicationMessage[IE_SIZE];
85 unsigned char ricCallProcessId[IE_SIZE];
86 size_t ricCallProcessId_size = IE_SIZE;
88 bool is_callProcessID, is_ricIndicationSN;
91 IndicationIEs(void) : ricRequestorID(0), ranFunctionID(0), ricActionID(0),ricIndicationSN(0), ricIndicationType(0),is_callProcessID(false),is_ricIndicationSN(false){};
92 void* get_ricIndicationMessage(){return this->ricIndicationMessage; };
93 void* get_ricIndicationHeader(){return this->ricIndicationHeader; };
94 void* get_ricCallProcessId(){return this->ricCallProcessId;};
96 size_t get_ricIndicationMessage_size(){return this->ricIndicationMessage_size; };
97 size_t get_ricIndicationHeader_size(){return this->ricIndicationHeader_size; };
98 size_t get_ricCallProcessId_size(){return this->ricCallProcessId_size;};
100 long int get_ricRequestorID(){return this->ricRequestorID;};
101 long int get_ranFunctionID(){return this->ranFunctionID;};
102 long int get_ricActionID(){return this->ricActionID;};
103 long int get_ricIndicationType(){return this->ricIndicationType;}
104 long int get_ricIndicationSN(){return this->ricIndicationSN;};
105 bool get_is_ricIndicationSN(){return this->is_ricIndicationSN;};
106 bool get_is_callProcessID(){return this->is_callProcessID;};
108 IndicationIEs& set_ricIndicationHeader(E2SMIndicationHeader e2smObj){
109 bool res = e2smObj.encode(&(this->ricIndicationHeader)[0],&this->ricIndicationHeader_size);
111 mdclog_write(MDCLOG_ERR, "Failed to encode: %s","RIC Indication Header");
112 mdclog_write(MDCLOG_ERR, "Error during encode: %s",e2smObj.get_error());
115 mdclog_write(MDCLOG_INFO, "Successfully encoded: %s","RIC Indication Header");
119 IndicationIEs& set_ricIndicationMessage(E2SMIndicationMessage e2smObj){
120 bool res = e2smObj.encode(&(this->ricIndicationMessage)[0],&this->ricIndicationMessage_size);
122 mdclog_write(MDCLOG_ERR, "Failed to encode: %s","RIC Indication Message");
123 mdclog_write(MDCLOG_ERR, "Error during encode: %s",e2smObj.get_error());
125 mdclog_write(MDCLOG_INFO, "Successfully encoded: %s","RIC Indication Message");
132 IndicationIEs& set_ricIndicationHeader(unsigned char* header, size_t header_size){
133 memcpy(ricIndicationHeader,header,header_size); ricIndicationHeader_size = header_size; return *this;
135 IndicationIEs& set_ricIndicationMessage(unsigned char* message, size_t message_size){
136 memcpy(ricIndicationHeader,message,message_size); ricIndicationMessage_size = message_size; return *this;}
138 IndicationIEs& set_ricCallProcessID(unsigned char* callproc, size_t callproc_size){
139 is_callProcessID = true;
140 memcpy(ricCallProcessId, callproc, callproc_size); ricCallProcessId_size = callproc_size;
144 IndicationIEs& set_ricRequestorID(long int reqID){this->ricRequestorID = reqID; return *this;}
145 IndicationIEs& set_ranFunctionID(long int funcID){this->ranFunctionID = funcID; return *this;}
146 IndicationIEs& set_ricActionID(long int actID){ this->ricActionID = actID; return *this;}
147 IndicationIEs& set_ricIndicationType(long int typ){ this->ricIndicationType = typ; return *this;}
148 IndicationIEs& set_ricIndicationSN(long int sn){ this->ricIndicationSN = sn; is_ricIndicationSN=true; return *this;}
153 E2APIndication(IndicationIEs&);
154 E2APIndication(unsigned char *, size_t *);
155 ~E2APIndication(void);
156 IndicationIEs getIndicationIEs(){ return *_indicationIEs.get(); }
158 std::string get_error(void) const {return _error_string ; };
159 bool encode(unsigned char *buf, size_t *size);
160 bool decode(unsigned char *buf, size_t *size);
164 E2AP_PDU_t * e2ap_pdu_obj;
165 InitiatingMessage_t *initMsg;
166 RICindication_IEs_t *IE_array;
167 std::unique_ptr<IndicationIEs> _indicationIEs;
169 std::string _error_string;
171 size_t _errbuf_len = 128;
173 bool setfields( InitiatingMessage_t *);
176 template<typename T1, typename T2>
177 E2APIndication<T1,T2>::E2APIndication(IndicationIEs& ieObj){
180 e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
181 assert(e2ap_pdu_obj != 0);
184 initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t));
185 assert(initMsg != 0);
188 IE_array = (RICindication_IEs_t *)calloc(RIC_INDICATION_IES_COUNT, sizeof(RICindication_IEs_t));
189 assert(IE_array != 0);
191 e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage;
192 e2ap_pdu_obj->choice.initiatingMessage = initMsg;
194 _indicationIEs = std::make_unique<IndicationIEs>();
195 *_indicationIEs = ieObj;
198 template<typename T1, typename T2>
199 E2APIndication<T1,T2>::E2APIndication(unsigned char *buf, size_t *size){
204 _indicationIEs = std::make_unique<IndicationIEs>();
205 bool status = this->decode(buf, size);
207 throw "E2AP Indication Decode Failed: "+this->get_error();
211 // Clear assigned protocolIE list from RIC indication IE container
212 template<typename T1, typename T2>
213 E2APIndication<T1,T2>::~E2APIndication(void){
215 mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Indication object memory");
216 RICindication_t *ricIndication = &(initMsg->value.choice.RICindication);
217 for(int i = 0; i < ricIndication->protocolIEs.list.size; i++){
218 ricIndication->protocolIEs.list.array[i] = 0;
220 if (ricIndication->protocolIEs.list.size > 0){
221 free(ricIndication->protocolIEs.list.array);
222 ricIndication->protocolIEs.list.array = 0;
223 ricIndication->protocolIEs.list.count = 0;
224 ricIndication->protocolIEs.list.size = 0;
229 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
230 mdclog_write(MDCLOG_DEBUG, "Freed E2AP Indication object memory");
233 template<typename T1, typename T2>
234 bool E2APIndication<T1, T2>::decode(unsigned char *buf, size_t *size)
237 asn_dec_rval_t dec_res = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(e2ap_pdu_obj), buf, *size);
238 if(dec_res.code != RC_OK){
239 mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Indication Message");
242 mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Indication Message");
245 initMsg = e2ap_pdu_obj->choice.initiatingMessage;
246 //write the decoding code.
248 _error_string = "Invalid reference for E2AP Indication message in get_fields";
253 for(int edx = 0; edx < initMsg->value.choice.RICindication.protocolIEs.list.count; edx++) {
254 RICindication_IEs_t *memb_ptr = initMsg->value.choice.RICindication.protocolIEs.list.array[edx];
257 case (ProtocolIE_ID_id_RICindicationHeader):
258 _indicationIEs->set_ricIndicationHeader(memb_ptr->value.choice.RICindicationHeader.buf, memb_ptr->value.choice.RICindicationHeader.size);
261 case (ProtocolIE_ID_id_RICindicationMessage):
262 _indicationIEs->set_ricIndicationMessage(memb_ptr->value.choice.RICindicationMessage.buf, memb_ptr->value.choice.RICindicationMessage.size);
265 case (ProtocolIE_ID_id_RICrequestID):
266 _indicationIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID);
269 case (ProtocolIE_ID_id_RANfunctionID):
270 _indicationIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID);
273 case (ProtocolIE_ID_id_RICindicationSN):
274 _indicationIEs->set_ricIndicationSN(memb_ptr->value.choice.RICindicationSN);
277 case (ProtocolIE_ID_id_RICindicationType):
278 _indicationIEs->set_ricIndicationType(memb_ptr->value.choice.RICindicationType);
281 case (ProtocolIE_ID_id_RICactionID):
282 _indicationIEs->set_ricActionID(memb_ptr->value.choice.RICactionID);
285 case (ProtocolIE_ID_id_RICcallProcessID):
286 _indicationIEs->set_ricCallProcessID(memb_ptr->value.choice.RICcallProcessID.buf,memb_ptr->value.choice.RICcallProcessID.size);
294 // xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
300 template<typename T1, typename T2>
301 bool E2APIndication<T1,T2>::encode(unsigned char *buf, size_t *size){
303 initMsg->procedureCode = ProcedureCode_id_RICindication;
304 initMsg->criticality = Criticality_ignore;
305 initMsg->value.present = InitiatingMessage__value_PR_RICindication;
308 asn_enc_rval_t retval;
310 res = setfields(initMsg);
315 int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu_obj, _errbuf, &_errbuf_len);
317 _error_string.assign(&_errbuf[0], _errbuf_len);
318 _error_string = "Error encoding E2AP Indication message. Reason = " + _error_string;
322 retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
323 if(retval.encoded == -1){
324 _error_string.assign(strerror(errno));
329 if(*size < retval.encoded){
330 std::stringstream ss;
331 ss <<"Error encoding E2AP Indication . Reason = encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
332 _error_string = ss.str();
337 *size = retval.encoded;
338 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
343 template<typename T1, typename T2>
344 bool E2APIndication<T1,T2>::setfields(InitiatingMessage_t *initMsg){
345 unsigned int ie_index;
348 _error_string = "Invalid reference for E2AP Indication message in set_fields";
353 RICindication_t * ric_indication = &(initMsg->value.choice.RICindication);
354 ric_indication->protocolIEs.list.count = 0;
358 RICindication_IEs_t *ies_ricreq = &IE_array[ie_index];
359 ies_ricreq->criticality = Criticality_reject;
360 ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
361 ies_ricreq->value.present = RICindication_IEs__value_PR_RICrequestID;
362 RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
363 ricrequest_ie->ricRequestorID = _indicationIEs->get_ricRequestorID();
364 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
367 RICindication_IEs_t *ies_ranfunc = &IE_array[ie_index];
368 ies_ranfunc->criticality = Criticality_reject;
369 ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
370 ies_ranfunc->value.present = RICindication_IEs__value_PR_RANfunctionID;
371 RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
372 *ranfunction_ie = _indicationIEs->get_ranFunctionID();
373 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
376 RICindication_IEs_t *ies_actid = &IE_array[ie_index];
377 ies_actid->criticality = Criticality_reject;
378 ies_actid->id = ProtocolIE_ID_id_RICactionID;
379 ies_actid->value.present = RICindication_IEs__value_PR_RICactionID;
380 RICactionID_t *ricaction_ie = &ies_actid->value.choice.RICactionID;
381 *ricaction_ie = _indicationIEs->get_ricActionID();
382 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
384 if(_indicationIEs->get_is_ricIndicationSN())
387 RICindication_IEs_t *ies_ricsn = &IE_array[ie_index];
388 ies_ricsn->criticality = Criticality_reject;
389 ies_ricsn->id = ProtocolIE_ID_id_RICindicationSN;
390 ies_ricsn->value.present = RICindication_IEs__value_PR_RICindicationSN;
391 RICindicationSN_t *ricsn_ie = &ies_ricsn->value.choice.RICindicationSN;
392 *ricsn_ie = _indicationIEs->get_ricIndicationSN();
393 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
397 RICindication_IEs_t *ies_indtyp = &IE_array[ie_index];
398 ies_indtyp->criticality = Criticality_reject;
399 ies_indtyp->id = ProtocolIE_ID_id_RICindicationType;
400 ies_indtyp->value.present = RICindication_IEs__value_PR_RICindicationType;
401 RICindicationType_t *rictype_ie = &ies_indtyp->value.choice.RICindicationType;
402 *rictype_ie = _indicationIEs->get_ricIndicationType();
403 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
406 RICindication_IEs_t *ies_richead = &IE_array[ie_index];
407 ies_richead->criticality = Criticality_reject;
408 ies_richead->id = ProtocolIE_ID_id_RICindicationHeader;
409 ies_richead->value.present = RICindication_IEs__value_PR_RICindicationHeader;
410 RICindicationHeader_t *richeader_ie = &ies_richead->value.choice.RICindicationHeader;
411 richeader_ie->buf = (uint8_t*)_indicationIEs->get_ricIndicationHeader();
412 richeader_ie->size = _indicationIEs->get_ricIndicationHeader_size();
413 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
416 RICindication_IEs_t *ies_indmsg = &IE_array[ie_index];
417 ies_indmsg->criticality = Criticality_reject;
418 ies_indmsg->id = ProtocolIE_ID_id_RICindicationMessage;
419 ies_indmsg->value.present = RICindication_IEs__value_PR_RICindicationMessage;
420 RICindicationMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICindicationMessage;
421 ricmsg_ie->buf = (uint8_t*)_indicationIEs->get_ricIndicationMessage();
422 ricmsg_ie->size = _indicationIEs->get_ricIndicationMessage_size();
423 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
426 // optional call process id ..
427 if (_indicationIEs->get_is_callProcessID()){
429 RICindication_IEs_t *ies_ind_callprocessid = &IE_array[ie_index];
430 ies_ind_callprocessid->criticality = Criticality_reject;
431 ies_ind_callprocessid->id = ProtocolIE_ID_id_RICcallProcessID;
432 ies_ind_callprocessid->value.present = RICindication_IEs__value_PR_RICcallProcessID;
433 RICcallProcessID_t *riccallprocessid_ie = &ies_ind_callprocessid->value.choice.RICcallProcessID;
434 riccallprocessid_ie->buf = (uint8_t*)_indicationIEs->get_ricCallProcessId();
435 riccallprocessid_ie->size = _indicationIEs->get_ricCallProcessId_size();
436 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
443 #endif /* SRC_XAPP_ASN_E2AP_E2AP_INDICATION_HPP_ */