Adding Bouncer code for RIC-Benchmarking
[ric-app/bouncer.git] / Bouncer / src / xapp-asn / e2ap / e2ap_control.cc
1 /*
2 ==================================================================================
3
4         Copyright (c) 2019-2020 AT&T Intellectual Property.
5
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
9
10        http://www.apache.org/licenses/LICENSE-2.0
11
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 ==================================================================================
18 */
19 /*
20  * ric_control_request.c
21  *
22  *  Created on: Jul 11, 2019
23  *      Author: sjana, Ashwin Sridharan
24  */
25
26 #include "e2ap_control.hpp"
27
28 // Set up memory allocations for each IE for encoding
29 // We are responsible for memory management for each IE for encoding
30 // Hence destructor should clear out memory
31 // When decoding, we rely on asn1c macro (ASN_STRUCT_FREE to be called
32 // for releasing memory by external calling function)
33 ric_control_request::ric_control_request(void){
34
35   e2ap_pdu_obj = 0;
36   e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
37   assert(e2ap_pdu_obj != 0);
38
39   initMsg = 0;
40   initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t));
41   assert(initMsg != 0);
42
43   IE_array = 0;
44   IE_array = (RICcontrolRequest_IEs_t *)calloc(NUM_CONTROL_REQUEST_IES, sizeof(RICcontrolRequest_IEs_t));
45   assert(IE_array != 0);
46
47   e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage;
48   e2ap_pdu_obj->choice.initiatingMessage = initMsg;
49
50   
51 };
52
53
54 // Clear assigned protocolIE list from RIC control_request IE container
55 ric_control_request::~ric_control_request(void){
56
57   mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Control Request object memory");
58   
59   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;
62   }
63   
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;
68   }
69   
70   free(IE_array);
71   free(initMsg);
72   e2ap_pdu_obj->choice.initiatingMessage = 0;
73   
74   ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
75   mdclog_write(MDCLOG_DEBUG, "Freed E2AP Control Request object mempory");
76   
77 }
78
79
80 bool ric_control_request::encode_e2ap_control_request(unsigned char *buf, size_t *size, ric_control_helper & dinput){
81
82   initMsg->procedureCode = ProcedureCode_id_RICcontrol;
83   initMsg->criticality = Criticality_ignore;
84   initMsg->value.present = InitiatingMessage__value_PR_RICcontrolRequest;
85
86   bool res;
87   
88   res = set_fields(initMsg, dinput);
89   if (!res){
90     return false;
91   }
92
93   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
94   if(ret_constr){
95     error_string.assign(errbuf, errbuf_len);
96     error_string = "Constraints failed for encoding control . Reason = " + error_string;
97     return false;
98   }
99
100   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
101   
102   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
103   
104   if(retval.encoded == -1){
105     error_string.assign(strerror(errno));
106     return false;
107   }
108   else {
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();
113       return false;
114     }
115   }
116
117   *size = retval.encoded;
118   return true;
119   
120 }
121
122 bool ric_control_request::set_fields(InitiatingMessage_t *initMsg, ric_control_helper &dinput){
123   unsigned int ie_index;
124
125   if (initMsg == 0){
126     error_string = "Invalid reference for E2AP Control_Request message in set_fields";
127     return false;
128   }
129
130   RICcontrolRequest_t * ric_control_request = &(initMsg->value.choice.RICcontrolRequest);
131   ric_control_request->protocolIEs.list.count = 0; // reset 
132   
133   // for(i = 0; i < NUM_CONTROL_REQUEST_IES;i++){
134   //   memset(&(IE_array[i]), 0, sizeof(RICcontrolRequest_IEs_t));
135   // }
136  
137   // Mandatory IE
138   ie_index = 0;
139   RICcontrolRequest_IEs_t *ies_ricreq = &IE_array[ie_index];
140   ies_ricreq->criticality = Criticality_reject;
141   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
142   ies_ricreq->value.present = RICcontrolRequest_IEs__value_PR_RICrequestID;
143   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]));
147
148   // Mandatory IE
149   ie_index = 1;
150   RICcontrolRequest_IEs_t *ies_ranfunc = &IE_array[ie_index];
151   ies_ranfunc->criticality = Criticality_reject;
152   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
153   ies_ranfunc->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID;
154   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
155   *ranfunction_ie = dinput.func_id;
156   ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
157
158
159   // Mandatory IE
160   ie_index = 2;
161   RICcontrolRequest_IEs_t *ies_richead = &IE_array[ie_index];
162   ies_richead->criticality = Criticality_reject;
163   ies_richead->id = ProtocolIE_ID_id_RICcontrolHeader;
164   ies_richead->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
165   RICcontrolHeader_t *richeader_ie = &ies_richead->value.choice.RICcontrolHeader;
166   richeader_ie->buf = dinput.control_header;
167   richeader_ie->size = dinput.control_header_size;
168   ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
169
170   // Mandatory IE
171   ie_index = 3;
172   RICcontrolRequest_IEs_t *ies_indmsg = &IE_array[ie_index];
173   ies_indmsg->criticality = Criticality_reject;
174   ies_indmsg->id = ProtocolIE_ID_id_RICcontrolMessage;
175   ies_indmsg->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
176   RICcontrolMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICcontrolMessage;
177   ricmsg_ie->buf = dinput.control_msg;
178   ricmsg_ie->size = dinput.control_msg_size;
179   ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
180
181   // Optional IE
182   ie_index = 4;
183   if (dinput.control_ack >= 0){
184     RICcontrolRequest_IEs_t *ies_indtyp = &IE_array[ie_index];
185     ies_indtyp->criticality = Criticality_reject;
186     ies_indtyp->id = ProtocolIE_ID_id_RICcontrolAckRequest;
187     ies_indtyp->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolAckRequest;
188     RICcontrolAckRequest_t *ricackreq_ie = &ies_indtyp->value.choice.RICcontrolAckRequest;
189     *ricackreq_ie = dinput.control_ack;
190     ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
191   }
192
193   // Optional IE
194   ie_index = 5;
195   if(dinput.call_process_id_size > 0){
196     RICcontrolRequest_IEs_t *ies_callprocid = &IE_array[ie_index];
197     ies_callprocid->criticality = Criticality_reject;
198     ies_callprocid->id = ProtocolIE_ID_id_RICcallProcessID;
199     ies_callprocid->value.present = RICcontrolRequest_IEs__value_PR_RICcallProcessID;
200     RICcallProcessID_t *riccallprocessid_ie = &ies_callprocid->value.choice.RICcallProcessID;
201     riccallprocessid_ie->buf = dinput.call_process_id;
202     riccallprocessid_ie->size = dinput.call_process_id_size;
203     ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[ie_index]));
204
205   }
206   return true;
207
208 };
209
210   
211
212
213 bool ric_control_request:: get_fields(InitiatingMessage_t * init_msg,  ric_control_helper &dout)
214 {
215   if (init_msg == 0){
216     error_string = "Invalid reference for E2AP Control_Request message in get_fields";
217     return false;
218   }
219   
220  
221   for(int edx = 0; edx < init_msg->value.choice.RICcontrolRequest.protocolIEs.list.count; edx++) {
222     RICcontrolRequest_IEs_t *memb_ptr = init_msg->value.choice.RICcontrolRequest.protocolIEs.list.array[edx];
223     
224     switch(memb_ptr->id)
225       {
226       case (ProtocolIE_ID_id_RICcontrolHeader):
227         dout.control_header = memb_ptr->value.choice.RICcontrolHeader.buf;
228         dout.control_header_size = memb_ptr->value.choice.RICcontrolHeader.size;
229         break;
230         
231       case (ProtocolIE_ID_id_RICcontrolMessage):
232         dout.control_msg =  memb_ptr->value.choice.RICcontrolMessage.buf;
233         dout.control_msg_size = memb_ptr->value.choice.RICcontrolMessage.size;
234         break;
235
236       case (ProtocolIE_ID_id_RICcallProcessID):
237         dout.call_process_id =  memb_ptr->value.choice.RICcallProcessID.buf;
238         dout.call_process_id_size = memb_ptr->value.choice.RICcallProcessID.size;
239         break;
240
241       case (ProtocolIE_ID_id_RICrequestID):
242         dout.req_id = memb_ptr->value.choice.RICrequestID.ricRequestorID;
243         //dout.req_seq_no = memb_ptr->value.choice.RICrequestID.ricRequestSequenceNumber;
244         break;
245         
246       case (ProtocolIE_ID_id_RANfunctionID):
247         dout.func_id = memb_ptr->value.choice.RANfunctionID;
248         break;
249         
250       case (ProtocolIE_ID_id_RICcontrolAckRequest):
251         dout.control_ack = memb_ptr->value.choice.RICcontrolAckRequest;
252         break;
253         
254       default:
255         break;
256       }
257     
258   }
259   
260   return true;
261
262 }
263
264 InitiatingMessage_t * ric_control_request::get_message(void)  {
265     return initMsg;
266 }