1 #include <gtest/gtest.h>
2 #include <gmock/gmock.h>
3 #include "sctpThread.h"
7 using namespace testing;
10 int32_t mtype; // message type ("long" network integer)
11 int32_t plen; // payload length (sender data length in payload)
12 int32_t rmr_ver; // our internal message version number
13 unsigned char xid[RMR_MAX_XID]; // space for user transaction id or somesuch
14 unsigned char sid[RMR_MAX_SID]; // sender ID for return to sender needs
15 unsigned char src[RMR_MAX_SRC]; // name:port of the sender (source)
16 unsigned char meid[RMR_MAX_MEID]; // managed element id.
17 struct timespec ts; // timestamp ???
18 int32_t flags; // HFL_* constants
19 int32_t len0; // length of the RMr header data
20 int32_t len1; // length of the tracing data
21 int32_t len2; // length of data 1 (d1)
22 int32_t len3; // length of data 2 (d2)
23 int32_t sub_id; // subscription id (-1 invalid)
25 unsigned char srcip[RMR_MAX_SRC]; // ip address and port of the source
29 mdclog_level_set(MDCLOG_DEBUG);
31 s = translateRmrErrorMessages(0);
32 EXPECT_THAT(s, HasSubstr("RMR_OK"));
33 s = translateRmrErrorMessages(1);
34 EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG"));
35 s = translateRmrErrorMessages(2);
36 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT"));
37 s = translateRmrErrorMessages(3);
38 EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY"));
39 s = translateRmrErrorMessages(4);
40 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR"));
41 s = translateRmrErrorMessages(5);
42 EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED"));
43 s = translateRmrErrorMessages(6);
44 EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED"));
45 s = translateRmrErrorMessages(7);
46 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN"));
47 s = translateRmrErrorMessages(8);
48 EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID"));
49 s = translateRmrErrorMessages(9);
50 EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW"));
51 s = translateRmrErrorMessages(10);
52 EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY"));
53 s = translateRmrErrorMessages(11);
54 EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED"));
55 s = translateRmrErrorMessages(12);
56 EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT"));
57 s = translateRmrErrorMessages(13);
58 EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET"));
59 s = translateRmrErrorMessages(14);
60 EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC"));
61 s = translateRmrErrorMessages(15);
62 EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED"));
63 s = translateRmrErrorMessages(16);
64 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP"));
65 s = translateRmrErrorMessages(17);
66 EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR"));
69 auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t));
72 struct epoll_event event;
73 event.events = EPOLLIN;
76 ConnectedCU_t *data = &data1;
77 event.data.ptr = (void *)data;
78 sctp_params_t sctp_ut_params;
79 sctp_params_t* sctp = &sctp_ut_params;
80 ReportingMessages_t reporting_msg;
81 RmrMessagesBuffer_t rmrmessagesbuffer;
82 handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp);
86 struct epoll_event event;
87 event.events = EPOLLIN;
90 ConnectedCU_t *data = &data1;
91 event.data.ptr = (void *)data;
92 sctp_params_t sctp_ut_params;
93 sctp_params_t* sctp = &sctp_ut_params;
96 ReportingMessages_t reporting_msg;
97 RmrMessagesBuffer_t rmrmessagesbuffer;
98 handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp);
103 ConnectedCU_t* connected_cu = &cu;
106 cleanHashEntry(connected_cu,m);
110 sctp_params_t sctp_ut_params;
111 sctp_params_t* sctp = &sctp_ut_params;
112 sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config/");
113 sctp->configFileName.assign("config.conf");
114 handleConfigChange(sctp);
118 int epoll_fd = epoll_create1(0);
120 ConnectedCU_t* peerinfo = &cu;
123 modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2);
128 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) {
129 message.peerInfo = peerInfo;
130 message.peerInfo->sctpParams = &sctp_ut_params;
131 snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
133 sctp_ut_params.myIP = "1.2.3.4";
134 sctp_ut_params.rmrPort = 38000;
135 snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
137 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
138 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
139 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA ");
140 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
143 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
145 if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) &&
146 (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]) ) {
147 free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]);
148 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = NULL;
150 if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) {
151 free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array);
152 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL;
154 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 0;
155 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = 0;
157 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
158 free(rmrMessageBuffer.sendMessage->header);
159 rmrMessageBuffer.sendMessage->header = NULL;
161 if(rmrMessageBuffer.sendMessage->payload) {
162 free(rmrMessageBuffer.sendMessage->payload);
163 rmrMessageBuffer.sendMessage->payload = NULL;
165 if(rmrMessageBuffer.sendMessage) {
166 free(rmrMessageBuffer.sendMessage);
167 rmrMessageBuffer.sendMessage = NULL;
169 if(rmrMessageBuffer.rmrCtx) {
170 rmr_close(rmrMessageBuffer.rmrCtx);
171 rmrMessageBuffer.rmrCtx = NULL;
175 void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu,
177 ReportingMessages_t &message,
178 RmrMessagesBuffer_t &rmrMessageBuffer,
179 sctp_params_t &sctp_ut_params) {
181 init_memories(message, rmrMessageBuffer, sctp_ut_params);
182 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
183 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
184 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
186 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
187 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
190 void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu,
192 ReportingMessages_t &message,
193 RmrMessagesBuffer_t &rmrMessageBuffer,
194 sctp_params_t &sctp_ut_params) {
196 init_memories(message, rmrMessageBuffer, sctp_ut_params);
197 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
198 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication;
199 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication;
200 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*));
201 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1;
202 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs);
203 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs));
204 RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0];
205 ie->id = ProtocolIE_ID_id_RICrequestID;
206 ie->value.present = RICindication_IEs__value_PR_RICrequestID;
207 ie->value.choice.RICrequestID.ricRequestorID = 12345;
208 ie->value.choice.RICrequestID.ricInstanceID = 1;
210 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
211 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
214 void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu,
216 ReportingMessages_t &message,
217 RmrMessagesBuffer_t &rmrMessageBuffer,
218 sctp_params_t &sctp_ut_params) {
220 init_memories(message, rmrMessageBuffer, sctp_ut_params);
221 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
222 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
223 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
224 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
225 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
228 void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu,
230 ReportingMessages_t &message,
231 RmrMessagesBuffer_t &rmrMessageBuffer,
232 sctp_params_t &sctp_ut_params) {
234 init_memories(message, rmrMessageBuffer, sctp_ut_params);
235 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
236 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
237 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
238 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
239 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
244 Sctp_Map_t *sctpMap = new Sctp_Map_t();
245 ReportingMessages_t message;
246 RmrMessagesBuffer_t rmrMessageBuffer;
247 sctp_params_t sctp_ut_params;
249 pdu.present = E2AP_PDU_PR_initiatingMessage;
250 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
251 memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage));
252 memset( (void*)&message, 0, sizeof(message));
253 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
255 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
256 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
258 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
259 create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
260 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
261 create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
262 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
263 create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
264 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
265 create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
266 /* For Procedure's Default case. */
267 pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100);
268 asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer);
270 if(pdu.choice.initiatingMessage) {
271 free(pdu.choice.initiatingMessage);
272 pdu.choice.initiatingMessage = NULL;
281 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
283 if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) &&
284 (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]) ) {
285 free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]);
286 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = NULL;
288 if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) {
289 free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array);
290 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL;
292 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 0;
293 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = 0;
295 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
296 free(rmrMessageBuffer.sendMessage->header);
297 rmrMessageBuffer.sendMessage->header = NULL;
299 if(rmrMessageBuffer.sendMessage->payload) {
300 free(rmrMessageBuffer.sendMessage->payload);
301 rmrMessageBuffer.sendMessage->payload = NULL;
304 if(rmrMessageBuffer.rmrCtx) {
305 rmr_close(rmrMessageBuffer.rmrCtx);
306 rmrMessageBuffer.rmrCtx = NULL;
309 if(rmrMessageBuffer.sendMessage) {
310 free(rmrMessageBuffer.sendMessage);
311 rmrMessageBuffer.sendMessage = NULL;
316 void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu,
318 ReportingMessages_t &message,
319 RmrMessagesBuffer_t &rmrMessageBuffer,
320 sctp_params_t &sctp_ut_params) {
322 init_memories(message, rmrMessageBuffer, sctp_ut_params);
323 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
324 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
325 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
326 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
329 void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
331 ReportingMessages_t &message,
332 RmrMessagesBuffer_t &rmrMessageBuffer,
333 sctp_params_t &sctp_ut_params) {
335 init_memories(message, rmrMessageBuffer, sctp_ut_params);
337 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*));
338 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1;
339 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t);
340 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t));
341 RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0];
343 ie->id = ProtocolIE_ID_id_RICrequestID;
344 ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
345 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
346 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
347 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
348 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
351 void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
353 ReportingMessages_t &message,
354 RmrMessagesBuffer_t &rmrMessageBuffer,
355 sctp_params_t &sctp_ut_params) {
357 init_memories(message, rmrMessageBuffer, sctp_ut_params);
358 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
359 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
360 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
361 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
364 void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
366 ReportingMessages_t &message,
367 RmrMessagesBuffer_t &rmrMessageBuffer,
368 sctp_params_t &sctp_ut_params) {
370 init_memories(message, rmrMessageBuffer, sctp_ut_params);
371 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
372 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
373 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
374 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
379 Sctp_Map_t *sctpMap = new Sctp_Map_t();
380 ReportingMessages_t message;
381 RmrMessagesBuffer_t rmrMessageBuffer;
382 sctp_params_t sctp_ut_params;
384 pdu.present = E2AP_PDU_PR_successfulOutcome;
385 pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
386 memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome));
387 memset( (void*)&message, 0, sizeof(message));
388 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
390 snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
392 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
393 create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
394 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
395 create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
396 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
397 create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
398 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
399 create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
400 /* For Procedure's Default case. */
401 pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100);
402 asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
404 if(pdu.choice.successfulOutcome) {
405 free(pdu.choice.successfulOutcome);
406 pdu.choice.successfulOutcome = NULL;
415 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
417 if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) &&
418 (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]) ) {
419 free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]);
420 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = NULL;
422 if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) {
423 free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array);
424 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL;
426 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 0;
427 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = 0;
429 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
430 free(rmrMessageBuffer.sendMessage->header);
431 rmrMessageBuffer.sendMessage->header = NULL;
433 if(rmrMessageBuffer.sendMessage->payload) {
434 free(rmrMessageBuffer.sendMessage->payload);
435 rmrMessageBuffer.sendMessage->payload = NULL;
438 if(rmrMessageBuffer.rmrCtx) {
439 rmr_close(rmrMessageBuffer.rmrCtx);
440 rmrMessageBuffer.rmrCtx = NULL;
443 if(rmrMessageBuffer.sendMessage) {
444 free(rmrMessageBuffer.sendMessage);
445 rmrMessageBuffer.sendMessage = NULL;
449 void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
451 ReportingMessages_t &message,
452 RmrMessagesBuffer_t &rmrMessageBuffer,
453 sctp_params_t &sctp_ut_params) {
455 init_memories(message, rmrMessageBuffer, sctp_ut_params);
457 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*));
458 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1;
459 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t);
460 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t));
461 RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0];
463 ie->id = ProtocolIE_ID_id_RICrequestID;
464 ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID;
465 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
466 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
467 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
468 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
471 void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
473 ReportingMessages_t &message,
474 RmrMessagesBuffer_t &rmrMessageBuffer,
475 sctp_params_t &sctp_ut_params) {
477 init_memories(message, rmrMessageBuffer, sctp_ut_params);
478 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
479 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
480 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
481 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
484 void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
486 ReportingMessages_t &message,
487 RmrMessagesBuffer_t &rmrMessageBuffer,
488 sctp_params_t &sctp_ut_params) {
490 init_memories(message, rmrMessageBuffer, sctp_ut_params);
491 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
492 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
493 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
494 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
499 Sctp_Map_t *sctpMap = new Sctp_Map_t();
500 ReportingMessages_t message;
501 RmrMessagesBuffer_t rmrMessageBuffer;
502 sctp_params_t sctp_ut_params;
504 pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
505 pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
506 memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome));
507 memset( (void*)&message, 0, sizeof(message));
508 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
510 snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
512 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
513 create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
514 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
515 create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
516 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
517 create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
518 /* For Procedure's Default case. */
519 pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100);
520 asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
522 if(pdu.choice.unsuccessfulOutcome) {
523 free(pdu.choice.unsuccessfulOutcome);
524 pdu.choice.unsuccessfulOutcome = NULL;
534 int epoll_fd = epoll_create1(0);
536 ConnectedCU_t* peerinfo = &cu;
539 addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0);
543 sctp_params_t sctpParams;
545 char **argv = (char**) calloc(argc, sizeof(char*));
546 argv[0] = (char*) malloc(40 * sizeof(char));
547 argv[1] = (char*) malloc(40 * sizeof(char));
548 argv[2] = (char*) malloc(40 * sizeof(char));
549 argv[3] = (char*) malloc(40 * sizeof(char));
550 argv[4] = (char*) malloc(40 * sizeof(char));
551 snprintf(argv[0], strlen("./e2 "), "%s", (char*)"./e2");
552 snprintf(argv[1], strlen("-p "), "%s", (char*)"-p");
553 snprintf(argv[2], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config");
554 snprintf(argv[3], strlen("-f "), "%s", (char*)"-f");
555 snprintf(argv[4], strlen("config.conf "), "%s", (char*)"config.conf");
557 auto result = parse(argc, argv, sctpParams);
558 sctpParams.podName.assign("E2TermAlpha_pod");
559 sctpParams.sctpMap = new mapWrapper();
560 sctpParams.epoll_fd = epoll_create1(0);
561 buildConfiguration(sctpParams);
562 // getRmrContext(sctpParams);
563 buildInotify(sctpParams);
564 buildListeningPort(sctpParams);
565 listener(&sctpParams);
567 if(sctpParams.sctpMap) {
568 delete sctpParams.sctpMap;
569 sctpParams.sctpMap = NULL;
588 ReportingMessages_t reporting_msg;
589 Sctp_Map_t *sctpMap = new Sctp_Map_t();
590 sendSctpMsg(peerInfo, reporting_msg, sctpMap);
600 void inti_buffers_rcv(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
601 message.peerInfo = peerInfo;
602 snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
604 rmrMessageBuffer.rcvMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
605 rmrMessageBuffer.rcvMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
606 rmrMessageBuffer.rcvMessage->len = strlen("Saying Hello from Ramji ");
607 rmrMessageBuffer.rcvMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
609 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
610 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
611 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
612 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
616 void delete_memories_rcv(RmrMessagesBuffer_t &rmrMessageBuffer) {
618 if(rmrMessageBuffer.rcvMessage && rmrMessageBuffer.rcvMessage->header) {
619 free(rmrMessageBuffer.rcvMessage->header);
620 rmrMessageBuffer.rcvMessage->header = NULL;
622 if(rmrMessageBuffer.rcvMessage) {
623 free(rmrMessageBuffer.rcvMessage);
624 rmrMessageBuffer.rcvMessage = NULL;
626 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
627 free(rmrMessageBuffer.sendMessage->header);
628 rmrMessageBuffer.sendMessage->header = NULL;
630 if(rmrMessageBuffer.sendMessage) {
631 free(rmrMessageBuffer.sendMessage);
632 rmrMessageBuffer.sendMessage = NULL;
637 void create_receiveXappMessages_RIC_ERROR_INDICATION(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
638 RmrMessagesBuffer_t &rmrMessageBuffer) {
639 inti_buffers_rcv(message, rmrMessageBuffer);
640 rmrMessageBuffer.rcvMessage->mtype = RIC_ERROR_INDICATION;
641 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
642 delete_memories_rcv(rmrMessageBuffer);
645 void create_receiveXappMessages_RIC_E2_SETUP_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
646 RmrMessagesBuffer_t &rmrMessageBuffer) {
647 inti_buffers_rcv(message, rmrMessageBuffer);
648 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_FAILURE;
649 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
650 delete_memories_rcv(rmrMessageBuffer);
653 void create_receiveXappMessages_RIC_SUB_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
654 RmrMessagesBuffer_t &rmrMessageBuffer) {
655 inti_buffers_rcv(message, rmrMessageBuffer);
656 rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_REQ;
657 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
658 delete_memories_rcv(rmrMessageBuffer);
661 void create_receiveXappMessages_RIC_CONTROL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
662 RmrMessagesBuffer_t &rmrMessageBuffer) {
663 inti_buffers_rcv(message, rmrMessageBuffer);
664 rmrMessageBuffer.rcvMessage->mtype = RIC_CONTROL_REQ;
665 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
666 delete_memories_rcv(rmrMessageBuffer);
669 void create_receiveXappMessages_RIC_SERVICE_QUERY(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
670 RmrMessagesBuffer_t &rmrMessageBuffer) {
671 inti_buffers_rcv(message, rmrMessageBuffer);
672 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_QUERY;
673 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
674 delete_memories_rcv(rmrMessageBuffer);
677 void create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
678 RmrMessagesBuffer_t &rmrMessageBuffer) {
679 inti_buffers_rcv(message, rmrMessageBuffer);
680 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_ACK;
681 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
682 delete_memories_rcv(rmrMessageBuffer);
685 void create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
686 RmrMessagesBuffer_t &rmrMessageBuffer) {
687 inti_buffers_rcv(message, rmrMessageBuffer);
688 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_FAILURE;
689 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
690 delete_memories_rcv(rmrMessageBuffer);
694 void create_receiveXappMessages_RIC_E2_RESET_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
695 RmrMessagesBuffer_t &rmrMessageBuffer) {
696 inti_buffers_rcv(message, rmrMessageBuffer);
697 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_REQ;
698 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
699 delete_memories_rcv(rmrMessageBuffer);
702 void create_receiveXappMessages_RIC_E2_RESET_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
703 RmrMessagesBuffer_t &rmrMessageBuffer) {
704 inti_buffers_rcv(message, rmrMessageBuffer);
705 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_RESP;
706 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
707 delete_memories_rcv(rmrMessageBuffer);
710 void create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
711 RmrMessagesBuffer_t &rmrMessageBuffer) {
712 inti_buffers_rcv(message, rmrMessageBuffer);
713 rmrMessageBuffer.rcvMessage->mtype = RIC_SCTP_CLEAR_ALL;
714 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
715 delete_memories_rcv(rmrMessageBuffer);
718 void create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
719 RmrMessagesBuffer_t &rmrMessageBuffer) {
720 inti_buffers_rcv(message, rmrMessageBuffer);
721 rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_REQ;
722 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
723 delete_memories_rcv(rmrMessageBuffer);
726 void create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
727 RmrMessagesBuffer_t &rmrMessageBuffer) {
728 inti_buffers_rcv(message, rmrMessageBuffer);
729 rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
730 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
731 delete_memories_rcv(rmrMessageBuffer);
736 Sctp_Map_t *sctpMap = new Sctp_Map_t();
737 ReportingMessages_t message;
738 RmrMessagesBuffer_t rmrMessageBuffer;
740 memset( (void*)&message, 0, sizeof(message));
741 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
743 // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset
744 create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer);
745 create_receiveXappMessages_RIC_ERROR_INDICATION(sctpMap, message, rmrMessageBuffer);
746 create_receiveXappMessages_RIC_SUB_REQ(sctpMap, message, rmrMessageBuffer);
747 create_receiveXappMessages_RIC_CONTROL_REQ(sctpMap, message, rmrMessageBuffer);
748 create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(sctpMap, message, rmrMessageBuffer);
749 create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(sctpMap, message, rmrMessageBuffer);
750 create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
751 create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
752 create_receiveXappMessages_RIC_E2_RESET_RESP(sctpMap, message, rmrMessageBuffer);
753 create_receiveXappMessages_RIC_E2_RESET_REQ(sctpMap, message, rmrMessageBuffer);
754 create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
755 create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
756 create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer);
758 inti_buffers_rcv(message, rmrMessageBuffer);
759 rmrMessageBuffer.rcvMessage->mtype = 100;
760 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
761 delete_memories_rcv(rmrMessageBuffer);
769 int main(int argc, char **argv) {
771 testing::InitGoogleTest(&argc, argv);
772 return RUN_ALL_TESTS();