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
28 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params);
31 mdclog_level_set(MDCLOG_DEBUG);
33 s = translateRmrErrorMessages(0);
34 EXPECT_THAT(s, HasSubstr("RMR_OK"));
35 s = translateRmrErrorMessages(1);
36 EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG"));
37 s = translateRmrErrorMessages(2);
38 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT"));
39 s = translateRmrErrorMessages(3);
40 EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY"));
41 s = translateRmrErrorMessages(4);
42 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR"));
43 s = translateRmrErrorMessages(5);
44 EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED"));
45 s = translateRmrErrorMessages(6);
46 EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED"));
47 s = translateRmrErrorMessages(7);
48 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN"));
49 s = translateRmrErrorMessages(8);
50 EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID"));
51 s = translateRmrErrorMessages(9);
52 EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW"));
53 s = translateRmrErrorMessages(10);
54 EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY"));
55 s = translateRmrErrorMessages(11);
56 EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED"));
57 s = translateRmrErrorMessages(12);
58 EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT"));
59 s = translateRmrErrorMessages(13);
60 EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET"));
61 s = translateRmrErrorMessages(14);
62 EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC"));
63 s = translateRmrErrorMessages(15);
64 EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED"));
65 s = translateRmrErrorMessages(16);
66 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP"));
67 s = translateRmrErrorMessages(17);
68 EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR"));
71 auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t));
74 struct epoll_event event;
75 event.events = EPOLLIN;
78 ConnectedCU_t *data = &data1;
79 event.data.ptr = (void *)data;
80 sctp_params_t sctp_ut_params;
81 sctp_params_t* sctp = &sctp_ut_params;
82 ReportingMessages_t reporting_msg;
83 RmrMessagesBuffer_t rmrmessagesbuffer;
84 handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp);
88 struct epoll_event event;
89 event.events = EPOLLIN;
92 ConnectedCU_t *data = &data1;
93 event.data.ptr = (void *)data;
94 sctp_params_t sctp_ut_params;
95 sctp_params_t* sctp = &sctp_ut_params;
98 ReportingMessages_t reporting_msg;
99 RmrMessagesBuffer_t rmrmessagesbuffer;
100 handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp);
105 ConnectedCU_t* connected_cu = &cu;
108 cleanHashEntry(connected_cu,m);
112 sctp_params_t sctp_ut_params;
113 sctp_params_t* sctp = &sctp_ut_params;
114 sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config");
115 sctp->configFileName.assign("config.conf");
116 handleConfigChange(sctp);
120 int epoll_fd = epoll_create1(0);
122 ConnectedCU_t* peerinfo = &cu;
125 modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2);
130 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) {
131 message.peerInfo = peerInfo;
132 message.peerInfo->sctpParams = &sctp_ut_params;
133 snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
135 sctp_ut_params.myIP = "1.2.3.4";
136 sctp_ut_params.rmrPort = 38000;
137 snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
139 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
140 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
141 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA ");
142 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
145 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
147 if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) &&
148 (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]) ) {
149 free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]);
150 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = NULL;
152 if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) {
153 free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array);
154 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL;
156 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 0;
157 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = 0;
159 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
160 free(rmrMessageBuffer.sendMessage->header);
161 rmrMessageBuffer.sendMessage->header = NULL;
163 if(rmrMessageBuffer.sendMessage->payload) {
164 free(rmrMessageBuffer.sendMessage->payload);
165 rmrMessageBuffer.sendMessage->payload = NULL;
167 if(rmrMessageBuffer.sendMessage) {
168 free(rmrMessageBuffer.sendMessage);
169 rmrMessageBuffer.sendMessage = NULL;
171 if(rmrMessageBuffer.rmrCtx) {
172 rmr_close(rmrMessageBuffer.rmrCtx);
173 rmrMessageBuffer.rmrCtx = NULL;
177 void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu,
179 ReportingMessages_t &message,
180 RmrMessagesBuffer_t &rmrMessageBuffer,
181 sctp_params_t &sctp_ut_params) {
183 init_memories(message, rmrMessageBuffer, sctp_ut_params);
184 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
185 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
186 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
188 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
189 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
192 void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu,
194 ReportingMessages_t &message,
195 RmrMessagesBuffer_t &rmrMessageBuffer,
196 sctp_params_t &sctp_ut_params) {
198 init_memories(message, rmrMessageBuffer, sctp_ut_params);
199 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
200 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication;
201 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication;
202 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*));
203 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1;
204 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs);
205 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs));
206 RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0];
207 ie->id = ProtocolIE_ID_id_RICrequestID;
208 ie->value.present = RICindication_IEs__value_PR_RICrequestID;
209 ie->value.choice.RICrequestID.ricRequestorID = 12345;
210 ie->value.choice.RICrequestID.ricInstanceID = 1;
212 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
213 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
216 void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu,
218 ReportingMessages_t &message,
219 RmrMessagesBuffer_t &rmrMessageBuffer,
220 sctp_params_t &sctp_ut_params) {
222 init_memories(message, rmrMessageBuffer, sctp_ut_params);
223 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
224 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
225 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
226 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
227 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
230 void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu,
232 ReportingMessages_t &message,
233 RmrMessagesBuffer_t &rmrMessageBuffer,
234 sctp_params_t &sctp_ut_params) {
236 init_memories(message, rmrMessageBuffer, sctp_ut_params);
237 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
238 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
239 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
240 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
241 delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
246 Sctp_Map_t *sctpMap = new Sctp_Map_t();
247 ReportingMessages_t message;
248 RmrMessagesBuffer_t rmrMessageBuffer;
249 sctp_params_t sctp_ut_params;
251 pdu.present = E2AP_PDU_PR_initiatingMessage;
252 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
253 memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage));
254 memset( (void*)&message, 0, sizeof(message));
255 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
257 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
258 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
260 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
261 create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
262 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
263 create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
264 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
265 create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
266 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
267 create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
268 /* For Procedure's Default case. */
269 pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100);
270 asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer);
272 if(pdu.choice.initiatingMessage) {
273 free(pdu.choice.initiatingMessage);
274 pdu.choice.initiatingMessage = NULL;
283 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
285 if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) &&
286 (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]) ) {
287 free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]);
288 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = NULL;
290 if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) {
291 free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array);
292 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL;
294 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 0;
295 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = 0;
297 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
298 free(rmrMessageBuffer.sendMessage->header);
299 rmrMessageBuffer.sendMessage->header = NULL;
301 if(rmrMessageBuffer.sendMessage->payload) {
302 free(rmrMessageBuffer.sendMessage->payload);
303 rmrMessageBuffer.sendMessage->payload = NULL;
305 if(rmrMessageBuffer.sendMessage) {
306 free(rmrMessageBuffer.sendMessage);
307 rmrMessageBuffer.sendMessage = NULL;
312 void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu,
314 ReportingMessages_t &message,
315 RmrMessagesBuffer_t &rmrMessageBuffer,
316 sctp_params_t &sctp_ut_params) {
318 init_memories(message, rmrMessageBuffer, sctp_ut_params);
319 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
320 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
321 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
322 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
325 void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
327 ReportingMessages_t &message,
328 RmrMessagesBuffer_t &rmrMessageBuffer,
329 sctp_params_t &sctp_ut_params) {
331 init_memories(message, rmrMessageBuffer, sctp_ut_params);
333 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*));
334 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1;
335 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t);
336 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t));
337 RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0];
339 ie->id = ProtocolIE_ID_id_RICrequestID;
340 ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
341 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
342 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
343 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
344 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
347 void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
349 ReportingMessages_t &message,
350 RmrMessagesBuffer_t &rmrMessageBuffer,
351 sctp_params_t &sctp_ut_params) {
353 init_memories(message, rmrMessageBuffer, sctp_ut_params);
354 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
355 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
356 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
357 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
360 void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
362 ReportingMessages_t &message,
363 RmrMessagesBuffer_t &rmrMessageBuffer,
364 sctp_params_t &sctp_ut_params) {
366 init_memories(message, rmrMessageBuffer, sctp_ut_params);
367 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
368 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
369 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
370 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
375 Sctp_Map_t *sctpMap = new Sctp_Map_t();
376 ReportingMessages_t message;
377 RmrMessagesBuffer_t rmrMessageBuffer;
378 sctp_params_t sctp_ut_params;
380 pdu.present = E2AP_PDU_PR_successfulOutcome;
381 pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
382 memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome));
383 memset( (void*)&message, 0, sizeof(message));
384 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
386 snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
388 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
389 create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
390 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
391 create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
392 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
393 create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
394 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
395 create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
396 /* For Procedure's Default case. */
397 pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100);
398 asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
400 if(pdu.choice.successfulOutcome) {
401 free(pdu.choice.successfulOutcome);
402 pdu.choice.successfulOutcome = NULL;
411 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
413 if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) &&
414 (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]) ) {
415 free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]);
416 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = NULL;
418 if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) {
419 free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array);
420 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL;
422 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 0;
423 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = 0;
425 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
426 free(rmrMessageBuffer.sendMessage->header);
427 rmrMessageBuffer.sendMessage->header = NULL;
429 if(rmrMessageBuffer.sendMessage->payload) {
430 free(rmrMessageBuffer.sendMessage->payload);
431 rmrMessageBuffer.sendMessage->payload = NULL;
433 if(rmrMessageBuffer.sendMessage) {
434 free(rmrMessageBuffer.sendMessage);
435 rmrMessageBuffer.sendMessage = NULL;
439 void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
441 ReportingMessages_t &message,
442 RmrMessagesBuffer_t &rmrMessageBuffer,
443 sctp_params_t &sctp_ut_params) {
445 init_memories(message, rmrMessageBuffer, sctp_ut_params);
447 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*));
448 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1;
449 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t);
450 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t));
451 RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0];
453 ie->id = ProtocolIE_ID_id_RICrequestID;
454 ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID;
455 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
456 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
457 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
458 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
461 void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
463 ReportingMessages_t &message,
464 RmrMessagesBuffer_t &rmrMessageBuffer,
465 sctp_params_t &sctp_ut_params) {
467 init_memories(message, rmrMessageBuffer, sctp_ut_params);
468 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
469 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
470 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
471 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
474 void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
476 ReportingMessages_t &message,
477 RmrMessagesBuffer_t &rmrMessageBuffer,
478 sctp_params_t &sctp_ut_params) {
480 init_memories(message, rmrMessageBuffer, sctp_ut_params);
481 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
482 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
483 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
484 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
489 Sctp_Map_t *sctpMap = new Sctp_Map_t();
490 ReportingMessages_t message;
491 RmrMessagesBuffer_t rmrMessageBuffer;
492 sctp_params_t sctp_ut_params;
494 pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
495 pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
496 memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome));
497 memset( (void*)&message, 0, sizeof(message));
498 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
500 snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
502 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
503 create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
504 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
505 create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
506 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
507 create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
508 /* For Procedure's Default case. */
509 pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100);
510 asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
512 if(pdu.choice.unsuccessfulOutcome) {
513 free(pdu.choice.unsuccessfulOutcome);
514 pdu.choice.unsuccessfulOutcome = NULL;
524 int epoll_fd = epoll_create1(0);
526 ConnectedCU_t* peerinfo = &cu;
529 addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0);
533 sctp_params_t sctpParams;
535 char **argv = (char**) calloc(argc, sizeof(char*));
536 argv[0] = (char*) malloc(40 * sizeof(char));
537 argv[1] = (char*) malloc(40 * sizeof(char));
538 argv[2] = (char*) malloc(40 * sizeof(char));
539 argv[3] = (char*) malloc(40 * sizeof(char));
540 argv[4] = (char*) malloc(40 * sizeof(char));
541 snprintf(argv[0], strlen("./e2 "), "%s", (char*)"./e2");
542 snprintf(argv[1], strlen("-p "), "%s", (char*)"-p");
543 snprintf(argv[2], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config");
544 snprintf(argv[3], strlen("-f "), "%s", (char*)"-f");
545 snprintf(argv[4], strlen("config.conf "), "%s", (char*)"config.conf");
547 auto result = parse(argc, argv, sctpParams);
548 sctpParams.podName.assign("E2TermAlpha_pod");
549 sctpParams.sctpMap = new mapWrapper();
550 sctpParams.epoll_fd = epoll_create1(0);
551 buildConfiguration(sctpParams);
552 // getRmrContext(sctpParams);
553 buildInotify(sctpParams);
554 buildListeningPort(sctpParams);
555 listener(&sctpParams);
557 if(sctpParams.sctpMap) {
558 delete sctpParams.sctpMap;
559 sctpParams.sctpMap = NULL;
578 ReportingMessages_t reporting_msg;
579 Sctp_Map_t *sctpMap = new Sctp_Map_t();
580 sendSctpMsg(peerInfo, reporting_msg, sctpMap);
590 void inti_buffers_rcv(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
591 message.peerInfo = peerInfo;
592 snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
594 rmrMessageBuffer.rcvMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
595 rmrMessageBuffer.rcvMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
596 rmrMessageBuffer.rcvMessage->len = strlen("Saying Hello from Ramji ");
597 rmrMessageBuffer.rcvMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
599 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
600 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
601 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
602 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
606 void delete_memories_rcv(RmrMessagesBuffer_t &rmrMessageBuffer) {
608 if(rmrMessageBuffer.rcvMessage && rmrMessageBuffer.rcvMessage->header) {
609 free(rmrMessageBuffer.rcvMessage->header);
610 rmrMessageBuffer.rcvMessage->header = NULL;
612 if(rmrMessageBuffer.rcvMessage) {
613 free(rmrMessageBuffer.rcvMessage);
614 rmrMessageBuffer.rcvMessage = NULL;
616 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
617 free(rmrMessageBuffer.sendMessage->header);
618 rmrMessageBuffer.sendMessage->header = NULL;
620 if(rmrMessageBuffer.sendMessage) {
621 free(rmrMessageBuffer.sendMessage);
622 rmrMessageBuffer.sendMessage = NULL;
627 void create_receiveXappMessages_RIC_ERROR_INDICATION(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
628 RmrMessagesBuffer_t &rmrMessageBuffer) {
629 inti_buffers_rcv(message, rmrMessageBuffer);
630 rmrMessageBuffer.rcvMessage->mtype = RIC_ERROR_INDICATION;
631 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
632 delete_memories_rcv(rmrMessageBuffer);
635 void create_receiveXappMessages_RIC_E2_SETUP_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
636 RmrMessagesBuffer_t &rmrMessageBuffer) {
637 inti_buffers_rcv(message, rmrMessageBuffer);
638 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_FAILURE;
639 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
640 delete_memories_rcv(rmrMessageBuffer);
643 void create_receiveXappMessages_RIC_SUB_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
644 RmrMessagesBuffer_t &rmrMessageBuffer) {
645 inti_buffers_rcv(message, rmrMessageBuffer);
646 rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_REQ;
647 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
648 delete_memories_rcv(rmrMessageBuffer);
651 void create_receiveXappMessages_RIC_CONTROL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
652 RmrMessagesBuffer_t &rmrMessageBuffer) {
653 inti_buffers_rcv(message, rmrMessageBuffer);
654 rmrMessageBuffer.rcvMessage->mtype = RIC_CONTROL_REQ;
655 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
656 delete_memories_rcv(rmrMessageBuffer);
659 void create_receiveXappMessages_RIC_SERVICE_QUERY(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
660 RmrMessagesBuffer_t &rmrMessageBuffer) {
661 inti_buffers_rcv(message, rmrMessageBuffer);
662 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_QUERY;
663 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
664 delete_memories_rcv(rmrMessageBuffer);
667 void create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
668 RmrMessagesBuffer_t &rmrMessageBuffer) {
669 inti_buffers_rcv(message, rmrMessageBuffer);
670 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_ACK;
671 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
672 delete_memories_rcv(rmrMessageBuffer);
675 void create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
676 RmrMessagesBuffer_t &rmrMessageBuffer) {
677 inti_buffers_rcv(message, rmrMessageBuffer);
678 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_FAILURE;
679 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
680 delete_memories_rcv(rmrMessageBuffer);
684 void create_receiveXappMessages_RIC_E2_RESET_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
685 RmrMessagesBuffer_t &rmrMessageBuffer) {
686 inti_buffers_rcv(message, rmrMessageBuffer);
687 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_REQ;
688 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
689 delete_memories_rcv(rmrMessageBuffer);
692 void create_receiveXappMessages_RIC_E2_RESET_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
693 RmrMessagesBuffer_t &rmrMessageBuffer) {
694 inti_buffers_rcv(message, rmrMessageBuffer);
695 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_RESP;
696 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
697 delete_memories_rcv(rmrMessageBuffer);
700 void create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
701 RmrMessagesBuffer_t &rmrMessageBuffer) {
702 inti_buffers_rcv(message, rmrMessageBuffer);
703 rmrMessageBuffer.rcvMessage->mtype = RIC_SCTP_CLEAR_ALL;
704 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
705 delete_memories_rcv(rmrMessageBuffer);
708 void create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
709 RmrMessagesBuffer_t &rmrMessageBuffer) {
710 inti_buffers_rcv(message, rmrMessageBuffer);
711 rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_REQ;
712 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
713 delete_memories_rcv(rmrMessageBuffer);
716 void create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
717 RmrMessagesBuffer_t &rmrMessageBuffer) {
718 inti_buffers_rcv(message, rmrMessageBuffer);
719 rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
720 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
721 delete_memories_rcv(rmrMessageBuffer);
724 void create_receiveXappMessages_RIC_SUB_DEL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
725 RmrMessagesBuffer_t &rmrMessageBuffer) {
726 inti_buffers_rcv(message, rmrMessageBuffer);
727 rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
728 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
729 delete_memories_rcv(rmrMessageBuffer);
733 Sctp_Map_t *sctpMap = new Sctp_Map_t();
734 ReportingMessages_t message;
735 RmrMessagesBuffer_t rmrMessageBuffer;
737 memset( (void*)&message, 0, sizeof(message));
738 memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
740 // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset
741 create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer);
742 create_receiveXappMessages_RIC_ERROR_INDICATION(sctpMap, message, rmrMessageBuffer);
743 create_receiveXappMessages_RIC_SUB_REQ(sctpMap, message, rmrMessageBuffer);
744 create_receiveXappMessages_RIC_CONTROL_REQ(sctpMap, message, rmrMessageBuffer);
745 create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(sctpMap, message, rmrMessageBuffer);
746 create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(sctpMap, message, rmrMessageBuffer);
747 create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
748 create_receiveXappMessages_RIC_E2_RESET_RESP(sctpMap, message, rmrMessageBuffer);
749 create_receiveXappMessages_RIC_E2_RESET_REQ(sctpMap, message, rmrMessageBuffer);
750 create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
751 create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
752 create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer);
753 create_receiveXappMessages_RIC_SUB_DEL_REQ(sctpMap, message, rmrMessageBuffer);
755 inti_buffers_rcv(message, rmrMessageBuffer);
756 rmrMessageBuffer.rcvMessage->mtype = 52345; /*Dummy Integer Value for default case*/
757 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
758 delete_memories_rcv(rmrMessageBuffer);
766 void receiveDataFromSctp_asnSuccessfulMsg_Procedure_Default( E2AP_PDU_t *pdu,
767 RmrMessagesBuffer_t &rmrMessageBuffer) {
768 pdu->present = E2AP_PDU_PR_successfulOutcome;
769 pdu->choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
770 memset( (void*)pdu->choice.successfulOutcome, 0, sizeof(pdu->choice.successfulOutcome));
771 pdu->choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100);
773 rmrMessageBuffer.sendMessage->tp_buf = pdu;
776 void delete_pdu_memories(E2AP_PDU_t *pdu) {
777 if(pdu->choice.successfulOutcome) {
778 free(pdu->choice.successfulOutcome);
779 pdu->choice.successfulOutcome = NULL;
781 if(pdu->choice.unsuccessfulOutcome) {
782 free(pdu->choice.unsuccessfulOutcome);
783 pdu->choice.unsuccessfulOutcome = NULL;
787 void receiveDataFromSctp_asnUnSuccsesfulMsg_Procedure_Default(E2AP_PDU_t *pdu,
788 RmrMessagesBuffer_t &rmrMessageBuffer) {
789 pdu->present = E2AP_PDU_PR_unsuccessfulOutcome;
790 pdu->choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
791 memset( (void*)pdu->choice.unsuccessfulOutcome, 0, sizeof(pdu->choice.unsuccessfulOutcome));
792 pdu->choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100);
794 rmrMessageBuffer.sendMessage->tp_buf = pdu;
799 struct epoll_event events;
800 Sctp_Map_t *sctpMap = new Sctp_Map_t();
802 RmrMessagesBuffer_t rmrMessageBuffer;
804 ConnectedCU_t *peerInfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
805 events.data.ptr = peerInfo;
806 snprintf(peerInfo->enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
808 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
809 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
810 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA ");
811 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
813 clock_gettime(CLOCK_MONOTONIC, &ts);
815 receiveDataFromSctp_asnSuccessfulMsg_Procedure_Default(&pdu, rmrMessageBuffer);
816 receiveDataFromSctp(&events, sctpMap, numOfMessages, rmrMessageBuffer, ts);
817 delete_pdu_memories(&pdu);
819 if(rmrMessageBuffer.sendMessage->payload) {
820 free(rmrMessageBuffer.sendMessage->payload);
821 rmrMessageBuffer.sendMessage->payload = NULL;
824 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
825 receiveDataFromSctp_asnUnSuccsesfulMsg_Procedure_Default(&pdu, rmrMessageBuffer);
826 receiveDataFromSctp(&events, sctpMap, numOfMessages, rmrMessageBuffer, ts);
827 delete_pdu_memories(&pdu);
829 if(rmrMessageBuffer.sendMessage->payload) {
830 free(rmrMessageBuffer.sendMessage->payload);
831 rmrMessageBuffer.sendMessage->payload = NULL;
833 if(rmrMessageBuffer.sendMessage->header) {
834 free(rmrMessageBuffer.sendMessage->header);
835 rmrMessageBuffer.sendMessage->header = NULL;
837 if(rmrMessageBuffer.sendMessage) {
838 free(rmrMessageBuffer.sendMessage);
850 int main(int argc, char **argv) {
852 testing::InitGoogleTest(&argc, argv);
853 return RUN_ALL_TESTS();