2 ==================================================================================
4 Copyright (c) 2019-2020 AT&T Intellectual Property.
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
21 * e2ap_control_request.hpp
23 * Created on: Oct 10, 2020
24 * Author: Shraboni Jana
26 /*RICcontrolRequest ::= SEQUENCE {
27 protocolIEs ProtocolIE-Container {{RICcontrolRequest-IEs}},
31 RICcontrolRequest-IEs E2AP-PROTOCOL-IES ::= {
32 { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory }|
33 { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory }|
34 { ID id-RICcallProcessID CRITICALITY reject TYPE RICcallProcessID PRESENCE optional }|
35 { ID id-RICcontrolHeader CRITICALITY reject TYPE RICcontrolHeader PRESENCE mandatory }|
36 { ID id-RICcontrolMessage CRITICALITY reject TYPE RICcontrolMessage PRESENCE mandatory }|
37 { ID id-RICcontrolAckRequest CRITICALITY reject TYPE RICcontrolAckRequest PRESENCE optional },
42 #ifndef SRC_XAPP_ASN_E2AP_E2AP_CONTROL_REQUEST_HPP_
43 #define SRC_XAPP_ASN_E2AP_E2AP_CONTROL_REQUEST_HPP_
46 #include <mdclog/mdclog.h>
50 #include <InitiatingMessage.h>
51 #include <RICcontrolRequest.h>
52 #include <ProtocolIE-Field.h>
53 #include "e2ap_consts.hpp"
56 template <typename E2SMControlHeader, typename E2SMControlMessage>
57 class E2APControlMessage{
60 class ControlRequestIEs{
62 long int ricRequestorID , ricInstanceID, ranFunctionID, ricCallProcessID, ricControlAckRequest;
63 unsigned char ricControlHeader[IE_SIZE];
64 size_t ricControlHeader_size=IE_SIZE;
65 unsigned char ricControlMessage[IE_SIZE];
66 size_t ricControlMessage_size=IE_SIZE;
67 unsigned char ricCallProcessId[IE_SIZE];
68 size_t ricCallProcessId_size = IE_SIZE;
69 bool is_ricCallProcessId;
72 ControlRequestIEs(void):ricRequestorID(1), ricInstanceID(1),ranFunctionID(1), ricCallProcessID(0), ricControlAckRequest(-1),is_ricCallProcessId(false){};
73 void* get_ricControlMessage(){return this->ricControlMessage; };
74 void* get_ricControlHeader(){return this->ricControlHeader; };
75 void* get_ricCallProcessId(){return this->ricCallProcessId;};
77 size_t get_ricControlMessageSize(){return this->ricControlMessage_size; };
78 size_t get_ricControlHeaderSize(){return this->ricControlHeader_size; };
79 size_t get_ricCallProcessIdSize(){return this->ricCallProcessId_size;};
81 long int get_ricRequestorID(){return this->ricRequestorID;};
82 long int get_ricInstanceID(){return this->ricInstanceID;};
83 long int get_ranFunctionID(){return this->ranFunctionID;};
84 long int get_ricControlAckRequest(){return this->ricControlAckRequest;};
85 bool get_is_ricCallProcessId(){return is_ricCallProcessId;};
86 ControlRequestIEs& set_ricControlHeader(E2SMControlHeader headerObj){
87 bool res = headerObj.encode(&(this->ricControlHeader)[0],&this->ricControlHeader_size);
89 mdclog_write(MDCLOG_ERR, "Failed to encode: %s","RIC Control Header");
90 mdclog_write(MDCLOG_ERR, "Error during encode: %s",headerObj.get_error());
92 mdclog_write(MDCLOG_INFO, "Successfully encoded: %s","RIC Control Header");
97 ControlRequestIEs& set_ricControlMessage(E2SMControlMessage msgObj){
98 bool res = msgObj.encode(&(this->ricControlMessage)[0],&this->ricControlMessage_size);
100 mdclog_write(MDCLOG_ERR, "Failed to encode: %s","RIC Control Message");
101 mdclog_write(MDCLOG_ERR, "Error during encode: %s",msgObj.get_error());
103 mdclog_write(MDCLOG_INFO, "Successfully encoded: %s","RIC Control Message");
108 ControlRequestIEs& set_ricCallProcessID(std::string strCallProcID){
109 is_ricCallProcessId = true; ricCallProcessId_size = strlen(strCallProcID.c_str());
110 memcpy((char*)ricCallProcessId, strCallProcID.c_str(), ricCallProcessId_size);
113 ControlRequestIEs& set_ricCallProcessID(unsigned char* callproc, size_t callproc_size){
114 is_ricCallProcessId = true;
115 memcpy(ricCallProcessId, callproc, callproc_size); ricCallProcessId_size = callproc_size;
119 ControlRequestIEs& set_ricRequestorID(long int reqID){this->ricRequestorID = reqID; return *this;}
120 ControlRequestIEs& set_ricInstanceID(long int reqID){this->ricInstanceID = reqID; return *this;}
121 ControlRequestIEs& set_ranFunctionID(long int funcID){this->ranFunctionID = funcID; return *this;}
124 E2APControlMessage(ControlRequestIEs &);
125 ~E2APControlMessage(void);
126 bool encode(unsigned char *, size_t *);
127 ControlRequestIEs& getIEs(){ return *_cntrlIEs.get();};
128 std::string get_error(void) const {return _error_string ; };
131 E2AP_PDU_t * _e2ap_pdu_obj;
132 InitiatingMessage_t *_initMsg;
133 RICcontrolRequest_IEs_t *IE_array;
134 std::string _error_string;
135 bool setfields(InitiatingMessage_t *);
136 std::unique_ptr<ControlRequestIEs> _cntrlIEs;
138 size_t _errbuf_len = IE_SIZE;
141 template <typename T1, typename T2>
142 E2APControlMessage<T1,T2>::E2APControlMessage(ControlRequestIEs &controlObj){
144 _cntrlIEs = std::make_unique<ControlRequestIEs>();
145 *_cntrlIEs = controlObj;
148 _e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
149 assert(_e2ap_pdu_obj != 0);
152 _initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t));
153 assert(_initMsg != 0);
156 IE_array = (RICcontrolRequest_IEs_t *)calloc(RIC_CONTROL_REQUEST_IES_COUNT, sizeof(RICcontrolRequest_IEs_t));
157 assert(IE_array != 0);
159 _e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage;
160 _e2ap_pdu_obj->choice.initiatingMessage = _initMsg;
166 // Clear assigned protocolIE list from RIC control_request IE container
167 template <typename T1, typename T2>
168 E2APControlMessage<T1,T2>::~E2APControlMessage(void){
170 mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Control Request object memory");
172 RICcontrolRequest_t *ricControl_Request = &(_initMsg->value.choice.RICcontrolRequest);
173 for(int i = 0; i < ricControl_Request->protocolIEs.list.size; i++){
174 ricControl_Request->protocolIEs.list.array[i] = 0;
177 if (ricControl_Request->protocolIEs.list.size > 0){
178 free(ricControl_Request->protocolIEs.list.array);
179 ricControl_Request->protocolIEs.list.size = 0;
180 ricControl_Request->protocolIEs.list.count = 0;
185 _e2ap_pdu_obj->choice.initiatingMessage = 0;
187 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
188 mdclog_write(MDCLOG_DEBUG, "Freed E2AP Control Request object memory");
192 template <typename T1, typename T2>
193 bool E2APControlMessage<T1,T2>::encode(unsigned char *buf, size_t *size){
195 _initMsg->procedureCode = ProcedureCode_id_RICcontrol;
196 _initMsg->criticality = Criticality_ignore;
197 _initMsg->value.present = InitiatingMessage__value_PR_RICcontrolRequest;
201 res = setfields(_initMsg);
206 int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len);
208 _error_string.assign(_errbuf, _errbuf_len);
209 _error_string = "Constraints failed for encoding control . Reason = " + _error_string;
213 xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
215 asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size);
217 if(retval.encoded == -1){
218 _error_string.assign(strerror(errno));
222 if(*size < retval.encoded){
223 std::stringstream ss;
224 ss <<"Error encoding event trigger definition. Reason = encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
225 _error_string = ss.str();
230 *size = retval.encoded;
235 template <typename T1, typename T2>
236 bool E2APControlMessage<T1,T2>::setfields(InitiatingMessage_t *_initMsg){
237 unsigned int ie_index;
240 _error_string = "Invalid reference for E2AP Control_Request message in set_fields";
244 RICcontrolRequest_t * E2APControlMessage = &(_initMsg->value.choice.RICcontrolRequest);
245 E2APControlMessage->protocolIEs.list.count = 0;
250 RICcontrolRequest_IEs_t *ies_ricreq = &IE_array[ie_index];
251 ies_ricreq->criticality = Criticality_reject;
252 ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
253 ies_ricreq->value.present = RICcontrolRequest_IEs__value_PR_RICrequestID;
254 RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
255 ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID();
256 ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID();
257 ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index]));
261 RICcontrolRequest_IEs_t *ies_ranfunc = &IE_array[ie_index];
262 ies_ranfunc->criticality = Criticality_reject;
263 ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
264 ies_ranfunc->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID;
265 RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
266 *ranfunction_ie = this->getIEs().get_ranFunctionID();
267 ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index]));
272 RICcontrolRequest_IEs_t *ies_richead = &IE_array[ie_index];
273 ies_richead->criticality = Criticality_reject;
274 ies_richead->id = ProtocolIE_ID_id_RICcontrolHeader;
275 ies_richead->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
276 RICcontrolHeader_t *richeader_ie = &ies_richead->value.choice.RICcontrolHeader;
277 richeader_ie->buf = (uint8_t*)this->getIEs().get_ricControlHeader();
278 richeader_ie->size = this->getIEs().get_ricControlHeaderSize();
279 ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index]));
283 RICcontrolRequest_IEs_t *ies_indmsg = &IE_array[ie_index];
284 ies_indmsg->criticality = Criticality_reject;
285 ies_indmsg->id = ProtocolIE_ID_id_RICcontrolMessage;
286 ies_indmsg->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
287 RICcontrolMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICcontrolMessage;
288 ricmsg_ie->buf = (uint8_t*)this->getIEs().get_ricControlMessage();
289 ricmsg_ie->size = this->getIEs().get_ricControlMessageSize();
290 ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index]));
294 if (this->getIEs().get_ricControlAckRequest()>= 0){
295 RICcontrolRequest_IEs_t *ies_indtyp = &IE_array[ie_index];
296 ies_indtyp->criticality = Criticality_reject;
297 ies_indtyp->id = ProtocolIE_ID_id_RICcontrolAckRequest;
298 ies_indtyp->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolAckRequest;
299 RICcontrolAckRequest_t *ricackreq_ie = &ies_indtyp->value.choice.RICcontrolAckRequest;
300 *ricackreq_ie = this->getIEs().get_ricControlAckRequest();
301 ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index]));
306 if(this->getIEs().get_is_ricCallProcessId()){
307 RICcontrolRequest_IEs_t *ies_callprocid = &IE_array[ie_index];
308 ies_callprocid->criticality = Criticality_reject;
309 ies_callprocid->id = ProtocolIE_ID_id_RICcallProcessID;
310 ies_callprocid->value.present = RICcontrolRequest_IEs__value_PR_RICcallProcessID;
311 RICcallProcessID_t *riccallprocessid_ie = &ies_callprocid->value.choice.RICcallProcessID;
312 riccallprocessid_ie->buf = (uint8_t*)this->getIEs().get_ricCallProcessId();
313 riccallprocessid_ie->size = this->getIEs().get_ricCallProcessIdSize();
314 ASN_SEQUENCE_ADD(&(E2APControlMessage->protocolIEs), &(IE_array[ie_index]));
321 #endif /* SRC_XAPP_ASN_E2AP_E2AP_CONTROL_REQUEST_HPP_ */