2 ==================================================================================
4 Copyright (c) 2018-2019 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 ==================================================================================
20 * ric_control_request.c
22 * Created on: Jul 11, 2019
23 * Author: sjana, Ashwin Sridharan
26 #include <e2ap_control.hpp>
28 // Set up the initiating message and also allocate protocolIEs in container
29 // Note : this bypasses requirement to use ASN_SEQUENCE_ADD. We can directly
30 // assign pointers to the array in ProtocolIE. However, this also leaves us on the
31 // hook to manually clear the memory
33 ric_control_request::ric_control_request(void){
36 e2ap_pdu_obj = (E2N_E2AP_PDU_t * )calloc(1, sizeof(E2N_E2AP_PDU_t));
37 assert(e2ap_pdu_obj != 0);
40 initMsg = (E2N_InitiatingMessage_t * )calloc(1, sizeof(E2N_InitiatingMessage_t));
44 IE_array = (E2N_RICcontrolRequest_IEs_t *)calloc(NUM_CONTROL_REQUEST_IES, sizeof(E2N_RICcontrolRequest_IEs_t));
45 assert(IE_array != 0);
47 e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_initiatingMessage;
48 e2ap_pdu_obj->choice.initiatingMessage = initMsg;
54 // Clear assigned protocolIE list from RIC control_request IE container
55 ric_control_request::~ric_control_request(void){
57 mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Control Request object memory");
59 E2N_RICcontrolRequest_t *ricControl_Request = &(initMsg->value.choice.RICcontrolRequest);
60 for(int i = 0; i < ricControl_Request->protocolIEs.list.size; i++){
61 ricControl_Request->protocolIEs.list.array[i] = 0;
64 if (ricControl_Request->protocolIEs.list.size > 0){
65 free(ricControl_Request->protocolIEs.list.array);
66 ricControl_Request->protocolIEs.list.size = 0;
67 ricControl_Request->protocolIEs.list.count = 0;
72 e2ap_pdu_obj->choice.initiatingMessage = 0;
74 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj);
75 mdclog_write(MDCLOG_DEBUG, "Freed E2N_E2AP Control Request object mempory");
80 bool ric_control_request::encode_e2ap_control_request(unsigned char *buf, size_t *size, ric_control_helper & dinput){
82 initMsg->procedureCode = E2N_ProcedureCode_id_ricControl;
83 initMsg->criticality = E2N_Criticality_ignore;
84 initMsg->value.present = E2N_InitiatingMessage__value_PR_RICcontrolRequest;
88 res = set_fields(initMsg, dinput);
93 int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
95 error_string.assign(errbuf, errbuf_len);
96 error_string = "Constraints failed for encoding control . Reason = " + error_string;
100 //xer_fprint(stdout, &asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj);
102 asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj, buf, *size);
104 if(retval.encoded == -1){
105 error_string.assign(strerror(errno));
109 if(*size < retval.encoded){
110 std::stringstream ss;
111 ss <<"Error encoding event trigger definition. Reason = encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
112 error_string = ss.str();
117 *size = retval.encoded;
122 bool ric_control_request::set_fields(E2N_InitiatingMessage_t *initMsg, ric_control_helper &dinput){
123 unsigned int ie_index;
126 error_string = "Invalid reference for E2AP Control_Request message in set_fields";
130 E2N_RICcontrolRequest_t * ric_control_request = &(initMsg->value.choice.RICcontrolRequest);
131 ric_control_request->protocolIEs.list.count = 0;
133 // for(i = 0; i < NUM_CONTROL_REQUEST_IES;i++){
134 // memset(&(IE_array[i]), 0, sizeof(RICcontrolRequest_IEs_t));
139 E2N_RICcontrolRequest_IEs_t *ies_ricreq = &IE_array[ie_index];
140 ies_ricreq->criticality = E2N_Criticality_reject;
141 ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
142 ies_ricreq->value.present = E2N_RICcontrolRequest_IEs__value_PR_RICrequestID;
143 E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
144 ricrequest_ie->ricRequestorID = dinput.req_id;
145 ricrequest_ie->ricRequestSequenceNumber = dinput.req_seq_no;
146 ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
149 E2N_RICcontrolRequest_IEs_t *ies_ranfunc = &IE_array[ie_index];
150 ies_ranfunc->criticality = E2N_Criticality_reject;
151 ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
152 ies_ranfunc->value.present = E2N_RICcontrolRequest_IEs__value_PR_RANfunctionID;
153 E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
154 *ranfunction_ie = dinput.func_id;
155 ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
159 // RICcontrolRequest_IEs_t *ies_riccallprocessid = &IE_array[ie_index];
160 // ies_riccallprocessid->criticality = E2N_Criticality_reject;
161 // ies_riccallprocessid->id = E2N_ProtocolIE_ID_id_RICcallProcessID;
162 // ies_riccallprocessid->value.present = E2N_RICcontrolRequest_IEs__value_PR_RICcallProcessID;
163 // RICcallProcessID_t *riccallprocessid_ie = &ies_riccallprocessid->value.choice.RICcallProcessID;
164 // riccallprocessid_ie->buf = dinput.call_process_id;
165 // riccallprocessid_ie->size = dinput.call_process_id_size;
168 E2N_RICcontrolRequest_IEs_t *ies_richead = &IE_array[ie_index];
169 ies_richead->criticality = E2N_Criticality_reject;
170 ies_richead->id = E2N_ProtocolIE_ID_id_RICcontrolHeader;
171 ies_richead->value.present = E2N_RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
172 E2N_RICcontrolHeader_t *richeader_ie = &ies_richead->value.choice.RICcontrolHeader;
173 richeader_ie->buf = dinput.control_header;
174 richeader_ie->size = dinput.control_header_size;
175 ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
178 E2N_RICcontrolRequest_IEs_t *ies_indmsg = &IE_array[ie_index];
179 ies_indmsg->criticality = E2N_Criticality_reject;
180 ies_indmsg->id = E2N_ProtocolIE_ID_id_RICcontrolMessage;
181 ies_indmsg->value.present = E2N_RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
182 E2N_RICcontrolMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICcontrolMessage;
183 ricmsg_ie->buf = dinput.control_msg;
184 ricmsg_ie->size = dinput.control_msg_size;
185 ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
188 E2N_RICcontrolRequest_IEs_t *ies_indtyp = &IE_array[ie_index];
189 ies_indtyp->criticality = E2N_Criticality_reject;
190 ies_indtyp->id = E2N_ProtocolIE_ID_id_RICcontrolAckRequest;
191 ies_indtyp->value.present = E2N_RICcontrolRequest_IEs__value_PR_RICcontrolAckRequest;
192 E2N_RICcontrolAckRequest_t *ricackreq_ie = &ies_indtyp->value.choice.RICcontrolAckRequest;
193 *ricackreq_ie = dinput.control_ack;
194 ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
197 if(dinput.call_process_id_size > 0){
198 E2N_RICcontrolRequest_IEs_t *ies_callprocid = &IE_array[ie_index];
199 ies_callprocid->criticality = E2N_Criticality_reject;
200 ies_callprocid->id = E2N_ProtocolIE_ID_id_RICcallProcessID;
201 ies_callprocid->value.present = E2N_RICcontrolRequest_IEs__value_PR_RICcallProcessID;
202 E2N_RICcallProcessID_t *riccallprocessid_ie = &ies_callprocid->value.choice.RICcallProcessID;
203 riccallprocessid_ie->buf = dinput.call_process_id;
204 riccallprocessid_ie->size = dinput.call_process_id_size;
205 ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
215 bool ric_control_request:: get_fields(E2N_InitiatingMessage_t * init_msg, ric_control_helper &dout)
218 error_string = "Invalid reference for E2AP Control_Request message in get_fields";
223 for(int edx = 0; edx < init_msg->value.choice.RICcontrolRequest.protocolIEs.list.count; edx++) {
224 E2N_RICcontrolRequest_IEs_t *memb_ptr = init_msg->value.choice.RICcontrolRequest.protocolIEs.list.array[edx];
228 case (E2N_ProtocolIE_ID_id_RICcontrolHeader):
229 dout.control_header = memb_ptr->value.choice.RICcontrolHeader.buf;
230 dout.control_header_size = memb_ptr->value.choice.RICcontrolHeader.size;
233 case (E2N_ProtocolIE_ID_id_RICcontrolMessage):
234 dout.control_msg = memb_ptr->value.choice.RICcontrolMessage.buf;
235 dout.control_msg_size = memb_ptr->value.choice.RICcontrolMessage.size;
238 case (E2N_ProtocolIE_ID_id_RICcallProcessID):
239 dout.call_process_id = memb_ptr->value.choice.RICcallProcessID.buf;
240 dout.call_process_id_size = memb_ptr->value.choice.RICcallProcessID.size;
243 case (E2N_ProtocolIE_ID_id_RICrequestID):
244 dout.req_id = memb_ptr->value.choice.RICrequestID.ricRequestorID;
245 dout.req_seq_no = memb_ptr->value.choice.RICrequestID.ricRequestSequenceNumber;
248 case (E2N_ProtocolIE_ID_id_RANfunctionID):
249 dout.func_id = memb_ptr->value.choice.RANfunctionID;
252 case (E2N_ProtocolIE_ID_id_RICcontrolAckRequest):
253 dout.control_ack = memb_ptr->value.choice.RICcontrolAckRequest;
266 E2N_InitiatingMessage_t * ric_control_request::get_message(void) {